poe-code 11.0.23 → 11.0.25

package/packages/safejs/dist/cli.js

@@ -20,7 +20,7 @@ import {
   parseMcpConfig,
   splitFrontmatter,
   withBrokenPipeGuard
-} from "./chunks/chunk-LRGHMX22.js";
+} from "./chunks/chunk-BGO2B5YI.js";
 import {
   Budget,
   SandboxError,
@@ -32,7 +32,7 @@ import {
   replaceErrorStack,
   restore,
   run
-} from "./chunks/chunk-3627FMJF.js";
+} from "./chunks/chunk-DXJLYASS.js";
 import "./chunks/chunk-4YIDX44G.js";
 
 // packages/safejs/src/cli.ts

package/packages/safejs/dist/core.js

@@ -3,7 +3,7 @@ import {
   createReplayableRandom,
   lint,
   run
-} from "./chunks/chunk-3627FMJF.js";
+} from "./chunks/chunk-DXJLYASS.js";
 import "./chunks/chunk-4YIDX44G.js";
 export {
   Budget,

package/packages/safejs/dist/index.js

@@ -27,7 +27,7 @@ import {
   runWithSpawnUsageAccumulator,
   splitFrontmatter,
   supportsSpawnMode
-} from "./chunks/chunk-LRGHMX22.js";
+} from "./chunks/chunk-BGO2B5YI.js";
 import {
   Budget,
   FileSnapshotBackend,
@@ -49,7 +49,7 @@ import {
   registerPendingHostCallPolicy,
   restore,
   run
-} from "./chunks/chunk-3627FMJF.js";
+} from "./chunks/chunk-DXJLYASS.js";
 import "./chunks/chunk-4YIDX44G.js";
 
 // packages/safejs/src/runner/run-harness.ts

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

