@opencode/codemode 0.0.0-dev-19942 → 0.0.0-dev-19959

package/dist/interpreter/callback.d.ts

@@ -1,14 +1,9 @@
 import { Effect } from "effect";
 import type { Interpreter } from "./interpreter.js";
-import { Callable, type Value } from "./objects.js";
-export type IteratorCursor<R> = {
-    readonly next: Effect.Effect<{
-        readonly done: boolean;
-        readonly value: Value;
-    }, unknown, R>;
-    readonly close: Effect.Effect<void, unknown, R>;
-};
-export declare const preserveConsumerError: <A, R>(cursor: IteratorCursor<R>, effect: Effect.Effect<A, unknown, R>) => Effect.Effect<A, unknown, R>;
+import { Callable, type Cursor, type Value } from "./objects.js";
+/** IteratorClose: a consumer failure closes the iterator and wins over any close failure, except that a generator's
+ * return() is a return completion, so a failing close wins over it, as after `break`. */
+export declare const preserveConsumerError: <A, R>(close: Cursor<R>["close"], effect: Effect.Effect<A, unknown, R>) => Effect.Effect<A, unknown, R>;
 /**
  * ToPrimitive: calls `valueOf`/`toString` in hint order and returns the first primitive result. Dates treat the
  * default hint as "string", like their `Symbol.toPrimitive`.

package/dist/interpreter/callback.js

@@ -1,11 +1,20 @@
-import { Effect, Exit } from "effect";
+import { Cause, Effect, Exit } from "effect";
 import { primitivePrototype } from "./intrinsics.js";
-import { typeError } from "./model.js";
-import { Callable, get, Native, DateObj, Obj, coerceToNumber, coerceToString } from "./objects.js";
+import { GeneratorReturn, typeError } from "./model.js";
+import { Callable, get, Native, DateObj, Obj, coerceToNumber, coerceToString, } from "./objects.js";
 import { typeofValue } from "./references.js";
-export const preserveConsumerError = (cursor, effect) => Effect.flatMap(Effect.exit(effect), (exit) => Exit.isSuccess(exit)
-    ? Effect.succeed(exit.value)
-    : Effect.andThen(Effect.exit(cursor.close), Effect.failCause(exit.cause)));
+/** IteratorClose: a consumer failure closes the iterator and wins over any close failure, except that a generator's
+ * return() is a return completion, so a failing close wins over it, as after `break`. */
+export const preserveConsumerError = (close, effect) => Effect.flatMap(Effect.exit(effect), (exit) => {
+    if (Exit.isSuccess(exit))
+        return Effect.succeed(exit.value);
+    return Effect.flatMap(Effect.exit(close), (closed) => {
+        if (!Exit.isSuccess(closed) && Cause.squash(exit.cause) instanceof GeneratorReturn) {
+            return Effect.failCause(closed.cause);
+        }
+        return Effect.failCause(exit.cause);
+    });
+});
 /**
  * ToPrimitive: calls `valueOf`/`toString` in hint order and returns the first primitive result. Dates treat the
  * default hint as "string", like their `Symbol.toPrimitive`.

package/dist/interpreter/globals.js

@@ -60,6 +60,7 @@ const table = {
     console: (ctx) => consoleGlobal(ctx),
     Promise: (ctx) => promiseGlobal(ctx),
     Symbol: (ctx) => symbolGlobal(ctx),
+    Iterator: (ctx) => iteratorGlobals(ctx),
     Number: (ctx) => numberGlobal(ctx),
     String: (ctx) => stringGlobal(ctx),
     Boolean: (ctx) => booleanGlobal(ctx),
@@ -91,6 +92,5 @@ export const globalNames = new Set(Object.keys(table));
 /** The immutable global bindings of every program, in declaration order. */
 export const globals = (ctx) => {
     generatorGlobals(ctx);
-    iteratorGlobals(ctx);
     return Object.entries(table).map(([name, factory]) => [name, factory(ctx)]);
 };

package/dist/interpreter/interpreter.d.ts

@@ -3,7 +3,7 @@ import { Effect } from "effect";
 import { type Json } from "../data.js";
 import { type ToolRuntime } from "../tool-runtime.js";
 import { type Builtins } from "./intrinsics.js";
