@opencode/codemode 2.0.11 → 2.0.13

package/dist/stdlib/collections.js

@@ -1,13 +1,13 @@
 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, isWrapper, Arr, IteratorObj, MapObj, Obj, PromiseObj, SetObj, } from "../interpreter/objects.js";
-import { describeValue, isRuntimeReference } from "../interpreter/references.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) => {
     if (value instanceof PromiseObj)
-        return Effect.succeed("[object Promise]");
-    if (!isWrapper(value) && isRuntimeReference(value)) {
+        return Effect.succeed(coerceToString(value));
+    if (isOpaque(value)) {
         throw invalidData(`Object.groupBy callback must return a data value, received ${describeValue(value)}.`);
     }
     return toPrimitiveString(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;
@@ -109,7 +109,6 @@ export const mapGlobal = (ctx) => {
     });
     define(map, "groupBy", groupBy(ctx, "Map"), hidden);
     const self = (thisValue, name) => receiver(MapObj, thisValue, `Map.prototype.${name}`);
-    const wrap = (items) => new Arr(builtins.Array, items);
     defineAccessor(proto, "size", (thisValue) => receiver(MapObj, thisValue, "Map.prototype.size").map.size);
     methods(builtins, proto, [
         ["get", 1, (thisValue, args) => self(thisValue, "get").map.get(args[0])],
@@ -123,6 +122,31 @@ export const mapGlobal = (ctx) => {
                 return target;
             },
         ],
+        [
+            "getOrInsert",
+            2,
+            (thisValue, args) => {
+                const target = self(thisValue, "getOrInsert").map;
+                if (!target.has(args[0]))
+                    target.set(args[0], args[1]);
+                return target.get(args[0]);
+            },
+        ],
+        [
+            "getOrInsertComputed",
+            2,
+            (thisValue, args) => {
+                const target = self(thisValue, "getOrInsertComputed").map;
+                const apply = applyCollectionCallback(ctx, args[1], "Map.getOrInsertComputed");
+                if (target.has(args[0]))
+                    return target.get(args[0]);
+                // The callback sees the stored key (-0 is +0) and its result wins over anything it inserted itself.
+                return Effect.map(apply([args[0] === 0 ? 0 : args[0]]), (value) => {
+                    target.set(args[0], value);
+                    return value;
+                });
+            },
+        ],
         ["delete", 1, (thisValue, args) => self(thisValue, "delete").map.delete(args[0])],
         [
             "clear",
@@ -132,15 +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")
-                .map.entries()
-                .map(([key, item]) => wrap([key, item]))),
-        ],
+        ["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,
@@ -148,7 +166,7 @@ export const mapGlobal = (ctx) => {
                 const target = self(thisValue, "forEach");
                 const apply = applyCollectionCallback(ctx, args[0], "Map.forEach");
                 return Effect.gen(function* () {
-                    for (const [key, item] of Array.from(target.map.entries()))
+                    for (const [key, item] of target.map.entries())
                         yield* apply([item, key, target]);
                     return undefined;
                 });
@@ -189,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.iterator);
-                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);
+                }
             }),
         };
     });
@@ -318,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]))),
         ],
