poe-code 14.0.69 → 14.0.70

package/packages/safe-js/dist/chunks/{chunk-KLAZUIHL.js → chunk-DUCQNFXN.js}

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-KHKBLB42.js";
+} from "./chunk-BTIHHHII.js";
 import {
   createFileSystem,
   createNodeFileSystemAdapterRegistry,
@@ -8249,4 +8249,4 @@ export {
   parseMcpConfig,
   makeMcpModule
 };
-//# sourceMappingURL=chunk-KLAZUIHL.js.map
+//# sourceMappingURL=chunk-DUCQNFXN.js.map

package/packages/safe-js/dist/cli.js

@@ -22,7 +22,7 @@ import {
   resolveFsConfig,
   splitFrontmatter,
   withBrokenPipeGuard
-} from "./chunks/chunk-KLAZUIHL.js";
+} from "./chunks/chunk-DUCQNFXN.js";
 import {
   Budget,
   SandboxError,
@@ -34,7 +34,7 @@ import {
   replaceErrorStack,
   restore,
   run
-} from "./chunks/chunk-KHKBLB42.js";
+} from "./chunks/chunk-BTIHHHII.js";
 import "./chunks/chunk-ZWJ5BJUI.js";
 import "./chunks/chunk-3YTQEPZI.js";
 import "./chunks/chunk-4YIDX44G.js";

package/packages/safe-js/dist/core.js

@@ -5,7 +5,7 @@ import {
   defineExtension,
   lint,
   run
-} from "./chunks/chunk-KHKBLB42.js";
+} from "./chunks/chunk-BTIHHHII.js";
 import "./chunks/chunk-4YIDX44G.js";
 export {
   Budget,

package/packages/safe-js/dist/index.js

@@ -26,7 +26,7 @@ import {
   runWithSpawnUsageAccumulator,
   splitFrontmatter,
   supportsSpawnMode
-} from "./chunks/chunk-KLAZUIHL.js";
+} from "./chunks/chunk-DUCQNFXN.js";
 import {
   Budget,
   FileSnapshotBackend,
@@ -50,7 +50,7 @@ import {
   registerPendingHostCallPolicy,
   restore,
   run
-} from "./chunks/chunk-KHKBLB42.js";
+} from "./chunks/chunk-BTIHHHII.js";
 import "./chunks/chunk-ZWJ5BJUI.js";
 import "./chunks/chunk-3YTQEPZI.js";
 import "./chunks/chunk-4YIDX44G.js";

package/packages/safe-js/dist/interp/cancel.d.ts