-import { PromiseObj, type Value } from "./objects.js";
+import { type Cursor, PromiseObj, type Value } from "./objects.js";
 import { Pending } from "./promises.js";
 /** One program execution: the tool bridge, promise scheduler, captured logs, and the global scope built once. */
 export declare class Interpreter<R> {
@@ -22,13 +22,8 @@ export declare class Interpreter<R> {
     run(program: Program): Effect.Effect<Value, unknown, R>;
     call(callable: Value, thisValue: Value, args: Array<Value>): Effect.Effect<Value, unknown, R>;
     await(promise: PromiseObj): Effect.Effect<Value, unknown, never>;
-    iterate(value: Value): Effect.Effect<{
-        next: Effect.Effect<{
-            done: boolean;
-            value: Value;
-        }, unknown, R>;
-        close: Effect.Effect<void, unknown, R>;
-    } | undefined, unknown, R>;
+    iterate(value: Value): Effect.Effect<Cursor<R> | undefined, unknown, R>;
+    iterateDirect(value: Value): Cursor<R>;
     /** Runs one host tool: arguments cross as JSON and the result comes back as program values. */
     tool(run: (args: Array<Json | undefined>) => Effect.Effect<Json | undefined, unknown, R>, args: Array<Value>): Effect.Effect<Value, unknown, R>;
 }

package/dist/interpreter/interpreter.js

@@ -6,7 +6,7 @@ import { checkStringLength } from "./limits.js";
 import { locate, materialize } from "./errors.js";
 import { primitivePrototype } from "./intrinsics.js";
 import { globals } from "./globals.js";
-import { assign, Callable, define, get, has, hasPrototype, keys, Native, parseArrayIndex, Arr, Fn, GeneratorObj, Obj, PromiseObj, record, remove, set, coerceToNumber, coerceToString, } from "./objects.js";
+import { assign, Callable, define, get, hostCursor, IteratorObj, has, hasPrototype, keys, Native, parseArrayIndex, Arr, Fn, GeneratorObj, Obj, PromiseObj, record, remove, set, coerceToNumber, coerceToString, } from "./objects.js";
 import { preserveConsumerError } from "./callback.js";
 import { Pending, resolvePromise, resolvePromiseValue } from "./promises.js";
 import { containsOpaqueReference, describeValue, rejectCircularInsertion, typeofValue } from "./references.js";
@@ -188,6 +188,9 @@ export class Interpreter {
     iterate(value) {
         return this.root.iterate(value);
     }
+    iterateDirect(value) {
+        return this.root.iterateDirect(value);
+    }
     /** Runs one host tool: arguments cross as JSON and the result comes back as program values. */
     tool(run, args) {
         const ctx = this;
@@ -492,7 +495,7 @@ class Frame {
             if (declared?.lexical)
                 self.predeclarePattern(declared.pattern, declared.mutable, left);
             const right = yield* self.evaluateExpression(node.right);
-            const cursor = self.hostCursor(right);
+            const cursor = self.builtinCursor(right);
             const iterator = cursor === undefined ? yield* self.customIterator(right, node, awaiting) : undefined;
             if (iterator === undefined && cursor === undefined) {
                 throw invalidData(`${awaiting ? "for await...of" : "for...of"} requires an iterable value, received ${describeValue(right)}.`, node);
@@ -533,10 +536,9 @@ class Frame {
                 const bodyExit = yield* Effect.exit(evaluateBody(step.value));
                 if (!Exit.isSuccess(bodyExit)) {
                     // Process interruption must remain prompt; user cleanup cannot extend a timeout.
-                    if (!Cause.hasInterruptsOnly(bodyExit.cause)) {
-                        yield* Effect.exit(close());
-                    }
-                    return yield* Effect.failCause(bodyExit.cause);
+                    if (Cause.hasInterruptsOnly(bodyExit.cause))
+                        return yield* Effect.failCause(bodyExit.cause);
+                    return yield* preserveConsumerError(close(), Effect.failCause(bodyExit.cause));
                 }
                 const exit = loopExit(bodyExit.value, labels);
                 if (exit !== undefined) {
@@ -565,32 +567,40 @@ class Frame {
         });
     }
     iterate(value, node) {
-        const cursor = this.hostCursor(value);
+        const cursor = this.builtinCursor(value);
         if (cursor !== undefined)
             return Effect.succeed(cursor);
-        const self = this;
-        return Effect.map(this.customIterator(value, node, false), (iterator) => iterator === undefined
-            ? undefined
-            : {
-                next: self.nextIteratorResult(iterator, node, false),
-                close: Effect.suspend(() => self.closeIterator(iterator, node, false)),
-            });
+        return Effect.map(this.customIterator(value, node, false), (iterator) => iterator === undefined ? undefined : this.customCursor(iterator, node));
+    }
+    /** GetIteratorDirect: drive an iterator by its own `next`, without asking for `[Symbol.iterator]`. */
+    iterateDirect(value, node) {
+        if (value instanceof IteratorObj)
+            return value.cursor;
+        if (!(value instanceof Obj)) {
+            throw typeError(`An iterator must be an object, received ${describeValue(value)}.`, node);
+        }
+        return this.customCursor({
+            iterator: value,
+            next: this.requireIteratorMethod(get(value, "next"), "Iterator next", node),
+            asynchronous: false,
+        }, node);
     }
-    hostCursor(value) {
+    customCursor(iterator, node) {
+        return {
+            next: this.nextIteratorResult(iterator, node, false),
+            close: Effect.suspend(() => this.closeIterator(iterator, node, false)),
+        };
+    }
+    builtinCursor(value) {
+        // Natives build their cursors without knowing R, like `lift` in native.ts.
+        if (value instanceof IteratorObj)
+            return value.cursor;
         const iterator = typeof value === "string"
             ? value[Symbol.iterator]()
             : value instanceof Obj
                 ? value.iterator(this.ctx.builtins)
                 : undefined;
-        if (iterator === undefined)
-            return undefined;
-        return {
-            next: Effect.sync(() => {
-                const step = iterator.next();
-                return { done: Boolean(step.done), value: step.value };
-            }),
-            close: Effect.void,
-        };
+        return iterator === undefined ? undefined : hostCursor(iterator);
     }
     customIterator(value, node, allowAsync = true) {
         if (!(value instanceof Obj))
@@ -933,7 +943,7 @@ class Frame {
                     return;
                 }
                 const consumed = consume(element, step.done ? undefined : step.value, pattern);
-                yield* step.done ? consumed : preserveConsumerError(cursor, consumed);
+                yield* step.done ? consumed : preserveConsumerError(cursor.close, consumed);
             }
             if (!done)
                 yield* cursor.close;
@@ -1505,7 +1515,7 @@ class Frame {
     delegateYield(value, node) {
         const self = this;
         return Effect.gen(function* () {
-            const cursor = self.hostCursor(value);
+            const cursor = self.builtinCursor(value);
             if (cursor !== undefined) {
                 while (true) {
                     const step = yield* cursor.next;

package/dist/interpreter/intrinsics.d.ts

@@ -2,7 +2,7 @@ import { ErrorObj, Obj, type Value } 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;
-declare const builtins: readonly ["Object", "Function", "Array", "String", "Number", "Boolean", "Date", "RegExp", "Map", "Set", "URL", "URLSearchParams", "Headers", "Uint8Array", "TextEncoder", "TextDecoder", "Promise", "Iterator", "AsyncIterator", "Generator", "AsyncGenerator"];
+declare const builtins: readonly ["Object", "Function", "Array", "String", "Number", "Boolean", "Date", "RegExp", "Map", "Set", "URL", "URLSearchParams", "Headers", "Uint8Array", "TextEncoder", "TextDecoder", "Promise", "Iterator", "IteratorHelper", "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.

package/dist/interpreter/intrinsics.js

@@ -30,6 +30,7 @@ const builtins = [
     "TextDecoder",
     "Promise",
     "Iterator",
+    "IteratorHelper",
     "AsyncIterator",
     "Generator",
     "AsyncGenerator",
@@ -85,6 +86,7 @@ export const createBuiltins = () => {
         TextDecoder: plain(),
         Promise: plain(),
         Iterator: iterator,
+        IteratorHelper: new Obj(iterator),
         AsyncIterator: asyncIterator,
         Generator: new Obj(iterator),
         AsyncGenerator: new Obj(asyncIterator),

package/dist/interpreter/objects.d.ts

@@ -1,5 +1,5 @@
 import type { BlockStatement, Expression, Pattern } from "acorn";
-import type { Effect, Fiber } from "effect";
+import { Effect, type Fiber } from "effect";
 import { ToolReference } from "../tool-runtime.js";
 import type { Builtins } from "./intrinsics.js";
 import { type Binding, type GeneratorRequestKind, type PendingThrow } from "./model.js";
@@ -73,6 +73,7 @@ export declare class ErrorObj extends Obj {
     host?: PendingThrow;
     /** Error.prototype.toString: "name: message", or just one when the other is empty. */
     toString(): string;
+    inspect(): string;
 }
 /** Interpreter machinery a program can hold but never inspect, serialize, or hand to the host. */
 export declare abstract class Opaque extends Obj {
@@ -122,14 +123,27 @@ export declare class GeneratorObj extends Opaque {
     constructor(proto: Obj, asynchronous: boolean, request: (kind: GeneratorRequestKind, value: Value) => Effect.Effect<Value, unknown, unknown>);
     get describe(): string;
 }
-/** A built-in collection iterator: live over the host collection, yielding program values. */
+/** One pull from an iterator, as `for...of` sees it. */
+export type Step = {
+    readonly done: boolean;
+    readonly value: Value;
+};
+/** How the interpreter drives any iterator: pull the next step, or close it early. */
+export type Cursor<R = unknown> = {
+    readonly next: Effect.Effect<Step, unknown, R>;
+    readonly close: Effect.Effect<void, unknown, R>;
+};
+/** A cursor over a host iterator; there is nothing to close. */
+export declare const hostCursor: (iterator: Iterator<Value, undefined>) => Cursor<never>;
+/** A built-in iterator: a live cursor over a host collection or an iterator helper, yielding program values. */
 export declare class IteratorObj extends Opaque {
-    readonly source: IteratorObject<Value, undefined>;
+    readonly cursor: Cursor;
     readonly tag = "Iterator";
-    constructor(proto: Obj, source: IteratorObject<Value, undefined>);
+    constructor(proto: Obj, cursor: Cursor);
     get describe(): string;
-    iterator(): IteratorObject<Value, undefined, unknown>;
 }
+/** A built-in iterator over a host iterator, e.g. `array.values()`. */
+export declare const hostIterator: (builtins: Builtins, iterator: Iterator<Value, undefined>) => IteratorObj;
 /** A built-in object around a host value: data-like, so it prints as itself and crosses to extensions as a copy. */
 export declare abstract class Wrapper extends Obj {
     inspect(item: (value: Value) => string): string;

package/dist/interpreter/objects.js

@@ -1,3 +1,4 @@
+import { Effect } from "effect";
 import { ToolReference } from "../tool-runtime.js";
 import { checkArrayLength } from "./limits.js";
 import { AsyncIteratorSymbol, IteratorSymbol, } from "./model.js";
@@ -96,6 +97,9 @@ export class ErrorObj extends Obj {
             return shownMessage;
         return `${shownName}: ${shownMessage}`;
     }
+    inspect() {
+        return this.toString();
+    }
 }
 /** Interpreter machinery a program can hold but never inspect, serialize, or hand to the host. */
 export class Opaque extends Obj {
@@ -168,21 +172,28 @@ export class GeneratorObj extends Opaque {
         return "a generator";
     }
 }
-/** A built-in collection iterator: live over the host collection, yielding program values. */
+/** A cursor over a host iterator; there is nothing to close. */
+export const hostCursor = (iterator) => ({
+    next: Effect.sync(() => {
+        const step = iterator.next();
+        return { done: Boolean(step.done), value: step.value };
+    }),
+    close: Effect.void,
+});
+/** A built-in iterator: a live cursor over a host collection or an iterator helper, yielding program values. */
 export class IteratorObj extends Opaque {
-    source;
+    cursor;
     tag = "Iterator";
-    constructor(proto, source) {
+    constructor(proto, cursor) {
         super(proto);
-        this.source = source;
+        this.cursor = cursor;
     }
     get describe() {
         return "an iterator";
     }
-    iterator() {
-        return this.source;
-    }
 }
+/** A built-in iterator over a host iterator, e.g. `array.values()`. */
+export const hostIterator = (builtins, iterator) => new IteratorObj(builtins.Iterator, hostCursor(iterator));
 /** A built-in object around a host value: data-like, so it prints as itself and crosses to extensions as a copy. */
 export class Wrapper extends Obj {
     inspect(item) {

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/stdlib/array.js

@@ -2,7 +2,7 @@ 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, coerceToNumber, coerceToString, } from "../interpreter/objects.js";
+import { define, get, hidden, Arr, GeneratorObj, hostIterator, Obj, 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";
@@ -13,7 +13,7 @@ const arrayLikeSource = (source) => {
         checkArrayLength(normalized);
         return { length: normalized, 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];
@@ -23,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 = [];
@@ -39,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;
         }
     });
@@ -323,12 +323,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,7 +2,7 @@ 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, coerceToNumber, coerceToString, } from "../interpreter/objects.js";
+import { define, defineAccessor, get, hidden, Arr, Bytes, hostIterator, Obj, coerceToNumber, coerceToString, } from "../interpreter/objects.js";
 import { describeValue } from "../interpreter/references.js";
 /** The bytes a Uint8Array, array, or other iterable of numbers describes; the host array clamps each value. */
 const collectBytes = (ctx, source, name) => {
@@ -151,12 +151,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]))),
         ],

package/dist/stdlib/collections.js

@@ -1,7 +1,7 @@
 import { Effect } from "effect";
 import { constructor, fn, methods, prototypeFrom, receiver, requiresNew } from "../interpreter/native.js";
 import { invalidData, IteratorSymbol, typeError } from "../interpreter/model.js";
-import { define, defineAccessor, get, getOwn, hidden, Arr, coerceToString, IteratorObj, MapObj, Obj, PromiseObj, SetObj, } from "../interpreter/objects.js";
+import { define, defineAccessor, get, getOwn, hidden, Arr, coerceToString, hostCursor, hostIterator, MapObj, Obj, PromiseObj, SetObj, } from "../interpreter/objects.js";
 import { describeValue, isOpaque } from "../interpreter/references.js";
 import { applyCollectionCallback, isSupportedCallback, preserveConsumerError, toPrimitiveNumber, toPrimitiveString, } from "../interpreter/callback.js";
 const coerceGroupByPropertyKey = (ctx, value) => {
@@ -33,7 +33,7 @@ export const groupBy = (ctx, namespace) => fn(ctx.builtins, "groupBy", 2, (_, ar
                 if (step.done)
                     return result;
                 const item = step.value;
-                const key = yield* preserveConsumerError(cursor, apply([item, index]));
+                const key = yield* preserveConsumerError(cursor.close, apply([item, index]));
                 const group = result.map.get(key);
                 if (group === undefined)
                     result.map.set(key, new Arr(builtins.Array, [item]));
@@ -50,7 +50,7 @@ export const groupBy = (ctx, namespace) => fn(ctx.builtins, "groupBy", 2, (_, ar
             if (step.done)
                 return result;
             const item = step.value;
-            const key = yield* preserveConsumerError(cursor, Effect.flatMap(apply([item, index]), (value) => coerceGroupByPropertyKey(ctx, value)));
+            const key = yield* preserveConsumerError(cursor.close, Effect.flatMap(apply([item, index]), (value) => coerceGroupByPropertyKey(ctx, value)));
             const group = getOwn(result, key);
             if (group === undefined)
                 define(result, key, new Arr(builtins.Array, [item]));
@@ -67,13 +67,13 @@ const constructMap = (ctx, init, proto) => {
     return Effect.gen(function* () {
         const cursor = yield* ctx.iterate(init);
         if (cursor === undefined) {
-            throw typeError("new Map(...) expects an iterable of [key, value] pairs or no argument.");
+            throw typeError(`new Map(...) expects an iterable of [key, value] pairs, received ${describeValue(init)}.`);
         }
         while (true) {
             const step = yield* cursor.next;
             if (step.done)
                 return target;
-            yield* preserveConsumerError(cursor, Effect.sync(() => {
+            yield* preserveConsumerError(cursor.close, Effect.sync(() => {
                 if (!(step.value instanceof Obj)) {
                     throw typeError("new Map(...) expects [key, value] pairs as entry objects.");
                 }
@@ -89,7 +89,7 @@ const constructSet = (ctx, init, proto) => {
     return Effect.gen(function* () {
         const cursor = yield* ctx.iterate(init);
         if (cursor === undefined) {
-            throw typeError("new Set(...) expects a synchronous iterable or no argument.");
+            throw typeError(`new Set(...) expects a synchronous iterable, received ${describeValue(init)}.`);
         }
         while (true) {
             const step = yield* cursor.next;
@@ -156,9 +156,9 @@ export const mapGlobal = (ctx) => {
                 return undefined;
             },
         ],
-        ["keys", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "keys").map.keys())],
-        ["values", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "values").map.values())],
-        ["entries", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "entries").iterator(builtins))],
+        ["keys", 0, (thisValue) => hostIterator(builtins, self(thisValue, "keys").map.keys())],
+        ["values", 0, (thisValue) => hostIterator(builtins, self(thisValue, "values").map.values())],
+        ["entries", 0, (thisValue) => hostIterator(builtins, self(thisValue, "entries").iterator(builtins))],
         [
             "forEach",
             1,
@@ -207,12 +207,16 @@ const loadSetRecord = (ctx, source, name) => {
         return {
             size: Math.max(Math.trunc(size), 0),
             has: (item) => Effect.map(ctx.call(has, source, [item]), Boolean),
-            keys: () => Effect.flatMap(ctx.call(keys, source, []), (result) => {
-                if (result instanceof IteratorObj)
-                    return Effect.succeed(result.source);
-                if (result instanceof Arr)
-                    return Effect.succeed(result.items);
-                throw typeError(`Set.${name} expected 'keys' to return an iterator.`);
+            keys: () => Effect.gen(function* () {
+                const result = yield* ctx.call(keys, source, []);
+                const cursor = result instanceof Arr ? hostCursor(result.items.values()) : ctx.iterateDirect(result);
+                const items = [];
+                while (true) {
+                    const step = yield* cursor.next;
+                    if (step.done)
+                        return items;
+                    items.push(step.value);
+                }
             }),
         };
     });
@@ -336,12 +340,12 @@ export const setGlobal = (ctx) => {
                 return undefined;
             },
         ],
-        ["keys", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "keys").set.values())],
-        ["values", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "values").set.values())],
+        ["keys", 0, (thisValue) => hostIterator(builtins, self(thisValue, "keys").set.values())],
+        ["values", 0, (thisValue) => hostIterator(builtins, self(thisValue, "values").set.values())],
         [
             "entries",
             0,
-            (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "entries")
+            (thisValue) => hostIterator(builtins, self(thisValue, "entries")
                 .set.values()
                 .map((item) => wrap([item, item]))),
         ],

package/dist/stdlib/headers.js

@@ -1,7 +1,7 @@
 import { Effect } from "effect";
 import { constructor, methods, prototypeFrom, receiver, requiresNew } from "../interpreter/native.js";
 import { IteratorSymbol, typeError } from "../interpreter/model.js";
-import { define, entries, get, hidden, Arr, HeadersObj, IteratorObj, Obj, coerceToString, isRuntimeReference, } from "../interpreter/objects.js";
+import { define, entries, get, hidden, Arr, HeadersObj, hostIterator, Obj, coerceToString, isRuntimeReference, } from "../interpreter/objects.js";
 import { applyCollectionCallback } from "../interpreter/callback.js";
 import { readPairs } from "./url.js";
 // The host validates header names and values and throws its own TypeError; the program gets one of its own.
@@ -92,18 +92,9 @@ export const headersGlobal = (ctx) => {
                 return undefined;
             },
         ],
-        // Iterator.from because Bun's Headers typings predate iterator helpers; the runtime iterators already have them.
-        [
-            "keys",
-            0,
-            (thisValue) => new IteratorObj(builtins.Iterator, Iterator.from(self(thisValue, "keys").headers.keys())),
-        ],
-        [
-            "values",
-            0,
-            (thisValue) => new IteratorObj(builtins.Iterator, Iterator.from(self(thisValue, "values").headers.values())),
-        ],
-        ["entries", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "entries").iterator(builtins))],
+        ["keys", 0, (thisValue) => hostIterator(builtins, self(thisValue, "keys").headers.keys())],
+        ["values", 0, (thisValue) => hostIterator(builtins, self(thisValue, "values").headers.values())],
+        ["entries", 0, (thisValue) => hostIterator(builtins, self(thisValue, "entries").iterator(builtins))],
         [
             "forEach",
             1,

package/dist/stdlib/iterator.d.ts

@@ -1,2 +1,2 @@
 import type { Interpreter } from "../interpreter/interpreter.js";
-export declare const iteratorGlobals: <R>(ctx: Interpreter<R>) => void;
+export declare const iteratorGlobals: <R>(ctx: Interpreter<R>) => import("../interpreter/objects.js").Native<R>;

package/dist/stdlib/iterator.js

@@ -1,17 +1,305 @@
-import { methods, receiver } from "../interpreter/native.js";
-import { IteratorObj, record } from "../interpreter/objects.js";
-// Every built-in collection iterator shares the Iterator prototype; JS gives each collection its own, which is only
+import { Cause, Effect, Exit } from "effect";
+import { applyCollectionCallback } from "../interpreter/callback.js";
+import { rangeError, typeError } from "../interpreter/model.js";
+import { constructor, fn, methods, receiver, requiresNew } from "../interpreter/native.js";
+import { Arr, coerceToNumber, define, hasPrototype, hidden, IteratorObj, Obj, record, } from "../interpreter/objects.js";
+import { describeValue } from "../interpreter/references.js";
+const finished = { done: true, value: undefined };
+// Every built-in iterator and helper shares the Iterator prototype; JS gives each collection its own, which is only
 // observable through getPrototypeOf.
 export const iteratorGlobals = (ctx) => {
     const builtins = ctx.builtins;
-    methods(builtins, builtins.Iterator, [
+    const proto = builtins.Iterator;
+    const method = (name) => `Iterator.prototype.${name}`;
+    // A step that runs program code: when it throws, close the source first, as IteratorClose does.
+    const guarded = (source, body) => Effect.flatMap(Effect.exit(body), (exit) => {
+        if (Exit.isSuccess(exit))
+            return Effect.succeed(exit.value);
+        if (Cause.hasInterruptsOnly(exit.cause))
+            return Effect.failCause(exit.cause);
+        return Effect.andThen(Effect.exit(source.close), Effect.failCause(exit.cause));
+    });
+    // A lazy helper: `pull` advances it once. Once it reports done, throws, or is closed, it stays done. A callback
+    // that re-enters its own helper is a TypeError, as for a running generator.
+    const helper = (source, pull, close = source.close) => {
+        let done = false;
+        let running = false;
+        const enter = () => {
+            if (running)
+                throw typeError("Iterator helper is already running.");
+            running = true;
+        };
+        return new IteratorObj(builtins.IteratorHelper, {
+            next: Effect.suspend(() => {
+                if (done)
+                    return Effect.succeed(finished);
+                enter();
+                return Effect.flatMap(Effect.exit(pull), (exit) => {
+                    running = false;
+                    done = Exit.isSuccess(exit) ? exit.value.done : true;
+                    return exit;
+                });
+            }),
+            close: Effect.suspend(() => {
+                if (done)
+                    return Effect.void;
+                enter();
+                done = true;
+                return Effect.ensuring(close, Effect.sync(() => {
+                    running = false;
+                }));
+            }),
+        });
+    };
+    // GetIteratorFlattenable: an iterable by `[Symbol.iterator]`, otherwise the object itself as an iterator.
+    const flattenable = (value, name, strings) => Effect.gen(function* () {
+        if (typeof value === "string" ? !strings : !(value instanceof Obj)) {
+            throw typeError(`${name} expects an iterable or iterator, received ${describeValue(value)}.`);
+        }
+        return (yield* ctx.iterate(value)) ?? ctx.iterateDirect(value);
+    });
+    const limit = (value, name) => {
+        const count = Math.trunc(coerceToNumber(value));
+        if (Number.isNaN(count) || count < 0) {
+            throw rangeError(`${method(name)} expects a non-negative count, received ${count}.`);
+        }
+        return count;
+    };
+    methods(builtins, proto, [
         [
             "next",
             0,
+            (thisValue) => Effect.map(receiver(IteratorObj, thisValue, method("next")).cursor.next, (step) => record(builtins.Object, { value: step.value, done: step.done })),
+        ],
+        [
+            "map",
+            1,
+            (thisValue, args) => {
+                const source = ctx.iterateDirect(thisValue);
+                const apply = applyCollectionCallback(ctx, args[0], method("map"));
+                let counter = 0;
+                return helper(source, Effect.gen(function* () {
+                    const step = yield* source.next;
+                    if (step.done)
+                        return finished;
+                    return { done: false, value: yield* guarded(source, apply([step.value, counter++])) };
+                }));
+            },
+        ],
+        [
+            "filter",
+            1,
+            (thisValue, args) => {
+                const source = ctx.iterateDirect(thisValue);
+                const apply = applyCollectionCallback(ctx, args[0], method("filter"));
+                let counter = 0;
+                return helper(source, Effect.gen(function* () {
+                    while (true) {
+                        const step = yield* source.next;
+                        if (step.done)
+                            return finished;
+                        if (yield* guarded(source, apply([step.value, counter++])))
+                            return step;
+                    }
+                }));
+            },
+        ],
+        [
+            "take",
+            1,
+            (thisValue, args) => {
+                const source = ctx.iterateDirect(thisValue);
+                let remaining = limit(args[0], "take");
+                return helper(source, Effect.gen(function* () {
+                    if (remaining === 0) {
+                        yield* source.close;
+                        return finished;
+                    }
+                    remaining -= 1;
+                    return yield* source.next;
+                }));
+            },
+        ],
+        [
+            "drop",
+            1,
+            (thisValue, args) => {
+                const source = ctx.iterateDirect(thisValue);
+                let remaining = limit(args[0], "drop");
+                return helper(source, Effect.gen(function* () {
+                    while (remaining > 0) {
+                        remaining -= 1;
+                        const step = yield* source.next;
+                        if (step.done)
+                            return finished;
+                    }
+                    return yield* source.next;
+                }));
+            },
+        ],
+        [
+            "flatMap",
+            1,
+            (thisValue, args) => {
+                const source = ctx.iterateDirect(thisValue);
+                const apply = applyCollectionCallback(ctx, args[0], method("flatMap"));
+                let counter = 0;
+                let inner;
+                return helper(source, Effect.gen(function* () {
+                    while (true) {
+                        if (inner !== undefined) {
+                            const step = yield* guarded(source, inner.next);
+                            if (!step.done)
+                                return step;
+                            inner = undefined;
+                        }
+                        const step = yield* source.next;
+                        if (step.done)
+                            return finished;
+                        inner = yield* guarded(source, Effect.flatMap(apply([step.value, counter++]), (mapped) => flattenable(mapped, method("flatMap"), false)));
+                    }
+                }), Effect.suspend(() => (inner === undefined ? source.close : Effect.andThen(inner.close, source.close))));
+            },
+        ],
+        [
+            "reduce",
+            1,
+            (thisValue, args) => {
+                const source = ctx.iterateDirect(thisValue);
+                const apply = applyCollectionCallback(ctx, args[0], method("reduce"));
+                return Effect.gen(function* () {
+                    let counter = 0;
+                    let accumulator = args[1];
+                    if (args.length < 2) {
+                        const first = yield* source.next;
+                        if (first.done)
+                            throw typeError("Iterator.prototype.reduce of an empty iterator with no initial value.");
+                        accumulator = first.value;
+                        counter = 1;
+                    }
+                    while (true) {
+                        const step = yield* source.next;
+                        if (step.done)
+                            return accumulator;
+                        accumulator = yield* guarded(source, apply([accumulator, step.value, counter++]));
+                    }
+                });
+            },
+        ],
+        [
+            "toArray",
+            0,
             (thisValue) => {
-                const step = receiver(IteratorObj, thisValue, "Iterator.prototype.next").source.next();
-                return record(builtins.Object, { value: step.value, done: Boolean(step.done) });
+                const source = ctx.iterateDirect(thisValue);
+                return Effect.gen(function* () {
+                    const items = [];
+                    while (true) {
+                        const step = yield* source.next;
+                        if (step.done)
+                            return new Arr(builtins.Array, items);
+                        items.push(step.value);
+                    }
+                });
+            },
+        ],
+        [
+            "forEach",
+            1,
+            (thisValue, args) => {
+                const source = ctx.iterateDirect(thisValue);
+                const apply = applyCollectionCallback(ctx, args[0], method("forEach"));
+                return Effect.gen(function* () {
+                    let counter = 0;
+                    while (true) {
+                        const step = yield* source.next;
+                        if (step.done)
+                            return undefined;
+                        yield* guarded(source, apply([step.value, counter++]));
+                    }
+                });
+            },
+        ],
+        [
+            "some",
+            1,
+            (thisValue, args) => {
+                const source = ctx.iterateDirect(thisValue);
+                const apply = applyCollectionCallback(ctx, args[0], method("some"));
+                return Effect.gen(function* () {
+                    let counter = 0;
+                    while (true) {
+                        const step = yield* source.next;
+                        if (step.done)
+                            return false;
+                        if (yield* guarded(source, apply([step.value, counter++]))) {
+                            yield* source.close;
+                            return true;
+                        }
+                    }
+                });
+            },
+        ],
+        [
+            "every",
+            1,
+            (thisValue, args) => {
+                const source = ctx.iterateDirect(thisValue);
+                const apply = applyCollectionCallback(ctx, args[0], method("every"));
+                return Effect.gen(function* () {
+                    let counter = 0;
+                    while (true) {
+                        const step = yield* source.next;
+                        if (step.done)
+                            return true;
+                        if (!(yield* guarded(source, apply([step.value, counter++])))) {
+                            yield* source.close;
+                            return false;
+                        }
+                    }
+                });
+            },
+        ],
+        [
+            "find",
+            1,
+            (thisValue, args) => {
+                const source = ctx.iterateDirect(thisValue);
+                const apply = applyCollectionCallback(ctx, args[0], method("find"));
+                return Effect.gen(function* () {
+                    let counter = 0;
+                    while (true) {
+                        const step = yield* source.next;
+                        if (step.done)
+                            return undefined;
+                        if (yield* guarded(source, apply([step.value, counter++]))) {
+                            yield* source.close;
+                            return step.value;
+                        }
+                    }
+                });
             },
         ],
     ]);
+    // Helpers and `Iterator.from` wrappers can be closed; collection iterators, as in JS, cannot.
+    methods(builtins, builtins.IteratorHelper, [
+        [
+            "return",
+            0,
+            (thisValue) => Effect.map(receiver(IteratorObj, thisValue, "Iterator.prototype.return").cursor.close, () => record(builtins.Object, { value: undefined, done: true })),
+        ],
+    ]);
+    const iterator = constructor(builtins, proto, {
+        name: "Iterator",
+        length: 0,
+        call: requiresNew("Iterator"),
+        construct: () => Effect.sync(() => {
+            throw typeError("Iterator is abstract; use Iterator.from(...) or a built-in iterator.");
+        }),
+    });
+    define(iterator, "from", fn(builtins, "from", 1, (_, args) => Effect.gen(function* () {
+        if (args[0] instanceof Obj && hasPrototype(args[0], proto))
+            return args[0];
+        return new IteratorObj(builtins.IteratorHelper, yield* flattenable(args[0], "Iterator.from", true));
+    })), hidden);
+    return iterator;
 };

package/dist/stdlib/math.js

@@ -91,7 +91,7 @@ export const mathGlobal = (ctx) => {
                     const step = yield* cursor.next;
                     if (step.done)
                         return Math.sumPrecise(numbers);
-                    yield* preserveConsumerError(cursor, Effect.sync(() => {
+                    yield* preserveConsumerError(cursor.close, Effect.sync(() => {
                         if (typeof step.value !== "number") {
                             throw typeError("Math.sumPrecise expects an iterable of numbers.");
                         }

package/dist/stdlib/object.js

@@ -56,7 +56,7 @@ const objectFromEntries = (ctx, source) => {
             const step = yield* cursor.next;
             if (step.done)
                 return out;
-            yield* preserveConsumerError(cursor, Effect.sync(() => {
+            yield* preserveConsumerError(cursor.close, Effect.sync(() => {
                 if (!(step.value instanceof Obj) || containsOpaqueReference(step.value)) {
                     throw typeError("Object.fromEntries expects [key, value] entry objects.");
                 }

package/dist/stdlib/string.js

@@ -2,7 +2,7 @@ import { Effect } from "effect";
 import { constructor, fn, methods } from "../interpreter/native.js";
 import { checkArrayLength, checkStringLength } from "../interpreter/limits.js";
 import { invalidData, IteratorSymbol, rangeError, typeError } from "../interpreter/model.js";
-import { define, hidden, Arr, IteratorObj, RegExpObj, record, coerceToNumber, coerceToString, } from "../interpreter/objects.js";
+import { define, hidden, Arr, hostIterator, RegExpObj, record, coerceToNumber, coerceToString, } from "../interpreter/objects.js";
 import { containsOpaqueReference, typeofValue } from "../interpreter/references.js";
 import { applyCollectionCallback, isSupportedCallback } from "../interpreter/callback.js";
 import { matchToValue, toHostRegex } from "./regexp.js";
@@ -229,6 +229,6 @@ export const stringGlobal = (ctx) => {
             return joined;
         }),
     ]);
-    define(builtins.String, IteratorSymbol, fn(builtins, "[Symbol.iterator]", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "[Symbol.iterator]")[Symbol.iterator]())), hidden);
+    define(builtins.String, IteratorSymbol, fn(builtins, "[Symbol.iterator]", 0, (thisValue) => hostIterator(builtins, self(thisValue, "[Symbol.iterator]")[Symbol.iterator]())), hidden);
     return string;
 };

package/dist/stdlib/url.js

@@ -1,7 +1,7 @@
 import { Effect } from "effect";
 import { constructor, fn, methods, prototypeFrom, receiver, requiresNew } from "../interpreter/native.js";
 import { IteratorSymbol, PendingThrow, typeError, uriError } from "../interpreter/model.js";
-import { define, defineAccessor, entries, get, hidden, Arr, IteratorObj, Obj, URLObj, URLSearchParamsObj, coerceToString, isRuntimeReference, } from "../interpreter/objects.js";
+import { define, defineAccessor, entries, get, hidden, Arr, hostIterator, Obj, URLObj, URLSearchParamsObj, coerceToString, isRuntimeReference, } from "../interpreter/objects.js";
 import { applyCollectionCallback, preserveConsumerError } from "../interpreter/callback.js";
 const urlProperties = [
     "href",
@@ -105,7 +105,7 @@ const readPair = (ctx, value, label) => Effect.gen(function* () {
         const step = yield* cursor.next;
         if (step.done)
             return items;
-        items.push(yield* preserveConsumerError(cursor, Effect.sync(() => coerceToString(step.value))));
+        items.push(yield* preserveConsumerError(cursor.close, Effect.sync(() => coerceToString(step.value))));
     }
 });
 /**
@@ -124,7 +124,7 @@ export const readPairs = (ctx, init, label) => Effect.gen(function* () {
                 throw typeError(`${label} expects iterable [name, value] pairs.`);
             return pairs;
         }
-        pairs.push(yield* preserveConsumerError(cursor, readPair(ctx, step.value, label)));
+        pairs.push(yield* preserveConsumerError(cursor.close, readPair(ctx, step.value, label)));
     }
 });
 const constructURLSearchParams = (ctx, init, proto) => {
@@ -233,9 +233,9 @@ export const urlSearchParamsGlobal = (ctx) => {
                 return undefined;
             },
         ],
-        ["keys", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "keys").params.keys())],
-        ["values", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "values").params.values())],
-        ["entries", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "entries").iterator(builtins))],
+        ["keys", 0, (thisValue) => hostIterator(builtins, self(thisValue, "keys").params.keys())],
+        ["values", 0, (thisValue) => hostIterator(builtins, self(thisValue, "values").params.values())],
+        ["entries", 0, (thisValue) => hostIterator(builtins, self(thisValue, "entries").iterator(builtins))],
         ["toString", 0, (thisValue) => self(thisValue, "toString").params.toString()],
         [
             "forEach",

package/dist/tool-runtime.js

@@ -90,7 +90,7 @@ const describeTool = (visible) => {
             // Joining the final fragments avoids retaining the rendering's intermediate string ropes in JSC.
             return (signature ??= [
                 toolExpression(visible.path),
-                isEmptyInput(visible.tool) ? "()" : `(input: ${inputTypeScript(visible.tool, true)})`,
+                isEmptyInput(visible.tool) ? "()" : `(${inputTypeScript(visible.tool, true)})`,
                 `: Promise<${outputTypeScript(visible.tool, true)}>`,
             ].join(""));
         },
@@ -118,10 +118,16 @@ const makeSearchTool = (searchIndex) => ({
         const request = input;
         const query = request.query ?? "";
         const offset = request.offset ?? 0;
-        const scoped = request.namespace === undefined
+        let ns = request.namespace;
+        if (ns !== undefined && !searchIndex.some((entry) => entry.description.path.startsWith("tools."))) {
+            if (ns === "tools")
+                ns = undefined;
+            else if (ns.startsWith("tools."))
+                ns = ns.slice("tools.".length);
+        }
+        const scoped = ns === undefined
             ? searchIndex
-            : searchIndex.filter((entry) => entry.description.path === request.namespace ||
-                entry.description.path.startsWith(`${request.namespace}.`));
+            : searchIndex.filter((entry) => entry.description.path === ns || entry.description.path.startsWith(`${ns}.`));
         const trimmed = query.trim();
         const pathQuery = trimmed.startsWith("tools.") ? trimmed.slice("tools.".length) : trimmed;
         const exact = pathQuery === ""
@@ -160,7 +166,7 @@ const makeSearchTool = (searchIndex) => ({
 /** Exact callable signature of the built-in `search` function, for host-owned instructions. */
 export const searchSignature = (() => {
     const tool = makeSearchTool([]);
-    return `search(input: ${inputTypeScript(tool, true)}): ${outputTypeScript(tool, true)}`;
+    return `search(${inputTypeScript(tool, true)}): ${outputTypeScript(tool, true)}`;
 })();
 const toSearchEntry = (visible) => ({
     description: describeTool(visible),

package/package.json

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