@opencode/codemode 0.0.0-dev-19878 → 0.0.0-dev-19882

package/dist/interpreter/extensions.js

@@ -5,7 +5,7 @@ import { createErrorValue, isErrorType } from "./intrinsics.js";
 import { MAX_VALUE_DEPTH } from "./limits.js";
 import { PendingThrow, Throw, typeError } from "./model.js";
 import { fn } from "./native.js";
-import { Callable, define, entries, get, has, hidden, keys, Arr, Bytes, DateObj, ErrorObj, GeneratorObj, MapObj, Obj, PromiseObj, RegExpObj, SetObj, URLObj, URLSearchParamsObj, HeadersObj, } from "./objects.js";
+import { Callable, define, entries, get, has, hidden, keys, Arr, Bytes, DateObj, ErrorObj, GeneratorObj, IteratorObj, MapObj, Obj, PromiseObj, RegExpObj, SetObj, URLObj, URLSearchParamsObj, HeadersObj, } from "./objects.js";
 import { describeValue } from "./references.js";
 /**
  * The global bindings of one run's extensions. Everything crossing the boundary is converted: plain data and
@@ -42,6 +42,7 @@ export const extensionGlobals = (ctx, extensions) => {
         if (!(value instanceof Obj) ||
             value instanceof Callable ||
             value instanceof GeneratorObj ||
+            value instanceof IteratorObj ||
             value instanceof PromiseObj) {
             throw typeError(`${label} contains ${describeValue(value)}, which cannot be passed to an extension.`);
         }

package/dist/interpreter/globals.js

@@ -12,6 +12,7 @@ import { regexpGlobal } from "../stdlib/regexp.js";
 import { stringGlobal } from "../stdlib/string.js";
 import { uriGlobal, urlGlobal, urlSearchParamsGlobal } from "../stdlib/url.js";
 import { headersGlobal } from "../stdlib/headers.js";
+import { iteratorGlobals } from "../stdlib/iterator.js";
 import { coercion } from "../stdlib/value.js";
 import { base64Global, cryptoGlobal } from "../stdlib/web.js";
 import { ToolReference } from "../tool-runtime.js";
@@ -90,5 +91,6 @@ 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.js

@@ -5,7 +5,7 @@ import { AsyncIteratorSymbol, CallSite, GeneratorReturn, IteratorSymbol, Optiona
 import { checkStringLength } from "./limits.js";
 import { locate, materialize } from "./errors.js";
 import { globals } from "./globals.js";
-import { assign, Callable, define, get, has, hasPrototype, keys, Native, parseArrayIndex, Arr, Bytes, DateObj, Fn, GeneratorObj, MapObj, Obj, PromiseObj, SetObj, URLSearchParamsObj, HeadersObj, record, remove, set, } from "./objects.js";
+import { assign, Callable, define, get, has, hasPrototype, keys, Native, parseArrayIndex, Arr, Bytes, DateObj, Fn, GeneratorObj, IteratorObj, MapObj, Obj, PromiseObj, SetObj, URLSearchParamsObj, HeadersObj, record, remove, set, } from "./objects.js";
 import { preserveConsumerError } from "./callback.js";
 import { Pending, resolvePromise, resolvePromiseValue } from "./promises.js";
 import { containsOpaqueReference, describeValue, rejectCircularInsertion, typeofValue } from "./references.js";
@@ -477,8 +477,8 @@ class Frame {
             if (declared?.lexical)
                 self.predeclarePattern(declared.pattern, declared.mutable, left);
             const right = yield* self.evaluateExpression(node.right);
-            const iterator = yield* self.customIterator(right, node, awaiting);
-            const cursor = iterator === undefined ? yield* self.iterate(right, node) : undefined;
+            const cursor = self.hostCursor(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 array, string, Map, Set, URLSearchParams, or Headers, or custom iterator value.`, node);
             }
@@ -550,6 +550,18 @@ class Frame {
         });
     }
     iterate(value, node) {
+        const cursor = this.hostCursor(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)),
+            });
+    }
+    hostCursor(value) {
         const iterator = value instanceof Arr
             ? value.items[Symbol.iterator]()
             : typeof value === "string"
@@ -564,27 +576,22 @@ class Frame {
                                 ? value.headers.entries()
                                 : value instanceof Bytes
                                     ? value.bytes.values()
-                                    : undefined;
-        if (iterator !== undefined) {
-            const proto = this.ctx.builtins.Array;
-            return Effect.succeed({
-                next: Effect.sync(() => {
-                    const step = iterator.next();
-                    return {
-                        done: Boolean(step.done),
-                        value: Array.isArray(step.value) ? new Arr(proto, step.value) : step.value,
-                    };
-                }),
-                close: Effect.void,
-            });
-        }
-        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)),
-            });
+                                    : value instanceof IteratorObj
+                                        ? value.iterator
+                                        : undefined;
+        if (iterator === undefined)
+            return undefined;
+        const proto = this.ctx.builtins.Array;
+        return {
+            next: Effect.sync(() => {
+                const step = iterator.next();
+                return {
+                    done: Boolean(step.done),
+                    value: Array.isArray(step.value) ? new Arr(proto, step.value) : step.value,
+                };
+            }),
+            close: Effect.void,
+        };
     }
     customIterator(value, node, allowAsync = true) {
         if (!(value instanceof Obj))

package/dist/interpreter/objects.d.ts

@@ -81,6 +81,11 @@ export declare class GeneratorObj extends Obj {
     readonly request: (kind: GeneratorRequestKind, value: unknown) => Effect.Effect<unknown, unknown, unknown>;
     constructor(proto: Obj, asynchronous: boolean, request: (kind: GeneratorRequestKind, value: unknown) => Effect.Effect<unknown, unknown, unknown>);
 }
+/** A built-in collection iterator: live over the host collection, yielding program values. */
+export declare class IteratorObj extends Obj {
+    readonly iterator: IteratorObject<unknown>;
+    constructor(proto: Obj, iterator: IteratorObject<unknown>);
+}
 export declare class DateObj extends Obj {
     time: number;
     constructor(proto: Obj, time: number);

package/dist/interpreter/objects.js

@@ -78,6 +78,14 @@ export class GeneratorObj extends Obj {
         this.request = request;
     }
 }