@@ -334,7 +356,7 @@ export const setGlobal = (ctx) => {
                 const target = self(thisValue, "forEach");
                 const apply = applyCollectionCallback(ctx, args[0], "Set.forEach");
                 return Effect.gen(function* () {
-                    for (const item of Array.from(target.set.values()))
+                    for (const item of target.set.values())
                         yield* apply([item, item, target]);
                     return undefined;
                 });

package/dist/stdlib/console.d.ts

@@ -1,6 +1,6 @@
-import { Obj } from "../interpreter/objects.js";
+import { Obj, type Value } from "../interpreter/objects.js";
 import type { Interpreter } from "../interpreter/interpreter.js";
 /** Captured console: every method appends one formatted line to `logs`. */
 export declare const consoleGlobal: <R>(ctx: Interpreter<R>) => Obj;
 /** One value as `console.log` shows it. */
-export declare const formatValue: (value: unknown) => string;
+export declare const formatValue: (value: Value) => string;

package/dist/stdlib/console.js

@@ -1,7 +1,7 @@
 import { methods } from "../interpreter/native.js";
-import { entries, get, Arr, Bytes, DateObj, MapObj, Obj, PromiseObj, RegExpObj, SetObj, URLObj, URLSearchParamsObj, HeadersObj, } from "../interpreter/objects.js";
-import { containsOpaqueReference, isRuntimeReference } from "../interpreter/references.js";
-import { coerceToString } from "./value.js";
+import { entries, get, Arr, Obj } from "../interpreter/objects.js";
+import { ToolReference } from "../tool-runtime.js";
+import { containsOpaqueReference } from "../interpreter/references.js";
 const consoleMethods = ["log", "info", "debug", "warn", "error", "dir", "table"];
 /** Captured console: every method appends one formatted line to `logs`. */
 export const consoleGlobal = (ctx) => {
@@ -39,64 +39,20 @@ const formatConsoleValue = (value, seen, depth) => {
         return "null";
     if (typeof value === "string")
         return JSON.stringify(value);
-    if (typeof value === "number" || typeof value === "boolean")
-        return String(value);
-    if (typeof value !== "object")
-        return String(value);
-    if (value instanceof PromiseObj)
-        return "[Promise (await it to get its value)]";
-    if (value instanceof DateObj)
-        return coerceToString(value);
-    if (value instanceof RegExpObj)
-        return coerceToString(value);
-    if (value instanceof URLObj)
-        return coerceToString(value);
-    if (value instanceof URLSearchParamsObj)
-        return coerceToString(value);
-    if (value instanceof HeadersObj)
-        return `Headers ${JSON.stringify(Object.fromEntries(value.headers))}`;
-    if (value instanceof Bytes)
-        return `Uint8Array(${value.bytes.length}) [${value.bytes.join(",")}]`;
+    if (!(value instanceof Obj))
+        return value instanceof ToolReference ? "[opaque reference]" : String(value);
     if (depth > MAX_CONSOLE_DEPTH)
         return "...";
     if (seen.has(value))
         return "[Circular]";
-    if (value instanceof MapObj) {
-        seen.add(value);
-        try {
-            const items = Array.from(value.map.entries(), ([key, item]) => `[${formatItems([key, item], seen, depth + 1)}]`);
-            return `Map(${value.map.size}) [${items.join(",")}]`;
-        }
-        finally {
-            seen.delete(value);
-        }
-    }
-    if (value instanceof SetObj) {
-        seen.add(value);
-        try {
-            return `Set(${value.set.size}) [${formatItems([...value.set.values()], seen, depth + 1)}]`;
-        }
-        finally {
-            seen.delete(value);
-        }
-    }
-    if (isRuntimeReference(value))
-        return "[opaque reference]";
     seen.add(value);
     try {
-        if (value instanceof Arr)
-            return `[${formatItems(value.items, seen, depth + 1)}]`;
-        if (!(value instanceof Obj))
-            return "[object Object]";
-        return `{${entries(value)
-            .map(([key, item]) => `${JSON.stringify(key)}:${formatConsoleValue(item, seen, depth + 1)}`)
-            .join(",")}}`;
+        return value.inspect((item) => formatConsoleValue(item, seen, depth + 1));
     }
     finally {
         seen.delete(value);
     }
 };
-const formatItems = (items, seen, depth) => items.map((item) => formatConsoleValue(item, seen, depth)).join(",");
 const formatConsoleTable = (value, columnsArgument) => {
     if (value === undefined)
         return "undefined";

package/dist/stdlib/date.js

@@ -1,9 +1,8 @@
 import { Effect } from "effect";
 import { constructor, methods, prototypeFrom, receiver } from "../interpreter/native.js";
 import { rangeError } from "../interpreter/model.js";
-import { DateObj, Obj } from "../interpreter/objects.js";
+import { DateObj, Obj, coerceToNumber, coerceToString } from "../interpreter/objects.js";
 import { toPrimitive, toPrimitiveNumber } from "../interpreter/callback.js";
-import { coerceToNumber, coerceToString } from "./value.js";
 const constructDate = (ctx, args, proto) => {
     if (args.length === 0)
         return Effect.succeed(new DateObj(proto, Date.now()));
@@ -92,6 +91,11 @@ export const dateGlobal = (ctx) => {
         ["toTimeString", 0, (thisValue) => new Date(self(thisValue, "toTimeString").time).toTimeString()],
         ["toUTCString", 0, (thisValue) => new Date(self(thisValue, "toUTCString").time).toUTCString()],
         ["toGMTString", 0, (thisValue) => new Date(self(thisValue, "toGMTString").time).toUTCString()],
+        ...["toLocaleString", "toLocaleDateString", "toLocaleTimeString"].map((name) => [
+            name,
+            0,
+            (thisValue) => new Date(self(thisValue, name).time)[name]("en-US", { timeZone: "UTC" }),
+        ]),
         ...getters.map((name) => [name, 0, (thisValue) => new Date(self(thisValue, name).time)[name]()]),
         ...setters.map(([name, length]) => [
             name,

package/dist/stdlib/headers.js

@@ -1,10 +1,8 @@
 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 } 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 { isRuntimeReference } from "../interpreter/references.js";
-import { coerceToString } from "./value.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.
 const attempt = (run) => {
@@ -51,7 +49,8 @@ export const headersGlobal = (ctx) => {
             (thisValue, args) => {
                 requireArgs("append", args, 2);
                 const target = self(thisValue, "append").headers;
-                return attempt(() => target.append(arg(args, 0), arg(args, 1)));
+                attempt(() => target.append(arg(args, 0), arg(args, 1)));
+                return undefined;
             },
         ],
         [
@@ -60,7 +59,8 @@ export const headersGlobal = (ctx) => {
             (thisValue, args) => {
                 requireArgs("delete", args, 1);
                 const target = self(thisValue, "delete").headers;
-                return attempt(() => target.delete(arg(args, 0)));
+                attempt(() => target.delete(arg(args, 0)));
+                return undefined;
             },
         ],
         [
@@ -88,25 +88,13 @@ export const headersGlobal = (ctx) => {
             (thisValue, args) => {
                 requireArgs("set", args, 2);
                 const target = self(thisValue, "set").headers;
-                return attempt(() => target.set(arg(args, 0), arg(args, 1)));
+                attempt(() => target.set(arg(args, 0), arg(args, 1)));
+                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, Iterator.from(self(thisValue, "entries").headers.entries()).map(([key, value]) => wrap([key, value]))),
-        ],
+        ["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").iterator.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;
 };