@@ -227,7 +227,7 @@ function isAssignableSandboxTarget(value) {
         !isSandboxRegex(value));
 }
 async function arrayFromSandboxValues(args, budget) {
-    const [items, mapFn] = args;
+    const [items, mapFn, thisValue] = args;
     const iterator = getSandboxIterator(items);
     const values = iterator === undefined
         ? Reflect.apply(Array.from, Array, [items])
@@ -240,7 +240,7 @@ async function arrayFromSandboxValues(args, budget) {
     }
     const mappedValues = [];
     for (const [index, value] of values.entries()) {
-        const result = await mapFn.call([value, index]);
+        const result = await mapFn.call([value, index], { stack: [], thisValue });
         if (isSandboxPromise(result) && result.synchronousPrefix !== undefined) {
             await result.synchronousPrefix;
         }

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

@@ -2286,19 +2286,19 @@ async function evaluateNumberMethodCall(node, target, methodName, context) {
 function createArrayMethodOptions(context) {
     return {
         budget: context.budget,
-        callClosure: (closure, args, stack) => invokeSandboxClosure(closure, args, context, stack)
+        callClosure: (closure, args, stack, thisValue) => invokeSandboxClosure(closure, args, context, stack, undefined, thisValue)
     };
 }
 function createMapMethodOptions(context) {
     return {
         budget: context.budget,
-        callClosure: (closure, args, stack) => invokeSandboxClosure(closure, args, context, stack)
+        callClosure: (closure, args, stack, thisValue) => invokeSandboxClosure(closure, args, context, stack, undefined, thisValue)
     };
 }
 function createSetMethodOptions(context) {
     return {
         budget: context.budget,
-        callClosure: (closure, args, stack) => invokeSandboxClosure(closure, args, context, stack)
+        callClosure: (closure, args, stack, thisValue) => invokeSandboxClosure(closure, args, context, stack, undefined, thisValue)
     };
 }
 function createFunctionMethodOptions(context) {

package/packages/safejs/dist/interp/methods/array.d.ts

@@ -3,7 +3,7 @@ import { type SandboxArray, type SandboxClosure, type SandboxValue } from "../va
 export type ArrayMethodName = "map" | "filter" | "find" | "findIndex" | "findLast" | "findLastIndex" | "some" | "every" | "reduce" | "reduceRight" | "forEach" | "flatMap" | "flat" | "includes" | "indexOf" | "lastIndexOf" | "join" | "slice" | "concat" | "splice" | "fill" | "copyWithin" | "at" | "sort" | "reverse" | "toSorted" | "toReversed" | "toSpliced" | "with" | "push" | "pop" | "shift" | "unshift";
 export type ArrayMethodOptions = {
     budget: Budget;
-    callClosure: (closure: SandboxClosure, args: readonly SandboxValue[], stack: readonly string[]) => Promise<SandboxValue>;
+    callClosure: (closure: SandboxClosure, args: readonly SandboxValue[], stack: readonly string[], thisValue?: SandboxValue) => Promise<SandboxValue>;
 };
 export declare function getArrayMember(value: SandboxArray, property: string | number, options: ArrayMethodOptions): SandboxValue | undefined;
 export declare function isArrayMethodName(property: string | number): property is ArrayMethodName;

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

@@ -96,30 +96,30 @@ export async function callArrayMethod(value, methodName, args, options, stack =
 async function callArrayMethodUnlocked(value, methodName, args, options, stack) {
     switch (methodName) {
         case "map":
-            return budgetProducedValue(await mapArray(value, getRequiredCallback(methodName, args[0]), options, stack), options.budget);
+            return budgetProducedValue(await mapArray(value, getRequiredCallback(methodName, args[0]), options, stack, args[1]), options.budget);
         case "filter":
-            return budgetProducedValue(await filterArray(value, getRequiredCallback(methodName, args[0]), options, stack), options.budget);
+            return budgetProducedValue(await filterArray(value, getRequiredCallback(methodName, args[0]), options, stack, args[1]), options.budget);
         case "find":
-            return budgetProducedValue(await findInArray(value, getRequiredCallback(methodName, args[0]), options, stack), options.budget);
+            return budgetProducedValue(await findInArray(value, getRequiredCallback(methodName, args[0]), options, stack, args[1]), options.budget);
         case "findIndex":
-            return await findIndexInArray(value, getRequiredCallback(methodName, args[0]), options, stack);
+            return await findIndexInArray(value, getRequiredCallback(methodName, args[0]), options, stack, args[1]);
         case "findLast":
-            return budgetProducedValue(await findLastInArray(value, getRequiredCallback(methodName, args[0]), options, stack), options.budget);
+            return budgetProducedValue(await findLastInArray(value, getRequiredCallback(methodName, args[0]), options, stack, args[1]), options.budget);
         case "findLastIndex":
-            return await findLastIndexInArray(value, getRequiredCallback(methodName, args[0]), options, stack);
+            return await findLastIndexInArray(value, getRequiredCallback(methodName, args[0]), options, stack, args[1]);
         case "some":
-            return await someInArray(value, getRequiredCallback(methodName, args[0]), options, stack);
+            return await someInArray(value, getRequiredCallback(methodName, args[0]), options, stack, args[1]);
         case "every":
-            return await everyInArray(value, getRequiredCallback(methodName, args[0]), options, stack);
+            return await everyInArray(value, getRequiredCallback(methodName, args[0]), options, stack, args[1]);
         case "reduce":
             return budgetProducedValue(await reduceArray(value, getRequiredCallback(methodName, args[0]), args.length > 1, args[1], options, stack), options.budget);
         case "reduceRight":
             return budgetProducedValue(await reduceRightArray(value, getRequiredCallback(methodName, args[0]), args.length > 1, args[1], options, stack), options.budget);
         case "forEach":
-            await forEachArray(value, getRequiredCallback(methodName, args[0]), options, stack);
+            await forEachArray(value, getRequiredCallback(methodName, args[0]), options, stack, args[1]);
             return undefined;
         case "flatMap":
-            return budgetProducedValue(await flatMapArray(value, getRequiredCallback(methodName, args[0]), options, stack), options.budget);
+            return budgetProducedValue(await flatMapArray(value, getRequiredCallback(methodName, args[0]), options, stack, args[1]), options.budget);
         case "flat":
             return budgetProducedValue(flattenArray(value, toIntegerOrInfinity(args[0] ?? 1), options.budget), options.budget);
         case "includes":
@@ -264,83 +264,83 @@ function getRequiredCallback(methodName, value) {
     }
     return value;
 }
-async function mapArray(value, callback, options, stack) {
+async function mapArray(value, callback, options, stack, thisValue) {
     const length = value.length;
     const result = new Array(length);
     for (let index = 0; index < length; index += 1) {
         if (!(index in value)) {
             continue;
         }
-        result[index] = await callArrayCallback(callback, value[index], index, value, options, stack);
+        result[index] = await callArrayCallback(callback, value[index], index, value, options, stack, thisValue);
     }
     return result;
 }
-async function filterArray(value, callback, options, stack) {
+async function filterArray(value, callback, options, stack, thisValue) {
     const length = value.length;
     const result = [];
     for (let index = 0; index < length; index += 1) {
         if (!(index in value)) {
             continue;
         }
-        if (await callArrayCallback(callback, value[index], index, value, options, stack)) {
+        if (await callArrayCallback(callback, value[index], index, value, options, stack, thisValue)) {
             result.push(value[index]);
         }
     }
     return result;
 }
-async function findInArray(value, callback, options, stack) {
-    const index = await findIndexInArray(value, callback, options, stack);
+async function findInArray(value, callback, options, stack, thisValue) {
+    const index = await findIndexInArray(value, callback, options, stack, thisValue);
     return index < 0 ? undefined : value[index];
 }
-async function findIndexInArray(value, callback, options, stack) {
+async function findIndexInArray(value, callback, options, stack, thisValue) {
     const length = value.length;
     for (let index = 0; index < length; index += 1) {
         const entry = index in value ? value[index] : undefined;
-        if (await callArrayCallback(callback, entry, index, value, options, stack)) {
+        if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
             return index;
         }
     }
     return -1;
 }
-async function findLastInArray(value, callback, options, stack) {
+async function findLastInArray(value, callback, options, stack, thisValue) {
     const length = value.length;
     for (let index = length - 1; index >= 0; index -= 1) {
         const entry = index in value ? value[index] : undefined;
-        if (await callArrayCallback(callback, entry, index, value, options, stack)) {
+        if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
             return entry;
         }
     }
     return undefined;
 }
-async function findLastIndexInArray(value, callback, options, stack) {
+async function findLastIndexInArray(value, callback, options, stack, thisValue) {
     const length = value.length;
     for (let index = length - 1; index >= 0; index -= 1) {
         const entry = index in value ? value[index] : undefined;
-        if (await callArrayCallback(callback, entry, index, value, options, stack)) {
+        if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
             return index;
         }
     }
     return -1;
 }
-async function someInArray(value, callback, options, stack) {
+async function someInArray(value, callback, options, stack, thisValue) {
     const length = value.length;
     for (let index = 0; index < length; index += 1) {
         if (!(index in value)) {
             continue;
         }
-        if (await callArrayCallback(callback, value[index], index, value, options, stack)) {
+        if (await callArrayCallback(callback, value[index], index, value, options, stack, thisValue)) {
             return true;
         }
     }
     return false;
 }
-async function everyInArray(value, callback, options, stack) {
+async function everyInArray(value, callback, options, stack, thisValue) {
     const length = value.length;
     for (let index = 0; index < length; index += 1) {
         if (!(index in value)) {
             continue;
         }
-        if (!(await callArrayCallback(callback, value[index], index, value, options, stack))) {
+        if (!(await callArrayCallback(callback, value[index], index, value, options, stack, thisValue))) {
             return false;
         }
     }
@@ -388,23 +388,23 @@ async function reduceFromRight(value, callback, accumulator, startIndex, length,
     }
     return current;
 }
-async function forEachArray(value, callback, options, stack) {
+async function forEachArray(value, callback, options, stack, thisValue) {
     const length = value.length;
     for (let index = 0; index < length; index += 1) {
         if (!(index in value)) {
             continue;
         }
-        await callArrayCallback(callback, value[index], index, value, options, stack);
+        await callArrayCallback(callback, value[index], index, value, options, stack, thisValue);
     }
 }
-async function flatMapArray(value, callback, options, stack) {
+async function flatMapArray(value, callback, options, stack, thisValue) {
     const length = value.length;
     const result = [];
     for (let index = 0; index < length; index += 1) {
         if (!(index in value)) {
             continue;
         }
-        const mapped = await callArrayCallback(callback, value[index], index, value, options, stack);
+        const mapped = await callArrayCallback(callback, value[index], index, value, options, stack, thisValue);
         if (Array.isArray(mapped)) {
             for (let mappedIndex = 0; mappedIndex < mapped.length; mappedIndex += 1) {
                 if (!(mappedIndex in mapped)) {
@@ -477,8 +477,8 @@ async function compareEntries(left, right, comparator, options, stack) {
     const result = Number(await options.callClosure(comparator, [left, right], stack));
     return Number.isNaN(result) ? 0 : result;
 }
-async function callArrayCallback(callback, value, index, array, options, stack) {
-    return options.callClosure(callback, [value, index, array], stack);
+async function callArrayCallback(callback, value, index, array, options, stack, thisValue) {
+    return options.callClosure(callback, [value, index, array], stack, thisValue);
 }
 function findNextDefinedIndex(value, startIndex, direction, length) {
     for (let index = startIndex; direction > 0 ? index < length : index >= 0; index += direction) {

package/packages/safejs/dist/interp/methods/map.d.ts

@@ -3,7 +3,7 @@ import { type SandboxClosure, type SandboxMap, type SandboxValue } from "../valu
 export type MapMethodName = "get" | "set" | "has" | "delete" | "clear" | "forEach" | "keys" | "values" | "entries";
 export type MapMethodOptions = {
     budget: Budget;
-    callClosure: (closure: SandboxClosure, args: readonly SandboxValue[], stack: readonly string[]) => Promise<SandboxValue>;
+    callClosure: (closure: SandboxClosure, args: readonly SandboxValue[], stack: readonly string[], thisValue?: SandboxValue) => Promise<SandboxValue>;
 };
 export declare function isMapMethodName(value: string | number): value is MapMethodName;
 export declare function getMapMember(target: SandboxMap, property: string | number, options: MapMethodOptions): SandboxValue | undefined;

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

@@ -57,7 +57,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];
-                    await options.callClosure(callback, [value, key, target], stack);
+                    await options.callClosure(callback, [value, key, target], stack, args[1]);
                 }
             }
             finally {

package/packages/safejs/dist/interp/methods/set.d.ts

@@ -3,7 +3,7 @@ import { type SandboxClosure, type SandboxSet, type SandboxValue } from "../valu
 export type SetMethodName = "add" | "has" | "delete" | "clear" | "forEach" | "keys" | "values" | "entries";
 export type SetMethodOptions = {
     budget: Budget;
-    callClosure: (closure: SandboxClosure, args: readonly SandboxValue[], stack: readonly string[]) => Promise<SandboxValue>;
+    callClosure: (closure: SandboxClosure, args: readonly SandboxValue[], stack: readonly string[], thisValue?: SandboxValue) => Promise<SandboxValue>;
 };
 export declare function isSetMethodName(value: string | number): value is SetMethodName;
 export declare function getSetMember(target: SandboxSet, property: string | number, options: SetMethodOptions): SandboxValue | undefined;

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

@@ -54,7 +54,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];
-                    await options.callClosure(callback, [value, value, target], stack);
+                    await options.callClosure(callback, [value, value, target], stack, args[1]);
                 }
             }
             finally {

package/packages/safejs/dist/restore.js

@@ -20,6 +20,7 @@ export function restore(snapshot, options) {
     validateDumpEnvelope(snapshot);
     validateSnapshotMigration(snapshot.migration, snapshot.sourceHash);
     if (snapshot.executionSemantics !== EXECUTION_SEMANTICS &&
+        snapshot.executionSemantics !== "jobs-v6" &&
         (snapshot.executionSemantics !== undefined ||
             snapshot.promiseReplay !== undefined ||
             snapshot.replay !== undefined ||

package/packages/safejs/dist/run.js

@@ -71,6 +71,8 @@ export function run(source, options = {}) {
             options.signal?.addEventListener("abort", captureCancellationSnapshot, { once: true });
             try {
                 const restoredSnapshot = options.snapshot === undefined ? undefined : restore(options.snapshot, { source });
+                const executionSemantics = restoredSnapshot?.executionSemantics === "jobs-v6" ? "jobs-v6" : EXECUTION_SEMANTICS;
+                const convertInitialInput = (convert) => executionSemantics === "jobs-v6" ? convert() : promiseReplayContext.exit(convert);
                 if (restoredSnapshot !== undefined) {
                     leaveSnapshotRun = enterSnapshotRun(restoredSnapshot);
                 }
@@ -93,7 +95,7 @@ export function run(source, options = {}) {
                         resumeNodeId: restoredSnapshot.pendingAwaits?.[0]?.nodeId
                     }
                     : undefined;
-                const callerBindings = options.bindings === undefined
+                const callerBindings = convertInitialInput(() => options.bindings === undefined
                     ? {}
                     : wrapCallerInjectedBindings(options.bindings, {
                         budget,
@@ -101,7 +103,7 @@ export function run(source, options = {}) {
                         moduleId: "<bindings>",
                         signal: options.signal,
                         lifecycle
-                    });
+                    }));
                 const builtinBindings = {
                     ...createConsoleJsonGlobals({
                         budget,
@@ -126,7 +128,7 @@ export function run(source, options = {}) {
                     }),
                     ...createRegexGlobals()
                 };
-                const importMeta = deepCopyToSandbox(options.importMeta ?? {});
+                const importMeta = convertInitialInput(() => deepCopyToSandbox(options.importMeta ?? {}));
                 if (restoredSnapshot?.migration !== undefined) {
                     if (Object.hasOwn(importMeta, "migration"))
                         throw new TypeError("import.meta.migration is reserved for migrated checkpoint state.");
@@ -139,15 +141,15 @@ export function run(source, options = {}) {
                 }
                 const initialInputs = prepareReplayInputs({
                     bindings: callerBindings,
-                    imports: resolveModuleImports(module, options.modules, {
+                    imports: convertInitialInput(() => resolveModuleImports(module, options.modules, {
                         budget,
                         hostCalls,
                         signal: options.signal,
                         allowMissing: restoredSnapshot?.initialInputs !== undefined
-                    }),
-                    entryPointArgs: options.entryPointArgs === undefined
+                    })),
+                    entryPointArgs: convertInitialInput(() => options.entryPointArgs === undefined
                         ? undefined
-                        : deepCopyToSandbox([...options.entryPointArgs]),
+                        : deepCopyToSandbox([...options.entryPointArgs])),
                     importMeta
                 }, restoredSnapshot?.initialInputs, (promise, id) => {
                     if (promise !== undefined)
@@ -188,6 +190,7 @@ export function run(source, options = {}) {
                 });
                 snapshotScheduler = activeSnapshotScheduler;
                 createFailureSnapshot = () => createRunSnapshot({
+                    executionSemantics,
                     migration: restoredSnapshot?.migration,
                     bindings: executionScope.snapshot().bindings,
                     clock: options.clock,
@@ -214,6 +217,7 @@ export function run(source, options = {}) {
                             }
                             const interpreterSnapshot = yieldPoint.snapshot();
                             snapshot = createRunSnapshot({
+                                executionSemantics,
                                 migration: restoredSnapshot?.migration,
                                 bindings: interpreterSnapshot.bindings,
                                 clock: options.clock,
@@ -258,6 +262,7 @@ export function run(source, options = {}) {
                                 }
                                 const interpreterSnapshot = yieldPoint.snapshot();
                                 snapshot = createRunSnapshot({
+                                    executionSemantics,
                                     migration: restoredSnapshot?.migration,
                                     bindings: interpreterSnapshot.bindings,
                                     clock: options.clock,
@@ -296,6 +301,7 @@ export function run(source, options = {}) {
                     replayError = error.message;
                 }
                 const snapshot = createRunSnapshot({
+                    executionSemantics,
                     migration: restoredSnapshot?.migration,
                     bindings: executionScope.snapshot().bindings,
                     clock: options.clock,
@@ -459,7 +465,7 @@ function createExecutableNode(module) {
 function createRunSnapshot(input) {
     return {
         version: DUMP_FORMAT_VERSION,
-        executionSemantics: EXECUTION_SEMANTICS,
+        executionSemantics: input.executionSemantics,
         sourceHash: input.sourceHash,
         ...(input.migration === undefined ? {} : { migration: structuredClone(input.migration) }),
         bindings: input.bindings,

package/packages/safejs/dist/snapshot/dump-format.d.ts

@@ -1,5 +1,5 @@
 export declare const DUMP_FORMAT_VERSION = 1;
-export declare const EXECUTION_SEMANTICS = "jobs-v6";
+export declare const EXECUTION_SEMANTICS = "jobs-v7";
 export type DumpableSnapshot = {
     sourceHash: string;
     [key: string]: unknown;

package/packages/safejs/dist/snapshot/dump-format.js

@@ -1,5 +1,5 @@
 export const DUMP_FORMAT_VERSION = 1;
-export const EXECUTION_SEMANTICS = "jobs-v6";
+export const EXECUTION_SEMANTICS = "jobs-v7";
 import { assertSnapshotGraphDepth } from "../graph-depth.js";
 import { sandboxErrorTypes } from "../error/shape.js";
 import { getSandboxArgumentEntries, isSandboxArguments } from "../interp/arguments.js";

package/packages/safejs/dist/snapshot/migration.js

@@ -2,8 +2,8 @@ import { HostCallJournal } from "../interp/host-call.js";
 import { decodeReplayData } from "./replay-data.js";
 import { validateSnapshotData } from "./validation.js";
 export function validateMigrationSemantics(value) {
-    if (!["jobs-v1", "jobs-v2", "jobs-v3", "jobs-v4", "jobs-v5", "jobs-v6"].includes(value))
-        throw new TypeError("Migration requires a supported execution-semantics marker (jobs-v1 through jobs-v6).");
+    if (!["jobs-v1", "jobs-v2", "jobs-v3", "jobs-v4", "jobs-v5", "jobs-v6", "jobs-v7"].includes(value))
+        throw new TypeError("Migration requires a supported execution-semantics marker (jobs-v1 through jobs-v7).");
 }
 export function validateMigrationJournal(sourceHash, replay, hostCalls = []) {
     if (replay === undefined)