+/** A built-in collection iterator: live over the host collection, yielding program values. */
+export class IteratorObj extends Obj {
+    iterator;
+    constructor(proto, iterator) {
+        super(proto);
+        this.iterator = iterator;
+    }
+}
 export class DateObj extends Obj {
     time;
     constructor(proto, time) {

package/dist/interpreter/references.js

@@ -1,9 +1,10 @@
 import { ToolReference } from "../tool-runtime.js";
 import { invalidData } from "./model.js";
-import { Callable, getOwn, isWrapper, ownKeys, Arr, Bytes, DateObj, GeneratorObj, MapObj, Obj, PromiseObj, RegExpObj, SetObj, URLObj, URLSearchParamsObj, HeadersObj, } from "./objects.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);
@@ -69,6 +70,8 @@ export const describeValue = (value) => {
         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")

package/dist/stdlib/array.js

@@ -1,8 +1,8 @@
 import { Effect } from "effect";
 import { constructor, methods, prototypeFrom, receiver } from "../interpreter/native.js";
 import { checkArrayLength, checkStringLength, MAX_ARRAY_LENGTH } from "../interpreter/limits.js";
-import { invalidData, rangeError, typeError } from "../interpreter/model.js";
-import { get, Arr, GeneratorObj, Obj } from "../interpreter/objects.js";
+import { invalidData, IteratorSymbol, rangeError, typeError } from "../interpreter/model.js";
+import { define, get, hidden, Arr, GeneratorObj, IteratorObj, Obj } from "../interpreter/objects.js";
 import { describeValue, rejectCircularInsertion } from "../interpreter/references.js";
 import { applyCollectionCallback, preserveConsumerError } from "../interpreter/callback.js";
 import { compareText } from "../tool-runtime.js";
@@ -317,12 +317,14 @@ export const arrayGlobal = (ctx) => {
                 return target;
             },
         ],
-        ["keys", 0, (thisValue) => wrap(Array.from(self(thisValue, "keys").items.keys()))],
-        ["values", 0, (thisValue) => wrap([...self(thisValue, "values").items])],
+        ["keys", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "keys").items.keys())],
+        ["values", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "values").items.values())],
         [
             "entries",
             0,
-            (thisValue) => wrap(Array.from(self(thisValue, "entries").items.entries(), ([index, item]) => wrap([index, item]))),
+            (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "entries")
+                .items.entries()
+                .map(([index, item]) => wrap([index, item]))),
         ],
         iterate("map", 1, (target, receiver, apply) => Effect.gen(function* () {
             const length = target.length;
@@ -461,5 +463,6 @@ export const arrayGlobal = (ctx) => {
             return accumulator;
         })),
     ]);
