poe-code 11.0.23 → 11.0.25

package/package.json

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

package/packages/safejs/dist/chunks/{chunk-LRGHMX22.js → chunk-BGO2B5YI.js}

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-3627FMJF.js";
+} from "./chunk-DXJLYASS.js";
 
 // packages/safejs/src/migrate.ts
 import { createHash } from "node:crypto";
@@ -8055,4 +8055,4 @@ export {
   parseMcpConfig,
   makeMcpModule
 };
-//# sourceMappingURL=chunk-LRGHMX22.js.map
+//# sourceMappingURL=chunk-BGO2B5YI.js.map

package/packages/safejs/dist/chunks/{chunk-3627FMJF.js → chunk-DXJLYASS.js}

@@ -16961,7 +16961,7 @@ function serializeArray(value, serializeValue) {
 
 // packages/safejs/src/snapshot/dump-format.ts
 var DUMP_FORMAT_VERSION = 1;
-var EXECUTION_SEMANTICS = "jobs-v6";
+var EXECUTION_SEMANTICS = "jobs-v7";
 var SKIP_VALUE = /* @__PURE__ */ Symbol("SafeJS.skip-dump-value");
 function serializeSafeJSSnapshot(snapshot) {
   const replayError = Object.getOwnPropertyDescriptor(snapshot, "replayError");
@@ -21309,9 +21309,11 @@ function shouldIncludeTemplateRaw(record2, key, includeTemplateRaw) {
 
 // packages/safejs/src/snapshot/migration.ts
 function validateMigrationSemantics(value) {
-  if (!["jobs-v1", "jobs-v2", "jobs-v3", "jobs-v4", "jobs-v5", "jobs-v6"].includes(value))
+  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-v6)."
+      "Migration requires a supported execution-semantics marker (jobs-v1 through jobs-v7)."
     );
 }
 function validateMigrationJournal(sourceHash, replay, hostCalls = []) {
@@ -21408,7 +21410,7 @@ function restore(snapshot, options) {
   assertSnapshotInactive(snapshot);
   validateDumpEnvelope(snapshot);
   validateSnapshotMigration(snapshot.migration, snapshot.sourceHash);
-  if (snapshot.executionSemantics !== EXECUTION_SEMANTICS && (snapshot.executionSemantics !== void 0 || snapshot.promiseReplay !== void 0 || snapshot.replay !== void 0 || snapshot.initialInputs !== void 0)) {
+  if (snapshot.executionSemantics !== EXECUTION_SEMANTICS && snapshot.executionSemantics !== "jobs-v6" && (snapshot.executionSemantics !== void 0 || snapshot.promiseReplay !== void 0 || snapshot.replay !== void 0 || snapshot.initialInputs !== void 0)) {
     throw new SnapshotValidationError(
       "unsupportedVersion",
       "$.executionSemantics",
@@ -23942,7 +23944,7 @@ function isAssignableSandboxTarget(value) {
   return typeof value === "object" && value !== null && !isSandboxClosure(value) && !isSandboxMap(value) && !isSandboxSet(value) && !isSandboxPromise(value) && !isSandboxRegex(value);
 }
 async function arrayFromSandboxValues(args, budget) {
-  const [items, mapFn] = args;
+  const [items, mapFn, thisValue] = args;
   const iterator = getSandboxIterator(items);
   const values = iterator === void 0 ? Reflect.apply(Array.from, Array, [items]) : await collectIteratorValues(iterator);
   if (mapFn === void 0 || !isSandboxClosure(mapFn)) {
@@ -23953,7 +23955,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 !== void 0) {
       await result.synchronousPrefix;
     }
@@ -24116,17 +24118,17 @@ async function callArrayMethodUnlocked(value, methodName, args, options, stack)
   switch (methodName) {
     case "map":
       return budgetProducedValue(
-        await mapArray(value, getRequiredCallback(methodName, args[0]), options, stack),
+        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),
+        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),
+        await findInArray(value, getRequiredCallback(methodName, args[0]), options, stack, args[1]),
         options.budget
       );
     case "findIndex":
@@ -24134,11 +24136,18 @@ async function callArrayMethodUnlocked(value, methodName, args, options, stack)
         value,
         getRequiredCallback(methodName, args[0]),
         options,
-        stack
+        stack,
+        args[1]
       );
     case "findLast":
       return budgetProducedValue(
-        await findLastInArray(value, getRequiredCallback(methodName, args[0]), options, stack),
+        await findLastInArray(
+          value,
+          getRequiredCallback(methodName, args[0]),
+          options,
+          stack,
+          args[1]
+        ),
         options.budget
       );
     case "findLastIndex":
@@ -24146,12 +24155,25 @@ async function callArrayMethodUnlocked(value, methodName, args, options, stack)
         value,
         getRequiredCallback(methodName, args[0]),
         options,
-        stack
+        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(
@@ -24177,11 +24199,17 @@ async function callArrayMethodUnlocked(value, methodName, args, 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 void 0;
     case "flatMap":
       return budgetProducedValue(
-        await flatMapArray(value, getRequiredCallback(methodName, args[0]), options, stack),
+        await flatMapArray(
+          value,
+          getRequiredCallback(methodName, args[0]),
+          options,
+          stack,
+          args[1]
+        ),
         options.budget
       );
     case "flat":
@@ -24318,83 +24346,91 @@ 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 ? void 0 : 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] : void 0;
-    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] : void 0;
-    if (await callArrayCallback(callback, entry, index, value, options, stack)) {
+    if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
       return entry;
     }
   }
   return void 0;
 }
-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] : void 0;
-    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;
     }
   }
