poe-code 13.0.1 → 13.0.3

package/package.json

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

package/packages/safe-js/dist/chunks/{chunk-DALBPQDZ.js → chunk-73LWNNUG.js}

@@ -18670,14 +18670,6 @@ function enterRunningState(object) {
     runningObjects.delete(object);
   };
 }
-function enterCollectionCallback(object) {
-  const leaveRunning = enterRunningState(object);
-  lockedCollections.add(object);
-  return () => {
-    lockedCollections.delete(object);
-    leaveRunning();
-  };
-}
 function assertCollectionMutable(object) {
   if (lockedCollections.has(object)) {
     throw new SandboxError("reentry");
@@ -24158,6 +24150,85 @@ function assertStructuredCloneable(value, seen) {
   }
 }
 
+// packages/safe-js/src/interp/string-coercion.ts
+function sandboxString(value, budget, context, joining = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value !== "object") {
+    if (typeof value === "function") throw new TypeError("Expected a sandbox value.");
+    return budget.allocateString(String(value));
+  }
+  return stringifyObject2(value, budget, context, joining);
+}
+async function stringifyObject2(value, budget, context, joining) {
+  const leaveCall = budget.enterCall();
+  try {
+    budget.visitNode();
+    for (const name of ["toString", "valueOf"]) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, name);
+      let result;
+      if (descriptor === void 0) {
+        if (name === "valueOf") continue;
+        result = await defaultToString(value, budget, context, joining);
+      } else {
+        const hook = ownDataValue(value, name);
+        if (!isSandboxClosure(hook)) continue;
+        if (context?.invokeClosure === void 0) {
+          throw new TypeError("String hooks require a sandbox call context.");
+        }
+        result = await context.invokeClosure(hook, [], value);
+      }
+      if (result === null || typeof result !== "object") {
+        return sandboxString(result, budget, context, joining);
+      }
+    }
+    throw new TypeError("Cannot convert object to primitive value");
+  } finally {
+    leaveCall();
+  }
+}
+async function defaultToString(value, budget, context, joining) {
+  if (Array.isArray(value) || isFloat32Array(value)) {
+    if (Object.hasOwn(value, "join")) {
+      const join = ownDataValue(value, "join");
+      if (!isSandboxClosure(join))
+        return isFloat32Array(value) ? "[object Float32Array]" : "[object Array]";
+      if (context?.invokeClosure === void 0) {
+        throw new TypeError("String hooks require a sandbox call context.");
+      }
+      return context.invokeClosure(join, [], value);
+    }
+    if (joining.has(value)) return "";
+    joining.add(value);
+    try {
+      const length = isFloat32Array(value) ? float32Storage(value).length : value.length;
+      let text = "";
+      for (let index = 0; index < length; index++) {
+        budget.visitNode();
+        const element = ownDataValue(value, String(index));
+        const part = element === null || element === void 0 ? "" : await sandboxString(element, budget, context, joining);
+        text = budget.allocateString(text + (index === 0 ? "" : ",") + part);
+      }
+      return text;
+    } finally {
+      joining.delete(value);
+    }
+  }
+  if (sandboxErrorTypes.has(value)) {
+    const nameValue = ownDataValue(value, "name");
+    const name = nameValue === void 0 ? "Error" : await sandboxString(nameValue, budget, context, joining);
+    const messageValue = ownDataValue(value, "message");
+    const message = messageValue === void 0 ? "" : await sandboxString(messageValue, budget, context, joining);
+    return name === "" ? message : message === "" ? name : `${name}: ${message}`;
+  }
+  return isSandboxPromise(value) ? "[object Promise]" : "[object Object]";
+}
+function ownDataValue(value, name) {
+  const descriptor = Object.getOwnPropertyDescriptor(value, name);
+  if (descriptor !== void 0 && !Object.hasOwn(descriptor, "value")) {
+    throw new TypeError("String conversion requires sandbox data properties.");
+  }
+  return descriptor?.value;
+}
+
 // packages/safe-js/src/interp/globals/object-array.ts
 function createObjectArrayGlobals(options) {
   return {
@@ -24253,9 +24324,7 @@ function createObjectArrayGlobals(options) {
     }),
     String: createSandboxClosure({
       sandbox: true,
-      call: ([value]) => options.budget.allocateString(
-        typeof value === "object" && value !== null && sandboxErrorTypes.has(value) && !Object.hasOwn(value, "toString") ? Error.prototype.toString.call(value) : String(value)
-      ),
+      call: (args, context) => sandboxString(args.length === 0 ? "" : args[0], options.budget, context),
       name: "String",
       properties: {
         raw: createSandboxClosure({
@@ -24543,7 +24612,7 @@ async function callArrayMethod(value, methodName, args, options, stack = []) {
   if (isCallbackArrayMethod(methodName)) {
     let callbackState = activeArrayCallbacks.get(value);
     if (callbackState === void 0) {
-      callbackState = { depth: 0, leave: enterCollectionCallback(value) };
+      callbackState = { depth: 0, leave: enterRunningState(value) };
       activeArrayCallbacks.set(value, callbackState);
     }
     callbackState.depth += 1;
@@ -24794,42 +24863,63 @@ function getRequiredCallback(methodName, value) {
 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;
+  options.budget.setRetainedValues(result, () => [result]);
+  try {
+    for (let index = 0; index < length; index += 1) {
+      options.budget.visitNode();
+      if (!(index in value)) {
+        continue;
+      }
+      result[index] = await callArrayCallback(
+        callback,
+        value[index],
+        index,
+        value,
+        options,
+        stack,
+        thisValue
+      );
     }
-    result[index] = await callArrayCallback(
-      callback,
-      value[index],
-      index,
-      value,
-      options,
-      stack,
-      thisValue
-    );
+    return result;
+  } finally {
+    options.budget.setRetainedValues(result, void 0);
   }
-  return result;
 }
 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, thisValue)) {
-      result.push(value[index]);
+  options.budget.setRetainedValues(result, () => [result]);
+  try {
+    for (let index = 0; index < length; index += 1) {
+      options.budget.visitNode();
+      if (!(index in value)) {
+        continue;
+      }
+      const entry = value[index];
+      if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
+        result.push(entry);
+      }
     }
+    return result;
+  } finally {
+    options.budget.setRetainedValues(result, void 0);
   }
-  return result;
 }
 async function findInArray(value, callback, options, stack, thisValue) {
-  const index = await findIndexInArray(value, callback, options, stack, thisValue);
-  return index < 0 ? void 0 : value[index];
+  const length = value.length;
+  for (let index = 0; index < length; index += 1) {
+    options.budget.visitNode();
+    const entry = index in value ? value[index] : void 0;
+    if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
+      return entry;
+    }
+  }
+  return void 0;
 }
 async function findIndexInArray(value, callback, options, stack, thisValue) {
   const length = value.length;
   for (let index = 0; index < length; index += 1) {
+    options.budget.visitNode();
     const entry = index in value ? value[index] : void 0;
     if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
       return index;
@@ -24840,6 +24930,7 @@ async function findIndexInArray(value, callback, options, stack, thisValue) {
 async function findLastInArray(value, callback, options, stack, thisValue) {
   const length = value.length;
   for (let index = length - 1; index >= 0; index -= 1) {
+    options.budget.visitNode();
     const entry = index in value ? value[index] : void 0;
     if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
       return entry;
@@ -24850,6 +24941,7 @@ async function findLastInArray(value, callback, options, stack, thisValue) {
 async function findLastIndexInArray(value, callback, options, stack, thisValue) {
   const length = value.length;
   for (let index = length - 1; index >= 0; index -= 1) {
+    options.budget.visitNode();
     const entry = index in value ? value[index] : void 0;
     if (await callArrayCallback(callback, entry, index, value, options, stack, thisValue)) {
       return index;
@@ -24860,6 +24952,7 @@ async function findLastIndexInArray(value, callback, options, stack, thisValue)
 async function someInArray(value, callback, options, stack, thisValue) {
   const length = value.length;
   for (let index = 0; index < length; index += 1) {
+    options.budget.visitNode();
     if (!(index in value)) {
       continue;
     }
@@ -24872,6 +24965,7 @@ async function someInArray(value, callback, options, stack, thisValue) {
 async function everyInArray(value, callback, options, stack, thisValue) {
   const length = value.length;
   for (let index = 0; index < length; index += 1) {
+    options.budget.visitNode();
     if (!(index in value)) {
       continue;
     }
@@ -24883,10 +24977,10 @@ async function everyInArray(value, callback, options, stack, thisValue) {
 }
 async function reduceArray(value, callback, hasInitialValue, initialValue, options, stack) {
   const length = value.length;
-  const start = findNextDefinedIndex(value, 0, 1, length);
   if (hasInitialValue) {
-    return reduceFromLeft(value, callback, initialValue, start, length, options, stack);
+    return reduceFromLeft(value, callback, initialValue, 0, length, options, stack);
   }
+  const start = findNextDefinedIndex(value, 0, 1, length, options.budget);
   if (start < 0) {
     throw new TypeError("Reduce of empty array with no initial value.");
   }
@@ -24894,10 +24988,10 @@ async function reduceArray(value, callback, hasInitialValue, initialValue, optio
 }
 async function reduceRightArray(value, callback, hasInitialValue, initialValue, options, stack) {
   const length = value.length;
-  const start = findNextDefinedIndex(value, length - 1, -1, length);
   if (hasInitialValue) {
-    return reduceFromRight(value, callback, initialValue, start, length, options, stack);
+    return reduceFromRight(value, callback, initialValue, length - 1, length, options, stack);
   }
+  const start = findNextDefinedIndex(value, length - 1, -1, length, options.budget);
   if (start < 0) {
     throw new TypeError("Reduce of empty array with no initial value.");
   }
@@ -24905,27 +24999,42 @@ async function reduceRightArray(value, callback, hasInitialValue, initialValue,
 }
 async function reduceFromLeft(value, callback, accumulator, startIndex, length, options, stack) {
   let current = accumulator;
-  for (let index = startIndex; index < length; index += 1) {
-    if (!(index in value)) {
-      continue;
+  const retainedAccumulator = {};
+  options.budget.setRetainedValues(retainedAccumulator, () => [current]);
+  try {
+    for (let index = startIndex; index < length; index += 1) {
+      options.budget.visitNode();
+      if (!(index in value)) {
+        continue;
+      }
+      current = await options.callClosure(callback, [current, value[index], index, value], stack);
     }
-    current = await options.callClosure(callback, [current, value[index], index, value], stack);
+    return current;
+  } finally {
+    options.budget.setRetainedValues(retainedAccumulator, void 0);
   }
-  return current;
 }
 async function reduceFromRight(value, callback, accumulator, startIndex, length, options, stack) {
   let current = accumulator;
-  for (let index = Math.min(startIndex, length - 1); index >= 0; index -= 1) {
-    if (!(index in value)) {
-      continue;
+  const retainedAccumulator = {};
+  options.budget.setRetainedValues(retainedAccumulator, () => [current]);
+  try {
+    for (let index = Math.min(startIndex, length - 1); index >= 0; index -= 1) {
+      options.budget.visitNode();
+      if (!(index in value)) {
+        continue;
+      }
+      current = await options.callClosure(callback, [current, value[index], index, value], stack);
     }
-    current = await options.callClosure(callback, [current, value[index], index, value], stack);
+    return current;
+  } finally {
+    options.budget.setRetainedValues(retainedAccumulator, void 0);
   }
-  return current;
 }
 async function forEachArray(value, callback, options, stack, thisValue) {
   const length = value.length;
   for (let index = 0; index < length; index += 1) {
+    options.budget.visitNode();
     if (!(index in value)) {
       continue;
     }
@@ -24935,33 +25044,40 @@ async function forEachArray(value, callback, options, stack, thisValue) {
 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,
-      thisValue
-    );
-    if (Array.isArray(mapped)) {
-      for (let mappedIndex = 0; mappedIndex < mapped.length; mappedIndex += 1) {
-        if (!(mappedIndex in mapped)) {
-          continue;
+  options.budget.setRetainedValues(result, () => [result]);
+  try {
+    for (let index = 0; index < length; index += 1) {
+      options.budget.visitNode();
+      if (!(index in value)) {
+        continue;
+      }
+      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) {
+          options.budget.visitNode();
+          if (!(mappedIndex in mapped)) {
+            continue;
+          }
+          result.push(mapped[mappedIndex]);
+          options.budget.allocateArrayLength(result.length);
         }
-        result.push(mapped[mappedIndex]);
-        options.budget.allocateArrayLength(result.length);
+        continue;
       }
-      continue;
+      result.push(mapped);
+      options.budget.allocateArrayLength(result.length);
     }
-    result.push(mapped);
-    options.budget.allocateArrayLength(result.length);
+    return result;
+  } finally {
+    options.budget.setRetainedValues(result, void 0);
   }
-  return result;
 }
 function flattenArray(value, depth, budget) {
   const result = [];
@@ -24983,47 +25099,59 @@ function appendFlattenedEntries(value, depth, result, budget) {
   }
 }
 async function sortArray(value, comparator, options, stack) {
+  const length = value.length;
   const definedValues = [];
   let undefinedCount = 0;
-  for (let index = 0; index < value.length; index += 1) {
-    if (!(index in value)) {
-      continue;
+  let currentEntry;
+  options.budget.setRetainedValues(definedValues, () => [definedValues, currentEntry]);
+  try {
+    for (let index = 0; index < length; index += 1) {
+      options.budget.visitNode();
+      if (!(index in value)) {
+        continue;
+      }
+      const entry = value[index];
+      if (entry === void 0) {
+        undefinedCount += 1;
+        continue;
+      }
+      definedValues.push(entry);
     }
-    const entry = value[index];
-    if (entry === void 0) {
-      undefinedCount += 1;
-      continue;
+    for (let index = 1; index < definedValues.length; index += 1) {
+      currentEntry = definedValues[index];
+      let cursor = index - 1;
+      while (cursor >= 0 && await compareEntries(definedValues[cursor], currentEntry, comparator, options, stack) > 0) {
+        definedValues[cursor + 1] = definedValues[cursor];
+        cursor -= 1;
+      }
+      definedValues[cursor + 1] = currentEntry;
     }
-    definedValues.push(entry);
-  }
-  for (let index = 1; index < definedValues.length; index += 1) {
-    const entry = definedValues[index];
-    let cursor = index - 1;
-    while (cursor >= 0 && await compareEntries(definedValues[cursor], entry, comparator, options, stack) > 0) {
-      definedValues[cursor + 1] = definedValues[cursor];
-      cursor -= 1;
+    currentEntry = void 0;
+    for (let index = 0; index < definedValues.length; index += 1) {
+      value[index] = definedValues[index];
     }
-    definedValues[cursor + 1] = entry;
-  }
-  for (let index = 0; index < definedValues.length; index += 1) {
-    value[index] = definedValues[index];
-  }
-  for (let index = 0; index < undefinedCount; index += 1) {
-    value[definedValues.length + index] = void 0;
-  }
-  for (let index = definedValues.length + undefinedCount; index < value.length; index += 1) {
-    delete value[index];
+    for (let index = 0; index < undefinedCount; index += 1) {
+      value[definedValues.length + index] = void 0;
+    }
+    for (let index = definedValues.length + undefinedCount; index < length; index += 1) {
+      options.budget.visitNode();
+      delete value[index];
+    }
+  } finally {
+    options.budget.setRetainedValues(definedValues, void 0);
   }
 }
 async function compareEntries(left, right, comparator, options, stack) {
+  options.budget.visitNode();
   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, thisValue) {
   return options.callClosure(callback, [value, index, array], stack, thisValue);
 }
-function findNextDefinedIndex(value, startIndex, direction, length) {
+function findNextDefinedIndex(value, startIndex, direction, length, budget) {
   for (let index = startIndex; direction > 0 ? index < length : index >= 0; index += direction) {
+    budget.visitNode();
     if (index in value) {
       return index;
     }
@@ -28712,6 +28840,7 @@ async function invokeSandboxClosure(callee, args, context, stack, span, thisValu
       {
         stack,
         thisValue,
+        invokeClosure: (closure, argumentsList, receiver) => invokeSandboxClosure(closure, argumentsList, context, stack, span, receiver),
         ...span === void 0 ? {} : { span }
       }
     ]);
@@ -29763,4 +29892,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-DALBPQDZ.js.map
+//# sourceMappingURL=chunk-73LWNNUG.js.map