+    define(proto, IteratorSymbol, get(proto, "values"), hidden);
     return array;
 };

package/dist/stdlib/bytes.js

@@ -1,8 +1,8 @@
 import { Effect } from "effect";
 import { checkArrayLength, checkStringLength } from "../interpreter/limits.js";
 import { constructor, methods, prototypeFrom, receiver, requiresNew } from "../interpreter/native.js";
-import { rangeError, syntaxError, typeError } from "../interpreter/model.js";
-import { defineAccessor, get, Arr, Bytes, Obj } from "../interpreter/objects.js";
+import { IteratorSymbol, rangeError, syntaxError, typeError } from "../interpreter/model.js";
+import { define, defineAccessor, get, hidden, Arr, Bytes, IteratorObj, Obj } 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. */
@@ -152,14 +152,17 @@ 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) => wrapAll(Array.from(self(thisValue, "keys").bytes.keys()))],
-        ["values", 0, (thisValue) => wrapAll(Array.from(self(thisValue, "values").bytes.values()))],
+        ["keys", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "keys").bytes.keys())],
+        ["values", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "values").bytes.values())],
         [
             "entries",
             0,
-            (thisValue) => wrapAll(Array.from(self(thisValue, "entries").bytes.entries(), ([index, byte]) => wrapAll([index, byte]))),
+            (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "entries")
+                .bytes.entries()
+                .map(([index, byte]) => wrapAll([index, byte]))),
         ],
     ]);
+    define(proto, IteratorSymbol, get(proto, "values"), hidden);
     return uint8Array;
 };
 export const textEncoderGlobal = (ctx) => {

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, typeError } from "../interpreter/model.js";
-import { define, defineAccessor, get, getOwn, hidden, isWrapper, Arr, MapObj, Obj, PromiseObj, SetObj, } from "../interpreter/objects.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 { applyCollectionCallback, isSupportedCallback, preserveConsumerError, toPrimitiveNumber, toPrimitiveString, } from "../interpreter/callback.js";
 const coerceGroupByPropertyKey = (ctx, value) => {
@@ -132,12 +132,14 @@ export const mapGlobal = (ctx) => {
                 return undefined;
             },
         ],
-        ["keys", 0, (thisValue) => wrap(Array.from(self(thisValue, "keys").map.keys()))],
-        ["values", 0, (thisValue) => wrap(Array.from(self(thisValue, "values").map.values()))],
+        ["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) => wrap(Array.from(self(thisValue, "entries").map.entries(), ([key, item]) => wrap([key, item]))),
+            (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "entries")
+                .map.entries()
+                .map(([key, item]) => wrap([key, item]))),
         ],
         [
             "forEach",
@@ -153,6 +155,7 @@ export const mapGlobal = (ctx) => {
             },
         ],
     ]);
