poe-code 4.0.72 → 5.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poe-code",
-  "version": "4.0.72",
+  "version": "5.0.0",
   "description": "CLI tool to configure Poe API for developer workflows.",
   "license": "MIT",
   "type": "module",

package/packages/safejs/dist/interp/async.d.ts

@@ -22,6 +22,7 @@ export type AsyncEvaluationContext = {
     budget: Budget;
     callStack: string[];
     onYield?: (yieldPoint: InterpreterYieldPoint) => void;
+    onSuspend?: () => void;
     captureReplayState?: () => unknown;
     rootNode?: ParseResult;
     restoredLoopIterations: Map<number, LoopIterationSnapshot>;
@@ -29,13 +30,13 @@ export type AsyncEvaluationContext = {
         nodeId?: number;
     };
     scope: Scope;
+    signal?: AbortSignal;
     snapshot?: (scope: Scope) => InterpreterSnapshot;
     stats: {
         currentDataSize: number;
         nodeVisits: number;
         peakDataSize: number;
     };
-    microtasks: Array<() => void>;
     generatorYield?: (value?: SandboxValue, yieldNodeId?: number) => Promise<GeneratorCompletion>;
     generatorResume?: {
         sent: GeneratorCompletion[];

package/packages/safejs/dist/interp/async.js

@@ -1,7 +1,9 @@
 import { createGeneratorChannel } from "./generator.js";
 import { getBoundOtelSpan } from "../observability/otel.js";
 import { bindPattern } from "./patterns.js";
-import { resolveSandboxValue } from "./promise.js";
+import { getThenable, resolveSandboxValue } from "./promise.js";
+import { runAsyncPrefix, suspendJob } from "./jobs.js";
+import { awaitSandboxValue } from "./cancel.js";
 import { hoistVarDeclarations } from "./var-hoist.js";
 import { createSandboxArguments, createSandboxClosure, createSandboxGenerator, createSandboxPromise, isSandboxPromise } from "./values.js";
 export function emitResumeBreakpoint(context, breakpoint) {
@@ -59,15 +61,23 @@ export function createInterpretedClosure(node, context, evaluateNode) {
             : {}),
         ...(construct === undefined ? {} : { construct }),
         retainedValues: () => context.scope.retainedValues(),
-        call: (args, callContext) => node.async
-            ? createSandboxPromise(resolveSandboxValue(executeClosure(node, args, callContext?.thisValue, {
+        call: (args, callContext) => {
+            const invocationContext = {
                 ...context,
                 callStack: [...(callContext?.stack ?? context.callStack)]
-            }, evaluateNode), { budget: context.budget }))
-            : executeClosure(node, args, callContext?.thisValue, {
-                ...context,
-                callStack: [...(callContext?.stack ?? context.callStack)]
-            }, evaluateNode)
+            };
+            if (!node.async)
+                return executeClosure(node, args, callContext?.thisValue, invocationContext, evaluateNode);
+            let completePrefix;
+            const synchronousPrefix = new Promise((resolve) => {
+                completePrefix = resolve;
+            });
+            const execution = runAsyncPrefix(() => executeClosure(node, args, callContext?.thisValue, { ...invocationContext, onSuspend: completePrefix }, evaluateNode));
+            execution.then(completePrefix, completePrefix);
+            return createSandboxPromise(resolveSandboxValue(execution.then((value) => isSandboxPromise(value) || getThenable(value) !== undefined
+                ? awaitSandboxValue(value, context.signal)
+                : value), { budget: context.budget }), { synchronousPrefix });
+        }
     });
 }
 function createGeneratorClosure(node, context, evaluateNode) {
@@ -111,6 +121,7 @@ export async function evaluateAwaitExpression(node, context, evaluateNode) {
     if (argument.kind !== "normal") {
         return argument;
     }
+    context.onSuspend?.();
     emitResumeBreakpoint(context, {
         kind: "await",
         replayState,
@@ -122,13 +133,10 @@ export async function evaluateAwaitExpression(node, context, evaluateNode) {
     });
     const leaveAwait = context.budget.enterAwait();
     try {
-        while (context.microtasks.length > 0) {
-            context.microtasks.shift()?.();
-        }
         return {
             kind: "normal",
             hasValue: true,
-            value: await resolveSandboxValue(argument.value)
+            value: await suspendJob(awaitSandboxValue(argument.value, context.signal))
         };
     }
     finally {

package/packages/safejs/dist/interp/cancel.d.ts

@@ -1,2 +1,3 @@
 import { type SandboxValue } from "./values.js";
 export declare function wrapCancelableBindings(bindings: Record<string, SandboxValue>, signal?: AbortSignal): Record<string, SandboxValue>;
+export declare function awaitSandboxValue(value: SandboxValue, signal?: AbortSignal): Promise<SandboxValue>;

package/packages/safejs/dist/interp/cancel.js

@@ -1,6 +1,8 @@
 import { createSandboxClosure, createSandboxPromise, isSandboxClosure, isSandboxPromise } from "./values.js";
 import { observeSandboxPromise } from "./promise-tracker.js";
 import { replaceErrorStack } from "../error/shape.js";
+import { resolveSandboxValue } from "./promise.js";
+const cancellationSignals = new WeakMap();
 export function wrapCancelableBindings(bindings, signal) {
     if (signal === undefined) {
         return bindings;
@@ -38,11 +40,15 @@ function wrapCancelableValue(value, signal, seen) {
         observeSandboxPromise(value);
         const wrapped = createSandboxPromise(wrapCancelablePromise(value.promise, signal, seen), {
             trackReplay: false,
+            ...(value.synchronousPrefix === undefined
+                ? {}
+                : { synchronousPrefix: value.synchronousPrefix }),
             ...(value.hostCall === undefined ? {} : { hostCall: value.hostCall }),
             ...(value.hostCallJournal === undefined ? {} : { hostCallJournal: value.hostCallJournal }),
             ...(value.span === undefined ? {} : { span: value.span })
         });
         seen.set(value, wrapped);
+        cancellationSignals.set(wrapped, signal);
         return wrapped;
     }
     if (Array.isArray(value)) {
@@ -67,7 +73,24 @@ function wrapCancelableResult(result, signal, seen) {
     return wrapCancelablePromise(result, signal, seen);
 }
 function wrapCancelablePromise(promise, signal, seen) {
+    return awaitWithSignal(promise, signal).then((value) => wrapCancelableValue(value, signal, seen), (reason) => {
+        if (signal.aborted && reason === signal.reason)
+            throw reason;
+        throw wrapCancelableUnknown(reason, signal, seen);
+    });
+}
+export function awaitSandboxValue(value, signal) {
+    const resolved = resolveSandboxValue(value);
+    return isSandboxPromise(value) &&
+        (value.synchronousPrefix !== undefined || cancellationSignals.get(value) === signal)
+        ? resolved
+        : awaitWithSignal(resolved, signal);
+}
+function awaitWithSignal(promise, signal) {
+    if (signal === undefined)
+        return Promise.resolve(promise);
     if (signal.aborted) {
+        void Promise.resolve(promise).catch(() => undefined);
         return Promise.reject(readAbortReason(signal));
     }
     return new Promise((resolve, reject) => {
@@ -96,9 +119,9 @@ function wrapCancelablePromise(promise, signal, seen) {
         };
         signal.addEventListener("abort", onAbort, { once: true });
         Promise.resolve(promise).then((value) => {
-            settle(() => resolve(wrapCancelableValue(value, signal, seen)));
+            settle(() => resolve(value));
         }, (reason) => {
-            settle(() => reject(wrapCancelableUnknown(reason, signal, seen)));
+            settle(() => reject(reason));
         });
     });
 }

package/packages/safejs/dist/interp/globals/console-json.js

@@ -1,6 +1,5 @@
 import { wrapCallerInjectedBindings } from "../host-bridge.js";
-import { resolveSandboxValue } from "../promise.js";
-import { createSandboxClosure, deepCopyFromSandbox, isSandboxClosure, isSandboxPromise } from "../values.js";
+import { allocateProducedSandboxValue, createSandboxClosure, deepCopyFromSandbox, isSandboxClosure, isSandboxPromise } from "../values.js";
 export function createConsoleJsonGlobals(options) {
     const sink = options.sink ?? console;
     return {
@@ -87,11 +86,11 @@ async function stringifyProperty(key, holder, state, indent = "") {
     if (isStringifyContainer(value)) {
         const toJSON = getOwnDataValue(value, "toJSON");
         if (isSandboxClosure(toJSON)) {
-            value = await callStringifyClosure(toJSON, [key], state);
+            value = await callStringifyClosure(toJSON, [key], value, state);
         }
     }
     if (state.replacer !== undefined) {
-        value = await callStringifyClosure(state.replacer, [key, toSandboxValue(value)], state);
+        value = await callStringifyClosure(state.replacer, [key, toSandboxValue(value)], holder, state);
     }
     return stringifyValue(value, state, indent);
 }
@@ -111,7 +110,9 @@ async function stringifyValue(value, state, indent) {
     if (typeof value === "bigint") {
         throw new TypeError("Do not know how to serialize a BigInt.");
     }
-    if (value === undefined || isSandboxClosure(value) || isSandboxPromise(value)) {
+    if (isSandboxPromise(value))
+        return "{}";
+    if (value === undefined || isSandboxClosure(value)) {
         return undefined;
     }
     if (Array.isArray(value)) {
@@ -165,8 +166,12 @@ async function stringifyObject(value, state, indent) {
         leaveStringifyObject(value, state);
     }
 }
-async function callStringifyClosure(closure, args, state) {
-    return resolveSandboxValue(closure.call(args), { budget: state.budget });
+async function callStringifyClosure(closure, args, thisValue, state) {
+    const result = await closure.call(args, { stack: [], thisValue });
+    if (isSandboxPromise(result) && result.synchronousPrefix !== undefined) {
+        await result.synchronousPrefix;
+    }
+    return allocateProducedSandboxValue(result, state.budget);
 }
 function enterStringifyObject(value, state) {
     if (state.stack.includes(value)) {

package/packages/safejs/dist/interp/globals/object-array.js

@@ -169,7 +169,10 @@ async function arrayFromSandboxValues(args, budget) {
     const mappedValues = [];
     for (const [index, value] of values.entries()) {
         const result = await mapFn.call([value, index]);
-        mappedValues.push(isSandboxPromise(result) ? await result.promise : result);
+        if (isSandboxPromise(result) && result.synchronousPrefix !== undefined) {
+            await result.synchronousPrefix;
+        }
+        mappedValues.push(result);
     }
     return budgetSandboxValue(mappedValues, budget);
 }

package/packages/safejs/dist/interp/interpreter.d.ts

@@ -46,6 +46,7 @@ export type InterpretOptions = {
     budget?: Budget;
     onYield?: (yieldPoint: InterpreterYieldPoint) => void;
     scope?: Scope;
+    signal?: AbortSignal;
     surfaceUnhandledThrows?: boolean;
     useScopeDirectly?: boolean;
     generatorYield?: (value?: SandboxValue, yieldNodeId?: number) => Promise<GeneratorCompletion>;

package/packages/safejs/dist/interp/interpreter.js

@@ -1,4 +1,5 @@
 import { promiseReplayContext } from "./promise-replay.js";
+import { SandboxJobQueue, suspendJob } from "./jobs.js";
 import { attachErrorSpan, formatErrorStack, readErrorSpan, replaceErrorStack } from "../error/shape.js";
 import { evaluateArrowFunctionExpression, evaluateFunctionExpression, evaluateAwaitExpression, emitResumeBreakpoint, createInterpretedClosure, normalizeClosureResult } from "./async.js";
 import { HostCallResumabilityError } from "./host-call.js";
@@ -87,7 +88,7 @@ export async function interpret(node, options = {}) {
         peakDataSize: { enumerable: false, value: 0, writable: true }
     });
     const activeLoopIterations = new Map();
-    const microtasks = [];
+    const jobs = new SandboxJobQueue();
     hoistVarDeclarations(node, scope);
     const context = {
         budget,
@@ -96,8 +97,8 @@ export async function interpret(node, options = {}) {
         captureReplayState: options.captureReplayState,
         rootNode: node,
         scope,
+        signal: options.signal,
         stats,
-        microtasks,
         activeLoopIterations,
         restoredLoopIterations: new Map(Object.entries(options.snapshot?.loopIterations ?? {}).map(([nodeId, iteration]) => [
             Number(nodeId),
@@ -107,8 +108,8 @@ export async function interpret(node, options = {}) {
         generatorYield: options.generatorYield,
         resumeTarget: { nodeId: options.snapshot?.resumeNodeId }
     };
-    const evaluation = await evaluateNode(node, context);
-    await drainMicrotasks(context);
+    const evaluation = await jobs.run(() => evaluateNode(node, context));
+    await jobs.drain();
     const snapshot = scope.snapshot();
     reconcileDataBudget(budget, stats, scope, "hasValue" in evaluation && evaluation.hasValue ? evaluation.value : undefined);
     if (evaluation.kind === "error") {
@@ -149,25 +150,10 @@ export async function interpret(node, options = {}) {
     };
 }
 export { Scope } from "./scope.js";
-async function drainMicrotasks(context) {
-    let idleTurns = 0;
-    while (idleTurns < 20) {
-        const task = context.microtasks.shift();
-        if (task === undefined) {
-            idleTurns += 1;
-            await Promise.resolve();
-            continue;
-        }
-        idleTurns = 0;
-        context.budget.visitNode();
-        task();
-        await Promise.resolve();
-    }
-}
 async function evaluateNode(node, context) {
     const replayWait = promiseReplayContext.getStore()?.beforeNode(node.nodeId);
     if (replayWait !== undefined)
-        await replayWait;
+        await suspendJob(replayWait);
     context.budget.visitNode();
     context.stats.nodeVisits += 1;
     if (node.nodeId !== undefined && context.resumeTarget?.nodeId === node.nodeId) {
@@ -1611,7 +1597,7 @@ async function evaluateMemberExpression(node, context) {
         return {
             kind: "normal",
             hasValue: true,
-            value: getPromiseMember(member.object, member.property, context.budget, (task) => enqueueMicrotask(context, task))
+            value: getPromiseMember(member.object, member.property, context.budget)
         };
     }
     if (isSandboxRegex(member.object)) {
@@ -1630,13 +1616,6 @@ async function evaluateMemberExpression(node, context) {
         value: getMemberValue(member.object, member.property, context)
     };
 }
-function enqueueMicrotask(context, task) {
-    return new Promise((resolve, reject) => {
-        context.microtasks.push(() => {
-            task().then(resolve, reject);
-        });
-    });
-}
 async function evaluateCallExpression(node, context) {
     if (node.callee.type === "MemberExpression") {
         context.budget.visitNode();
@@ -1860,7 +1839,7 @@ async function evaluateMemberCallExpression(node, context) {
         return evaluateResolvedCallExpression(node, memberValue, context, member.object);
     }
     if (isSandboxPromise(member.object)) {
-        return evaluateResolvedCallExpression(node, getPromiseMember(member.object, member.property, context.budget, (task) => enqueueMicrotask(context, task)), context, member.object);
+        return evaluateResolvedCallExpression(node, getPromiseMember(member.object, member.property, context.budget), context, member.object);
     }
     if (isSandboxRegex(member.object) && isRegexMethodName(member.property)) {
         return evaluateResolvedCallExpression(node, getRegexMember(member.object, member.property), context, member.object);
@@ -1887,10 +1866,7 @@ async function evaluateStringMethodCall(node, target, methodName, context) {
         return {
             kind: "normal",
             hasValue: true,
-            value: await callStringMethod(target, methodName, args.value, context.budget, async (closure, closureArgs) => {
-                const result = await invokeSandboxClosure(closure, closureArgs, context, context.callStack);
-                return isSandboxPromise(result) ? await result.promise : result;
-            })
+            value: await callStringMethod(target, methodName, args.value, context.budget, (closure, closureArgs) => invokeSandboxClosure(closure, closureArgs, context, context.callStack))
         };
     }
     catch (error) {
@@ -2360,6 +2336,9 @@ async function invokeSandboxClosure(callee, args, context, stack, span, thisValu
                 ...(span === undefined ? {} : { span })
             }
         ]);
+        if (isSandboxPromise(result) && result.synchronousPrefix !== undefined) {
+            await result.synchronousPrefix;
+        }
         return callee.async === true
             ? normalizeClosureResult(wrapHostResult(result, stack), context.budget)
             : await wrapHostResult(result, stack);

package/packages/safejs/dist/interp/jobs.d.ts

@@ -0,0 +1,20 @@
+type ExecutionJob = {
+    queue: SandboxJobQueue;
+    ownsExecution: boolean;
+    prefixParent?: ExecutionJob;
+};
+export declare class SandboxJobQueue {
+    private running;
+    private readonly pending;
+    private readonly idle;
+    private generation;
+    acquire(job: ExecutionJob): Promise<void>;
+    release(job: ExecutionJob): void;
+    run<T>(task: () => T | Promise<T>): Promise<T>;
+    drain(): Promise<void>;
+    private advance;
+}
+export declare function runPromiseJob<T>(task: () => T | Promise<T>): Promise<T>;
+export declare function runAsyncPrefix<T>(task: () => Promise<T>): Promise<T>;
+export declare function suspendJob<T>(pending: Promise<T>): Promise<T>;
+export {};

package/packages/safejs/dist/interp/jobs.js

@@ -0,0 +1,96 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+const activeJob = new AsyncLocalStorage();
+export class SandboxJobQueue {
+    running = false;
+    pending = [];
+    idle = [];
+    generation = 0;
+    acquire(job) {
+        return new Promise((resolve) => {
+            this.pending.push(() => {
+                this.running = true;
+                this.generation += 1;
+                job.ownsExecution = true;
+                resolve();
+            });
+            this.advance();
+        });
+    }
+    release(job) {
+        job.prefixParent = undefined;
+        if (!job.ownsExecution)
+            return;
+        job.ownsExecution = false;
+        this.running = false;
+        this.advance();
+    }
+    async run(task) {
+        const job = { queue: this, ownsExecution: false };
+        await this.acquire(job);
+        return activeJob.run(job, async () => {
+            try {
+                return await task();
+            }
+            finally {
+                this.release(job);
+            }
+        });
+    }
+    async drain() {
+        let idleTurns = 0;
+        while (idleTurns < 20) {
+            const generation = this.generation;
+            if (this.running)
+                await new Promise((resolve) => this.idle.push(resolve));
+            await Promise.resolve();
+            idleTurns = generation === this.generation ? idleTurns + 1 : 0;
+        }
+    }
+    advance() {
+        if (this.running)
+            return;
+        const next = this.pending.shift();
+        if (next !== undefined) {
+            next();
+        }
+        else {
+            for (const resolve of this.idle.splice(0))
+                resolve();
+        }
+    }
+}
+export function runPromiseJob(task) {
+    const job = activeJob.getStore();
+    return job === undefined ? Promise.resolve().then(task) : job.queue.run(task);
+}
+export function runAsyncPrefix(task) {
+    const parent = activeJob.getStore();
+    if (parent === undefined)
+        return task();
+    let owner = parent;
+    while (owner !== undefined && !owner.ownsExecution)
+        owner = owner.prefixParent;
+    if (owner === undefined)
+        return parent.queue.run(task);
+    const job = { queue: parent.queue, ownsExecution: false, prefixParent: parent };
+    return activeJob.run(job, async () => {
+        try {
+            return await task();
+        }
+        finally {
+            job.queue.release(job);
+        }
+    });
+}
+export async function suspendJob(pending) {
+    const job = activeJob.getStore();
+    if (job === undefined)
+        return pending;
+    job.queue.release(job);
+    try {
+        return await pending;
+    }
+    finally {
+        await job.queue.acquire(job);
+    }
+}

package/packages/safejs/dist/interp/methods/map.js

@@ -1,4 +1,4 @@
-import { allocateProducedSandboxValue, createSandboxClosure, isSandboxClosure, isSandboxPromise } from "../values.js";
+import { allocateProducedSandboxValue, createSandboxClosure, isSandboxClosure } from "../values.js";
 import { assertCollectionMutable, enterCollectionCallback } from "../running-state.js";
 const mapMethodNames = new Set([
     "get",
@@ -56,10 +56,7 @@ export async function callMapMethod(target, methodName, args, options, stack = [
                 const entries = [...target.entries];
                 for (let index = 0; index < entries.length; index += 1) {
                     const [key, value] = entries[index];
-                    const result = await options.callClosure(callback, [value, key, target], stack);
-                    if (isSandboxPromise(result)) {
-                        await result.promise;
-                    }
+                    await options.callClosure(callback, [value, key, target], stack);
                 }
             }
             finally {

package/packages/safejs/dist/interp/methods/set.js

@@ -1,4 +1,4 @@
-import { allocateProducedSandboxValue, createSandboxClosure, isSandboxClosure, isSandboxPromise } from "../values.js";
+import { allocateProducedSandboxValue, createSandboxClosure, isSandboxClosure } from "../values.js";
 import { assertCollectionMutable, enterCollectionCallback } from "../running-state.js";
 const setMethodNames = new Set([
     "add",
@@ -53,10 +53,7 @@ export async function callSetMethod(target, methodName, args, options, stack = [
                 const values = [...target.values];
                 for (let index = 0; index < values.length; index += 1) {
                     const value = values[index];
-                    const result = await options.callClosure(callback, [value, value, target], stack);
-                    if (isSandboxPromise(result)) {
-                        await result.promise;
-                    }
+                    await options.callClosure(callback, [value, value, target], stack);
                 }
             }
             finally {

package/packages/safejs/dist/interp/promise.d.ts

@@ -1,13 +1,14 @@
 import type { Budget } from "./budget.js";
-import { type SandboxObject, type SandboxPromise, type SandboxValue } from "./values.js";
+import { type SandboxClosure, type SandboxObject, type SandboxPromise, type SandboxValue } from "./values.js";
 export type PromiseGlobals = {
     Promise: SandboxObject;
 };
 export declare function createPromiseGlobals(options: {
     budget: Budget;
 }): PromiseGlobals;
-export declare function getPromiseMember(target: SandboxPromise, property: string | number, budget: Budget, enqueue?: <T>(task: () => Promise<T>) => Promise<T>): SandboxValue;
+export declare function getPromiseMember(target: SandboxPromise, property: string | number, budget: Budget): SandboxValue;
 export declare function resolveSandboxValue(value: SandboxValue | Promise<SandboxValue> | PromiseLike<SandboxValue>, options?: {
     budget?: Budget;
 }): Promise<SandboxValue>;
 export declare function consumeSettledHostCall(value: SandboxPromise): void;
+export declare function getThenable(value: SandboxValue): SandboxClosure | undefined;