@@ -6,3 +6,4 @@ export declare function wrapCancelableBindings(bindings: Record<string, SandboxV
 export declare function registerPromiseCancellation(promise: SandboxPromise): void;
 export declare function readPromiseCancellation(promise: SandboxPromise, original: Promise<SandboxValue>): Promise<SandboxValue>;
 export declare function awaitSandboxValue(value: SandboxValue, signal?: AbortSignal, budget?: Budget): Promise<SandboxValue>;
+export declare function awaitWithSignal<T>(promise: PromiseLike<T>, signal?: AbortSignal): Promise<T>;

package/packages/safe-js/dist/interp/cancel.js

@@ -142,7 +142,7 @@ export function awaitSandboxValue(value, signal, budget) {
         : awaitWithSignal(resolved, signal);
     return isSandboxPromise(value) ? pending : interruptOnFatalPromiseRejection(pending);
 }
-function awaitWithSignal(promise, signal) {
+export function awaitWithSignal(promise, signal) {
     if (signal === undefined)
         return Promise.resolve(promise);
     if (signal.aborted) {

package/packages/safe-js/dist/interp/interpreter.js

@@ -23,7 +23,7 @@ import { assertSandboxDataDepth } from "../graph-depth.js";
 import { callMapMethod, getMapMember, isMapMethodName } from "./methods/map.js";
 import { callNumberMethod, getNumberMember, isNumberMethodName } from "./methods/number.js";
 import { getPromiseMember, isSandboxPromiseConstructor } from "./promise.js";
-import { generatorIterator, getSandboxIterator } from "./iteration.js";
+import { closeIterator, getSandboxAsyncIterator, getSandboxIterator } from "./iteration.js";
 import { assertCollectionMutable } from "./running-state.js";
 import { getGeneratorMember } from "./methods/generator.js";
 import { getRegexMember, isRegexMethodName, setRegexMember } from "./methods/regex.js";
@@ -1116,7 +1116,7 @@ async function evaluateForOfStatement(node, context) {
         const restored = context.scope.consumeRestoredBinding(restoredIteration.values[0]);
         if (restored.found && Array.isArray(restored.value)) {
             restoredEntry = { done: false, value: restored.value[1] };
-            if (isSandboxMap(restored.value[0]) || isSandboxSet(restored.value[0]) || isSandboxCollectionIterator(restored.value[0])) {
+            if (Array.isArray(restored.value[0]) || isSandboxMap(restored.value[0]) || isSandboxSet(restored.value[0]) || isSandboxCollectionIterator(restored.value[0])) {
                 return evaluateForOfIterator(node, restored.value[0], context, restoredEntry);
             }
         }
@@ -1125,7 +1125,7 @@ async function evaluateForOfStatement(node, context) {
     if (iterable.kind !== "normal") {
         return iterable;
     }
-    const values = snapshotableIterationValues(iterable.value);
+    const values = node.await ? undefined : snapshotableIterationValues(iterable.value);
     if (values === undefined) {
         return evaluateForOfIterator(node, iterable.value, context, restoredEntry);
     }
@@ -1164,16 +1164,31 @@ async function evaluateForOfStatement(node, context) {
     };
 }
 async function evaluateForOfIterator(node, value, context, restoredEntry) {
-    const iterator = getSandboxIterator(value, context.budget, createCoercionContext(context));
+    const iterator = node.await
+        ? getSandboxAsyncIterator(value, context.budget, createCoercionContext(context), context.signal)
+        : getSandboxIterator(value, context.budget, createCoercionContext(context));
     if (iterator === undefined) {
         throw new TypeError(`${String(value)} is not a supported iterable`);
     }
+    const nextIteration = async () => {
+        const pending = Promise.resolve(iterator.next());
+        if (!node.await)
+            return pending;
+        context.onSuspend?.();
+        const leaveAwait = context.budget.enterAwait();
+        try {
+            return await suspendJob(pending);
+        }
+        finally {
+            leaveAwait();
+        }
+    };
     const releaseIterator = retainValues(context.budget, () => [value, iterator.retainedValue]);
     try {
         const nodeId = node.nodeId ?? -1;
         let index = consumeRestoredLoopIterationIndex(node, context);
         for (let skipped = 0; skipped < index; skipped += 1) {
-            const skippedIteration = await iterator.next();
+            const skippedIteration = await nextIteration();
             if (typeof skippedIteration !== "object" || skippedIteration === null) {
                 throw new TypeError("Iterator result must be an object.");
             }
@@ -1182,7 +1197,7 @@ async function evaluateForOfIterator(node, value, context, restoredEntry) {
             }
         }
         while (true) {
-            const iteration = restoredEntry ?? (await iterator.next());
+            const iteration = restoredEntry ?? (await nextIteration());
             restoredEntry = undefined;
             if (typeof iteration !== "object" || iteration === null) {
                 throw new TypeError("Iterator result must be an object.");
@@ -1497,7 +1512,7 @@ function createLoopIterationContext(context, scope) {
             snapshot.loopIterations = {};
             for (const [nodeId, iteration] of context.activeLoopIterations) {
                 if (typeof iteration !== "number" &&
-                    (isSandboxMap(iteration.values[0]) || isSandboxSet(iteration.values[0]) || isSandboxCollectionIterator(iteration.values[0]))) {
+                    (Array.isArray(iteration.values[0]) || isSandboxMap(iteration.values[0]) || isSandboxSet(iteration.values[0]) || isSandboxCollectionIterator(iteration.values[0]))) {
                     const bindingName = `#for-of:${nodeId}`;
                     snapshot.bindings[bindingName] = iteration.values;
                     snapshot.loopIterations[nodeId] = { index: iteration.index, values: [bindingName] };
@@ -1614,7 +1629,7 @@ async function evaluateYieldExpression(node, context) {
     return generatorCompletionResult(completion);
 }
 async function yieldGeneratorValue(value, node, context) {
-    if (context.asyncGenerator)
+    if (context.asyncGenerator && !node.delegate)
         value = await suspendJob(awaitSandboxValue(value, context.signal, context.budget));
     const completionPromise = context.generatorYield(allocateProducedSandboxValue(value, context.budget), node.nodeId);
     emitResumeBreakpoint(context, {
@@ -1638,10 +1653,9 @@ async function evaluateYieldDelegate(node, context) {
     if (argument.kind !== "normal") {
         return argument;
     }
-    const asyncDelegate = context.asyncGenerator && isSandboxGenerator(argument.value) && argument.value.async
-        ? argument.value : undefined;
-    const iterator = asyncDelegate
-        ? generatorIterator(asyncDelegate, context.budget) : getSandboxIterator(argument.value, context.budget, createCoercionContext(context));
+    const iterator = context.asyncGenerator
+        ? getSandboxAsyncIterator(argument.value, context.budget, createCoercionContext(context), context.signal)
+        : getSandboxIterator(argument.value, context.budget, createCoercionContext(context));
     if (iterator === undefined) {
         throw new TypeError(`${String(argument.value)} is not a supported iterable`);
     }
@@ -1672,19 +1686,7 @@ async function evaluateYieldDelegate(node, context) {
                 throw new TypeError("Iterator result must be an object.");
             }
             const done = result.done;
-            let value = result.value;
-            if (context.asyncGenerator) {
-                try {
-                    value = await suspendJob(awaitSandboxValue(value, context.signal, context.budget));
-                }
-                catch (error) {
-                    if (isFatalSandboxError(error) || error instanceof HostCallResumabilityError)
-                        throw error;
-                    if (!asyncDelegate && !done && method !== "return")
-                        await closeIterator(iterator, true);
-                    throw error;
-                }
-            }
+            const value = result.value;
             if (done) {
                 if (completion.type === "return") {
                     return generatorCompletionResult({ type: "return", value });
@@ -2937,23 +2939,6 @@ function describeObjectSpreadValue(value) {
     }
     return typeof value;
 }
-async function closeIterator(iterator, preserveThrow = false) {
-    try {
-        const close = iterator.return;
-        if (close === undefined)
-            return;
-        const returned = close();
-        const result = iterator.generator || iterator.asynchronous ? await returned : returned;
-        if ((typeof result !== "object" && typeof result !== "function") || result === null) {
-            throw new TypeError("Iterator return result must be an object.");
-        }
-    }
-    catch (error) {
-        if (!preserveThrow || isFatalSandboxError(error) || error instanceof HostCallResumabilityError) {
-            throw error;
-        }
-    }
-}
 function defineSandboxProperty(target, key, value) {
     Object.defineProperty(target, key, {
         configurable: true,

package/packages/safe-js/dist/interp/iteration.d.ts

@@ -1,6 +1,7 @@
 import { type SandboxGenerator, type SandboxCallContext, type SandboxValue } from "./values.js";
 import { Budget } from "./budget.js";
 export type SandboxIterator = {
+    readonly asyncProtocol?: true;
     readonly generator?: true;
     readonly asynchronous?: true;
     readonly retainedValue?: SandboxValue;
@@ -9,5 +10,7 @@ export type SandboxIterator = {
     return?(value?: SandboxValue): IteratorResult<SandboxValue> | Promise<IteratorResult<SandboxValue>>;
     throw?(error?: SandboxValue): IteratorResult<SandboxValue> | Promise<IteratorResult<SandboxValue>>;
 };
+export declare function getSandboxAsyncIterator(value: SandboxValue, budget: Budget, context?: SandboxCallContext, signal?: AbortSignal): SandboxIterator | undefined;
+export declare function closeIterator(iterator: SandboxIterator, preserveThrow?: boolean): Promise<void>;
 export declare function getSandboxIterator(value: SandboxValue, budget?: Budget, context?: SandboxCallContext): SandboxIterator | undefined;
 export declare function generatorIterator(generator: SandboxGenerator, budget?: Budget): SandboxIterator;

package/packages/safe-js/dist/interp/iteration.js

@@ -4,9 +4,110 @@ import { isFloat32Array } from "./float32.js";
 import { boxedValue, isSandboxBox } from "./boxed.js";
 import { getHostObjectIterator, isGuestHostObject } from "./host-capabilities.js";
 import { isSandboxCollectionIterator, nextCollectionIterator } from "./collection-iterator.js";
-import { Budget } from "./budget.js";
+import { Budget, isFatalSandboxError } from "./budget.js";
 import { sandboxString } from "./string-coercion.js";
-import { awaitSandboxValue } from "./cancel.js";
+import { awaitSandboxValue, awaitWithSignal } from "./cancel.js";
+import { HostCallResumabilityError } from "./host-call.js";
+import { suspendJob } from "./jobs.js";
+export function getSandboxAsyncIterator(value, budget, context, signal) {
+    if (isSandboxGenerator(value) && value.async) {
+        return { ...generatorIterator(value, budget), asyncProtocol: true };
+    }
+    if (value !== null && (typeof value === "object" || typeof value === "function") && !isGuestHostObject(value)) {
+        const method = value[Symbol.asyncIterator];
+        if (method !== undefined && method !== null) {
+            if (typeof method !== "function")
+                throw new TypeError("Async iterator method must be callable.");
+            const iterator = Reflect.apply(method, value, []);
+            if ((typeof iterator !== "object" && typeof iterator !== "function") || iterator === null) {
+                throw new TypeError("Async iterator must be an object.");
+            }
+            const next = iterator.next;
+            const invoke = async (operation, args) => {
+                if (typeof operation !== "function")
+                    throw new TypeError("Async iterator operation must be callable.");
+                const pending = Promise.resolve(Reflect.apply(operation, iterator, args)).then(result => ({ result }));
+                const { result } = await awaitWithSignal(pending, signal);
+                if ((typeof result !== "object" && typeof result !== "function") || result === null) {
+                    throw new TypeError("Iterator result must be an object.");
+                }
+                // Keep protocol reads lazy without re-assimilating the result's `then` property.
+                return {
+                    get done() { return result.done; },
+                    get value() { return result.value; }
+                };
+            };
+            return {
+                asyncProtocol: true,
+                retainedValue: value,
+                next: (...args) => invoke(next, args),
+                get return() {
+                    const operation = iterator.return;
+                    return operation === undefined || operation === null ? undefined : (...args) => invoke(operation, args);
+                },
+                get throw() {
+                    const operation = iterator.throw;
+                    return operation === undefined || operation === null ? undefined : (...args) => invoke(operation, args);
+                }
+            };
+        }
+    }
+    const iterator = getSandboxIterator(value, budget, context);
+    if (iterator === undefined)
+        return undefined;
+    const invoke = async (method, args) => {
+        const operation = iterator[method];
+        if (operation === undefined) {
+            if (method === "throw") {
+                await closeIterator(iterator);
+                throw new TypeError("Delegated iterator does not provide a throw method.");
+            }
+            return { done: true, value: args[0] };
+        }
+        const returned = operation(...args);
+        const result = iterator.generator || iterator.asynchronous ? await returned : returned;
+        if ((typeof result !== "object" && typeof result !== "function") || result === null) {
+            throw new TypeError("Iterator result must be an object.");
+        }
+        const done = Boolean(result.done);
+        const resultValue = result.value;
+        try {
+            return { done, value: await awaitSandboxValue(resultValue, signal, budget) };
+        }
+        catch (error) {
+            if (isFatalSandboxError(error) || error instanceof HostCallResumabilityError)
+                throw error;
+            if (!done && method !== "return")
+                await closeIterator(iterator, true);
+            throw error;
+        }
+    };
+    return {
+        asyncProtocol: true,
+        snapshotIndex: iterator.snapshotIndex,
+        get retainedValue() { return iterator.retainedValue; },
+        next: (...args) => invoke("next", args),
+        return: (...args) => invoke("return", args),
+        throw: (...args) => invoke("throw", args)
+    };
+}
+export async function closeIterator(iterator, preserveThrow = false) {
+    try {
+        const close = iterator.return;
+        if (close === undefined)
+            return;
+        const returned = close();
+        const result = iterator.asyncProtocol ? await suspendJob(Promise.resolve(returned))
+            : iterator.generator || iterator.asynchronous ? await returned : returned;
+        if ((typeof result !== "object" && typeof result !== "function") || result === null) {
+            throw new TypeError("Iterator return result must be an object.");
+        }
+    }
+    catch (error) {
+        if (!preserveThrow || isFatalSandboxError(error) || error instanceof HostCallResumabilityError)
+            throw error;
+    }
+}
 export function getSandboxIterator(value, budget, context) {
     if (isSandboxBox(value) && typeof boxedValue(value) === "string") {
         const primitive = boxedValue(value);

package/packages/safe-js/dist/lint/rules/AS-async-not-needed.js

@@ -437,7 +437,8 @@ function statementContainsAwait(node) {
                 statementContainsAwait(node.body));
         case "ForInStatement":
         case "ForOfStatement":
-            return ((node.left.type === "VariableDeclaration" && variableDeclarationContainsAwait(node.left)) ||
+            return ((node.type === "ForOfStatement" && node.await === true) ||
+                (node.left.type === "VariableDeclaration" && variableDeclarationContainsAwait(node.left)) ||
                 (node.left.type !== "VariableDeclaration" && assignmentTargetContainsAwait(node.left)) ||
                 expressionContainsAwait(node.right) ||
                 statementContainsAwait(node.body));

package/packages/safe-js/dist/parse/parser.d.ts

@@ -305,6 +305,7 @@ export type ForStatement = BaseNode & {
 };
 export type ForOfStatement = BaseNode & {
     type: "ForOfStatement";
+    await?: boolean;
     left: PatternTarget | VariableDeclaration;
     right: Expression;
     body: Statement;

package/packages/safe-js/dist/parse/parser.js

@@ -121,7 +121,7 @@ class Parser {
     scopes = [new Map()];
     functionScopes = new WeakSet();
     varNames = new WeakMap();
-    constructor(tokens, source, compilation, functionContext = "normal", lexicalContext = { ...ordinaryFunctionContext, newTarget: false }) {
+    constructor(tokens, source, compilation, functionContext = "top-level", lexicalContext = { ...ordinaryFunctionContext, newTarget: false }) {
         this.tokens = tokens;
         this.source = source;
         this.compilation = compilation;
@@ -283,7 +283,7 @@ class Parser {
         this.expectPunctuator("=>");
         const body = this.withLexicalContext({
             ...this.lexicalContext, return: true, await: isAsync || this.lexicalContext.strictAwait !== true
-        }, () => this.parseArrowFunctionBody(params));
+        }, () => this.parseArrowFunctionBody(params, isAsync));
         return this.withFunctionSource({
             type: "ArrowFunctionExpression",
             async: isAsync,
@@ -322,11 +322,11 @@ class Parser {
             this.conditionalExpressionDepth -= 1;
         }
     }
-    parseArrowFunctionBody(params) {
+    parseArrowFunctionBody(params, async) {
         if (this.currentToken().type === "punctuator" && this.currentToken().value === "{") {
-            return this.withFunctionContext("normal", () => this.parseBlockStatement(params));
+            return this.withFunctionContext(async ? "async" : "normal", () => this.parseBlockStatement(params));
         }
-        return this.withFunctionContext("normal", () => this.parseExpression().node);
+        return this.withFunctionContext(async ? "async" : "normal", () => this.parseExpression().node);
     }
     parseBlockStatement(params, catchParam) {
         const start = this.expectPunctuator("{");
@@ -600,9 +600,17 @@ class Parser {
     }
     parseForStatement(labels) {
         const forToken = this.expectKeyword("for");
+        const awaitToken = this.consumeKeyword("await");
+        if (awaitToken !== undefined && this.functionContext !== "top-level" &&
+            this.functionContext !== "async" && this.functionContext !== "async-generator") {
+            throw new Error("for await is only valid at top level or inside an async function.");
+        }
         return this.withScope(() => {
             this.expectPunctuator("(");
             const iterationOperator = this.findTopLevelForIterationOperator(this.index);
+            if (awaitToken !== undefined && iterationOperator?.value !== "of") {
+                throw new Error("for await requires an of loop.");
+            }
             if (iterationOperator?.value === "in") {
                 const left = this.parseForInLeft();
                 this.expectKeyword("in");
@@ -626,6 +634,7 @@ class Parser {
                 const body = this.withLoopContext(() => this.parseStatement());
                 return {
                     type: "ForOfStatement",
+                    ...(awaitToken === undefined ? {} : { await: true }),
                     left,
                     right,
                     body,
@@ -999,7 +1008,7 @@ class Parser {
             if (accessor === "set" && (params.length !== 1 || params[0]?.type === "RestElement"))
                 throw new Error("A setter must have exactly one non-rest parameter.");
             const bodyTokenIndex = this.index;
-            const body = this.withFunctionContext(generator ? async ? "async-generator" : "generator" : "normal", () => this.parseBlockStatement(params));
+            const body = this.withFunctionContext(generator ? async ? "async-generator" : "generator" : async ? "async" : "normal", () => this.parseBlockStatement(params));
             if (accessor === "set" && params[0]?.type !== "Identifier") {
                 let directiveTokenIndex = bodyTokenIndex + 1;
                 for (const statement of body.body) {