+    define(proto, IteratorSymbol, get(proto, "entries"), hidden);
     return map;
 };
 const loadSetRecord = (ctx, source, name) => {
@@ -187,6 +190,8 @@ const loadSetRecord = (ctx, source, name) => {
             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.`);
@@ -313,12 +318,14 @@ export const setGlobal = (ctx) => {
                 return undefined;
             },
         ],
-        ["keys", 0, (thisValue) => wrap(Array.from(self(thisValue, "keys").set.values()))],
-        ["values", 0, (thisValue) => wrap(Array.from(self(thisValue, "values").set.values()))],
+        ["keys", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "keys").set.values())],
+        ["values", 0, (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "values").set.values())],
         [
             "entries",
             0,
-            (thisValue) => wrap(Array.from(self(thisValue, "entries").set.values(), (item) => wrap([item, item]))),
+            (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "entries")
+                .set.values()
+                .map((item) => wrap([item, item]))),
         ],
         [
             "forEach",
@@ -341,5 +348,6 @@ export const setGlobal = (ctx) => {
         operation("isSupersetOf"),
         operation("isDisjointFrom"),
     ]);
+    define(proto, IteratorSymbol, get(proto, "values"), hidden);
     return set;
 };

package/dist/stdlib/headers.js

@@ -1,7 +1,7 @@
 import { Effect } from "effect";
 import { constructor, methods, prototypeFrom, receiver, requiresNew } from "../interpreter/native.js";
-import { typeError } from "../interpreter/model.js";
-import { entries, Arr, HeadersObj, Obj } from "../interpreter/objects.js";
+import { IteratorSymbol, typeError } from "../interpreter/model.js";
+import { define, entries, get, hidden, Arr, HeadersObj, IteratorObj, Obj } from "../interpreter/objects.js";
 import { applyCollectionCallback } from "../interpreter/callback.js";
 import { isRuntimeReference } from "../interpreter/references.js";
 import { coerceToString } from "./value.js";
@@ -91,12 +91,21 @@ export const headersGlobal = (ctx) => {
                 return attempt(() => target.set(arg(args, 0), arg(args, 1)));
             },
         ],
-        ["keys", 0, (thisValue) => wrap(Array.from(self(thisValue, "keys").headers.keys()))],
-        ["values", 0, (thisValue) => wrap(Array.from(self(thisValue, "values").headers.values()))],
+        // 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) => wrap(Array.from(self(thisValue, "entries").headers.entries(), ([key, value]) => wrap([key, value]))),
+            (thisValue) => new IteratorObj(builtins.Iterator, Iterator.from(self(thisValue, "entries").headers.entries()).map(([key, value]) => wrap([key, value]))),
         ],
         [
             "forEach",
@@ -113,5 +122,6 @@ export const headersGlobal = (ctx) => {
             },
         ],
     ]);
+    define(proto, IteratorSymbol, get(proto, "entries"), hidden);
     return headers;
 };

package/dist/stdlib/iterator.d.ts

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

package/dist/stdlib/iterator.js

@@ -0,0 +1,17 @@
+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
+// observable through getPrototypeOf.
+export const iteratorGlobals = (ctx) => {
+    const builtins = ctx.builtins;
+    methods(builtins, builtins.Iterator, [
+        [
+            "next",
+            0,
+            (thisValue) => {
+                const step = receiver(IteratorObj, thisValue, "Iterator.prototype.next").iterator.next();
+                return record(builtins.Object, { value: step.value, done: Boolean(step.done) });
+            },
+        ],
+    ]);
+};

package/dist/stdlib/string.js

@@ -1,8 +1,8 @@
 import { Effect } from "effect";
-import { constructor, methods } from "../interpreter/native.js";
+import { constructor, fn, methods } from "../interpreter/native.js";
 import { checkArrayLength, checkStringLength } from "../interpreter/limits.js";
-import { invalidData, rangeError, typeError } from "../interpreter/model.js";
-import { Arr, PromiseObj, RegExpObj, record } from "../interpreter/objects.js";
+import { invalidData, IteratorSymbol, rangeError, typeError } from "../interpreter/model.js";
+import { define, hidden, Arr, IteratorObj, PromiseObj, RegExpObj, record } from "../interpreter/objects.js";
 import { containsOpaqueReference, typeofValue } from "../interpreter/references.js";
 import { applyCollectionCallback, isSupportedCallback } from "../interpreter/callback.js";
 import { matchToValue, toHostRegex } from "./regexp.js";
@@ -232,5 +232,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);
     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 { PendingThrow, typeError, uriError } from "../interpreter/model.js";
-import { defineAccessor, entries, isWrapper, Arr, Obj, URLObj, URLSearchParamsObj } from "../interpreter/objects.js";
+import { IteratorSymbol, PendingThrow, typeError, uriError } from "../interpreter/model.js";
+import { define, defineAccessor, entries, get, hidden, isWrapper, Arr, IteratorObj, Obj, URLObj, URLSearchParamsObj, } from "../interpreter/objects.js";
 import { isRuntimeReference } from "../interpreter/references.js";
 import { applyCollectionCallback, preserveConsumerError } from "../interpreter/callback.js";
 import { coerceToString } from "./value.js";
@@ -237,12 +237,14 @@ export const urlSearchParamsGlobal = (ctx) => {
                 return undefined;
             },
         ],
-        ["keys", 0, (thisValue) => wrap(Array.from(self(thisValue, "keys").params.keys()))],
-        ["values", 0, (thisValue) => wrap(Array.from(self(thisValue, "values").params.values()))],
+        ["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) => wrap(Array.from(self(thisValue, "entries").params.entries(), ([key, value]) => wrap([key, value]))),
+            (thisValue) => new IteratorObj(builtins.Iterator, self(thisValue, "entries")
+                .params.entries()
+                .map(([key, value]) => wrap([key, value]))),
         ],
         ["toString", 0, (thisValue) => self(thisValue, "toString").params.toString()],
         [
@@ -260,5 +262,6 @@ export const urlSearchParamsGlobal = (ctx) => {
             },
         ],
     ]);
+    define(proto, IteratorSymbol, get(proto, "entries"), hidden);
     return searchParams;
 };

package/package.json

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