poe-code 14.0.57 → 14.0.59

package/dist/index.js

@@ -144084,6 +144084,50 @@ var init_var_hoist = __esm({
   }
 });
 
+// packages/safe-js/src/interp/resources.ts
+import { AsyncLocalStorage as AsyncLocalStorage8 } from "node:async_hooks";
+async function withRunResources(signal, execute2) {
+  const controller = new AbortController();
+  const cancel2 = () => controller.abort(signal?.reason);
+  const cleanups = /* @__PURE__ */ new Set();
+  const resources = {
+    signal: controller.signal,
+    referenceReleases: /* @__PURE__ */ new Set(),
+    add(close) {
+      cleanups.add(close);
+    }
+  };
+  signal?.addEventListener("abort", cancel2, { once: true });
+  if (signal?.aborted) cancel2();
+  let result;
+  let failure;
+  let errors2 = [];
+  try {
+    result = await runResources.run(resources, execute2);
+  } catch (error3) {
+    failure = { reason: error3 };
+  } finally {
+    signal?.removeEventListener("abort", cancel2);
+    controller.abort(new Error("SafeJS run finished."));
+    for (const release2 of resources.referenceReleases) release2();
+    resources.referenceReleases.clear();
+    const outcomes = await Promise.allSettled(
+      [...cleanups].map((close) => Promise.resolve().then(close))
+    );
+    errors2 = outcomes.flatMap((outcome) => outcome.status === "rejected" ? [outcome.reason] : []);
+  }
+  if (failure !== void 0) throw failure.reason;
+  if (errors2.length > 0) throw new AggregateError(errors2, "SafeJS resource cleanup failed.");
+  return result;
+}
+var runResources;
+var init_resources = __esm({
+  "packages/safe-js/src/interp/resources.ts"() {
+    "use strict";
+    runResources = new AsyncLocalStorage8();
+  }
+});
+
 // packages/safe-js/src/interp/methods/array.ts
 function getArrayMember(value, property, options) {
   const index = getArrayIndex(property);
@@ -146855,89 +146899,110 @@ async function evaluateEmptyStatement(_node, _context) {
 }
 async function evaluateArrayExpression(node, context) {
   const values = [];
-  for (const element of node.elements) {
-    if (element.type === "UndefinedLiteral" && element.elision === true) {
-      values.length += 1;
-      context.budget.allocateArrayLength(values.length);
-      continue;
-    }
-    if (element.type === "SpreadElement") {
-      const spreadValues = await evaluateSpreadElement(element, context);
-      if (!spreadValues.ok) {
-        return spreadValues.result;
+  const release2 = retainValues(context.budget, () => [values]);
+  try {
+    for (const element of node.elements) {
+      if (element.type === "UndefinedLiteral" && element.elision === true) {
+        values.length += 1;
+        context.budget.allocateArrayLength(values.length);
+        continue;
+      }
+      if (element.type === "SpreadElement") {
+        const spreadValues = await evaluateSpreadElement(element, context);
+        if (!spreadValues.ok) {
+          return spreadValues.result;
+        }
+        appendArrayValues2(values, spreadValues.value);
+        context.budget.allocateArrayLength(values.length);
+        continue;
       }
-      appendArrayValues2(values, spreadValues.value);
+      const result = await evaluateNode2(element, context);
+      if (result.kind !== "normal") {
+        return result;
+      }
+      values.push(result.value);
       context.budget.allocateArrayLength(values.length);
-      continue;
     }
-    const result = await evaluateNode2(element, context);
-    if (result.kind !== "normal") {
-      return result;
-    }
-    values.push(result.value);
-    context.budget.allocateArrayLength(values.length);
+    return {
+      kind: "normal",
+      hasValue: true,
+      value: values
+    };
+  } finally {
+    release2();
   }
-  return {
-    kind: "normal",
-    hasValue: true,
-    value: values
-  };
 }
 async function evaluateObjectExpression(node, context) {
   const object = /* @__PURE__ */ Object.create(null);
-  for (const property of node.properties) {
-    if (property.type === "SpreadElement") {
-      const spreadEntries = await evaluateObjectSpread(property, context);
-      if (!spreadEntries.ok) {
-        return spreadEntries.result;
+  const release2 = retainValues(context.budget, () => [object]);
+  try {
+    for (const property of node.properties) {
+      if (property.type === "SpreadElement") {
+        const spreadEntries = await evaluateObjectSpread(property, context);
+        if (!spreadEntries.ok) {
+          return spreadEntries.result;
+        }
+        for (const [key4, value2] of spreadEntries.value) {
+          defineSandboxProperty(object, key4, value2);
+        }
+        continue;
       }
-      for (const [key4, value2] of spreadEntries.value) {
-        defineSandboxProperty(object, key4, value2);
+      const key3 = await evaluateObjectPropertyKey(property, context);
+      if (!key3.ok) {
+        return key3.result;
       }
-      continue;
-    }
-    const key3 = await evaluateObjectPropertyKey(property, context);
-    if (!key3.ok) {
-      return key3.result;
-    }
-    const value = await evaluateNode2(property.value, context);
-    if (value.kind !== "normal") {
-      return value;
-    }
-    if (isObjectPrototypeSetterProperty(property, key3.value)) {
-      if (value.value === null || typeof value.value === "object") {
-        setSandboxPrototype(object, value.value, context.budget);
+      const releaseKey = retainValues(context.budget, () => [key3.value]);
+      let value;
+      try {
+        value = await evaluateNode2(property.value, context);
+      } finally {
+        releaseKey();
       }
-      continue;
+      if (value.kind !== "normal") {
+        return value;
+      }
+      if (isObjectPrototypeSetterProperty(property, key3.value)) {
+        if (value.value === null || typeof value.value === "object") {
+          setSandboxPrototype(object, value.value, context.budget);
+        }
+        continue;
+      }
+      defineSandboxProperty(object, String(key3.value), value.value);
     }
-    defineSandboxProperty(object, String(key3.value), value.value);
+    return {
+      kind: "normal",
+      hasValue: true,
+      value: object
+    };
+  } finally {
+    release2();
   }
-  return {
-    kind: "normal",
-    hasValue: true,
-    value: object
-  };
 }
 function isObjectPrototypeSetterProperty(property, key3) {
   return !property.computed && !property.shorthand && key3 === "__proto__";
 }
 async function evaluateTemplateLiteral(node, context) {
   let value = context.budget.allocateString(node.quasis[0]?.value.cooked ?? "");
-  for (let index = 0; index < node.expressions.length; index += 1) {
-    const expression = await evaluateNode2(node.expressions[index], context);
-    if (expression.kind !== "normal") {
-      return expression;
+  const release2 = retainValues(context.budget, () => [value]);
+  try {
+    for (let index = 0; index < node.expressions.length; index += 1) {
+      const expression = await evaluateNode2(node.expressions[index], context);
+      if (expression.kind !== "normal") {
+        return expression;
+      }
+      const expressionText = context.budget.allocateString(String(expression.value));
+      value = context.budget.allocateString(value + expressionText);
+      const quasiText = context.budget.allocateString(node.quasis[index + 1]?.value.cooked ?? "");
+      value = context.budget.allocateString(value + quasiText);
     }
-    const expressionText = context.budget.allocateString(String(expression.value));
-    value = context.budget.allocateString(value + expressionText);
-    const quasiText = context.budget.allocateString(node.quasis[index + 1]?.value.cooked ?? "");
-    value = context.budget.allocateString(value + quasiText);
+    return {
+      kind: "normal",
+      hasValue: true,
+      value
+    };
+  } finally {
+    release2();
   }
-  return {
-    kind: "normal",
-    hasValue: true,
-    value
-  };
 }
 async function evaluateTaggedTemplateExpression(node, context) {
   const tag = await evaluateNode2(node.tag, context);
@@ -146964,20 +147029,25 @@ async function evaluateTaggedTemplateExpression(node, context) {
 }
 async function evaluateTemplateExpressionValues(node, context) {
   const values = [];
-  for (const expressionNode of node.expressions) {
-    const expression = await evaluateNode2(expressionNode, context);
-    if (expression.kind !== "normal") {
-      return {
-        ok: false,
-        result: expression
-      };
+  const release2 = retainValues(context.budget, () => values);
+  try {
+    for (const expressionNode of node.expressions) {
+      const expression = await evaluateNode2(expressionNode, context);
+      if (expression.kind !== "normal") {
+        return {
+          ok: false,
+          result: expression
+        };
+      }
+      values.push(expression.value);
     }
-    values.push(expression.value);
+    return {
+      ok: true,
+      value: values
+    };
+  } finally {
+    release2();
   }
-  return {
-    ok: true,
-    value: values
-  };
 }
 function createTaggedTemplateStrings(node, context) {
   context.budget.allocateArrayLength(node.quasis.length);
@@ -147025,23 +147095,30 @@ async function evaluateBinaryExpression(node, context) {
   if (left.kind !== "normal") {
     return left;
   }
-  const right = await evaluateNode2(node.right, context);
-  if (right.kind !== "normal") {
-    return right;
-  }
-  let leftValue = left.value;
-  if (node.operator === "in") {
-    if (typeof right.value !== "object" || right.value === null) {
-      throw new TypeError("Right-hand side of 'in' must be an object.");
+  let rightValue;
+  const release2 = retainValues(context.budget, () => [left.value, rightValue]);
+  try {
+    const right = await evaluateNode2(node.right, context);
+    if (right.kind !== "normal") {
+      return right;
+    }
+    rightValue = right.value;
+    let leftValue = left.value;
+    if (node.operator === "in") {
+      if (typeof right.value !== "object" || right.value === null) {
+        throw new TypeError("Right-hand side of 'in' must be an object.");
+      }
+      leftValue = await toPropertyKey(leftValue, context.budget, createCoercionContext(context));
     }
-    leftValue = await toPropertyKey(leftValue, context.budget, createCoercionContext(context));
+    const value = applyBinaryOperator(node, leftValue, right.value, context);
+    return {
+      kind: "normal",
+      hasValue: true,
+      value
+    };
+  } finally {
+    release2();
   }
-  const value = applyBinaryOperator(node, leftValue, right.value, context);
-  return {
-    kind: "normal",
-    hasValue: true,
-    value
-  };
 }
 async function evaluateAssignmentExpression(node, context) {
   if (node.left.type === "ArrayPattern" || node.left.type === "ObjectPattern") {
@@ -147114,61 +147191,64 @@ async function evaluateMemberAssignmentExpression(node, context) {
   if (node.left.type !== "MemberExpression") {
     throw new TypeError("Expected member assignment target.");
   }
-  const member = await evaluateMemberAccess(node.left, context);
-  if (member.kind === "error") {
-    return member;
-  }
-  if (member.kind === "completion") {
-    return member.result;
-  }
-  if (member.kind === "nullish") {
-    throw new TypeError("Cannot assign properties of null or undefined.");
-  }
-  let property;
-  let current = void 0;
-  if (node.operator !== "=") {
-    if (member.object === null || member.object === void 0) {
+  return evaluateMemberAccess(node.left, context, async (member) => {
+    if (member.kind === "nullish") {
       throw new TypeError("Cannot assign properties of null or undefined.");
     }
-    property = await toPropertyKey(member.property, context.budget, createCoercionContext(context));
-    current = getPropertyValue(member.object, property, context);
-  }
-  if (node.operator === "&&=" && !isTruthy(current)) {
-    return {
-      kind: "normal",
-      hasValue: true,
-      value: current
-    };
-  }
-  if (node.operator === "||=" && isTruthy(current)) {
-    return {
-      kind: "normal",
-      hasValue: true,
-      value: current
-    };
-  }
-  if (node.operator === "??=" && current !== null && current !== void 0) {
-    return {
-      kind: "normal",
-      hasValue: true,
-      value: current
-    };
-  }
-  const right = await evaluateNode2(node.right, context);
-  if (right.kind !== "normal") {
-    return right;
-  }
-  const value = node.operator === "=" || node.operator === "&&=" || node.operator === "||=" || node.operator === "??=" ? right.value : await applyCompoundAssignmentOperator(node.operator, current, right.value, context);
-  if (member.object === null || member.object === void 0) {
-    throw new TypeError("Cannot assign properties of null or undefined.");
-  }
-  property ??= await toPropertyKey(member.property, context.budget, createCoercionContext(context));
-  setSandboxProperty(member.object, property, value, context.budget);
-  return {
-    kind: "normal",
-    hasValue: true,
-    value
-  };
+    let property;
+    let current = void 0;
+    if (node.operator !== "=") {
+      if (member.object === null || member.object === void 0) {
+        throw new TypeError("Cannot assign properties of null or undefined.");
+      }
+      property = await toPropertyKey(member.property, context.budget, createCoercionContext(context));
+      current = getPropertyValue(member.object, property, context);
+    }
+    if (node.operator === "&&=" && !isTruthy(current)) {
+      return {
+        kind: "normal",
+        hasValue: true,
+        value: current
+      };
+    }
+    if (node.operator === "||=" && isTruthy(current)) {
+      return {
+        kind: "normal",
+        hasValue: true,
+        value: current
+      };
+    }
+    if (node.operator === "??=" && current !== null && current !== void 0) {
+      return {
+        kind: "normal",
+        hasValue: true,
+        value: current
+      };
+    }
+    let operands = [current, property];
+    const release2 = retainValues(context.budget, () => operands);
+    try {
+      const right = await evaluateNode2(node.right, context);
+      if (right.kind !== "normal") {
+        return right;
+      }
+      operands.push(right.value);
+      const value = node.operator === "=" || node.operator === "&&=" || node.operator === "||=" || node.operator === "??=" ? right.value : await applyCompoundAssignmentOperator(node.operator, current, right.value, context);
+      if (member.object === null || member.object === void 0) {
+        throw new TypeError("Cannot assign properties of null or undefined.");
+      }
+      operands = [value];
+      property ??= await toPropertyKey(member.property, context.budget, createCoercionContext(context));
+      setSandboxProperty(member.object, property, value, context.budget);
+      return {
+        kind: "normal",
+        hasValue: true,
+        value
+      };
+    } finally {
+      release2();
+    }
+  });
 }
 async function evaluateLogicalExpression(node, context) {
   const left = await evaluateNode2(node.left, context);
@@ -148147,33 +148227,28 @@ async function evaluateDeleteExpression(node, context) {
       "Unary operator 'delete' requires a member target."
     );
   }
-  const member = await evaluateMemberAccess(node.argument, context);
-  if (member.kind === "error") {
-    return member;
-  }
-  if (member.kind === "completion") {
-    return member.result;
-  }
-  if (member.kind === "nullish" || member.object === null || member.object === void 0) {
-    if (member.kind === "nullish" && node.argument.optional) {
-      return {
-        kind: "normal",
-        hasValue: true,
-        value: true
-      };
+  return evaluateMemberAccess(node.argument, context, async (member) => {
+    if (member.kind === "nullish" || member.object === null || member.object === void 0) {
+      if (member.kind === "nullish") {
+        return {
+          kind: "normal",
+          hasValue: true,
+          value: true
+        };
+      }
+      throw new TypeError("Cannot delete properties of null or undefined.");
     }
-    throw new TypeError("Cannot delete properties of null or undefined.");
-  }
-  if (!isIndexableSandboxValue(member.object)) {
-    throw new TypeError("Unary operator 'delete' requires a sandbox object property.");
-  }
-  const property = await toPropertyKey(member.property, context.budget, createCoercionContext(context));
-  const deleted = deleteSandboxProperty(member.object, property);
-  return {
-    kind: "normal",
-    hasValue: true,
-    value: deleted
-  };
+    if (!isIndexableSandboxValue(member.object)) {
+      throw new TypeError("Unary operator 'delete' requires a sandbox object property.");
+    }
+    const property = await toPropertyKey(member.property, context.budget, createCoercionContext(context));
+    const deleted = deleteSandboxProperty(member.object, property);
+    return {
+      kind: "normal",
+      hasValue: true,
+      value: deleted
+    };
+  });
 }
 async function evaluateUpdateExpression(node, context) {
   if (node.argument.type === "Identifier") {
@@ -148209,41 +148284,35 @@ async function evaluateMemberUpdateExpression(node, context) {
   if (node.argument.type !== "MemberExpression") {
     throw new TypeError("Expected member update target.");
   }
-  const member = await evaluateMemberAccess(node.argument, context);
-  if (member.kind === "error") {
-    return member;
-  }
-  if (member.kind === "completion") {
-    return member.result;
-  }
-  if (member.kind === "nullish" || member.object === null || member.object === void 0) {
-    throw new TypeError("Cannot update properties of null or undefined.");
-  }
-  const property = await toPropertyKey(member.property, context.budget, createCoercionContext(context));
-  const current = toNumber(
-    await toNumericPrimitive(getPropertyValue(member.object, property, context), context)
-  );
-  const next = node.operator === "++" ? current + 1 : current - 1;
-  setSandboxProperty(member.object, property, next, context.budget);
-  return {
-    kind: "normal",
-    hasValue: true,
-    value: node.prefix ? next : current
-  };
+  return evaluateMemberAccess(node.argument, context, async (member) => {
+    if (member.kind === "nullish" || member.object === null || member.object === void 0) {
+      throw new TypeError("Cannot update properties of null or undefined.");
+    }
+    const property = await toPropertyKey(member.property, context.budget, createCoercionContext(context));
+    const current = toNumber(
+      await toNumericPrimitive(getPropertyValue(member.object, property, context), context)
+    );
+    const next = node.operator === "++" ? current + 1 : current - 1;
+    setSandboxProperty(member.object, property, next, context.budget);
+    return {
+      kind: "normal",
+      hasValue: true,
+      value: node.prefix ? next : current
+    };
+  });
 }
 async function evaluateMemberExpression(node, context) {
-  const member = await evaluateMemberAccess(node, context);
-  if (member.kind === "error") return member;
-  if (member.kind === "completion") return member.result;
-  if (member.kind === "nullish" || member.object === null || member.object === void 0) {
-    if (member.kind === "nullish" && node.optional) return { kind: "normal", hasValue: true, value: void 0 };
-    throw new TypeError("Cannot read properties of null or undefined.");
-  }
-  return {
-    kind: "normal",
-    hasValue: true,
-    value: getPropertyValue(member.object, await toPropertyKey(member.property, context.budget, createCoercionContext(context)), context)
-  };
+  return evaluateMemberAccess(node, context, async (member) => {
+    if (member.kind === "nullish" || member.object === null || member.object === void 0) {
+      if (member.kind === "nullish") return { kind: "normal", hasValue: true, value: void 0 };
+      throw new TypeError("Cannot read properties of null or undefined.");
+    }
+    return {
+      kind: "normal",
+      hasValue: true,
+      value: getPropertyValue(member.object, await toPropertyKey(member.property, context.budget, createCoercionContext(context)), context)
+    };
+  });
 }
 function getPropertyValue(target, property, context) {
   if (isGuestHostObject(target)) return getHostObjectMember(target, String(property));
@@ -148351,26 +148420,33 @@ function attachFatalSandboxErrorContext(error3, node, stackFrames) {
   attachErrorSpan(error3, node.span);
   replaceErrorStack(error3, stackFrames);
 }
-async function evaluateMemberAccess(node, context) {
+async function evaluateMemberAccess(node, context, consume) {
   const object = await evaluateNode2(node.object, context);
-  if (object.kind !== "normal") {
-    return {
-      kind: "completion",
-      result: object
-    };
-  }
+  if (object.kind !== "normal") return object;
   if ((object.value === null || object.value === void 0) && node.optional) {
-    return {
-      kind: "nullish"
-    };
+    return consume({ kind: "nullish" });
   }
-  const property = node.computed ? await evaluateNode2(node.property, context) : { kind: "normal", value: getStaticPropertyName2(node.property) };
-  if (property.kind !== "normal") return { kind: "completion", result: property };
-  return {
-    kind: "resolved",
-    object: object.value,
-    property: property.value
+  let property;
+  const release2 = retainValues(context.budget, () => [object.value, property]);
+  try {
+    const result = node.computed ? await evaluateNode2(node.property, context) : { kind: "normal", value: getStaticPropertyName2(node.property) };
+    if (result.kind !== "normal") return result;
+    property = result.value;
+    return await consume({ kind: "resolved", object: object.value, property });
+  } finally {
+    release2();
+  }
+}
+function retainValues(budget, values) {
+  const retained = {};
+  budget.setRetainedValues(retained, values);
+  const pending = runResources.getStore()?.referenceReleases;
+  const release2 = () => {
+    budget.setRetainedValues(retained, void 0);
+    pending?.delete(release2);
   };
+  pending?.add(release2);
+  return release2;
 }
 async function evaluateMemberProperty(node, context) {
   const property = await evaluateNode2(node, context);
@@ -148407,137 +148483,132 @@ async function evaluateMemberCallExpression(node, context) {
   if (node.callee.type !== "MemberExpression") {
     throw new TypeError("Expected member call expression.");
   }
-  const reference = await evaluateMemberAccess(node.callee, context);
-  if (reference.kind === "error") {
-    return reference;
-  }
-  if (reference.kind === "completion") {
-    return reference.result;
-  }
-  if (reference.kind === "nullish" || reference.object === null || reference.object === void 0) {
-    if (reference.kind === "nullish") {
-      return {
-        kind: "normal",
-        hasValue: true,
-        value: void 0
-      };
+  return evaluateMemberAccess(node.callee, context, async (reference) => {
+    if (reference.kind === "nullish" || reference.object === null || reference.object === void 0) {
+      if (reference.kind === "nullish") {
+        return {
+          kind: "normal",
+          hasValue: true,
+          value: void 0
+        };
+      }
+      throw new TypeError("Cannot read properties of null or undefined.");
     }
-    throw new TypeError("Cannot read properties of null or undefined.");
-  }
-  const member = {
-    ...reference,
-    property: await toPropertyKey(reference.property, context.budget, createCoercionContext(context))
-  };
-  if (typeof member.object === "string" && isStringMethodName(member.property)) {
-    return evaluateStringMethodCall(node, member.object, member.property, context);
-  }
-  if (typeof member.object === "number" && isNumberMethodName(member.property)) {
-    return evaluateNumberMethodCall(node, member.object, member.property, context);
-  }
-  if (Array.isArray(member.object) && isArrayMethodName(member.property) && !Object.hasOwn(member.object, member.property)) {
-    return evaluateArrayMethodCall(node, member.object, member.property, context);
-  }
-  if (isSandboxMap(member.object) && isMapMethodName(member.property)) {
-    return evaluateMapMethodCall(node, member.object, member.property, context);
-  }
-  if (isSandboxSet(member.object) && isSetMethodName(member.property)) {
-    return evaluateSetMethodCall(node, member.object, member.property, context);
-  }
-  if (typeof member.object === "string") {
-    return evaluatePrimitiveMemberCall(
-      node,
-      "String",
-      member.property,
-      getStringMember(member.object, member.property, context.budget),
-      context
-    );
-  }
-  if (typeof member.object === "number") {
-    return evaluatePrimitiveMemberCall(
-      node,
-      "Number",
-      member.property,
-      getNumberMember(member.property, context.budget),
-      context
-    );
-  }
-  if (Array.isArray(member.object) && !Object.hasOwn(member.object, member.property)) {
-    return evaluatePrimitiveMemberCall(
-      node,
-      "Array",
-      member.property,
-      getArrayMemberValue(member.object, member.property, context),
-      context
-    );
-  }
-  if (isSandboxMap(member.object)) {
-    return evaluatePrimitiveMemberCall(
-      node,
-      "Map",
-      member.property,
-      getMapMember(member.object, member.property, createMapMethodOptions(context)),
-      context
-    );
-  }
-  if (isSandboxDate(member.object)) {
-    return evaluateResolvedCallExpression(node, getDateMember(member.property, context.budget, context.compilation?.owner), context, member.object);
-  }
-  if (isFloat32Array(member.object)) {
-    return evaluateResolvedCallExpression(
-      node,
-      getFloat32Member(member.object, member.property, context.budget),
-      context,
-      member.object
-    );
-  }
-  if (isSandboxSet(member.object)) {
-    return evaluatePrimitiveMemberCall(
-      node,
-      "Set",
-      member.property,
-      getSetMember(member.object, member.property, createSetMethodOptions(context)),
-      context
-    );
-  }
-  if (isSandboxGenerator(member.object)) {
-    const memberValue = getGeneratorMember(member.object, member.property, context.budget);
-    if (memberValue === void 0) {
-      throw new TypeError(`Generator#${String(member.property)} is not a supported method.`);
+    const member = {
+      ...reference,
+      property: await toPropertyKey(reference.property, context.budget, createCoercionContext(context))
+    };
+    if (typeof member.object === "string" && isStringMethodName(member.property)) {
+      return evaluateStringMethodCall(node, member.object, member.property, context);
     }
-    return evaluateResolvedCallExpression(node, memberValue, context, member.object);
-  }
-  if (isSandboxClosure(member.object)) {
-    const memberValue = getClosureMemberValue(member.object, member.property, context);
-    if (memberValue === void 0) {
-      throw new TypeError(`Function#${String(member.property)} is not a supported method.`);
+    if (typeof member.object === "number" && isNumberMethodName(member.property)) {
+      return evaluateNumberMethodCall(node, member.object, member.property, context);
+    }
+    if (Array.isArray(member.object) && isArrayMethodName(member.property) && !Object.hasOwn(member.object, member.property)) {
+      return evaluateArrayMethodCall(node, member.object, member.property, context);
+    }
+    if (isSandboxMap(member.object) && isMapMethodName(member.property)) {
+      return evaluateMapMethodCall(node, member.object, member.property, context);
+    }
+    if (isSandboxSet(member.object) && isSetMethodName(member.property)) {
+      return evaluateSetMethodCall(node, member.object, member.property, context);
+    }
+    if (typeof member.object === "string") {
+      return evaluatePrimitiveMemberCall(
+        node,
+        "String",
+        member.property,
+        getStringMember(member.object, member.property, context.budget),
+        context
+      );
+    }
+    if (typeof member.object === "number") {
+      return evaluatePrimitiveMemberCall(
+        node,
+        "Number",
+        member.property,
+        getNumberMember(member.property, context.budget),
+        context
+      );
+    }
+    if (Array.isArray(member.object) && !Object.hasOwn(member.object, member.property)) {
+      return evaluatePrimitiveMemberCall(
+        node,
+        "Array",
+        member.property,
+        getArrayMemberValue(member.object, member.property, context),
+        context
+      );
+    }
+    if (isSandboxMap(member.object)) {
+      return evaluatePrimitiveMemberCall(
+        node,
+        "Map",
+        member.property,
+        getMapMember(member.object, member.property, createMapMethodOptions(context)),
+        context
+      );
+    }
+    if (isSandboxDate(member.object)) {
+      return evaluateResolvedCallExpression(node, getDateMember(member.property, context.budget, context.compilation?.owner), context, member.object);
+    }
+    if (isFloat32Array(member.object)) {
+      return evaluateResolvedCallExpression(
+        node,
+        getFloat32Member(member.object, member.property, context.budget),
+        context,
+        member.object
+      );
+    }
+    if (isSandboxSet(member.object)) {
+      return evaluatePrimitiveMemberCall(
+        node,
+        "Set",
+        member.property,
+        getSetMember(member.object, member.property, createSetMethodOptions(context)),
+        context
+      );
+    }
+    if (isSandboxGenerator(member.object)) {
+      const memberValue = getGeneratorMember(member.object, member.property, context.budget);
+      if (memberValue === void 0) {
+        throw new TypeError(`Generator#${String(member.property)} is not a supported method.`);
+      }
+      return evaluateResolvedCallExpression(node, memberValue, context, member.object);
+    }
+    if (isSandboxClosure(member.object)) {
+      const memberValue = getClosureMemberValue(member.object, member.property, context);
+      if (memberValue === void 0) {
+        throw new TypeError(`Function#${String(member.property)} is not a supported method.`);
+      }
+      return evaluateResolvedCallExpression(node, memberValue, context, member.object);
+    }
+    if (isSandboxPromise(member.object)) {
+      return evaluateResolvedCallExpression(
+        node,
+        getPromiseMember(member.property, context.budget),
+        context,
+        member.object
+      );
+    }
+    if (isSandboxRegex(member.object) && isRegexMethodName(member.property)) {
+      return evaluateResolvedCallExpression(
+        node,
+        getRegexMember(member.object, member.property, context.budget),
+        context,
+        member.object
+      );
+    }
+    if (!isIndexableSandboxValue(member.object)) {
+      throw new TypeError("Attempted to read a property from a non-object value.");
     }
-    return evaluateResolvedCallExpression(node, memberValue, context, member.object);
-  }
-  if (isSandboxPromise(member.object)) {
-    return evaluateResolvedCallExpression(
-      node,
-      getPromiseMember(member.property, context.budget),
-      context,
-      member.object
-    );
-  }
-  if (isSandboxRegex(member.object) && isRegexMethodName(member.property)) {
     return evaluateResolvedCallExpression(
       node,
-      getRegexMember(member.object, member.property, context.budget),
+      getMemberValue(member.object, member.property, context),
       context,
       member.object
     );
-  }
-  if (!isIndexableSandboxValue(member.object)) {
-    throw new TypeError("Attempted to read a property from a non-object value.");
-  }
-  return evaluateResolvedCallExpression(
-    node,
-    getMemberValue(member.object, member.property, context),
-    context,
-    member.object
-  );
+  });
 }
 function evaluatePrimitiveMemberCall(node, receiverType, property, value, context) {
   if (value === void 0) {
@@ -149172,30 +149243,35 @@ async function invokeSandboxClosure(callee, args, context, stack, span, thisValu
 }
 async function evaluateCallArguments(args, context) {
   const values = [];
-  for (const arg of args) {
-    if (arg.type === "SpreadElement") {
-      const spreadValues = await evaluateSpreadElement(arg, context);
-      if (!spreadValues.ok) {
-        return spreadValues;
+  const release2 = retainValues(context.budget, () => values);
+  try {
+    for (const arg of args) {
+      if (arg.type === "SpreadElement") {
+        const spreadValues = await evaluateSpreadElement(arg, context);
+        if (!spreadValues.ok) {
+          return spreadValues;
+        }
+        appendArrayValues2(values, spreadValues.value);
+        context.budget.allocateArrayLength(values.length);
+        continue;
       }
-      appendArrayValues2(values, spreadValues.value);
+      const result = await evaluateNode2(arg, context);
+      if (result.kind !== "normal") {
+        return {
+          ok: false,
+          result
+        };
+      }
+      values.push(result.value);
       context.budget.allocateArrayLength(values.length);
-      continue;
     }
-    const result = await evaluateNode2(arg, context);
-    if (result.kind !== "normal") {
-      return {
-        ok: false,
-        result
-      };
-    }
-    values.push(result.value);
-    context.budget.allocateArrayLength(values.length);
+    return {
+      ok: true,
+      value: values
+    };
+  } finally {
+    release2();
   }
-  return {
-    ok: true,
-    value: values
-  };
 }
 async function evaluateSpreadElement(node, context) {
   const value = await evaluateNode2(node.argument, context);
@@ -149210,21 +149286,26 @@ async function evaluateSpreadElement(node, context) {
     throw new TypeError("Spread arguments must evaluate to an iterable.");
   }
   const spreadValues = [];
-  while (true) {
-    const next = await iterator.next();
-    if (typeof next !== "object" || next === null) {
-      throw new TypeError("Iterator result must be an object.");
-    }
-    if (next.done === true) {
-      break;
+  const release2 = retainValues(context.budget, () => [value.value, ...spreadValues]);
+  try {
+    while (true) {
+      const next = await iterator.next();
+      if (typeof next !== "object" || next === null) {
+        throw new TypeError("Iterator result must be an object.");
+      }
+      if (next.done === true) {
+        break;
+      }
+      spreadValues.push(next.value);
+      context.budget.allocateArrayLength(spreadValues.length);
     }
-    spreadValues.push(next.value);
-    context.budget.allocateArrayLength(spreadValues.length);
+    return {
+      ok: true,
+      value: spreadValues
+    };
+  } finally {
+    release2();
   }
-  return {
-    ok: true,
-    value: spreadValues
-  };
 }
 async function evaluateObjectSpread(node, context) {
   const value = await evaluateNode2(node.argument, context);
@@ -149315,6 +149396,7 @@ var init_interpreter = __esm({
     init_promise_tracker();
     init_jobs4();
     init_cancel2();
+    init_resources();
     init_shape();
     init_async();
     init_host_call();
@@ -151779,47 +151861,6 @@ var init_globals = __esm({
   }
 });
 
-// packages/safe-js/src/interp/resources.ts
-import { AsyncLocalStorage as AsyncLocalStorage8 } from "node:async_hooks";
-async function withRunResources(signal, execute2) {
-  const controller = new AbortController();
-  const cancel2 = () => controller.abort(signal?.reason);
-  const cleanups = /* @__PURE__ */ new Set();
-  const resources = {
-    signal: controller.signal,
-    add(close) {
-      cleanups.add(close);
-    }
-  };
-  signal?.addEventListener("abort", cancel2, { once: true });
-  if (signal?.aborted) cancel2();
-  let result;
-  let failure;
-  let errors2 = [];
-  try {
-    result = await runResources.run(resources, execute2);
-  } catch (error3) {
-    failure = { reason: error3 };
-  } finally {
-    signal?.removeEventListener("abort", cancel2);
-    controller.abort(new Error("SafeJS run finished."));
-    const outcomes = await Promise.allSettled(
-      [...cleanups].map((close) => Promise.resolve().then(close))
-    );
-    errors2 = outcomes.flatMap((outcome) => outcome.status === "rejected" ? [outcome.reason] : []);
-  }
-  if (failure !== void 0) throw failure.reason;
-  if (errors2.length > 0) throw new AggregateError(errors2, "SafeJS resource cleanup failed.");
-  return result;
-}
-var runResources;
-var init_resources = __esm({
-  "packages/safe-js/src/interp/resources.ts"() {
-    "use strict";
-    runResources = new AsyncLocalStorage8();
-  }
-});
-
 // packages/safe-js/src/modules/registry.ts
 function createUnknownModuleMessage2(moduleName, moduleNames) {
   if (moduleNames.length === 0) {
@@ -152192,6 +152233,7 @@ var init_realm = __esm({
       extensions;
       consoleExtension;
       cleanups = [];
+      referenceReleases = /* @__PURE__ */ new Set();
       callbacks = /* @__PURE__ */ new Map();
       pendingCallbacks = /* @__PURE__ */ new Set();
       callbackCache = /* @__PURE__ */ new WeakMap();
@@ -152518,7 +152560,7 @@ var init_realm = __esm({
           const pending = withSandboxPromiseRejectionTracker(
             this.tracker,
             () => runResources.run(
-              { signal: this.controller.signal, add: this.onCleanup },
+              { signal: this.controller.signal, referenceReleases: this.referenceReleases, add: this.onCleanup },
               () => withCancellationSignal(
                 this.controller.signal,
                 () => active && this.phase.getStore()?.active ? runAsyncPrefix(invoke2) : this.queue.run(invoke2)
@@ -152713,7 +152755,7 @@ var init_realm = __esm({
           () => withSandboxPromiseRejectionTracker(
             this.tracker,
             () => runResources.run(
-              { signal: this.controller.signal, add: this.onCleanup },
+              { signal: this.controller.signal, referenceReleases: this.referenceReleases, add: this.onCleanup },
               () => withCancellationSignal(this.controller.signal, task)
             )
           )
@@ -152770,6 +152812,8 @@ var init_realm = __esm({
         this.hostObjects.clear();
         for (const reference of this.guestReferences.keys()) revokeGuestReference(reference, this);
         this.guestReferences.clear();
+        for (const release2 of this.referenceReleases) release2();
+        this.referenceReleases.clear();
         this.budget.setRetainedValues(this, void 0);
         releaseObjectPrototype(this.budget);
         this.disposal = (async () => {