poe-code 11.0.22 → 11.0.24

package/dist/index.js

@@ -141613,7 +141613,7 @@ function invokeHostCallback(invoke2, options) {
   }
   lifecycle.hostCallbackDepth += 1;
   try {
-    const result = invoke2();
+    const result = lifecycle.hostCallbackContext.run(true, invoke2);
     if (isPromiseLike5(result)) {
       return Promise.resolve(result).finally(() => {
         lifecycle.hostCallbackDepth -= 1;
@@ -143060,7 +143060,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)) {
@@ -143071,7 +143071,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;
     }
@@ -143205,17 +143205,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":
@@ -143223,11 +143223,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":
@@ -143235,12 +143242,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(
@@ -143266,11 +143286,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":
@@ -143407,83 +143433,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;
     }
   }
@@ -143531,23 +143565,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)) {
@@ -143619,8 +143661,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) {
@@ -143850,7 +143892,7 @@ async function callMapMethod(target, methodName, args, options, stack = []) {
         const entries = [...target.entries];
         for (let index = 0; index < entries.length; index += 1) {
           const [key3, value] = entries[index];
-          await options.callClosure(callback, [value, key3, target], stack);
+          await options.callClosure(callback, [value, key3, target], stack, args[1]);
         }
       } finally {
         leaveCallback();
@@ -144665,7 +144707,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();
@@ -147219,19 +147261,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) {
@@ -147663,8 +147705,8 @@ function createDumpController(lifecycle) {
       }
       settlePendingSnapshot(createSnapshot());
     },
-    requestCurrentSnapshot() {
-      assertDumpAllowed();
+    requestCurrentSnapshot(options = {}) {
+      assertDumpAllowed(options);
       if (failed !== void 0) {
         return Promise.reject(failed.error);
       }
@@ -147675,10 +147717,10 @@ function createDumpController(lifecycle) {
           return Promise.reject(error3);
         }
       }
-      return this.requestSnapshot();
+      return this.requestSnapshot(options);
     },
     requestSnapshot(options = {}) {
-      assertDumpAllowed();
+      assertDumpAllowed(options);
       if (failed !== void 0) {
         if ((options.onFailure === "checkpoint" || options.onFailure === void 0 && isDataBudgetError(failed.error)) && finalSnapshot !== void 0) {
           try {
@@ -147700,6 +147742,9 @@ function createDumpController(lifecycle) {
           return Promise.reject(error3);
         }
       }
+      if (options.mode === "replay" && (latestSnapshot !== void 0 || latestSnapshotFactory !== void 0)) {
+        return this.requestCurrentSnapshot(options);
+      }
       if (pendingRequest !== void 0) {
         return pendingRequest.promise;
       }
@@ -147717,8 +147762,8 @@ function createDumpController(lifecycle) {
       return promise;
     }
   };
-  function assertDumpAllowed() {
-    if ((lifecycle?.hostCallbackDepth ?? 0) > 0) {
+  function assertDumpAllowed(options) {
+    if ((lifecycle?.hostCallbackDepth ?? 0) > 0 && (options.mode !== "replay" || lifecycle?.hostCallbackContext.getStore() === true)) {
       throw new SandboxError("reentry");
     }
   }
@@ -148163,8 +148208,12 @@ var init_replay_inputs = __esm({
 });
 
 // packages/safejs/src/run.ts
+import { AsyncLocalStorage as AsyncLocalStorage8 } from "node:async_hooks";
 function run(source, options = {}) {
-  const lifecycle = { hostCallbackDepth: 0 };
+  const lifecycle = {
+    hostCallbackDepth: 0,
+    hostCallbackContext: new AsyncLocalStorage8()
+  };
   const dumpController = createDumpController(lifecycle);
   const promiseTracker = createSandboxPromiseRejectionTracker();
   let completedSnapshot;
@@ -148470,6 +148519,7 @@ function run(source, options = {}) {
         dumpController.fail(error3);
         throw error3;
       } finally {
+        lifecycle.hostCallbackContext.disable();
         options.signal?.removeEventListener("abort", captureCancellationSnapshot);
         leaveInputReplay?.();
         leaveHostReplay?.();
@@ -149037,7 +149087,7 @@ var init_find_exported = __esm({
 });
 
 // packages/safejs/src/modules/agent.ts
-import { AsyncLocalStorage as AsyncLocalStorage8 } from "node:async_hooks";
+import { AsyncLocalStorage as AsyncLocalStorage9 } from "node:async_hooks";
 function createSpawnUsageAccumulator() {
   let inputTokens = 0;
   let outputTokens = 0;
@@ -149940,7 +149990,7 @@ var init_agent3 = __esm({
         hostErrorData.set(this, { result });
       }
     };
-    activeUsageAccumulator = new AsyncLocalStorage8();
+    activeUsageAccumulator = new AsyncLocalStorage9();
     oneAttemptRetryOptions = {
       maxAttempts: 1,
       backoffMs: 0,
@@ -155709,7 +155759,7 @@ var init_package2 = __esm({
   "package.json"() {
     package_default2 = {
       name: "poe-code",
-      version: "11.0.22",
+      version: "11.0.24",
       description: "CLI tool to configure Poe API for developer workflows.",
       license: "MIT",
       type: "module",