@opencode/codemode 2.0.12 → 2.0.14

package/dist/interpreter/promises.js

@@ -4,7 +4,7 @@ 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 { describeValue, typeofValue } from "./references.js";
 import { applyCollectionCallback, isSupportedCallback } from "./callback.js";
 // A `resolve`/`reject` handed to an executor or thenable: calling it settles the capability.
 const capability = (ctx, name, settle) => fn(ctx.builtins, name, 1, (_, args) => {
@@ -119,7 +119,7 @@ export const resolvePromise = (ctx, value) => {
         return Effect.succeed(value);
     return ctx.pending.createWithSelf((self) => resolvePromiseValue(ctx, value, self));
 };
-const promiseStatics = ["all", "allSettled", "race", "any", "resolve", "reject"];
+const promiseStatics = ["all", "allSettled", "race", "any", "resolve", "reject", "withResolvers", "try"];
 const invokePromiseMethod = (ctx, name, args) => {
     if (name === "resolve") {
         return resolvePromise(ctx, args[0]);
@@ -127,10 +127,26 @@ const invokePromiseMethod = (ctx, name, args) => {
     if (name === "reject") {
         return ctx.pending.create(Effect.fail(new Throw(args[0])));
     }
+    if (name === "withResolvers") {
+        return Effect.map(promiseCapability(ctx), (made) => record(ctx.builtins.Object, { promise: made.promise, resolve: made.resolve, reject: made.reject }));
+    }
+    if (name === "try") {
+        if (typeofValue(args[0]) !== "function") {
+            throw typeError(`Promise.try expects a function, received ${describeValue(args[0])}.`);
+        }
+        return Effect.flatMap(Effect.exit(ctx.call(args[0], undefined, args.slice(1))), (called) => {
+            if (Exit.isSuccess(called))
+                return resolvePromise(ctx, called.value);
+            if (Cause.hasInterruptsOnly(called.cause))
+                return Effect.failCause(called.cause);
+            return ctx.pending.create(Effect.fail(Cause.squash(called.cause)));
+        });
+    }
     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.`);
+        if (cursor === undefined) {
+            throw typeError(`Promise.${name} expects a synchronous iterable, received ${describeValue(args[0])}.`);
+        }
         const items = [];
         while (true) {
             const step = yield* cursor.next;
@@ -188,22 +204,27 @@ const instanceMethod = (ctx, name, thisValue, args) => {
     const onRejected = reactionHandler(name === "then" ? args[1] : args[0], method);
     return chainReaction(ctx, promise, onFulfilled, onRejected, method);
 };
+/** NewPromiseCapability: a pending promise with the resolve/reject callables that settle it exactly once. */
+const promiseCapability = (ctx) => Effect.gen(function* () {
+    const deferred = Deferred.makeUnsafe();
+    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))));
+    return { promise, resolve, reject, deferred };
+});
 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* 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]));
+        const made = yield* promiseCapability(ctx);
+        const executed = yield* Effect.exit(ctx.call(executor, undefined, [made.resolve, made.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)));
+            Deferred.doneUnsafe(made.deferred, Exit.fail(Cause.squash(executed.cause)));
         }
-        return promise;
+        return made.promise;
     });
 };
 // Settle one reaction turn after the deciding member, after its existing reactions.

package/dist/interpreter/references.d.ts

@@ -1,7 +1,8 @@
-/** Values that cannot cross the data boundary. */
-export declare const isRuntimeReference: (value: unknown) => boolean;
-export declare const containsRuntimeReference: (value: unknown) => boolean;
-export declare const containsOpaqueReference: (value: unknown) => boolean;
-export declare const rejectCircularInsertion: (container: object, value: unknown, label: string, seen?: Set<object>) => void;
-export declare const describeValue: (value: unknown) => string;
-export declare const typeofValue: (value: unknown) => string;
+import { Obj, type Value } from "./objects.js";
+/** Interpreter machinery that is never data, unlike a Date or Map, which cross some boundaries as copies. */
+export declare const isOpaque: (value: Value) => boolean;
+export declare const containsRuntimeReference: (value: Value) => boolean;
+export declare const containsOpaqueReference: (value: Value) => boolean;
+export declare const rejectCircularInsertion: (container: Obj, value: Value, label: string, seen?: Set<object>) => void;
+export declare const describeValue: (value: Value) => string;
+export declare const typeofValue: (value: Value) => string;

package/dist/interpreter/references.js

@@ -1,19 +1,8 @@
 import { ToolReference } from "../tool-runtime.js";
 import { invalidData } from "./model.js";
-import { Callable, getOwn, isWrapper, ownKeys, Arr, Bytes, DateObj, GeneratorObj, IteratorObj, MapObj, Obj, PromiseObj, RegExpObj, SetObj, URLObj, URLSearchParamsObj, HeadersObj, } from "./objects.js";
-/** Values that cannot cross the data boundary. */
-export const isRuntimeReference = (value) => value instanceof Callable ||
-    value instanceof GeneratorObj ||
-    value instanceof IteratorObj ||
-    value instanceof ToolReference ||
-    value instanceof PromiseObj ||
-    isWrapper(value);
-function* childValues(value) {
-    if (!(value instanceof Obj))
-        return;
-    for (const key of ownKeys(value))
-        yield getOwn(value, key);
-}
+import { Callable, getOwn, isRuntimeReference, Obj, Opaque, ownKeys } from "./objects.js";
+/** Interpreter machinery that is never data, unlike a Date or Map, which cross some boundaries as copies. */
+export const isOpaque = (value) => value instanceof Opaque || value instanceof ToolReference;
 // Depth-first search over a value tree. `match` stops the walk; `skip` prunes a subtree without matching it.
 const find = (value, match, skip, seen) => {
     const pending = [[value].values()];
@@ -26,17 +15,18 @@ const find = (value, match, skip, seen) => {
         const current = next.value;
         if (match(current))
             return true;
-        if (current === null || typeof current !== "object" || skip(current) || seen.has(current))
+        if (!(current instanceof Obj) || skip(current) || seen.has(current))
             continue;
         seen.add(current);
-        pending.push(childValues(current));
+        pending.push(ownKeys(current)
+            .map((key) => getOwn(current, key))
+            .values());
     }
     return false;
 };
 const never = () => false;
 export const containsRuntimeReference = (value) => find(value, isRuntimeReference, never, new Set());
-// Wrapper values are data here, not opaque interpreter references.
-export const containsOpaqueReference = (value) => find(value, (current) => !isWrapper(current) && isRuntimeReference(current), isWrapper, new Set());
+export const containsOpaqueReference = (value) => find(value, isOpaque, (current) => isRuntimeReference(current) && !isOpaque(current), new Set());
 // Reject cycles before mutation so later boundary walks remain safe.
 export const rejectCircularInsertion = (container, value, label, seen = new Set()) => {
     if (find(value, (current) => current === container, isRuntimeReference, seen)) {
@@ -46,36 +36,10 @@ export const rejectCircularInsertion = (container, value, label, seen = new Set(
 export const describeValue = (value) => {
     if (value === null || value === undefined)
         return String(value);
-    if (value instanceof Arr)
-        return "an array";
-    if (value instanceof PromiseObj)
-        return "an un-awaited Promise";
+    if (value instanceof Obj)
+        return value.describe;
     if (value instanceof ToolReference)
         return "a tool reference";
-    if (value instanceof DateObj)
-        return "a Date";
-    if (value instanceof RegExpObj)
-        return "a RegExp";
-    if (value instanceof MapObj)
-        return "a Map";
-    if (value instanceof SetObj)
-        return "a Set";
-    if (value instanceof URLObj)
-        return "a URL";
-    if (value instanceof URLSearchParamsObj)
-        return "a URLSearchParams";
-    if (value instanceof HeadersObj)
-        return "a Headers";
-    if (value instanceof Bytes)
-        return "a Uint8Array";
-    if (value instanceof GeneratorObj)
-        return "a generator";
-    if (value instanceof IteratorObj)
-        return "an iterator";
-    if (isRuntimeReference(value))
-        return "a function";
-    if (typeof value === "object")
-        return "a data object";
     return `a ${typeof value}`;
 };
 export const typeofValue = (value) => {

package/dist/interpreter/scope.d.ts

@@ -1,12 +1,13 @@
 import { type AstNode, type Binding } from "./model.js";
+import type { Value } from "./objects.js";
 export declare class ScopeStack {
     private readonly scopes;
     constructor(scopes: Array<Map<string, Binding>>);
     reserve(name: string, mutable: boolean, node: AstNode): void;
-    initialize(name: string, value: unknown, node: AstNode): void;
-    declare(name: string, value: unknown, mutable: boolean, node: AstNode): void;
-    get(name: string, node: AstNode): unknown;
-    set(name: string, value: unknown, node: AstNode): unknown;
+    initialize(name: string, value: Value, node: AstNode): void;
+    declare(name: string, value: Value, mutable: boolean, node: AstNode): void;
+    get(name: string, node: AstNode): Value;
+    set(name: string, value: Value, node: AstNode): Value;
     resolve(name: string): Binding | undefined;
     current(): Map<string, Binding>;
     push(scope?: Map<string, Binding>): void;

package/dist/stdlib/array.d.ts

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

package/dist/stdlib/array.js

@@ -2,19 +2,18 @@ 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, IteratorSymbol, rangeError, typeError } from "../interpreter/model.js";
-import { define, get, hidden, Arr, GeneratorObj, IteratorObj, Obj } from "../interpreter/objects.js";
+import { define, get, hidden, Arr, GeneratorObj, hostIterator, Obj, PromiseObj, coerceToInteger, coerceToNumber, coerceToString, } from "../interpreter/objects.js";
 import { describeValue, rejectCircularInsertion } from "../interpreter/references.js";
 import { applyCollectionCallback, invoke, preserveConsumerError } from "../interpreter/callback.js";
 import { compareText } from "../tool-runtime.js";
-import { coerceToNumber, coerceToString } from "./value.js";
 const arrayLikeSource = (source) => {
-    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);
-        return { length: normalized, source };
+    // JS would treat a promise as an empty array-like; that would hide a missing `await`.
+    if (source instanceof Obj && !(source instanceof PromiseObj)) {
+        const length = Math.max(0, coerceToInteger(get(source, "length")));
+        checkArrayLength(length);
+        return { length, source };
     }
-    throw invalidData(`Array.from expects an array, string, Map, Set, or array-like value, received ${describeValue(source)}.`);
+    throw invalidData(`Array.from expects an iterable or array-like value, received ${describeValue(source)}.`);
 };
 const arrayFrom = (ctx, args) => {
     const source = args[0];
@@ -24,7 +23,7 @@ const arrayFrom = (ctx, args) => {
         const cursor = yield* ctx.iterate(source);
         if (cursor === undefined) {
             if (source instanceof GeneratorObj) {
-                throw typeError("Array.from expects a synchronous iterable or array-like value.");
+                throw typeError(`Array.from expects a synchronous iterable or array-like value, received ${describeValue(source)}.`);
             }
             const arrayLike = arrayLikeSource(source);
             const values = [];
@@ -40,7 +39,7 @@ const arrayFrom = (ctx, args) => {
             const step = yield* cursor.next;
             if (step.done)
                 return new Arr(proto, values);
-            values.push(apply === undefined ? step.value : yield* preserveConsumerError(cursor, apply([step.value, index])));
+            values.push(apply === undefined ? step.value : yield* preserveConsumerError(cursor.close, apply([step.value, index])));
             index += 1;
         }
     });
@@ -103,14 +102,7 @@ export const arrayGlobal = (ctx) => {
         ["from", 1, (_, args) => arrayFrom(ctx, args)],
     ]);
     const self = (thisValue, name) => receiver(Arr, thisValue, `Array.prototype.${name}`);
-    const optNumber = (name, value, label) => {
-        if (value === undefined)
-            return undefined;
-        if (typeof value !== "number") {
-            throw typeError(`Array.${name} expects ${label} to be a number.`);
-        }
-        return value;
-    };
+    const optNumber = (value) => (value === undefined ? undefined : coerceToInteger(value));
     // Callback methods fix the iteration length while reading existing elements live.
     const iterate = (name, length, body) => [
         name,
@@ -125,13 +117,9 @@ export const arrayGlobal = (ctx) => {
             "join",
             1,
             (thisValue, args) => {
-                const target = self(thisValue, "join").items;
-                if (args.length > 1 || (args.length === 1 && typeof args[0] !== "string")) {
-                    throw typeError("Array.join expects zero arguments or one string separator.");
-                }
-                const joined = target
-                    .map((item) => coerceToString(item ?? ""))
-                    .join(args.length === 0 ? "," : args[0]);
+                const joined = self(thisValue, "join")
+                    .items.map((item) => coerceToString(item ?? ""))
+                    .join(args[0] === undefined ? "," : coerceToString(args[0]));
                 checkStringLength(joined.length);
                 return joined;
             },
@@ -147,33 +135,23 @@ export const arrayGlobal = (ctx) => {
             "includes",
             1,
             (thisValue, args) => {
-                const target = self(thisValue, "includes").items;
-                if (args.length === 0 || args.length > 2) {
-                    throw typeError("Array.includes expects a value and optional start index.");
-                }
-                return target.includes(args[0], optNumber("includes", args[1], "start index"));
+                return self(thisValue, "includes").items.includes(args[0], optNumber(args[1]));
             },
         ],
-        [
-            "indexOf",
-            1,
-            (thisValue, args) => self(thisValue, "indexOf").items.indexOf(args[0], optNumber("indexOf", args[1], "start index")),
-        ],
+        ["indexOf", 1, (thisValue, args) => self(thisValue, "indexOf").items.indexOf(args[0], optNumber(args[1]))],
         [
             "lastIndexOf",
             1,
             (thisValue, args) => {
                 const target = self(thisValue, "lastIndexOf").items;
-                return args[1] === undefined
-                    ? target.lastIndexOf(args[0])
-                    : target.lastIndexOf(args[0], optNumber("lastIndexOf", args[1], "start index"));
+                return args[1] === undefined ? target.lastIndexOf(args[0]) : target.lastIndexOf(args[0], optNumber(args[1]));
             },
         ],
-        ["at", 1, (thisValue, args) => self(thisValue, "at").items.at(optNumber("at", args[0], "index") ?? 0)],
+        ["at", 1, (thisValue, args) => self(thisValue, "at").items.at(optNumber(args[0]) ?? 0)],
         [
             "slice",
             2,
-            (thisValue, args) => wrap(self(thisValue, "slice").items.slice(optNumber("slice", args[0], "start"), optNumber("slice", args[1], "end"))),
+            (thisValue, args) => wrap(self(thisValue, "slice").items.slice(optNumber(args[0]), optNumber(args[1]))),
         ],
         [
             "concat",
@@ -189,7 +167,7 @@ export const arrayGlobal = (ctx) => {
             0,
             (thisValue, args) => {
                 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);
+                const flattened = flatten(self(thisValue, "flat").items, optNumber(args[0]) ?? 1);
                 checkArrayLength(flattened.length);
                 return wrap(flattened);
             },
@@ -234,7 +212,7 @@ export const arrayGlobal = (ctx) => {
             2,
             (thisValue, args) => {
                 const target = self(thisValue, "with").items;
-                const index = optNumber("with", args[0], "index") ?? 0;
+                const index = optNumber(args[0]) ?? 0;
                 const resolved = index < 0 ? target.length + index : index;
                 if (resolved < 0 || resolved >= target.length)
                     throw rangeError("Array.with index is out of range.");
@@ -273,10 +251,10 @@ export const arrayGlobal = (ctx) => {
                 const target = self(thisValue, "splice");
                 if (args.length === 0)
                     return wrap(target.items.splice(0, 0));
-                const start = optNumber("splice", args[0], "start") ?? 0;
+                const start = optNumber(args[0]) ?? 0;
                 if (args.length === 1)
                     return wrap(target.items.splice(start));
-                const deleteCount = optNumber("splice", args[1], "delete count") ?? 0;
+                const deleteCount = optNumber(args[1]) ?? 0;
                 const inserted = args.slice(2);
                 for (const item of inserted)
                     rejectCircularInsertion(target, item, "Array.splice result");
@@ -290,11 +268,11 @@ export const arrayGlobal = (ctx) => {
                 const copied = [...self(thisValue, "toSpliced").items];
                 if (args.length === 0)
                     return wrap(copied);
-                const start = optNumber("toSpliced", args[0], "start") ?? 0;
+                const start = optNumber(args[0]) ?? 0;
                 if (args.length === 1)
                     copied.splice(start);
                 else
-                    copied.splice(start, optNumber("toSpliced", args[1], "delete count") ?? 0, ...args.slice(2));
+                    copied.splice(start, optNumber(args[1]) ?? 0, ...args.slice(2));
                 return wrap(copied);
             },
         ],
@@ -304,7 +282,7 @@ export const arrayGlobal = (ctx) => {
             (thisValue, args) => {
                 const target = self(thisValue, "fill");
                 rejectCircularInsertion(target, args[0], "Array.fill result");
-                target.items.fill(args[0], optNumber("fill", args[1], "start"), optNumber("fill", args[2], "end"));
+                target.items.fill(args[0], optNumber(args[1]), optNumber(args[2]));
                 return target;
             },
         ],
@@ -313,7 +291,7 @@ export const arrayGlobal = (ctx) => {
             2,
             (thisValue, args) => {
                 const target = self(thisValue, "copyWithin");
-                target.items.copyWithin(optNumber("copyWithin", args[0], "target index") ?? 0, optNumber("copyWithin", args[1], "start") ?? 0, optNumber("copyWithin", args[2], "end"));
+                target.items.copyWithin(optNumber(args[0]) ?? 0, optNumber(args[1]) ?? 0, optNumber(args[2]));
                 return target;
             },
         ],
@@ -324,12 +302,12 @@ export const arrayGlobal = (ctx) => {
                 ? Effect.succeed("")
                 : Effect.map(invoke(ctx, item, "toLocaleString", "Array.prototype.toLocaleString"), coerceToString)), (parts) => parts.join(",")),
         ],
-        ["keys", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "keys").items.keys())],
-        ["values", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "values").items.values())],
+        ["keys", 0, (thisValue) => hostIterator(builtins, self(thisValue, "keys").items.keys())],
+        ["values", 0, (thisValue) => hostIterator(builtins, self(thisValue, "values").items.values())],
         [
             "entries",
             0,
-            (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "entries")
+            (thisValue) => hostIterator(builtins, self(thisValue, "entries")
                 .items.entries()
                 .map(([index, item]) => wrap([index, item]))),
         ],

package/dist/stdlib/bytes.js

@@ -2,9 +2,8 @@ import { Effect } from "effect";
 import { checkArrayLength, checkStringLength } from "../interpreter/limits.js";
 import { constructor, methods, prototypeFrom, receiver, requiresNew } from "../interpreter/native.js";
 import { IteratorSymbol, rangeError, syntaxError, typeError } from "../interpreter/model.js";
-import { define, defineAccessor, get, hidden, Arr, Bytes, IteratorObj, Obj } from "../interpreter/objects.js";
+import { define, defineAccessor, get, hidden, Arr, Bytes, hostIterator, Obj, coerceToInteger, coerceToNumber, coerceToString, } from "../interpreter/objects.js";
 import { describeValue } from "../interpreter/references.js";
-import { coerceToNumber, coerceToString } from "./value.js";
 /** The bytes a Uint8Array, array, or other iterable of numbers describes; the host array clamps each value. */
 const collectBytes = (ctx, source, name) => {
     if (source instanceof Bytes)
@@ -62,34 +61,28 @@ export const uint8ArrayGlobal = (ctx) => {
         ["fromHex", 1, (_, args) => decode("fromHex", args, (text) => Uint8Array.fromHex(text))],
     ]);
     const self = (thisValue, name) => receiver(Bytes, thisValue, `Uint8Array.prototype.${name}`);
-    const optNumber = (name, value, label) => {
-        if (value === undefined)
-            return undefined;
-        if (typeof value !== "number")
-            throw typeError(`Uint8Array.${name} expects ${label} to be a number.`);
-        return value;
-    };
+    const optNumber = (value) => (value === undefined ? undefined : coerceToInteger(value));
     const wrapAll = (items) => new Arr(builtins.Array, items);
     defineAccessor(proto, "length", (thisValue) => self(thisValue, "length").bytes.length);
     methods(builtins, proto, [
-        ["at", 1, (thisValue, args) => self(thisValue, "at").bytes.at(optNumber("at", args[0], "index") ?? 0)],
+        ["at", 1, (thisValue, args) => self(thisValue, "at").bytes.at(optNumber(args[0]) ?? 0)],
         [
             "slice",
             2,
-            (thisValue, args) => wrap(self(thisValue, "slice").bytes.slice(optNumber("slice", args[0], "start"), optNumber("slice", args[1], "end"))),
+            (thisValue, args) => wrap(self(thisValue, "slice").bytes.slice(optNumber(args[0]), optNumber(args[1]))),
         ],
         // A view on the same bytes, as in JS: writes through one are visible through the other.
         [
             "subarray",
             2,
-            (thisValue, args) => wrap(self(thisValue, "subarray").bytes.subarray(optNumber("subarray", args[0], "start"), optNumber("subarray", args[1], "end"))),
+            (thisValue, args) => wrap(self(thisValue, "subarray").bytes.subarray(optNumber(args[0]), optNumber(args[1]))),
         ],
         [
             "set",
             1,
             (thisValue, args) => {
                 const target = self(thisValue, "set");
-                const offset = optNumber("set", args[1], "offset") ?? 0;
+                const offset = optNumber(args[1]) ?? 0;
                 return Effect.map(collectBytes(ctx, args[0], "Uint8Array.set"), (source) => {
                     if (!Number.isInteger(offset) || offset < 0 || source.length + offset > target.bytes.length) {
                         throw rangeError("Uint8Array.set: the source does not fit at that offset.");
@@ -104,7 +97,7 @@ export const uint8ArrayGlobal = (ctx) => {
             1,
             (thisValue, args) => {
                 const target = self(thisValue, "fill");
-                target.bytes.fill(coerceToNumber(args[0]), optNumber("fill", args[1], "start"), optNumber("fill", args[2], "end"));
+                target.bytes.fill(coerceToNumber(args[0]), optNumber(args[1]), optNumber(args[2]));
                 return target;
             },
         ],
@@ -120,7 +113,7 @@ export const uint8ArrayGlobal = (ctx) => {
         [
             "indexOf",
             1,
-            (thisValue, args) => self(thisValue, "indexOf").bytes.indexOf(coerceToNumber(args[0]), optNumber("indexOf", args[1], "start index")),
+            (thisValue, args) => self(thisValue, "indexOf").bytes.indexOf(coerceToNumber(args[0]), optNumber(args[1])),
         ],
         [
             "lastIndexOf",
@@ -129,22 +122,19 @@ export const uint8ArrayGlobal = (ctx) => {
                 const target = self(thisValue, "lastIndexOf").bytes;
                 return args[1] === undefined
                     ? target.lastIndexOf(coerceToNumber(args[0]))
-                    : target.lastIndexOf(coerceToNumber(args[0]), optNumber("lastIndexOf", args[1], "start index"));
+                    : target.lastIndexOf(coerceToNumber(args[0]), optNumber(args[1]));
             },
         ],
         [
             "includes",
             1,
-            (thisValue, args) => self(thisValue, "includes").bytes.includes(coerceToNumber(args[0]), optNumber("includes", args[1], "start index")),
+            (thisValue, args) => self(thisValue, "includes").bytes.includes(coerceToNumber(args[0]), optNumber(args[1])),
         ],
         [
             "join",
             1,
             (thisValue, args) => {
-                if (args.length > 1 || (args.length === 1 && typeof args[0] !== "string")) {
-                    throw typeError("Uint8Array.join expects zero arguments or one string separator.");
-                }
-                const joined = self(thisValue, "join").bytes.join(args.length === 0 ? "," : args[0]);
+                const joined = self(thisValue, "join").bytes.join(args[0] === undefined ? "," : coerceToString(args[0]));
                 checkStringLength(joined.length);
                 return joined;
             },
@@ -152,12 +142,12 @@ export const uint8ArrayGlobal = (ctx) => {
         ["toString", 0, (thisValue) => self(thisValue, "toString").bytes.join(",")],
         ["toBase64", 0, (thisValue) => self(thisValue, "toBase64").bytes.toBase64()],
         ["toHex", 0, (thisValue) => self(thisValue, "toHex").bytes.toHex()],
-        ["keys", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "keys").bytes.keys())],
-        ["values", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "values").bytes.values())],
+        ["keys", 0, (thisValue) => hostIterator(builtins, self(thisValue, "keys").bytes.keys())],
+        ["values", 0, (thisValue) => hostIterator(builtins, self(thisValue, "values").bytes.values())],
         [
             "entries",
             0,
-            (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "entries")
+            (thisValue) => hostIterator(builtins, self(thisValue, "entries")
                 .bytes.entries()
                 .map(([index, byte]) => wrapAll([index, byte]))),
         ],