@@ -24442,23 +24478,31 @@ 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)) {
@@ -24530,8 +24574,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) {
@@ -24721,7 +24765,7 @@ 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 {
         leaveCallback();
@@ -25490,7 +25534,7 @@ 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 {
         leaveCallback();
@@ -28069,19 +28113,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, void 0, 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, void 0, 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, void 0, thisValue)
   };
 }
 function createFunctionMethodOptions(context) {
@@ -28609,6 +28653,8 @@ function run(source, options = {}) {
       options.signal?.addEventListener("abort", captureCancellationSnapshot, { once: true });
       try {
         const restoredSnapshot = options.snapshot === void 0 ? void 0 : 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 !== void 0) {
           leaveSnapshotRun = enterSnapshotRun(restoredSnapshot);
         }
@@ -28634,13 +28680,15 @@ function run(source, options = {}) {
           ...restoredSnapshot,
           resumeNodeId: restoredSnapshot.pendingAwaits?.[0]?.nodeId
         } : void 0;
-        const callerBindings = options.bindings === void 0 ? {} : wrapCallerInjectedBindings(options.bindings, {
-          budget,
-          hostCalls,
-          moduleId: "<bindings>",
-          signal: options.signal,
-          lifecycle
-        });
+        const callerBindings = convertInitialInput(
+          () => options.bindings === void 0 ? {} : wrapCallerInjectedBindings(options.bindings, {
+            budget,
+            hostCalls,
+            moduleId: "<bindings>",
+            signal: options.signal,
+            lifecycle
+          })
+        );
         const builtinBindings = {
           ...createConsoleJsonGlobals({
             budget,
@@ -28665,7 +28713,9 @@ function run(source, options = {}) {
           }),
           ...createRegexGlobals()
         };
-        const importMeta = deepCopyToSandbox(options.importMeta ?? {});
+        const importMeta = convertInitialInput(
+          () => deepCopyToSandbox(options.importMeta ?? {})
+        );
         if (restoredSnapshot?.migration !== void 0) {
           if (Object.hasOwn(importMeta, "migration"))
             throw new TypeError("import.meta.migration is reserved for migrated checkpoint state.");
@@ -28679,13 +28729,17 @@ function run(source, options = {}) {
         const initialInputs = prepareReplayInputs(
           {
             bindings: callerBindings,
-            imports: resolveModuleImports(module, options.modules, {
-              budget,
-              hostCalls,
-              signal: options.signal,
-              allowMissing: restoredSnapshot?.initialInputs !== void 0
-            }),
-            entryPointArgs: options.entryPointArgs === void 0 ? void 0 : deepCopyToSandbox([...options.entryPointArgs]),
+            imports: convertInitialInput(
+              () => resolveModuleImports(module, options.modules, {
+                budget,
+                hostCalls,
+                signal: options.signal,
+                allowMissing: restoredSnapshot?.initialInputs !== void 0
+              })
+            ),
+            entryPointArgs: convertInitialInput(
+              () => options.entryPointArgs === void 0 ? void 0 : deepCopyToSandbox([...options.entryPointArgs])
+            ),
             importMeta
           },
           restoredSnapshot?.initialInputs,
@@ -28751,6 +28805,7 @@ function run(source, options = {}) {
         });
         snapshotScheduler = activeSnapshotScheduler;
         createFailureSnapshot = () => createRunSnapshot({
+          executionSemantics,
           migration: restoredSnapshot?.migration,
           bindings: executionScope.snapshot().bindings,
           clock: options.clock,
@@ -28777,6 +28832,7 @@ function run(source, options = {}) {
               }
               const interpreterSnapshot2 = yieldPoint.snapshot();
               snapshot2 = createRunSnapshot({
+                executionSemantics,
                 migration: restoredSnapshot?.migration,
                 bindings: interpreterSnapshot2.bindings,
                 clock: options.clock,
@@ -28819,6 +28875,7 @@ function run(source, options = {}) {
               }
               const interpreterSnapshot2 = yieldPoint.snapshot();
               snapshot2 = createRunSnapshot({
+                executionSemantics,
                 migration: restoredSnapshot?.migration,
                 bindings: interpreterSnapshot2.bindings,
                 clock: options.clock,
@@ -28853,6 +28910,7 @@ function run(source, options = {}) {
           replayError = error.message;
         }
         const snapshot = createRunSnapshot({
+          executionSemantics,
           migration: restoredSnapshot?.migration,
           bindings: executionScope.snapshot().bindings,
           clock: options.clock,
@@ -29022,7 +29080,7 @@ function createExecutableNode(module) {
 function createRunSnapshot(input) {
   return {
     version: DUMP_FORMAT_VERSION,
-    executionSemantics: EXECUTION_SEMANTICS,
+    executionSemantics: input.executionSemantics,
     sourceHash: input.sourceHash,
     ...input.migration === void 0 ? {} : { migration: structuredClone(input.migration) },
     bindings: input.bindings,
@@ -29135,4 +29193,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-3627FMJF.js.map
+//# sourceMappingURL=chunk-DXJLYASS.js.map