@poe-platform/safe-js 0.1.722 → 0.1.724

package/dist/safe-js/chunks/{chunk-BNIEPGDU.js → chunk-ZHJPXLUJ.js}

@@ -39,7 +39,7 @@ import {
   sandboxErrorTypes,
   syntaxDiagnostics,
   templateRealms
-} from "./chunk-RYVHEOHM.js";
+} from "./chunk-KOO6YGQG.js";
 
 // packages/safe-js/src/interp/native-promise-properties.ts
 import { types } from "node:util";
@@ -95,6 +95,7 @@ async function withRunResources(signal, execute) {
   let failure;
   const resources = {
     signal: controller.signal,
+    nativeDataResults: true,
     referenceReleases: /* @__PURE__ */ new Set(),
     reportError(reason) {
       failure ??= { reason };
@@ -350,14 +351,14 @@ function copySandboxArgumentProperties(source, target, copyValue) {
     }
     Object.defineProperty(target, key, { ...descriptor, value: copyValue(descriptor.value, key) });
   }
-  const iterator = Object.getOwnPropertyDescriptor(source, Symbol.iterator);
-  if (iterator === void 0) {
+  const iterator2 = Object.getOwnPropertyDescriptor(source, Symbol.iterator);
+  if (iterator2 === void 0) {
     Reflect.deleteProperty(target, Symbol.iterator);
   } else {
-    if (iterator.value !== Array.prototype.values) {
+    if (iterator2.value !== Array.prototype.values) {
       throw new TypeError("Cannot copy a replaced arguments iterator.");
     }
-    Object.defineProperty(target, Symbol.iterator, iterator);
+    Object.defineProperty(target, Symbol.iterator, iterator2);
   }
   if (!Object.isExtensible(source)) Object.preventExtensions(target);
 }
@@ -377,10 +378,10 @@ function isSandboxCollectionIterator(value) {
   return typeof value === "object" && value !== null && states.has(value);
 }
 function createSandboxCollectionIterator(collection, method, budget) {
-  const iterator = restoreSandboxCollectionIterator({ collection, collectionKind: collection.kind, method, index: 0, exhausted: false });
+  const iterator2 = restoreSandboxCollectionIterator({ collection, collectionKind: collection.kind, method, index: 0, exhausted: false });
   const prototype = budget === void 0 ? void 0 : collectionIteratorPrototypes.get(budget)?.[collection.kind];
-  if (prototype !== void 0) setSandboxPrototype(iterator, prototype, budget);
-  return iterator;
+  if (prototype !== void 0) setSandboxPrototype(iterator2, prototype, budget);
+  return iterator2;
 }
 function restoreSandboxCollectionIterator(snapshot, target = /* @__PURE__ */ Object.create(null)) {
   const { collection, collectionKind, method, index, exhausted } = snapshot;
@@ -388,12 +389,12 @@ function restoreSandboxCollectionIterator(snapshot, target = /* @__PURE__ */ Obj
     throw new TypeError("Collection iterator source has the wrong brand.");
   if (!exhausted && collection === void 0)
     throw new TypeError("Live collection iterator requires its source collection.");
-  const iterator = exhausted ? void 0 : nativeIterator(collection, method);
+  const iterator2 = exhausted ? void 0 : nativeIterator(collection, method);
   for (let skipped = 0; skipped < index; skipped += 1) {
-    if (iterator === void 0 || iterator.next().done)
+    if (iterator2 === void 0 || iterator2.next().done)
       throw new TypeError("Collection iterator cursor exceeds its source.");
   }
-  states.set(target, { collection: exhausted ? void 0 : collection, collectionKind, method, exhausted, iterator });
+  states.set(target, { collection: exhausted ? void 0 : collection, collectionKind, method, exhausted, iterator: iterator2 });
   return target;
 }
 function collectionIteratorState(value) {
@@ -766,7 +767,7 @@ function appendScopeDataRoot(values, value) {
 var scopeDataRoots = Object.freeze({
   get: nativeGet,
   set(root, data) {
-    const snapshot = hasOwn(data, "value") ? freeze({ __proto__: null, value: data.value }) : hasOwn(data, "deferred") ? freeze({ __proto__: null, deferred: freeze(data.deferred) }) : freeze({ __proto__: null, values: freeze(data.values) });
+    const snapshot = hasOwn(data, "value") ? freeze(setPrototypeOf({ value: data.value }, null)) : hasOwn(data, "arguments") ? freeze(setPrototypeOf({ arguments: freeze(data.arguments) }, null)) : hasOwn(data, "deferred") ? freeze(setPrototypeOf({ deferred: freeze(data.deferred) }, null)) : freeze(setPrototypeOf({ values: freeze(data.values) }, null));
     nativeSet(root, snapshot);
   }
 });
@@ -1468,23 +1469,23 @@ function createSandboxSegments(state) {
 function isSandboxSegments(value) {
   return typeof value === "object" && value !== null && segments.has(value);
 }
-function segmentState(value, iterator) {
-  if (!isSandboxSegments(value) || iterator !== void 0 && segments.get(value).index !== void 0 !== iterator)
-    throw new TypeError(iterator ? "Segment iterator requires a segment iterator receiver." : "Segments method requires a Segments receiver.");
+function segmentState(value, iterator2) {
+  if (!isSandboxSegments(value) || iterator2 !== void 0 && segments.get(value).index !== void 0 !== iterator2)
+    throw new TypeError(iterator2 ? "Segment iterator requires a segment iterator receiver." : "Segments method requires a Segments receiver.");
   return segments.get(value);
 }
-function containingSegment(value, index, iterator, budget) {
-  const state = segmentState(value, iterator);
+function containingSegment(value, index, iterator2, budget) {
+  const state = segmentState(value, iterator2);
   budget.visitNode(state.input.length + 1);
   const result = findContainingSegment(state.native, state.input.length, index);
-  if (iterator && result !== void 0) state.index = result.index + result.segment.length;
+  if (iterator2 && result !== void 0) state.index = result.index + result.segment.length;
   return result === void 0 ? void 0 : { ...result };
 }
 function findContainingSegment(native, length, index) {
   if (index < 0 || index >= length) return void 0;
-  const iterator = Reflect.apply(nativeIterator2, native, []);
+  const iterator2 = Reflect.apply(nativeIterator2, native, []);
   for (; ; ) {
-    const next = Reflect.apply(nativeNext, iterator, []);
+    const next = Reflect.apply(nativeNext, iterator2, []);
     if (next.done) return void 0;
     if (index < next.value.index + next.value.segment.length) return next.value;
   }
@@ -4339,8 +4340,8 @@ function typeTag(value, builtinOnly = false) {
 var typedArrayPrototypes = /* @__PURE__ */ new WeakMap();
 
 // packages/safe-js/src/interp/methods/regexp-iterator.ts
-function nextRegExpIterator(iterator, budget) {
-  const state = regexpIteratorState(iterator);
+function nextRegExpIterator(iterator2, budget) {
+  const state = regexpIteratorState(iterator2);
   budget?.visitNode();
   if (state.exhausted) return createIteratorResult(void 0, true, budget);
   const matcher = state.matcher;
@@ -4361,14 +4362,14 @@ function nextRegExpIterator(iterator, budget) {
   }
   return createIteratorResult(toMatchArray(match, input, budget), false, budget);
 }
-async function nextObservableRegExpIterator(iterator, budget, context) {
-  const state = regexpIteratorState(iterator);
+async function nextObservableRegExpIterator(iterator2, budget, context) {
+  const state = regexpIteratorState(iterator2);
   if (state.exhausted) return createIteratorResult(void 0, true, budget);
   const matcher = state.matcher;
   const input = state.input;
   let result;
   let field;
-  const release = retainValues(budget, () => [iterator, matcher, input, result, field]);
+  const release = retainValues(budget, () => [iterator2, matcher, input, result, field]);
   const read = (value, key) => {
     if (context.getProperty !== void 0) return context.getProperty(value, key);
     const descriptor = getSandboxPropertyDescriptor(value, key, budget);
@@ -4623,13 +4624,13 @@ async function restoreSandboxIterator(snapshot, budget, context, signal) {
   if (snapshot.kind === "guest") return guestIterator(snapshot.value, snapshot.next, snapshot.async, budget, context, signal);
   if (snapshot.kind === "async-from-sync") return asyncFromSyncIterator(await restoreSandboxIterator(snapshot.inner, budget, context, signal), budget, signal, context);
   if (Array.isArray(snapshot.value)) return arrayIterator(snapshot.value, context, budget, snapshot.index);
-  const iterator = isSandboxGenerator(snapshot.value) ? {
+  const iterator2 = isSandboxGenerator(snapshot.value) ? {
     ...generatorObjectIterator(snapshot.value, budget, context),
     ...snapshot.value.async ? { asyncProtocol: true } : {}
   } : getSandboxIterator(snapshot.value, budget, context);
-  if (iterator === void 0) throw new TypeError("Invalid builtin iterator snapshot.");
-  for (let index = 0; index < snapshot.index; index++) await iterator.next();
-  return iterator;
+  if (iterator2 === void 0) throw new TypeError("Invalid builtin iterator snapshot.");
+  for (let index = 0; index < snapshot.index; index++) await iterator2.next();
+  return iterator2;
 }
 async function acquireSandboxIterator(value, budget, context, asyncProtocol = false, signal) {
   const key = asyncProtocol ? Symbol.asyncIterator : Symbol.iterator;
@@ -4649,8 +4650,8 @@ async function acquireSandboxIterator(value, budget, context, asyncProtocol = fa
     if (!asyncProtocol) return getSandboxIterator(value, budget, context);
     if (isSandboxGenerator(value) && value.async && !hasExplicitSandboxPrototype(value))
       return getSandboxAsyncIterator(value, budget, context, signal);
-    const iterator = await acquireSandboxIterator(value, budget, context);
-    return iterator === void 0 ? void 0 : asyncFromSyncIterator(iterator, budget, signal, context);
+    const iterator2 = await acquireSandboxIterator(value, budget, context);
+    return iterator2 === void 0 ? void 0 : asyncFromSyncIterator(iterator2, budget, signal, context);
   }
   const factory = await context.getProperty(value, key);
   if (!asyncProtocol && factory === void 0 && Array.isArray(value) && !hasExplicitSandboxPrototype(value)) {
@@ -4660,8 +4661,8 @@ async function acquireSandboxIterator(value, budget, context, asyncProtocol = fa
   }
   if (factory === null || factory === void 0) {
     if (!asyncProtocol) return void 0;
-    const iterator = await acquireSandboxIterator(value, budget, context);
-    return iterator === void 0 ? void 0 : asyncFromSyncIterator(iterator, budget, signal, context);
+    const iterator2 = await acquireSandboxIterator(value, budget, context);
+    return iterator2 === void 0 ? void 0 : asyncFromSyncIterator(iterator2, budget, signal, context);
   }
   return getSandboxIteratorFromMethod(value, factory, budget, context, asyncProtocol, signal);
 }
@@ -4672,20 +4673,20 @@ async function getSandboxIteratorFromMethod(value, factory, budget, context, asy
   if (!isSandboxClosure(factory)) {
     if (typeof factory !== "function") throw new TypeError("Iterator method must be callable.");
     if (asyncProtocol) return nativeAsyncIterator(value, factory, signal);
-    const iterator2 = Reflect.apply(factory, value, []);
-    if (typeof iterator2 !== "object" && typeof iterator2 !== "function" || iterator2 === null)
+    const iterator3 = Reflect.apply(factory, value, []);
+    if (typeof iterator3 !== "object" && typeof iterator3 !== "function" || iterator3 === null)
       throw new TypeError("Iterator must be an object.");
-    return syncIterator(iterator2);
+    return syncIterator(iterator3);
   }
-  const iterator = await invokeBuiltinClosure(factory, [], budget, context, value);
-  if (typeof iterator !== "object" && typeof iterator !== "function" || iterator === null)
+  const iterator2 = await invokeBuiltinClosure(factory, [], budget, context, value);
+  if (typeof iterator2 !== "object" && typeof iterator2 !== "function" || iterator2 === null)
     throw new TypeError("Iterator must be an object.");
-  if (!asyncProtocol && isSandboxGenerator(iterator) && !iterator.async && !hasExplicitSandboxPrototype(iterator) && getSandboxPropertyDescriptor(iterator, "next", budget) === void 0)
-    return getSandboxIterator(iterator, budget, context);
-  const next = await context.getProperty(iterator, "next");
-  return guestIterator(iterator, next, asyncProtocol, budget, context, signal);
+  if (!asyncProtocol && isSandboxGenerator(iterator2) && !iterator2.async && !hasExplicitSandboxPrototype(iterator2) && getSandboxPropertyDescriptor(iterator2, "next", budget) === void 0)
+    return getSandboxIterator(iterator2, budget, context);
+  const next = await context.getProperty(iterator2, "next");
+  return guestIterator(iterator2, next, asyncProtocol, budget, context, signal);
 }
-function guestIterator(iterator, next, asyncProtocol, budget, context, signal) {
+function guestIterator(iterator2, next, asyncProtocol, budget, context, signal) {
   const resumeAwait = async (state, value) => {
     if (state.kind !== "result") throw new TypeError("Invalid async iterator await state.");
     const result = await value();
@@ -4695,7 +4696,7 @@ function guestIterator(iterator, next, asyncProtocol, budget, context, signal) {
   };
   const invoke = async (operation, args) => {
     if (!isSandboxClosure(operation)) throw new TypeError("Iterator operation must be callable.");
-    const returned = await invokeBuiltinClosure(operation, args, budget, context, iterator);
+    const returned = await invokeBuiltinClosure(operation, args, budget, context, iterator2);
     if (asyncProtocol && wrapper.awaitValue !== void 0)
       return resumeAwait({ kind: "result" }, () => wrapper.awaitValue(returned, { kind: "result" }));
     const result = asyncProtocol ? await awaitSandboxValue(returned, signal, budget, context) : returned;
@@ -4707,11 +4708,11 @@ function guestIterator(iterator, next, asyncProtocol, budget, context, signal) {
     resumeAwait,
     ...asyncProtocol ? { asyncProtocol: true } : {},
     asynchronous: true,
-    retainedValue: [iterator, next],
-    snapshot: () => ({ kind: "guest", value: iterator, next, async: asyncProtocol }),
+    retainedValue: [iterator2, next],
+    snapshot: () => ({ kind: "guest", value: iterator2, next, async: asyncProtocol }),
     next: (...args) => invoke(next, args),
     getOperation: async (method) => {
-      const operation = method === "next" ? next : await context.getProperty(iterator, method);
+      const operation = method === "next" ? next : await context.getProperty(iterator2, method);
       return method !== "next" && (operation === void 0 || operation === null) ? void 0 : (...args) => invoke(operation, args);
     },
     readResultProperty: async (result, property) => ({
@@ -4720,8 +4721,8 @@ function guestIterator(iterator, next, asyncProtocol, budget, context, signal) {
   };
   return wrapper;
 }
-async function readIteratorResult(iterator, result, property) {
-  return iterator.readResultProperty === void 0 ? { value: result[property] } : iterator.readResultProperty(result, property);
+async function readIteratorResult(iterator2, result, property) {
+  return iterator2.readResultProperty === void 0 ? { value: result[property] } : iterator2.readResultProperty(result, property);
 }
 function getSandboxAsyncIterator(value, budget, context, signal) {
   if (isSandboxGenerator(value) && value.async) {
@@ -4733,20 +4734,20 @@ function getSandboxAsyncIterator(value, budget, context, signal) {
       return nativeAsyncIterator(value, method, signal);
     }
   }
-  const iterator = getSandboxIterator(value, budget, context);
-  return iterator === void 0 ? void 0 : asyncFromSyncIterator(iterator, budget, signal, context);
+  const iterator2 = getSandboxIterator(value, budget, context);
+  return iterator2 === void 0 ? void 0 : asyncFromSyncIterator(iterator2, budget, signal, context);
 }
 function nativeAsyncIterator(value, method, signal) {
   if (typeof method !== "function") throw new TypeError("Async iterator method must be callable.");
-  const iterator = Reflect.apply(method, value, []);
-  if (typeof iterator !== "object" && typeof iterator !== "function" || iterator === null) {
+  const iterator2 = Reflect.apply(method, value, []);
+  if (typeof iterator2 !== "object" && typeof iterator2 !== "function" || iterator2 === null) {
     throw new TypeError("Async iterator must be an object.");
   }
-  const next = iterator.next;
+  const next = iterator2.next;
   const invoke = async (operation, args) => {
     if (typeof operation !== "function")
       throw new TypeError("Async iterator operation must be callable.");
-    const pending = Promise.resolve(Reflect.apply(operation, iterator, args)).then((result2) => ({
+    const pending = Promise.resolve(Reflect.apply(operation, iterator2, args)).then((result2) => ({
       result: result2
     }));
     const { result } = await awaitWithSignal(pending, signal);
@@ -4767,42 +4768,42 @@ function nativeAsyncIterator(value, method, signal) {
     retainedValue: value,
     next: (...args) => invoke(next, args),
     get return() {
-      const operation = iterator.return;
+      const operation = iterator2.return;
       return operation === void 0 || operation === null ? void 0 : (...args) => invoke(operation, args);
     },
     get throw() {
-      const operation = iterator.throw;
+      const operation = iterator2.throw;
       return operation === void 0 || operation === null ? void 0 : (...args) => invoke(operation, args);
     }
   };
 }
-function asyncFromSyncIterator(iterator, budget, signal, context) {
+function asyncFromSyncIterator(iterator2, budget, signal, context) {
   const resumeAwait = async (state, value) => {
     if (state.kind !== "value") throw new TypeError("Invalid async-from-sync await state.");
     try {
       return { done: state.done, value: await value() };
     } catch (error) {
       if (isFatalSandboxError(error) || error instanceof HostCallResumabilityError) throw error;
-      if (state.closeOnReject) await closeIterator(iterator, true);
+      if (state.closeOnReject) await closeIterator(iterator2, true);
       throw error;
     }
   };
   const invoke = async (method, args) => {
-    const operation = iterator.getOperation === void 0 ? iterator[method] : await iterator.getOperation(method);
+    const operation = iterator2.getOperation === void 0 ? iterator2[method] : await iterator2.getOperation(method);
     if (operation === void 0) {
       if (method === "throw") {
-        await closeIterator(iterator);
+        await closeIterator(iterator2);
         throw new TypeError("Delegated iterator does not provide a throw method.");
       }
       return { done: true, value: args[0] };
     }
     const returned = operation(...args);
-    const result = iterator.generator || iterator.asynchronous ? await returned : returned;
+    const result = iterator2.generator || iterator2.asynchronous ? await returned : returned;
     if (typeof result !== "object" && typeof result !== "function" || result === null) {
       throw new TypeError("Iterator result must be an object.");
     }
-    const done = Boolean((await readIteratorResult(iterator, result, "done")).value);
-    const resultValue = (await readIteratorResult(iterator, result, "value")).value;
+    const done = Boolean((await readIteratorResult(iterator2, result, "done")).value);
+    const resultValue = (await readIteratorResult(iterator2, result, "value")).value;
     if (wrapper.awaitValue !== void 0) {
       const state = { kind: "value", done, closeOnReject: !done && method !== "return" };
       return resumeAwait(state, () => wrapper.awaitValue(resultValue, state));
@@ -4811,17 +4812,17 @@ function asyncFromSyncIterator(iterator, budget, signal, context) {
       return { done, value: await awaitSandboxValue(resultValue, signal, budget, context) };
     } catch (error) {
       if (isFatalSandboxError(error) || error instanceof HostCallResumabilityError) throw error;
-      if (!done && method !== "return") await closeIterator(iterator, true);
+      if (!done && method !== "return") await closeIterator(iterator2, true);
       throw error;
     }
   };
   const wrapper = {
     resumeAwait,
     asyncProtocol: true,
-    snapshotIndex: iterator.snapshotIndex,
-    snapshot: () => ({ kind: "async-from-sync", inner: iterator.snapshot?.() ?? { kind: "unsupported" } }),
+    snapshotIndex: iterator2.snapshotIndex,
+    snapshot: () => ({ kind: "async-from-sync", inner: iterator2.snapshot?.() ?? { kind: "unsupported" } }),
     get retainedValue() {
-      return iterator.retainedValue;
+      return iterator2.retainedValue;
     },
     next: (...args) => invoke("next", args),
     return: (...args) => invoke("return", args),
@@ -4829,12 +4830,12 @@ function asyncFromSyncIterator(iterator, budget, signal, context) {
   };
   return wrapper;
 }
-async function closeIterator(iterator, preserveThrow = false, awaitResult = suspendJob) {
+async function closeIterator(iterator2, preserveThrow = false, awaitResult = suspendJob) {
   try {
-    const close = iterator.getOperation === void 0 ? iterator.return : await iterator.getOperation("return");
+    const close = iterator2.getOperation === void 0 ? iterator2.return : await iterator2.getOperation("return");
     if (close === void 0) return;
     const returned = close();
-    const result = iterator.asyncProtocol ? iterator.awaitValue === void 0 ? await awaitResult(Promise.resolve(returned)) : await returned : iterator.generator || iterator.asynchronous ? await returned : returned;
+    const result = iterator2.asyncProtocol ? iterator2.awaitValue === void 0 ? await awaitResult(Promise.resolve(returned)) : await returned : iterator2.generator || iterator2.asynchronous ? await returned : returned;
     if (typeof result !== "object" && typeof result !== "function" || result === null) {
       throw new TypeError("Iterator return result must be an object.");
     }
@@ -4847,7 +4848,7 @@ function getSandboxIterator(value, budget, context) {
   if (isSandboxBox(value) && typeof boxedValue(value) === "string") {
     const primitive = boxedValue(value);
     let text;
-    let iterator2;
+    let iterator3;
     let initialized;
     return {
       asynchronous: true,
@@ -4858,11 +4859,11 @@ function getSandboxIterator(value, budget, context) {
         initialized ??= Promise.resolve(sandboxString(value, budget ?? new Budget(), context)).then(
           (converted) => {
             text = converted;
-            iterator2 = syncIterator(converted[Symbol.iterator]());
+            iterator3 = syncIterator(converted[Symbol.iterator]());
           }
         );
         await initialized;
-        return iterator2.next();
+        return iterator3.next();
       }
     };
   }
@@ -4904,12 +4905,12 @@ function getSandboxIterator(value, budget, context) {
     return generatorObjectIterator(value, budget, context);
   }
   if (typeof value === "string") {
-    const iterator2 = value[Symbol.iterator]();
+    const iterator3 = value[Symbol.iterator]();
     let index = 0;
     return {
       snapshot: () => ({ kind: "builtin", value, index }),
       next: () => {
-        const result = iterator2.next();
+        const result = iterator3.next();
         if (!result.done) index++;
         return result;
       }
@@ -4934,11 +4935,11 @@ function getSandboxIterator(value, budget, context) {
   if (typeof iteratorMethod !== "function") {
     throw new TypeError("Iterator method must be callable.");
   }
-  const iterator = Reflect.apply(iteratorMethod, value, []);
-  if (typeof iterator !== "object" && typeof iterator !== "function" || iterator === null) {
+  const iterator2 = Reflect.apply(iteratorMethod, value, []);
+  if (typeof iterator2 !== "object" && typeof iterator2 !== "function" || iterator2 === null) {
     throw new TypeError("Iterator must be an object.");
   }
-  return syncIterator(iterator);
+  return syncIterator(iterator2);
 }
 function arrayIterator(value, context, budget, initialIndex = 0) {
   let index = initialIndex;
@@ -4954,13 +4955,13 @@ function arrayIterator(value, context, budget, initialIndex = 0) {
   };
 }
 function collectionIterator(collection, value) {
-  let iterator = collection[Symbol.iterator]();
+  let iterator2 = collection[Symbol.iterator]();
   let exhausted = false;
   const adapter = {
     ...syncIterator({
       next: () => {
         if (exhausted) return { done: true, value: void 0 };
-        const result = iterator.next();
+        const result = iterator2.next();
         exhausted = result.done === true;
         return result;
       }
@@ -4968,10 +4969,10 @@ function collectionIterator(collection, value) {
     snapshotIndex: () => {
       if (exhausted) return collection.size;
       let remaining = 0;
-      while (!iterator.next().done) remaining += 1;
+      while (!iterator2.next().done) remaining += 1;
       const index = collection.size - remaining;
-      iterator = collection[Symbol.iterator]();
-      for (let skipped = 0; skipped < index; skipped += 1) iterator.next();
+      iterator2 = collection[Symbol.iterator]();
+      for (let skipped = 0; skipped < index; skipped += 1) iterator2.next();
       return index;
     }
   };
@@ -4991,9 +4992,9 @@ function guestProtocolAdapter(value, budget, context, asyncProtocol, signal) {
   };
   let resolved;
   let pending;
-  const initialize = () => pending ??= acquireSandboxIterator(value, budget, bridge, asyncProtocol, signal).then((iterator) => {
-    if (iterator === void 0) throw new TypeError("Value does not provide an iterator protocol.");
-    return resolved = iterator;
+  const initialize = () => pending ??= acquireSandboxIterator(value, budget, bridge, asyncProtocol, signal).then((iterator2) => {
+    if (iterator2 === void 0) throw new TypeError("Value does not provide an iterator protocol.");
+    return resolved = iterator2;
   });
   return {
     asynchronous: true,
@@ -5004,19 +5005,19 @@ function guestProtocolAdapter(value, budget, context, asyncProtocol, signal) {
     snapshot: () => resolved?.snapshot?.() ?? { kind: "unsupported" },
     next: async (...args) => (await initialize()).next(...args),
     getOperation: async (method) => {
-      const iterator = await initialize();
-      return iterator.getOperation === void 0 ? iterator[method] : iterator.getOperation(method);
+      const iterator2 = await initialize();
+      return iterator2.getOperation === void 0 ? iterator2[method] : iterator2.getOperation(method);
     },
     readResultProperty: async (result, property) => readIteratorResult(await initialize(), result, property)
   };
 }
 function generatorObjectIterator(generator, budget, context) {
-  const iterator = generatorIterator(generator, budget, context);
-  if (context?.getProperty === void 0) return iterator;
+  const iterator2 = generatorIterator(generator, budget, context);
+  if (context?.getProperty === void 0) return iterator2;
   return {
-    ...iterator,
+    ...iterator2,
     getOperation: async (method) => {
-      if (method === "next" || !hasExplicitSandboxPrototype(generator) && getSandboxPropertyDescriptor(generator, method, budget) === void 0) return iterator[method];
+      if (method === "next" || !hasExplicitSandboxPrototype(generator) && getSandboxPropertyDescriptor(generator, method, budget) === void 0) return iterator2[method];
       const operation = await context.getProperty(generator, method);
       if (operation === void 0 || operation === null) return void 0;
       if (!isSandboxClosure(operation)) throw new TypeError("Iterator operation must be callable.");
@@ -5059,12 +5060,12 @@ function generatorIterator(generator, budget, context) {
     throw: (error) => request("throw", error)
   };
 }
-function syncIterator(iterator) {
-  const next = iterator.next;
+function syncIterator(iterator2) {
+  const next = iterator2.next;
   const invoke = (method, args) => {
-    const leaveRunning = enterRunningState(iterator);
+    const leaveRunning = enterRunningState(iterator2);
     try {
-      return Reflect.apply(method, iterator, args);
+      return Reflect.apply(method, iterator2, args);
     } finally {
       leaveRunning();
     }
@@ -5072,13 +5073,13 @@ function syncIterator(iterator) {
   return {
     next: (...args) => invoke(next, args),
     get return() {
-      const method = iterator.return;
+      const method = iterator2.return;
       if (method === void 0 || method === null) return void 0;
       if (typeof method !== "function") throw new TypeError("Iterator return must be callable.");
       return (...args) => invoke(method, args);
     },
     get throw() {
-      const method = iterator.throw;
+      const method = iterator2.throw;
       if (method === void 0 || method === null) return void 0;
       if (typeof method !== "function") throw new TypeError("Iterator throw must be callable.");
       return (...args) => invoke(method, args);
@@ -5201,7 +5202,7 @@ async function bindArrayPattern(pattern, value, target, scope, context) {
   const saved = pattern.nodeId === void 0 ? void 0 : context.restoredPatternState?.(pattern.nodeId);
   if (saved !== void 0 && saved.kind !== "array-pattern") throw new TypeError("Invalid array pattern continuation.");
   const callContext = context.callContext ?? { stack: [], thisValue: void 0, getProperty: context.getProperty };
-  const iterator = saved === void 0 ? await acquireSandboxIterator(
+  const iterator2 = saved === void 0 ? await acquireSandboxIterator(
     value,
     budget,
     context.callContext ?? {
@@ -5210,16 +5211,16 @@ async function bindArrayPattern(pattern, value, target, scope, context) {
       getProperty: context.getProperty
     }
   ) : "kind" in saved.iterator ? await restoreSandboxIterator(saved.iterator, budget, callContext) : saved.iterator;
-  if (iterator === void 0) throw new TypeError("Array destructuring requires an iterable.");
+  if (iterator2 === void 0) throw new TypeError("Array destructuring requires an iterable.");
   let done = saved?.done ?? false;
   const next = async (readValue = true) => {
     if (done) return { value: void 0 };
     try {
-      const result = await iterator.next();
+      const result = await iterator2.next();
       if (typeof result !== "object" && typeof result !== "function" || result === null)
         throw new TypeError("Iterator result must be an object.");
-      done = Boolean((await readIteratorResult(iterator, result, "done")).value);
-      return done || !readValue ? { value: void 0 } : await readIteratorResult(iterator, result, "value");
+      done = Boolean((await readIteratorResult(iterator2, result, "done")).value);
+      return done || !readValue ? { value: void 0 } : await readIteratorResult(iterator2, result, "value");
     } catch (error) {
       done = true;
       throw error;
@@ -5229,7 +5230,7 @@ async function bindArrayPattern(pattern, value, target, scope, context) {
   let continuation;
   const release = retainValues(budget, () => [
     value,
-    iterator.retainedValue,
+    iterator2.retainedValue,
     retained,
     continuation?.current,
     continuation?.referenceObject,
@@ -5250,9 +5251,9 @@ async function bindArrayPattern(pattern, value, target, scope, context) {
         index,
         done,
         current: void 0,
-        iterator
+        iterator: iterator2
       };
-      if (resuming) Object.assign(state, saved, { iterator });
+      if (resuming) Object.assign(state, saved, { iterator: iterator2 });
       continuation = state;
       const elementContext = pattern.nodeId === void 0 ? context : context.withPatternState?.(pattern.nodeId, state) ?? context;
       const binding = resuming && saved.phase === "binding" ? await bindPattern(
@@ -5295,18 +5296,18 @@ async function bindArrayPattern(pattern, value, target, scope, context) {
       if (!binding.ok) {
         if (!done) {
           done = true;
-          await closeIterator(iterator, binding.result.kind === "throw");
+          await closeIterator(iterator2, binding.result.kind === "throw");
         }
         return binding;
       }
     }
     if (!done) {
       done = true;
-      await closeIterator(iterator);
+      await closeIterator(iterator2);
     }
     return { ok: true };
   } catch (error) {
-    if (!done && !isFatalSandboxError(error)) await closeIterator(iterator, true);
+    if (!done && !isFatalSandboxError(error)) await closeIterator(iterator2, true);
     throw error;
   } finally {
     release();
@@ -5503,6 +5504,63 @@ var DeferredFunction = class {
   }
 };
 
+// packages/safe-js/src/interp/deferred-arguments.ts
+var freeze3 = Object.freeze;
+var setPrototypeOf2 = Object.setPrototypeOf;
+var indexString = String;
+var iterator = Symbol.iterator;
+var DeferredArguments = class {
+  root = freeze3({ __proto__: null });
+  eligible;
+  #value;
+  #resolving = false;
+  #snapshot;
+  constructor(values) {
+    const captured = setPrototypeOf2([], null);
+    const references = setPrototypeOf2([], null);
+    let units = 8;
+    let eligible = true;
+    for (let index = 0; index < values.length; index++) {
+      const value = values[index];
+      captured[index] = value;
+      units += 1 + indexString(index).length;
+      if (typeof value === "string") units += value.length;
+      else if (typeof value === "bigint") eligible = false;
+      else if (typeof value === "symbol" || typeof value === "object" && value !== null)
+        references[references.length] = value;
+    }
+    this.eligible = eligible;
+    this.#snapshot = freeze3({
+      values: freeze3(captured),
+      references: freeze3(references),
+      length: values.length,
+      units,
+      iterator
+    });
+    scopeDataRoots.set(this.root, {
+      arguments: {
+        read: () => this.#value,
+        capture: () => this.#snapshot
+      }
+    });
+  }
+  resolve() {
+    if (this.#value !== void 0) return this.#value;
+    if (this.#resolving) throw new TypeError("Cannot reenter deferred arguments initialization.");
+    this.#resolving = true;
+    try {
+      const snapshot = this.#snapshot;
+      const value = createSandboxArguments(snapshot.values);
+      if (value.length !== snapshot.length) value.length = snapshot.length;
+      this.#value = value;
+      this.#snapshot = void 0;
+      return value;
+    } finally {
+      this.#resolving = false;
+    }
+  }
+};
+
 // packages/safe-js/src/modules/empty-environment.ts
 var environments = /* @__PURE__ */ new WeakSet();
 var has = WeakSet.prototype.has.bind(environments);
@@ -5516,24 +5574,25 @@ function registerImmutableEmptyModuleEnvironment(environment) {
 // packages/safe-js/src/interp/scope-binding-storage.ts
 var NativeMap = Map;
 var NativeSet = Set;
-var apply = Reflect.apply;
-var mapGet = Map.prototype.get;
-var mapSet = Map.prototype.set;
-var mapHas = Map.prototype.has;
-var mapDelete = Map.prototype.delete;
-var mapEntries2 = Map.prototype.entries;
-var mapValues = Map.prototype.values;
-var mapSize2 = Object.getOwnPropertyDescriptor(Map.prototype, "size").get;
-var mapNext = Object.getPrototypeOf((/* @__PURE__ */ new Map()).values()).next;
-var setAdd = Set.prototype.add;
-var setHas = Set.prototype.has;
-var setDelete = Set.prototype.delete;
-var setValues2 = Set.prototype.values;
-var setNext = Object.getPrototypeOf((/* @__PURE__ */ new Set()).values()).next;
-function privateIterator(iterator, next) {
+var mapGet = Function.prototype.call.bind(Map.prototype.get);
+var mapSet = Function.prototype.call.bind(Map.prototype.set);
+var mapHas = Function.prototype.call.bind(Map.prototype.has);
+var mapDelete = Function.prototype.call.bind(Map.prototype.delete);
+var mapEntries2 = Function.prototype.call.bind(Map.prototype.entries);
+var mapValues = Function.prototype.call.bind(Map.prototype.values);
+var mapSize2 = Function.prototype.call.bind(
+  Object.getOwnPropertyDescriptor(Map.prototype, "size").get
+);
+var mapNext = Function.prototype.call.bind(Object.getPrototypeOf((/* @__PURE__ */ new Map()).values()).next);
+var setAdd = Function.prototype.call.bind(Set.prototype.add);
+var setHas = Function.prototype.call.bind(Set.prototype.has);
+var setDelete = Function.prototype.call.bind(Set.prototype.delete);
+var setValues2 = Function.prototype.call.bind(Set.prototype.values);
+var setNext = Function.prototype.call.bind(Object.getPrototypeOf((/* @__PURE__ */ new Set()).values()).next);
+function privateIterator(iterator2, next) {
   return {
     next() {
-      return apply(next, iterator, []);
+      return next(iterator2);
     },
     [Symbol.iterator]() {
       return this;
@@ -5543,25 +5602,25 @@ function privateIterator(iterator, next) {
 var ScopeBindingMap = class {
   #data = new NativeMap();
   get size() {
-    return apply(mapSize2, this.#data, []);
+    return mapSize2(this.#data);
   }
   get(key) {
-    return apply(mapGet, this.#data, [key]);
+    return mapGet(this.#data, key);
   }
   has(key) {
-    return apply(mapHas, this.#data, [key]);
+    return mapHas(this.#data, key);
   }
   set(key, value) {
-    apply(mapSet, this.#data, [key, value]);
+    mapSet(this.#data, key, value);
   }
   delete(key) {
-    return apply(mapDelete, this.#data, [key]);
+    return mapDelete(this.#data, key);
   }
   entries() {
-    return privateIterator(apply(mapEntries2, this.#data, []), mapNext);
+    return privateIterator(mapEntries2(this.#data), mapNext);
   }
   values() {
-    return privateIterator(apply(mapValues, this.#data, []), mapNext);
+    return privateIterator(mapValues(this.#data), mapNext);
   }
   [Symbol.iterator]() {
     return this.entries();
@@ -5570,16 +5629,16 @@ var ScopeBindingMap = class {
 var ScopeBindingSet = class {
   #data = new NativeSet();
   has(value) {
-    return apply(setHas, this.#data, [value]);
+    return setHas(this.#data, value);
   }
   add(value) {
-    apply(setAdd, this.#data, [value]);
+    setAdd(this.#data, value);
   }
   delete(value) {
-    return apply(setDelete, this.#data, [value]);
+    return setDelete(this.#data, value);
   }
   [Symbol.iterator]() {
-    return privateIterator(apply(setValues2, this.#data, []), setNext);
+    return privateIterator(setValues2(this.#data), setNext);
   }
 };
 
@@ -5889,6 +5948,16 @@ var Scope = class _Scope {
     this.#bindings.get(name).deferred = new DeferredFunction(create3, collect);
     this.#bindingDataRoot = void 0;
   }
+  declareDeferredArguments(name, kind, values) {
+    const deferred2 = new DeferredArguments(values);
+    if (!deferred2.eligible) {
+      this.declare(name, kind, deferred2.resolve());
+      return;
+    }
+    this.declare(name, kind, void 0);
+    this.#bindings.get(name).deferred = deferred2;
+    this.#bindingDataRoot = void 0;
+  }
   declareAlias(name, target) {
     if (this.#bindings.has(name)) throw new Error(`Cannot redeclare binding '${name}' in the same scope.`);
     const binding = this.#bindings.get(target);
@@ -6383,7 +6452,7 @@ function createInterpretedClosure(node, context, evaluateNode2, homeObject, init
   const construction = context.functionEnvironment?.construction;
   const constructionState = construction === void 0 ? void 0 : constructionStates.get(construction);
   const construct = node.type !== "ArrowFunctionExpression" && !(node.type === "FunctionExpression" && node.method === true) && !node.async ? async (args, callContext) => {
-    const thisValue = {};
+    const thisValue = createIntrinsicObject({});
     const newTarget = callContext?.newTarget ?? closure;
     const prototype = callContext?.getProperty === void 0 ? getGuestFunctionProperty(newTarget, "prototype") : await callContext.getProperty(newTarget, "prototype");
     const selected = typeof prototype === "object" && prototype !== null ? prototype : getFunctionRealmPrototype(newTarget, "Object", getSandboxPrototype(thisValue, context.budget));
@@ -6765,7 +6834,12 @@ async function createClosureScope(node, args, thisValue, context, evaluateNode2)
     else scope.declare("this", "const", thisValue);
     if (needsArguments) {
       context.budget.allocateArrayLength(args.length);
-      if (!mapped) scope.declare("arguments", functionStrictness.get(node) === false && !separateParameters ? "var" : "let", createSandboxArguments(args));
+      if (!mapped) {
+        const kind = functionStrictness.get(node) === false && !separateParameters ? "var" : "let";
+        if (context.scriptScope !== void 0 || context.moduleInstantiated !== void 0)
+          scope.declareDeferredArguments("arguments", kind, args);
+        else scope.declare("arguments", kind, createSandboxArguments(args));
+      }
     }
     await construction?.initialize(scope);
   }
@@ -8584,13 +8658,14 @@ function functionString(value) {
 
 // packages/safe-js/src/interp/bound-function.ts
 function createBoundFunction(state, name, length, callClosure) {
+  const retainedValues = () => [state.target, state.thisValue, ...state.args, bound.name];
   const bound = createSandboxClosure({
     guest: true,
     sandbox: true,
     name,
     length,
     boundTarget: state.target,
-    retainedValues: () => [state.target, state.thisValue, ...state.args, bound.name],
+    retainedValues,
     call: (args, context) => callClosure(state.target, [...state.args, ...args], context?.stack ?? [], state.thisValue, void 0, void 0, context),
     ...state.target.construct === void 0 ? {} : {
       construct: (args, context) => callClosure(
@@ -8604,6 +8679,12 @@ function createBoundFunction(state, name, length, callClosure) {
       )
     }
   });
+  registerClosureCaptureCollector(bound, retainedValues, (append) => {
+    append(state.target);
+    append(state.thisValue);
+    for (const value of state.args) append(value);
+    append(bound.name);
+  });
   boundFunctionStates.set(bound, state);
   return bound;
 }
@@ -16802,21 +16883,21 @@ async function allocateTypedArrayInput(source, budget, Native, context) {
     invokeClosure: context?.invokeClosure ?? ((callee, values2, receiver, construct, newTarget) => invokeBuiltinClosure(callee, values2, budget, callerContext, receiver, construct, newTarget))
   };
   const values = [];
-  let iterator;
+  let iterator2;
   let current;
   let result;
-  const release = retainValues(budget, () => [source, values, iterator?.retainedValue, current, result]);
+  const release = retainValues(budget, () => [source, values, iterator2?.retainedValue, current, result]);
   const checkData = createDataCheckpoint(budget, bridge);
   try {
-    iterator = await acquireSandboxIterator(source, budget, bridge);
+    iterator2 = await acquireSandboxIterator(source, budget, bridge);
     let length;
-    if (iterator !== void 0) {
+    if (iterator2 !== void 0) {
       while (true) {
         budget.visitNode();
-        const next = await iterator.next();
+        const next = await iterator2.next();
         if (typeof next !== "object" || next === null) throw new TypeError("Iterator result must be an object.");
-        if ((await readIteratorResult(iterator, next, "done")).value) break;
-        current = (await readIteratorResult(iterator, next, "value")).value;
+        if ((await readIteratorResult(iterator2, next, "done")).value) break;
+        current = (await readIteratorResult(iterator2, next, "value")).value;
         budget.allocateArrayLength(values.length + 1);
         values.push(current);
         checkData(values, 1 + (budget.limits.dataSize === void 0 ? 0 : measureSandboxData([current])));
@@ -16832,7 +16913,7 @@ async function allocateTypedArrayInput(source, budget, Native, context) {
     checkData(result, 0, true);
     for (let index = 0; index < length; index++) {
       budget.visitNode();
-      current = iterator === void 0 ? await bridge.getProperty(source, String(index)) : values[index];
+      current = iterator2 === void 0 ? await bridge.getProperty(source, String(index)) : values[index];
       result[index] = await typedArrayElement(current, Native, budget, bridge);
     }
     return result;
@@ -16911,21 +16992,21 @@ function createNumericTypedArrayPrototypes(budget, bindings) {
         };
         let result;
         let current;
-        let iterator;
+        let iterator2;
         const values = [];
-        const release = retainValues(budget, () => [target, result, current, iterator?.retainedValue, values, ...args]);
+        const release = retainValues(budget, () => [target, result, current, iterator2?.retainedValue, values, ...args]);
         const checkData = createDataCheckpoint(budget, context);
         const read = (key) => context?.getProperty === void 0 ? getSandboxDataProperty(source, key, budget) : context.getProperty(source, key);
         try {
-          iterator = await acquireSandboxIterator(source, budget, context);
+          iterator2 = await acquireSandboxIterator(source, budget, context);
           let length;
-          if (iterator !== void 0) {
+          if (iterator2 !== void 0) {
             while (true) {
               budget.visitNode();
-              const next = await iterator.next();
+              const next = await iterator2.next();
               if (typeof next !== "object" || next === null) throw new TypeError("Iterator result must be an object.");
-              if ((await readIteratorResult(iterator, next, "done")).value) break;
-              current = (await readIteratorResult(iterator, next, "value")).value;
+              if ((await readIteratorResult(iterator2, next, "done")).value) break;
+              current = (await readIteratorResult(iterator2, next, "value")).value;
               budget.allocateArrayLength(values.length + 1);
               values.push(current);
               checkData(values, 1 + (budget.limits.dataSize === void 0 ? 0 : measureSandboxData([current])));
@@ -16941,7 +17022,7 @@ function createNumericTypedArrayPrototypes(budget, bindings) {
           checkData(result, 0, true);
           for (let index = 0; index < length; index++) {
             budget.visitNode();
-            current = iterator === void 0 ? await read(String(index)) : values[index];
+            current = iterator2 === void 0 ? await read(String(index)) : values[index];
             if (mapper !== void 0)
               current = await invokeBuiltinClosure(mapper, [current, index], budget, context, receiver);
             result[index] = await typedArrayElement(current, typedArrayStorage(result).Native, budget, context);
@@ -17831,6 +17912,13 @@ async function callStringPadding(value, method, args, budget, context) {
 }
 
 // packages/safe-js/src/interp/methods/string.ts
+var nativeStringPrototype = String.prototype;
+var nativeObjectPrototype = Object.prototype;
+var nativeStringSplit = nativeStringPrototype.split;
+var nativeSplitSymbol = Symbol.split;
+var nativeSplitDescriptor = Object.getOwnPropertyDescriptor;
+var nativeSplitPrototype = Object.getPrototypeOf;
+var nativeSplitApply = Reflect.apply;
 var stringMethodLengths = {
   ...Object.fromEntries(Object.entries(stringHtmlMethods).map(([name, [, attribute]]) => [name, attribute === "" ? 0 : 1])),
   at: 1,
@@ -17923,7 +18011,7 @@ function callStringMethod(value, methodName, args, budget, callClosure = async (
   if (value === null || value === void 0)
     throw new TypeError(`String#${methodName} requires a non-null receiver.`);
   const fallback = (coercePattern = false) => {
-    const apply2 = (string) => {
+    const apply = (string) => {
       if (coercePattern && (methodName === "match" || methodName === "matchAll" || methodName === "search"))
         return callStringPattern(string, methodName, args[0], budget, parent, context);
       const useRegex = isSandboxRegex(args[0]) && !coercePattern;
@@ -17932,7 +18020,7 @@ function callStringMethod(value, methodName, args, budget, callClosure = async (
       if (methodName === "split") return callSplit(string, args, budget, useRegex, parent, context);
       return callStringMethodBody(string, methodName, args, budget, parent, context);
     };
-    return typeof value === "string" ? apply2(value) : Promise.resolve(sandboxString(value, budget, context)).then(apply2);
+    return typeof value === "string" ? apply(value) : Promise.resolve(sandboxString(value, budget, context)).then(apply);
   };
   const symbol = methodName === "match" ? Symbol.match : methodName === "search" ? Symbol.search : methodName === "matchAll" ? Symbol.matchAll : methodName === "replace" || methodName === "replaceAll" ? Symbol.replace : methodName === "split" ? Symbol.split : void 0;
   const pattern = args[0];
@@ -18001,14 +18089,14 @@ function callStringMethodBody(value, methodName, args, budget, parent, context)
     return callStringPadding(value, methodName, args, budget, context);
   }
   if (methodName === "repeat" || methodName === "at" || methodName === "charAt" || methodName === "charCodeAt" || methodName === "codePointAt") {
-    const apply2 = (number2) => {
+    const apply = (number2) => {
       const result = value[methodName](number2);
       return typeof result === "string" ? budget.allocateString(result) : result;
     };
     const number = sandboxNumber(args[0], budget, context);
-    if (typeof number === "number") return apply2(number);
+    if (typeof number === "number") return apply(number);
     const release = retainValues(budget, () => [value, ...args]);
-    return number.then(apply2).finally(release);
+    return number.then(apply).finally(release);
   }
   if (methodName === "isWellFormed") {
     for (let index = 0; index < value.length; index++) {
@@ -18433,7 +18521,26 @@ function splitNormalized(value, separator, limit, budget, parent) {
       operation.release();
     }
   }
-  const result = value.split(separator, limit);
+  const arrayLimit = budget.limits.arrayLength;
+  if (arrayLimit !== void 0) {
+    let count = 1;
+    if (separator === "") {
+      count = Math.min(value.length, limit);
+    } else if (separator !== void 0) {
+      let offset = 0;
+      while (count < limit && count <= arrayLimit) {
+        const index = value.indexOf(separator, offset);
+        if (index === -1) break;
+        count++;
+        offset = index + separator.length;
+      }
+    }
+    budget.allocateArrayLength(count);
+  }
+  const split = value.split;
+  const owned = runResources.getStore()?.nativeDataResults !== true && split === nativeStringSplit && (separator === void 0 || nativeSplitPrototype(nativeStringPrototype) === nativeObjectPrototype && nativeSplitPrototype(nativeObjectPrototype) === null && nativeSplitDescriptor(nativeStringPrototype, nativeSplitSymbol) === void 0 && nativeSplitDescriptor(nativeObjectPrototype, nativeSplitSymbol) === void 0);
+  const nativeResult = nativeSplitApply(split, value, [separator, limit]);
+  const result = owned ? createIntrinsicArray(nativeResult) : nativeResult;
   budget.allocateArrayLength(result.length);
   for (const part of result) budget.allocateString(part);
   return result;
@@ -20795,8 +20902,8 @@ function serializeArguments(value, serializeValue) {
       writable: descriptor.writable === true
     };
   }
-  const iterator = Object.getOwnPropertyDescriptor(value, Symbol.iterator);
-  if (iterator !== void 0 && iterator.value !== Array.prototype.values) {
+  const iterator2 = Object.getOwnPropertyDescriptor(value, Symbol.iterator);
+  if (iterator2 !== void 0 && iterator2.value !== Array.prototype.values) {
     throw new TypeError("Cannot snapshot a replaced arguments iterator.");
   }
   const names = Object.getOwnPropertyNames(value);
@@ -20804,10 +20911,10 @@ function serializeArguments(value, serializeValue) {
     kind: "arguments",
     extensible: Object.isExtensible(value),
     lengthBeforeCallee: names.includes("length") && names.indexOf("length") < names.indexOf("callee"),
-    iterator: iterator === void 0 ? null : {
-      configurable: iterator.configurable === true,
-      enumerable: iterator.enumerable === true,
-      writable: iterator.writable === true
+    iterator: iterator2 === void 0 ? null : {
+      configurable: iterator2.configurable === true,
+      enumerable: iterator2.enumerable === true,
+      writable: iterator2.writable === true
     },
     properties
   };
@@ -21819,6 +21926,10 @@ var hostErrorMetadata = {
   syscall: "string"
 };
 var awaitedHostOperations = /* @__PURE__ */ new WeakSet();
+var budgetedHostOperations = /* @__PURE__ */ new WeakMap();
+function declareBudgetedHostOperation(operation, invoke) {
+  budgetedHostOperations.set(operation, invoke);
+}
 var hostOperationPolicies = /* @__PURE__ */ new WeakMap();
 var hostOperationReplayHandlers = /* @__PURE__ */ new WeakMap();
 function declareHostOperation(operation, policy, options = {}) {
@@ -21898,6 +22009,8 @@ function wrapCallerInjectedFunction(name, value, options, state) {
         });
         const captured = options.realm?.captureArguments(callable, args, copyArguments);
         const hostArgs = captured?.args ?? copyArguments(args);
+        const budgetedOperation = budgetedHostOperations.get(callable);
+        const callOperation = () => budgetedOperation === void 0 ? Reflect.apply(callable, void 0, hostArgs) : budgetedOperation(hostArgs, options.budget);
         const hostCalls = options.hostCalls;
         const operation = options.operation ?? bindingName;
         const moduleId = options.moduleId ?? "<bindings>";
@@ -21906,13 +22019,13 @@ function wrapCallerInjectedFunction(name, value, options, state) {
           let result2;
           if (options.realm !== void 0) {
             try {
-              result2 = options.realm.invoke(callable, () => Reflect.apply(callable, void 0, hostArgs));
+              result2 = options.realm.invoke(callable, callOperation);
             } catch (error) {
               captured.rollback();
               throw error;
             }
           } else {
-            result2 = invokeHostCallback(() => Reflect.apply(callable, void 0, hostArgs), options);
+            result2 = invokeHostCallback(callOperation, options);
           }
           if (awaitResult) {
             return wrapHostPromiseWithSignal(Promise.resolve(result2), options.signal).then((value2) => copyHostResultToSandbox(value2, stackFrames, options), (error) => {
@@ -22000,7 +22113,7 @@ function wrapCallerInjectedFunction(name, value, options, state) {
         const result = executeHostCall(
           issued.record,
           issued.restored,
-          () => invokeHostCallback(() => Reflect.apply(callable, void 0, hostArgs), options),
+          () => invokeHostCallback(callOperation, options),
           stackFrames,
           options,
           context?.span,
@@ -23041,7 +23154,7 @@ function readStringProperty(value, key) {
   return descriptor !== void 0 && "value" in descriptor && typeof descriptor.value === "string" ? descriptor.value : void 0;
 }
 function copyFunctionProperties(callable, stackFrames, options, state, path) {
-  const properties = {};
+  const properties = createIntrinsicObject({});
   const metadata = /* @__PURE__ */ new Map();
   for (const key of Object.getOwnPropertyNames(callable)) {
     const descriptor = Object.getOwnPropertyDescriptor(callable, key);
@@ -23294,8 +23407,8 @@ function callGeneratorMethod(target, method, value, budget, context, async) {
   const result = (async () => {
     if (!isSandboxGenerator(target) || target.async === true !== async)
       throw new TypeError(`${async ? "AsyncGenerator" : "Generator"}.${method} requires a matching generator receiver.`);
-    const iterator = generatorIterator(target, budget, context);
-    const result2 = await iterator[method](value);
+    const iterator2 = generatorIterator(target, budget, context);
+    const result2 = await iterator2[method](value);
     return allocateProducedSandboxValue(result2, budget);
   })();
   return async ? createSandboxPromise(result) : result;
@@ -23484,9 +23597,9 @@ async function createNativeError(name, args, budget, context, constructor) {
   const candidate = await readErrorProperty(newTarget, "prototype", budget, context);
   const prototype = candidate !== null && typeof candidate === "object" ? candidate : getFunctionRealmPrototype(newTarget, name, errorPrototypes.get(budget).get(name));
   let error;
-  let iterator;
+  let iterator2;
   const errors = [];
-  const release = retainValues(budget, () => [prototype, error, iterator?.retainedValue, ...errors, ...args]);
+  const release = retainValues(budget, () => [prototype, error, iterator2?.retainedValue, ...errors, ...args]);
   try {
     const message = name === "SuppressedError" ? args[2] : name === "AggregateError" ? args[1] : args[0];
     const options = name === "SuppressedError" ? void 0 : name === "AggregateError" ? args[2] : args[1];
@@ -23506,15 +23619,15 @@ async function createNativeError(name, args, budget, context, constructor) {
     if (name === "AggregateError") {
       const errorsPrototype = getSandboxPrototype(errors, budget);
       if (errorsPrototype !== null) setSandboxPrototype(errors, errorsPrototype, budget);
-      iterator = context === void 0 ? getSandboxIterator(args[0], budget) : await acquireSandboxIterator(args[0], budget, context);
-      if (iterator === void 0) throw new TypeError("AggregateError errors must be iterable.");
+      iterator2 = context === void 0 ? getSandboxIterator(args[0], budget) : await acquireSandboxIterator(args[0], budget, context);
+      if (iterator2 === void 0) throw new TypeError("AggregateError errors must be iterable.");
       while (true) {
         budget.visitNode();
-        const result = await iterator.next();
+        const result = await iterator2.next();
         if (result === null || typeof result !== "object") throw new TypeError("Iterator result must be an object.");
-        if ((await readIteratorResult(iterator, result, "done")).value) break;
+        if ((await readIteratorResult(iterator2, result, "done")).value) break;
         budget.allocateArrayLength(errors.length + 1);
-        errors.push((await readIteratorResult(iterator, result, "value")).value);
+        errors.push((await readIteratorResult(iterator2, result, "value")).value);
       }
       Object.defineProperty(error, "errors", { value: errors, writable: true, configurable: true });
     }
@@ -24046,7 +24159,7 @@ async function evaluateArrayExpression(node, context) {
   const restored = context.generatorResume === void 0 || node.nodeId === void 0 ? void 0 : context.restoredGeneratorExpressionStates?.get(node.nodeId);
   if (restored !== void 0 && (restored.kind !== "array" || !Array.isArray(restored.values)))
     throw new TypeError("Invalid array expression continuation.");
-  const values = restored?.kind === "array" ? restored.values : [];
+  const values = restored?.kind === "array" ? restored.values : context.scriptScope !== void 0 || context.moduleInstantiated !== void 0 ? createIntrinsicArray() : [];
   if (restored === void 0) {
     const prototype = getSandboxPrototype(values, context.budget);
     if (prototype !== null) setSandboxPrototype(values, prototype, context.budget);
@@ -25170,13 +25283,13 @@ async function evaluateForOfIterator(node, value, context, restoredEntry) {
   let resumeCurrent = saved !== void 0 && saved.phase !== "next";
   let resumeNext = saved?.phase === "next";
   let index = saved?.index ?? consumeRestoredLoopIterationIndex(node, context);
-  const iterator = saved === void 0 ? await acquireSandboxIterator(value, context.budget, createCoercionContext(context), node.await, context.signal) : "kind" in saved.iterator ? await restoreSandboxIterator(saved.iterator, context.budget, createCoercionContext(context), context.signal) : saved.iterator;
-  if (iterator === void 0) {
+  const iterator2 = saved === void 0 ? await acquireSandboxIterator(value, context.budget, createCoercionContext(context), node.await, context.signal) : "kind" in saved.iterator ? await restoreSandboxIterator(saved.iterator, context.budget, createCoercionContext(context), context.signal) : saved.iterator;
+  if (iterator2 === void 0) {
     throw new TypeError(`${String(value)} is not a supported iterable`);
   }
   const nextIteration = async () => {
-    if ((context.asyncFunction || context.asyncGeneratorFrame !== void 0) && node.await && iterator.resumeAwait !== void 0 && node.nodeId !== void 0) {
-      iterator.awaitValue = (awaited, awaitState) => suspendAsyncFunctionValue(awaited, node, {
+    if ((context.asyncFunction || context.asyncGeneratorFrame !== void 0) && node.await && iterator2.resumeAwait !== void 0 && node.nodeId !== void 0) {
+      iterator2.awaitValue = (awaited, awaitState) => suspendAsyncFunctionValue(awaited, node, {
         ...context,
         generatorExpressionStates: new Map([
           ...context.generatorExpressionStates ?? [],
@@ -25189,7 +25302,7 @@ async function evaluateForOfIterator(node, value, context, restoredEntry) {
             current: void 0,
             index,
             scope: context.scope,
-            iterator
+            iterator: iterator2
           }]
         ])
       }, void 0, createCoercionContext(context));
@@ -25197,14 +25310,14 @@ async function evaluateForOfIterator(node, value, context, restoredEntry) {
         if (resumeNext) {
           resumeNext = false;
           if (saved?.awaitState === void 0) throw new TypeError("Missing iterator await continuation.");
-          return await iterator.resumeAwait(saved.awaitState, () => iterator.awaitValue(void 0, saved.awaitState));
+          return await iterator2.resumeAwait(saved.awaitState, () => iterator2.awaitValue(void 0, saved.awaitState));
         }
-        return await iterator.next();
+        return await iterator2.next();
       } finally {
-        delete iterator.awaitValue;
+        delete iterator2.awaitValue;
       }
     }
-    const pending = Promise.resolve(iterator.next());
+    const pending = Promise.resolve(iterator2.next());
     if (!node.await) return pending;
     context.onSuspend?.();
     const leaveAwait = context.budget.enterAwait();
@@ -25215,16 +25328,16 @@ async function evaluateForOfIterator(node, value, context, restoredEntry) {
     }
   };
   const completion = context.evalCompletion ? new StatementCompletion(context.budget, true) : void 0;
-  const releaseIterator = retainValues(context.budget, () => [value, iterator.retainedValue]);
+  const releaseIterator = retainValues(context.budget, () => [value, iterator2.retainedValue]);
   const closeLoopIterator = async (completion2) => {
     const preserveThrow = completion2.kind === "throw";
-    if (!context.asyncFunction && context.asyncGeneratorFrame === void 0 || !node.await || iterator.resumeAwait === void 0 || node.nodeId === void 0 || completion2.kind === "error") {
-      await closeIterator(iterator, preserveThrow);
+    if (!context.asyncFunction && context.asyncGeneratorFrame === void 0 || !node.await || iterator2.resumeAwait === void 0 || node.nodeId === void 0 || completion2.kind === "error") {
+      await closeIterator(iterator2, preserveThrow);
       return;
     }
     const { node: ignoredNode, stackFrames, ...metadata } = completion2;
     const closeCompletion = { ...metadata, ...stackFrames === void 0 ? {} : { stackFrames: [...stackFrames] } };
-    iterator.awaitValue = (awaited, awaitState) => suspendAsyncFunctionValue(awaited, node, {
+    iterator2.awaitValue = (awaited, awaitState) => suspendAsyncFunctionValue(awaited, node, {
       ...context,
       generatorExpressionStates: new Map([
         ...context.generatorExpressionStates ?? [],
@@ -25238,19 +25351,19 @@ async function evaluateForOfIterator(node, value, context, restoredEntry) {
           current: void 0,
           index,
           scope: context.scope,
-          iterator
+          iterator: iterator2
         }]
       ])
     }, void 0, createCoercionContext(context));
     try {
       if (saved?.phase === "close" && context.generatorResume?.completed !== true) {
         if (saved.awaitState === void 0) throw new TypeError("Missing iterator close continuation.");
-        await iterator.resumeAwait(saved.awaitState, () => iterator.awaitValue(void 0, saved.awaitState));
-      } else await closeIterator(iterator, preserveThrow);
+        await iterator2.resumeAwait(saved.awaitState, () => iterator2.awaitValue(void 0, saved.awaitState));
+      } else await closeIterator(iterator2, preserveThrow);
     } catch (error) {
       if (!preserveThrow || isFatalSandboxError(error) || error instanceof HostCallResumabilityError) throw error;
     } finally {
-      delete iterator.awaitValue;
+      delete iterator2.awaitValue;
     }
   };
   try {
@@ -25265,7 +25378,7 @@ async function evaluateForOfIterator(node, value, context, restoredEntry) {
       if (typeof skippedIteration !== "object" || skippedIteration === null) {
         throw new TypeError("Iterator result must be an object.");
       }
-      if ((await readIteratorResult(iterator, skippedIteration, "done")).value) {
+      if ((await readIteratorResult(iterator2, skippedIteration, "done")).value) {
         return completion?.normal() ?? normalEmptyResult();
       }
     }
@@ -25277,16 +25390,16 @@ async function evaluateForOfIterator(node, value, context, restoredEntry) {
       if (typeof iteration !== "object" || iteration === null) {
         throw new TypeError("Iterator result must be an object.");
       }
-      if ((await readIteratorResult(iterator, iteration, "done")).value) {
+      if ((await readIteratorResult(iterator2, iteration, "done")).value) {
         context.activeLoopIterations.delete(nodeId);
         return completion?.normal() ?? normalEmptyResult();
       }
-      const nextValue = (await readIteratorResult(iterator, iteration, "value")).value;
+      const nextValue = (await readIteratorResult(iterator2, iteration, "value")).value;
       context.activeLoopIterations.set(
         nodeId,
-        iterator.snapshotIndex === void 0 ? index : {
+        iterator2.snapshotIndex === void 0 ? index : {
           get index() {
-            return iterator.snapshotIndex();
+            return iterator2.snapshotIndex();
           },
           values: [value, nextValue]
         }
@@ -25297,7 +25410,7 @@ async function evaluateForOfIterator(node, value, context, restoredEntry) {
         ...context.generatorYield === void 0 || node.nodeId === void 0 ? {} : {
           generatorExpressionStates: new Map([
             ...context.generatorExpressionStates ?? [],
-            [node.nodeId, { kind: "for-of-iterator", phase, async: node.await === true, value, current: nextValue, index, scope, iterator }]
+            [node.nodeId, { kind: "for-of-iterator", phase, async: node.await === true, value, current: nextValue, index, scope, iterator: iterator2 }]
           ])
         }
       });
@@ -25797,14 +25910,14 @@ async function evaluateYieldDelegate(node, context) {
     return argument;
   }
   if (context.generatorResume?.completed === true) context.generatorResume = void 0;
-  const iterator = saved === void 0 ? await acquireSandboxIterator(
+  const iterator2 = saved === void 0 ? await acquireSandboxIterator(
     argument.value,
     context.budget,
     createCoercionContext(context),
     context.asyncGenerator,
     context.signal
   ) : "kind" in saved.iterator ? await restoreSandboxIterator(saved.iterator, context.budget, createCoercionContext(context), context.signal) : saved.iterator;
-  if (iterator === void 0) {
+  if (iterator2 === void 0) {
     throw new TypeError(`${String(argument.value)} is not a supported iterable`);
   }
   const state = {
@@ -25812,21 +25925,21 @@ async function evaluateYieldDelegate(node, context) {
     async: context.asyncGenerator === true,
     value: argument.value,
     current: saved?.current,
-    iterator,
+    iterator: iterator2,
     ...saved?.phase === void 0 ? {} : { phase: saved.phase, awaitState: saved.awaitState, completion: saved.completion }
   };
   if (node.nodeId !== void 0) context = {
     ...context,
     generatorExpressionStates: new Map([...context.generatorExpressionStates ?? [], [node.nodeId, state]])
   };
-  if (context.asyncGeneratorFrame !== void 0 && iterator.resumeAwait !== void 0)
-    iterator.awaitValue = (value, awaitState) => {
+  if (context.asyncGeneratorFrame !== void 0 && iterator2.resumeAwait !== void 0)
+    iterator2.awaitValue = (value, awaitState) => {
       state.awaitState = awaitState;
       return suspendAsyncFunctionValue(value, node, context, void 0, createCoercionContext(context));
     };
   const releaseIterator = retainValues(context.budget, () => [
     argument.value,
-    iterator.retainedValue,
+    iterator2.retainedValue,
     state.current
   ]);
   try {
@@ -25851,20 +25964,20 @@ async function evaluateYieldDelegate(node, context) {
       let result;
       if (resumeOperation) {
         resumeOperation = false;
-        if (iterator.resumeAwait === void 0 || iterator.awaitValue === void 0 || saved?.awaitState === void 0)
+        if (iterator2.resumeAwait === void 0 || iterator2.awaitValue === void 0 || saved?.awaitState === void 0)
           throw new TypeError("Missing delegated iterator await continuation.");
-        result = await iterator.resumeAwait(saved.awaitState, () => iterator.awaitValue(void 0, saved.awaitState));
+        result = await iterator2.resumeAwait(saved.awaitState, () => iterator2.awaitValue(void 0, saved.awaitState));
         if (saved.phase === "close") throw new TypeError("Delegated iterator does not provide a throw method.");
         context.generatorResume = void 0;
       } else {
-        const iteratorMethod = iterator.getOperation === void 0 ? iterator[method] : await iterator.getOperation(method);
+        const iteratorMethod = iterator2.getOperation === void 0 ? iterator2[method] : await iterator2.getOperation(method);
         if (iteratorMethod === void 0) {
           if (completion.type === "throw") {
-            if (iterator.awaitValue !== void 0) {
+            if (iterator2.awaitValue !== void 0) {
               state.phase = "close";
               state.completion = completion;
             }
-            await closeIterator(iterator, false, context.asyncGeneratorFrame === void 0 ? suspendJob : async (pending) => await suspendAsyncFunctionValue(createSandboxPromise(pending), node, context, void 0, createCoercionContext(context)));
+            await closeIterator(iterator2, false, context.asyncGeneratorFrame === void 0 ? suspendJob : async (pending) => await suspendAsyncFunctionValue(createSandboxPromise(pending), node, context, void 0, createCoercionContext(context)));
             throw new TypeError("Delegated iterator does not provide a throw method.");
           }
           if (context.asyncGenerator && completion.type === "return") {
@@ -25875,12 +25988,12 @@ async function evaluateYieldDelegate(node, context) {
           }
           return generatorCompletionResult(completion);
         }
-        if (iterator.awaitValue !== void 0) {
+        if (iterator2.awaitValue !== void 0) {
           state.phase = "await";
           state.completion = completion;
         }
         const pendingResult = Promise.resolve(iteratorMethod(completion.value));
-        result = context.asyncGeneratorFrame !== void 0 && iterator.awaitValue === void 0 ? await suspendAsyncFunctionValue(createSandboxPromise(pendingResult), node, context, void 0, createCoercionContext(context)) : await (context.asyncGenerator && iterator.awaitValue === void 0 ? suspendJob(pendingResult) : pendingResult);
+        result = context.asyncGeneratorFrame !== void 0 && iterator2.awaitValue === void 0 ? await suspendAsyncFunctionValue(createSandboxPromise(pendingResult), node, context, void 0, createCoercionContext(context)) : await (context.asyncGenerator && iterator2.awaitValue === void 0 ? suspendJob(pendingResult) : pendingResult);
       }
       delete state.phase;
       delete state.awaitState;
@@ -25888,8 +26001,8 @@ async function evaluateYieldDelegate(node, context) {
       if (typeof result !== "object" && typeof result !== "function" || result === null) {
         throw new TypeError("Iterator result must be an object.");
       }
-      const done = (await readIteratorResult(iterator, result, "done")).value;
-      const value = done || context.asyncGenerator ? (await readIteratorResult(iterator, result, "value")).value : result;
+      const done = (await readIteratorResult(iterator2, result, "done")).value;
+      const value = done || context.asyncGenerator ? (await readIteratorResult(iterator2, result, "value")).value : result;
       if (done) {
         if (completion.type === "return") {
           return generatorCompletionResult({ type: "return", value });
@@ -25910,7 +26023,7 @@ async function evaluateYieldDelegate(node, context) {
       context.generatorResume = void 0;
     }
   } finally {
-    delete iterator.awaitValue;
+    delete iterator2.awaitValue;
     releaseIterator();
   }
 }
@@ -27378,23 +27491,23 @@ async function evaluateSpreadElement(node, context) {
       result: value
     };
   }
-  const iterator = await acquireSandboxIterator(value.value, context.budget, createCoercionContext(context));
-  if (iterator === void 0) {
+  const iterator2 = await acquireSandboxIterator(value.value, context.budget, createCoercionContext(context));
+  if (iterator2 === void 0) {
     throw new TypeError("Spread arguments must evaluate to an iterable.");
   }
   const spreadValues = [];
-  const release = retainValues(context.budget, () => [value.value, iterator.retainedValue, ...spreadValues]);
+  const release = retainValues(context.budget, () => [value.value, iterator2.retainedValue, ...spreadValues]);
   try {
     while (true) {
-      const next = await iterator.next();
+      const next = await iterator2.next();
       if (typeof next !== "object" || next === null) {
         throw new TypeError("Iterator result must be an object.");
       }
-      const done = iterator.readResultProperty === void 0 ? next.done : (await readIteratorResult(iterator, next, "done")).value;
+      const done = iterator2.readResultProperty === void 0 ? next.done : (await readIteratorResult(iterator2, next, "done")).value;
       if (done) {
         break;
       }
-      const item = iterator.readResultProperty === void 0 ? next.value : (await readIteratorResult(iterator, next, "value")).value;
+      const item = iterator2.readResultProperty === void 0 ? next.value : (await readIteratorResult(iterator2, next, "value")).value;
       spreadValues.push(item);
       context.budget.allocateArrayLength(spreadValues.length);
     }
@@ -27994,16 +28107,16 @@ function createGroupBy(budget, keyMode) {
     call: async ([items, callback], context) => {
       if (items === null || items === void 0) throw new TypeError("groupBy requires an iterable.");
       if (!isSandboxClosure(callback)) throw new TypeError("groupBy requires a callable callback.");
-      const iterator = context === void 0 ? getSandboxIterator(items, budget) : await acquireSandboxIterator(items, budget, context);
-      if (iterator === void 0) throw new TypeError("groupBy requires an iterable.");
+      const iterator2 = context === void 0 ? getSandboxIterator(items, budget) : await acquireSandboxIterator(items, budget, context);
+      if (iterator2 === void 0) throw new TypeError("groupBy requires an iterable.");
       const groups = createSandboxMap([]);
       let value;
       let key;
-      const release = retainValues(budget, () => [groups, callback, iterator.retainedValue, value, key]);
+      const release = retainValues(budget, () => [groups, callback, iterator2.retainedValue, value, key]);
       const checkpoint = createDataCheckpoint(budget, context);
       const closeOnThrow = async (error) => {
         try {
-          await closeIterator(iterator, true);
+          await closeIterator(iterator2, true);
         } catch (closeError) {
           if (!isFatalSandboxError(error) && isFatalSandboxError(closeError)) throw closeError;
         }
@@ -28018,9 +28131,9 @@ function createGroupBy(budget, keyMode) {
           } catch (error) {
             await closeOnThrow(error);
           }
-          const next = await iterator.next();
-          if ((await readIteratorResult(iterator, next, "done")).value) break;
-          value = (await readIteratorResult(iterator, next, "value")).value;
+          const next = await iterator2.next();
+          if ((await readIteratorResult(iterator2, next, "done")).value) break;
+          value = (await readIteratorResult(iterator2, next, "value")).value;
           try {
             key = await invokeBuiltinClosure(callback, [value, index], budget, context, void 0);
             if (keyMode === "property") key = await toPropertyKey(key, budget, context);
@@ -28204,9 +28317,9 @@ function createPrimitiveConstructor(options, budget) {
         const receiver = context?.thisValue;
         if (receiver === null || receiver === void 0) throw new TypeError("String iterator requires a receiver.");
         const input = await sandboxString(receiver, budget, context);
-        const iterator = restoreSandboxStringIterator({ input, index: 0 });
-        setSandboxPrototype(iterator, iteratorPrototype, budget);
-        return iterator;
+        const iterator2 = restoreSandboxStringIterator({ input, index: 0 });
+        setSandboxPrototype(iterator2, iteratorPrototype, budget);
+        return iterator2;
       }
     }), writable: true, configurable: true });
   }
@@ -28394,7 +28507,7 @@ function createObjectArrayGlobals(options) {
           sandbox: true,
           call: async ([prototype, descriptors2], context) => {
             if (prototype !== null) objectProperties(prototype);
-            const value = /* @__PURE__ */ Object.create(null);
+            const value = createIntrinsicObject();
             setSandboxPrototype(value, prototype, options.budget);
             if (descriptors2 !== void 0) {
               await definePropertiesFromObject(value, descriptors2, options.budget, context);
@@ -28414,19 +28527,19 @@ function createObjectArrayGlobals(options) {
         fromEntries: createSandboxClosure({
           sandbox: true,
           call: ([value], context) => {
-            if (context !== void 0) return acquireSandboxIterator(value, options.budget, context).then((iterator2) => {
-              if (iterator2 === void 0) throw new TypeError("Object.fromEntries requires an iterable.");
-              return objectFromSandboxEntries(value, iterator2, options.budget, context);
+            if (context !== void 0) return acquireSandboxIterator(value, options.budget, context).then((iterator3) => {
+              if (iterator3 === void 0) throw new TypeError("Object.fromEntries requires an iterable.");
+              return objectFromSandboxEntries(value, iterator3, options.budget, context);
             });
-            const iterator = getSandboxIterator(value, options.budget, context);
-            if (iterator === void 0) {
+            const iterator2 = getSandboxIterator(value, options.budget, context);
+            if (iterator2 === void 0) {
               throw new TypeError("Object.fromEntries requires an iterable.");
             }
-            if (context === void 0 && !iterator.generator && !iterator.asynchronous) {
+            if (context === void 0 && !iterator2.generator && !iterator2.asynchronous) {
               const object = allocateProducedSandboxValue(
                 Object.setPrototypeOf(
                   Reflect.apply(Object.fromEntries, Object, [
-                    { [Symbol.iterator]: () => iterator }
+                    { [Symbol.iterator]: () => iterator2 }
                   ]),
                   null
                 ),
@@ -28436,7 +28549,7 @@ function createObjectArrayGlobals(options) {
               if (prototype !== null) setSandboxPrototype(object, prototype, options.budget);
               return object;
             }
-            return objectFromSandboxEntries(value, iterator, options.budget, context);
+            return objectFromSandboxEntries(value, iterator2, options.budget, context);
           },
           name: "fromEntries",
           length: 1
@@ -28701,9 +28814,9 @@ function createArrayGlobal(budget) {
         const receiver = context?.thisValue;
         if (receiver === null || receiver === void 0) throw new TypeError("Array iterator method requires a receiver.");
         const source = typeof receiver === "object" ? receiver : createSandboxBox(receiver);
-        const iterator = restoreSandboxArrayIterator({ source, index: 0, method });
-        setSandboxPrototype(iterator, iteratorPrototype, budget);
-        return iterator;
+        const iterator2 = restoreSandboxArrayIterator({ source, index: 0, method });
+        setSandboxPrototype(iterator2, iteratorPrototype, budget);
+        return iterator2;
       }
     });
     Object.defineProperty(prototype, method, { value: closure, writable: true, configurable: true });
@@ -28822,7 +28935,7 @@ function createArrayGlobal(budget) {
   installArrayPrototype(budget, prototype, constructor);
   return constructor;
 }
-async function objectFromSandboxEntries(items, iterator, budget, context) {
+async function objectFromSandboxEntries(items, iterator2, budget, context) {
   const object = /* @__PURE__ */ Object.create(null);
   const prototype = getSandboxPrototype(object, budget);
   if (prototype !== null) setSandboxPrototype(object, prototype, budget);
@@ -28833,7 +28946,7 @@ async function objectFromSandboxEntries(items, iterator, budget, context) {
   const retained = {};
   budget.setRetainedValues(retained, () => [
     items,
-    iterator.retainedValue,
+    iterator2.retainedValue,
     object,
     entry,
     key,
@@ -28844,7 +28957,7 @@ async function objectFromSandboxEntries(items, iterator, budget, context) {
   const closeOnThrow = async (error) => {
     failure = isCapturedException(error) ? error.reason : error;
     try {
-      await closeIterator(iterator, true);
+      await closeIterator(iterator2, true);
     } catch (closeError) {
       if (!isFatalSandboxError(error) && isFatalSandboxError(closeError)) throw closeError;
     }
@@ -28858,12 +28971,12 @@ async function objectFromSandboxEntries(items, iterator, budget, context) {
       } catch (error) {
         await closeOnThrow(error);
       }
-      const result = await iterator.next();
+      const result = await iterator2.next();
       if (typeof result !== "object" || result === null) {
         throw new TypeError("Iterator result must be an object.");
       }
-      if ((await readIteratorResult(iterator, result, "done")).value) break;
-      entry = (await readIteratorResult(iterator, result, "value")).value;
+      if ((await readIteratorResult(iterator2, result, "done")).value) break;
+      entry = (await readIteratorResult(iterator2, result, "value")).value;
       try {
         if (typeof entry !== "object" || entry === null) {
           throw new TypeError("Object.fromEntries requires entry objects.");
@@ -28953,12 +29066,13 @@ function objectProperties(value, _mutable = false) {
   return value;
 }
 function exposePropertyDescriptor(descriptor, budget) {
-  const result = "value" in descriptor ? descriptor : {
+  const properties = "value" in descriptor ? descriptor : {
     get: accessorClosure(descriptor.get, budget),
     set: accessorClosure(descriptor.set, budget),
     enumerable: descriptor.enumerable,
     configurable: descriptor.configurable
   };
+  const result = runResources.getStore()?.nativeDataResults === true ? properties : createIntrinsicObject(properties);
   const prototype = getSandboxPrototype(result, budget);
   if (prototype !== null) setSandboxPrototype(result, prototype, budget);
   return result;
@@ -29128,8 +29242,8 @@ async function arrayFromSandboxValues(args, budget, context, onSuspend) {
   const iteratorMethod = observableMethod ? await context.getProperty(items, Symbol.iterator) : void 0;
   if (iteratorMethod !== null && iteratorMethod !== void 0 && !isSandboxClosure(iteratorMethod) && typeof iteratorMethod !== "function")
     throw new TypeError("Iterator method must be callable.");
-  let iterator = observableMethod ? void 0 : context === void 0 ? asyncProtocol ? getSandboxAsyncIterator(items, budget) : getSandboxIterator(items, budget) : await acquireSandboxIterator(items, budget, context, asyncProtocol);
-  const iterable = observableMethod ? iteratorMethod !== null && iteratorMethod !== void 0 : iterator !== void 0;
+  let iterator2 = observableMethod ? void 0 : context === void 0 ? asyncProtocol ? getSandboxAsyncIterator(items, budget) : getSandboxIterator(items, budget) : await acquireSandboxIterator(items, budget, context, asyncProtocol);
+  const iterable = observableMethod ? iteratorMethod !== null && iteratorMethod !== void 0 : iterator2 !== void 0;
   const constructor = context?.thisValue;
   let result;
   let currentValue;
@@ -29138,9 +29252,9 @@ async function arrayFromSandboxValues(args, budget, context, onSuspend) {
   budget.setRetainedValues(retained, () => [
     // Once acquired, a rooted protocol iterator owns the remaining input. Keep
     // the original only for array-like reads or implicit unrooted iterators.
-    iterator?.retainedValue === void 0 ? items : void 0,
+    iterator2?.retainedValue === void 0 ? items : void 0,
     iteratorMethod,
-    iterator?.retainedValue,
+    iterator2?.retainedValue,
     mapFn,
     thisValue,
     constructor,
@@ -29152,7 +29266,7 @@ async function arrayFromSandboxValues(args, budget, context, onSuspend) {
   const closeOnThrow = async (error) => {
     failure = isCapturedException(error) ? error.reason : error;
     try {
-      if (iterator !== void 0) await closeIterator(iterator, true);
+      if (iterator2 !== void 0) await closeIterator(iterator2, true);
     } catch (closeError) {
       if (!isFatalSandboxError(error) && isFatalSandboxError(closeError)) throw closeError;
     }
@@ -29174,23 +29288,23 @@ async function arrayFromSandboxValues(args, budget, context, onSuspend) {
     ) : createArrayFromConstructorArgs([length], budget);
     checkData(result, 0, true);
     if (observableMethod && iterable)
-      iterator = await getSandboxIteratorFromMethod(items, iteratorMethod, budget, context);
+      iterator2 = await getSandboxIteratorFromMethod(items, iteratorMethod, budget, context);
     let index = 0;
-    while (iterator !== void 0 || index < length) {
+    while (iterator2 !== void 0 || index < length) {
       try {
         budget.visitNode();
-        if (iterator !== void 0 && index >= Number.MAX_SAFE_INTEGER)
+        if (iterator2 !== void 0 && index >= Number.MAX_SAFE_INTEGER)
           throw new TypeError("Array.from input is too long.");
       } catch (error) {
         await closeOnThrow(error);
       }
-      if (iterator !== void 0) {
-        const pending = Promise.resolve(iterator.next());
+      if (iterator2 !== void 0) {
+        const pending = Promise.resolve(iterator2.next());
         const next = await (asyncProtocol ? awaitAsync(pending) : pending);
         if (typeof next !== "object" || next === null)
           throw new TypeError("Iterator result must be an object.");
-        if ((await readIteratorResult(iterator, next, "done")).value) break;
-        currentValue = (await readIteratorResult(iterator, next, "value")).value;
+        if ((await readIteratorResult(iterator2, next, "done")).value) break;
+        currentValue = (await readIteratorResult(iterator2, next, "value")).value;
       } else {
         currentValue = await read(index);
         if (asyncProtocol) currentValue = await awaitAsync(awaitSandboxValue(currentValue, void 0, budget, context));
@@ -30079,17 +30193,17 @@ async function settleIterable(iterable, method, budget, constructor, context) {
     const promiseResolve = await readPromiseReceiverProperty(constructor, "resolve", prototype, context);
     if (!isSandboxClosure(promiseResolve))
       throw new TypeError("Promise constructor requires a callable resolve.");
-    const iterator = context === void 0 ? getSandboxIterator(iterable, budget) : await acquireSandboxIterator(iterable, budget, context);
-    if (iterator === void 0) throw new TypeError("Promise helpers require an iterable.");
-    const releaseIterator = retainValues(budget, () => [iterator.retainedValue]);
+    const iterator2 = context === void 0 ? getSandboxIterator(iterable, budget) : await acquireSandboxIterator(iterable, budget, context);
+    if (iterator2 === void 0) throw new TypeError("Promise helpers require an iterable.");
+    const releaseIterator = retainValues(budget, () => [iterator2.retainedValue]);
     try {
       while (true) {
         budget.visitNode();
-        const next = iterator.generator || iterator.asynchronous ? await iterator.next() : iterator.next();
+        const next = iterator2.generator || iterator2.asynchronous ? await iterator2.next() : iterator2.next();
         if (typeof next !== "object" || next === null)
           throw new TypeError("Iterator result must be an object.");
-        if ((await readIteratorResult(iterator, next, "done")).value) break;
-        const value = (await readIteratorResult(iterator, next, "value")).value;
+        if ((await readIteratorResult(iterator2, next, "done")).value) break;
+        const value = (await readIteratorResult(iterator2, next, "value")).value;
         try {
           budget.allocateArrayLength(aggregate.size + 1);
           const entryIndex = aggregate.size++;
@@ -30123,7 +30237,7 @@ async function settleIterable(iterable, method, budget, constructor, context) {
             }
           }
         } catch (error) {
-          await closeIterator(iterator, true);
+          await closeIterator(iterator2, true);
           throw error;
         }
       }
@@ -31663,11 +31777,11 @@ function createSetOperation(name, budget) {
       const read = async (object, key) => context?.getProperty !== void 0 ? context.getProperty(object, key) : readPropertyDescriptor(getSandboxPropertyDescriptor(object, key, budget) ?? { value: void 0 }, object, context);
       const iterationContext = { ...context, thisValue: receiver, stack: context?.stack ?? [], getProperty: read };
       const result = createSandboxSet([]);
-      let iterator;
+      let iterator2;
       let current;
       let has2;
       let keys;
-      const release = retainValues(budget, () => [receiver, other, result, current, has2, keys, iterator?.retainedValue]);
+      const release = retainValues(budget, () => [receiver, other, result, current, has2, keys, iterator2?.retainedValue]);
       const checkpoint = createDataCheckpoint(budget, context);
       const add2 = (value) => {
         budget.visitNode();
@@ -31688,7 +31802,7 @@ function createSetOperation(name, budget) {
         if (name === "isSubsetOf" && receiver.values.size > size || name === "isSupersetOf" && receiver.values.size < size) return false;
         const visitReceiver = name === "isSubsetOf" || (name === "intersection" || name === "difference" || name === "isDisjointFrom") && receiver.values.size <= size;
         if (name === "union" || name === "symmetricDifference")
-          iterator = await getSandboxIteratorFromMethod(other, keys, budget, iterationContext);
+          iterator2 = await getSandboxIteratorFromMethod(other, keys, budget, iterationContext);
         if (name === "union" || name === "symmetricDifference" || name === "difference")
           for (const value of receiver.values) add2(value);
         if (visitReceiver) {
@@ -31707,15 +31821,15 @@ function createSetOperation(name, budget) {
             cursor.leave();
           }
         } else {
-          iterator ??= await getSandboxIteratorFromMethod(other, keys, budget, iterationContext);
+          iterator2 ??= await getSandboxIteratorFromMethod(other, keys, budget, iterationContext);
           while (true) {
             budget.visitNode();
-            const next = await iterator.next();
-            if ((await readIteratorResult(iterator, next, "done")).value) break;
-            current = (await readIteratorResult(iterator, next, "value")).value;
+            const next = await iterator2.next();
+            if ((await readIteratorResult(iterator2, next, "done")).value) break;
+            current = (await readIteratorResult(iterator2, next, "value")).value;
             const found = receiver.values.has(current);
             if (name === "isSupersetOf" && !found || name === "isDisjointFrom" && found) {
-              await closeIterator(iterator);
+              await closeIterator(iterator2);
               return false;
             }
             if (name === "union" || name === "intersection" && found || name === "symmetricDifference" && !found) add2(current);
@@ -31785,7 +31899,7 @@ function installCollectionPrototypes(budget, mapConstructor, setConstructor) {
       return context.thisValue.values.size;
     }
   });
-  for (const { name, constructor, methods: methods4, size, iterator } of [
+  for (const { name, constructor, methods: methods4, size, iterator: iterator2 } of [
     { name: "Map", constructor: mapConstructor, methods: mapMethods, size: mapSize3, iterator: mapMethods.entries },
     { name: "Set", constructor: setConstructor, methods: setMethods, size: setSize2, iterator: setMethods.values }
   ]) {
@@ -31804,7 +31918,7 @@ function installCollectionPrototypes(budget, mapConstructor, setConstructor) {
       Object.defineProperty(prototype, key, { value: method, writable: true, configurable: true });
     Object.defineProperty(prototype, "size", { get: accessorAdapter(size, "get"), configurable: true });
     Object.defineProperty(prototype, Symbol.toStringTag, { value: name, configurable: true });
-    Object.defineProperty(prototype, Symbol.iterator, { value: iterator, writable: true, configurable: true });
+    Object.defineProperty(prototype, Symbol.iterator, { value: iterator2, writable: true, configurable: true });
     installCollectionPrototype(budget, name, prototype, constructor);
     for (const method of /* @__PURE__ */ new Set([...Object.values(methods4), size, species])) registerIntrinsicFunction(budget, method);
   }
@@ -31932,14 +32046,14 @@ function populateCollection(source, collection, {
 }) {
   budget.allocateCollectionEntries(0);
   let adder;
-  const populate = (iterator) => {
-    if (iterator === void 0) throw new TypeError(`${name} constructor requires an iterable.`);
+  const populate = (iterator2) => {
+    if (iterator2 === void 0) throw new TypeError(`${name} constructor requires an iterable.`);
     let entry;
     let failure;
     const retained = {};
     budget.setRetainedValues(retained, () => [
       source,
-      iterator.retainedValue,
+      iterator2.retainedValue,
       collection,
       adder,
       entry,
@@ -31953,13 +32067,13 @@ function populateCollection(source, collection, {
         if (!isFatalSandboxError(error) && isFatalSandboxError(closeError)) throw closeError;
         throw error;
       };
-      if (iterator.getOperation !== void 0)
-        return closeIterator(iterator, true).then(() => {
+      if (iterator2.getOperation !== void 0)
+        return closeIterator(iterator2, true).then(() => {
           throw error;
         }, rethrow);
       try {
-        const closing = iterator.return?.();
-        if (iterator.generator || iterator.asynchronous)
+        const closing = iterator2.return?.();
+        if (iterator2.generator || iterator2.asynchronous)
           return Promise.resolve(closing).then(() => {
             throw error;
           }, rethrow);
@@ -31989,16 +32103,16 @@ function populateCollection(source, collection, {
       }
       return false;
     };
-    if (iterator.generator || iterator.asynchronous || context !== void 0 || adder !== void 0) {
+    if (iterator2.generator || iterator2.asynchronous || context !== void 0 || adder !== void 0) {
       return (async () => {
         try {
           checkData(collection, 0, true);
           while (true) {
-            const result = await iterator.next();
+            const result = await iterator2.next();
             if (typeof result !== "object" || result === null)
               throw new TypeError("Iterator result must be an object.");
-            if ((await readIteratorResult(iterator, result, "done")).value) break;
-            const value = (await readIteratorResult(iterator, result, "value")).value;
+            if ((await readIteratorResult(iterator2, result, "done")).value) break;
+            const value = (await readIteratorResult(iterator2, result, "value")).value;
             await consume({ done: false, value });
           }
           checkData(collection, 0, true);
@@ -32010,7 +32124,7 @@ function populateCollection(source, collection, {
     }
     try {
       checkData(collection, 0, true);
-      while (!consume(iterator.next())) {
+      while (!consume(iterator2.next())) {
       }
       checkData(collection, 0, true);
       return collection;
@@ -32022,8 +32136,8 @@ function populateCollection(source, collection, {
   const start = (candidate) => {
     if (!isSandboxClosure(candidate)) throw new TypeError(`${name} constructor adder must be callable.`);
     if (getIntrinsicIdentity(candidate) !== JSON.stringify([name, "prototype", method])) adder = candidate;
-    const iterator = context === void 0 ? getSandboxIterator(source, budget) : acquireSandboxIterator(source, budget, context);
-    return iterator instanceof Promise ? iterator.then(populate) : populate(iterator);
+    const iterator2 = context === void 0 ? getSandboxIterator(source, budget) : acquireSandboxIterator(source, budget, context);
+    return iterator2 instanceof Promise ? iterator2.then(populate) : populate(iterator2);
   };
   const initialize = (prototype2) => {
     if (typeof prototype2 !== "object" || prototype2 === null)
@@ -32070,14 +32184,14 @@ function createWeakCollectionGlobals(budget) {
           if (source === void 0 || source === null) return collection;
           adder = await read(collection, adderName);
           if (!isSandboxClosure(adder)) throw new TypeError(`${name} constructor adder must be callable.`);
-          const iterator = context === void 0 ? getSandboxIterator(source, budget) : await acquireSandboxIterator(source, budget, context);
-          if (iterator === void 0) throw new TypeError(`${name} constructor requires an iterable.`);
-          const releaseIterator = retainValues(budget, () => [iterator.retainedValue]);
+          const iterator2 = context === void 0 ? getSandboxIterator(source, budget) : await acquireSandboxIterator(source, budget, context);
+          if (iterator2 === void 0) throw new TypeError(`${name} constructor requires an iterable.`);
+          const releaseIterator = retainValues(budget, () => [iterator2.retainedValue]);
           try {
             while (true) {
-              const next = await iterator.next();
-              if ((await readIteratorResult(iterator, next, "done")).value) break;
-              entry = (await readIteratorResult(iterator, next, "value")).value;
+              const next = await iterator2.next();
+              if ((await readIteratorResult(iterator2, next, "done")).value) break;
+              entry = (await readIteratorResult(iterator2, next, "value")).value;
               try {
                 budget.visitNode();
                 if (kind === "map") {
@@ -32089,7 +32203,7 @@ function createWeakCollectionGlobals(budget) {
                 entry = key = value = void 0;
               } catch (error) {
                 try {
-                  await closeIterator(iterator, true);
+                  await closeIterator(iterator2, true);
                 } catch (closeError) {
                   if (!isFatalSandboxError(error) && isFatalSandboxError(closeError)) throw closeError;
                 }
@@ -32169,7 +32283,7 @@ function createWeakCollectionGlobals(budget) {
 
 // packages/safe-js/src/interp/globals/math-sum-precise.ts
 async function sumPrecise(source, budget, context) {
-  let iterator;
+  let iterator2;
   let current;
   let recordValue;
   let sum = 0n;
@@ -32179,25 +32293,25 @@ async function sumPrecise(source, budget, context) {
   let count = 0;
   const storage = new DataView(new ArrayBuffer(8));
   const checkData = createDataCheckpoint(budget, context);
-  const release = retainValues(budget, () => [source, iterator?.retainedValue, recordValue, current, sum]);
+  const release = retainValues(budget, () => [source, iterator2?.retainedValue, recordValue, current, sum]);
   try {
     if (source === void 0 || source === null) throw new TypeError("Math.sumPrecise requires an iterable.");
-    iterator = context === void 0 ? getSandboxIterator(source, budget) : await acquireSandboxIterator(source, budget, context);
-    if (iterator === void 0) throw new TypeError("Math.sumPrecise requires an iterable.");
+    iterator2 = context === void 0 ? getSandboxIterator(source, budget) : await acquireSandboxIterator(source, budget, context);
+    if (iterator2 === void 0) throw new TypeError("Math.sumPrecise requires an iterable.");
     checkData(source, 0, true);
     while (true) {
       budget.visitNode();
-      const next = iterator.next();
-      const result = iterator.asynchronous || iterator.generator ? await next : next;
+      const next = iterator2.next();
+      const result = iterator2.asynchronous || iterator2.generator ? await next : next;
       if (typeof result !== "object" && typeof result !== "function" || result === null)
         throw new TypeError("Iterator result must be an object.");
       recordValue = result;
       const record4 = result;
-      if ((await readIteratorResult(iterator, record4, "done")).value) break;
-      current = (await readIteratorResult(iterator, record4, "value")).value;
+      if ((await readIteratorResult(iterator2, record4, "done")).value) break;
+      current = (await readIteratorResult(iterator2, record4, "value")).value;
       if (count >= Number.MAX_SAFE_INTEGER || typeof current !== "number") {
         const error = count >= Number.MAX_SAFE_INTEGER ? new RangeError("Math.sumPrecise received too many elements.") : new TypeError("Math.sumPrecise requires number elements.");
-        await closeIterator(iterator, true);
+        await closeIterator(iterator2, true);
         throw error;
       }
       count++;
@@ -32818,21 +32932,21 @@ async function cloneWithOptions(value, options, budget, context) {
     })
   };
   let current;
-  let iterator;
+  let iterator2;
   const items = [];
-  const release = retainValues(budget, () => [value, options, current, items, iterator?.retainedValue]);
+  const release = retainValues(budget, () => [value, options, current, items, iterator2?.retainedValue]);
   try {
     current = await bridge.getProperty(options, "transfer");
     if (current !== void 0) {
       if (current === null || typeof current !== "object") throw new TypeError("Transfer list must be an iterable object.");
-      iterator = await acquireSandboxIterator(current, budget, bridge);
-      if (iterator === void 0) throw new TypeError("Transfer list must be iterable.");
+      iterator2 = await acquireSandboxIterator(current, budget, bridge);
+      if (iterator2 === void 0) throw new TypeError("Transfer list must be iterable.");
       for (; ; ) {
         budget.visitNode();
-        const result = await iterator.next();
+        const result = await iterator2.next();
         current = result;
-        if ((await readIteratorResult(iterator, result, "done")).value) break;
-        current = (await readIteratorResult(iterator, result, "value")).value;
+        if ((await readIteratorResult(iterator2, result, "done")).value) break;
+        current = (await readIteratorResult(iterator2, result, "value")).value;
         if (current === null || typeof current !== "object") {
           throw new TypeError("Transfer list elements must be objects.");
         }
@@ -32907,8 +33021,8 @@ function cloneStructuredValue(value, transfers, budget, context) {
       operation.release();
     }
   }
-  const iterator = execute();
-  const first = iterator.next();
+  const iterator2 = execute();
+  const first = iterator2.next();
   if (first.done) return first.value;
   return (async () => {
     let step = first;
@@ -32917,15 +33031,15 @@ function cloneStructuredValue(value, transfers, budget, context) {
         const request = step.value;
         if ("stringValue" in request) {
           createDataCheckpoint(budget, context)(request.stringValue, 0, true);
-          step = iterator.next(await sandboxString(request.stringValue, budget, context));
+          step = iterator2.next(await sandboxString(request.stringValue, budget, context));
         } else {
           createDataCheckpoint(budget, context)(request.receiver, 0, true);
-          step = iterator.next(await readPropertyDescriptor(request.descriptor, request.receiver, context));
+          step = iterator2.next(await readPropertyDescriptor(request.descriptor, request.receiver, context));
         }
       }
       return step.value;
     } finally {
-      iterator.return(void 0);
+      iterator2.return(void 0);
     }
   })();
 }
@@ -37598,20 +37712,20 @@ function installIteratorFrom(constructor, budget) {
     context = callContext(context);
     if (input === null || typeof input !== "object" && typeof input !== "string")
       throw new TypeError("Iterator.from requires an object or string.");
-    let iterator = input;
+    let iterator2 = input;
     let next;
-    const release = retainValues(budget, () => [input, iterator, next]);
+    const release = retainValues(budget, () => [input, iterator2, next]);
     try {
       const method = await context.getProperty(input, Symbol.iterator);
       if (method !== void 0 && method !== null) {
         if (!isSandboxClosure(method)) throw new TypeError("Symbol.iterator must be callable.");
-        iterator = await invokeBuiltinClosure(method, [], budget, context, input);
+        iterator2 = await invokeBuiltinClosure(method, [], budget, context, input);
       }
-      if (iterator === null || typeof iterator !== "object") throw new TypeError("Iterator must be an object.");
-      next = await context.getProperty(iterator, "next");
-      if (await ordinaryHasInstance(iterator, constructor, budget, context)) return iterator;
+      if (iterator2 === null || typeof iterator2 !== "object") throw new TypeError("Iterator must be an object.");
+      next = await context.getProperty(iterator2, "next");
+      if (await ordinaryHasInstance(iterator2, constructor, budget, context)) return iterator2;
       const wrapper = /* @__PURE__ */ Object.create(null);
-      iteratorWrapperStates.set(wrapper, { iterator, next });
+      iteratorWrapperStates.set(wrapper, { iterator: iterator2, next });
       setSandboxPrototype(wrapper, prototype, budget);
       createDataCheckpoint(budget, context)(wrapper, 0, true);
       return wrapper;
@@ -37676,7 +37790,7 @@ function installIteratorConsumers(prototype, budget) {
         }
         const release = retainValues(budget, () => [receiver, callback, next, accumulator, value, values]);
         const checkpoint = createDataCheckpoint(budget, context);
-        const iterator = {
+        const iterator2 = {
           asynchronous: true,
           next: async () => {
             if (!isSandboxClosure(next)) throw new TypeError("Iterator next must be callable.");
@@ -37693,7 +37807,7 @@ function installIteratorConsumers(prototype, budget) {
         };
         try {
           if (name !== "toArray" && !isSandboxClosure(callback)) {
-            await closeIterator(iterator, true);
+            await closeIterator(iterator2, true);
             throw new TypeError("Iterator callback must be callable.");
           }
           next = await bridge.getProperty(receiver, "next");
@@ -37701,7 +37815,7 @@ function installIteratorConsumers(prototype, budget) {
           let index = 0;
           while (true) {
             budget.visitNode();
-            const result = await iterator.next();
+            const result = await iterator2.next();
             if (await bridge.getProperty(result, "done")) {
               if (!initialized) throw new TypeError("Cannot reduce an empty iterator without an initial value.");
               if (name === "toArray") return values;
@@ -37729,12 +37843,12 @@ function installIteratorConsumers(prototype, budget) {
                   void 0
                 );
               } catch (error) {
-                if (!isFatalSandboxError(error)) await closeIterator(iterator, true);
+                if (!isFatalSandboxError(error)) await closeIterator(iterator2, true);
                 throw error;
               }
               if (name === "reduce") accumulator = selected;
               else if ((name === "some" || name === "find") && selected || name === "every" && !selected) {
-                await closeIterator(iterator);
+                await closeIterator(iterator2);
                 return name === "find" ? value : name === "some";
               }
             }
@@ -37780,17 +37894,17 @@ function installJointIteratorHelpers(prototype, constructor, budget, protocol) {
   }
   async function acquire(value, context, flattenable) {
     if (value === null || typeof value !== "object") throw new TypeError("Joint iteration inputs must be objects.");
-    let iterator = value;
+    let iterator2 = value;
     let method;
-    const release = retainValues(budget, () => [value, iterator, method]);
+    const release = retainValues(budget, () => [value, iterator2, method]);
     try {
       method = await context.getProperty(value, Symbol.iterator);
       if (!flattenable || method !== void 0 && method !== null) {
         if (!isSandboxClosure(method)) throw new TypeError("Input must be iterable.");
-        iterator = await invokeBuiltinClosure(method, [], budget, context, value);
-        if (iterator === null || typeof iterator !== "object") throw new TypeError("Iterator must be an object.");
+        iterator2 = await invokeBuiltinClosure(method, [], budget, context, value);
+        if (iterator2 === null || typeof iterator2 !== "object") throw new TypeError("Iterator must be an object.");
       }
-      return { iterator, next: await context.getProperty(iterator, "next") };
+      return { iterator: iterator2, next: await context.getProperty(iterator2, "next") };
     } finally {
       release();
     }
@@ -38018,10 +38132,10 @@ function installLazyIteratorHelpers(common, budget, constructor) {
                   complete(state);
                   return createIteratorResult(void 0, true, budget);
                 }
-                const iterator = await invokeBuiltinClosure(input.open, [], budget, context, input.iterable);
-                if (iterator === null || typeof iterator !== "object") throw new TypeError("Iterator must be an object.");
-                state.outer = { iterator, next: void 0 };
-                state.outer.next = await context.getProperty(iterator, "next");
+                const iterator2 = await invokeBuiltinClosure(input.open, [], budget, context, input.iterable);
+                if (iterator2 === null || typeof iterator2 !== "object") throw new TypeError("Iterator must be an object.");
+                state.outer = { iterator: iterator2, next: void 0 };
+                state.outer.next = await context.getProperty(iterator2, "next");
                 state.iterables.shift();
               }
               const result2 = await step(state.outer, context);
@@ -40258,20 +40372,20 @@ function createListFormatConstructor(budget) {
         const receiver = context?.thisValue;
         listFormatState(receiver);
         const strings = [];
-        let iterator;
-        const release = retainValues(budget, () => [receiver, strings, iterator?.retainedValue]);
+        let iterator2;
+        const release = retainValues(budget, () => [receiver, strings, iterator2?.retainedValue]);
         const checkpoint = createDataCheckpoint(budget, context);
         try {
           if (input !== void 0) {
-            iterator = context === void 0 ? getSandboxIterator(input, budget) : await acquireSandboxIterator(input, budget, context);
-            if (iterator === void 0) throw new TypeError("ListFormat requires an iterable.");
+            iterator2 = context === void 0 ? getSandboxIterator(input, budget) : await acquireSandboxIterator(input, budget, context);
+            if (iterator2 === void 0) throw new TypeError("ListFormat requires an iterable.");
             while (true) {
               budget.visitNode();
-              const result = await iterator.next();
-              if ((await readIteratorResult(iterator, result, "done")).value) break;
-              const value = (await readIteratorResult(iterator, result, "value")).value;
+              const result = await iterator2.next();
+              if ((await readIteratorResult(iterator2, result, "done")).value) break;
+              const value = (await readIteratorResult(iterator2, result, "value")).value;
               if (typeof value !== "string") {
-                await closeIterator(iterator, true);
+                await closeIterator(iterator2, true);
                 throw new TypeError("ListFormat requires string elements.");
               }
               budget.visitNode(value.length);
@@ -41237,8 +41351,8 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     validateGuestHeapNode({ kind: "guest-object", state: node2.state }, heap, maxArrayLength);
     const properties = array(record3(record3(node2.state).properties).properties).map(array);
     if (node2.nativeIterator) {
-      const iterator = properties.find(([key]) => typeof key === "object" && key !== null && record3(heap[String(record3(key).id)]).wellKnown === "iterator");
-      if (iterator === void 0 || record3(iterator[1]).kind !== "data" || !absent(record3(iterator[1]).value))
+      const iterator2 = properties.find(([key]) => typeof key === "object" && key !== null && record3(heap[String(record3(key).id)]).wellKnown === "iterator");
+      if (iterator2 === void 0 || record3(iterator2[1]).kind !== "data" || !absent(record3(iterator2[1]).value))
         throw new TypeError("Invalid native arguments iterator descriptor.");
     }
     const indices = /* @__PURE__ */ new Set(), names = /* @__PURE__ */ new Set();
@@ -41956,8 +42070,8 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     state(node.state);
   } else if (node.kind === "iterator-wrapper") {
     fields(node, ["kind", "iterator", "next", "state"]);
-    const iterator = reference(node.iterator);
-    if (iterator.kind === "symbol" || iterator.kind === "scope-frame") throw new TypeError("Invalid wrapped iterator.");
+    const iterator2 = reference(node.iterator);
+    if (iterator2.kind === "symbol" || iterator2.kind === "scope-frame") throw new TypeError("Invalid wrapped iterator.");
     state(node.state);
   } else if (node.kind === "disposable-stack") {
     fields(node, ["kind", "disposed", "resources", "state"]);
@@ -42328,34 +42442,34 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
           if (expression.kind !== "yield-delegate") integer(expression.index);
           if (expression.kind === "for-of-array") reference(expression.values, ["array", "guest-array"]);
           else {
-            let iterator = record3(expression.iterator);
+            let iterator2 = record3(expression.iterator);
             let depth = 0;
             let protocol = false;
-            while (iterator.kind === "async-from-sync") {
+            while (iterator2.kind === "async-from-sync") {
               if (++depth > 1) throw new TypeError("Invalid nested async iterator adapter.");
-              fields(iterator, ["kind", "inner"]);
-              iterator = record3(iterator.inner);
+              fields(iterator2, ["kind", "inner"]);
+              iterator2 = record3(iterator2.inner);
               protocol = true;
             }
             if ((expression.kind === "for-of-iterator" && (expression.phase === "next" || expression.phase === "close") || expression.kind === "yield-delegate" && expression.phase !== void 0 && expression.phase !== "return") && record3(expression.awaitState).kind !== (depth === 1 ? "value" : "result"))
               throw new TypeError("Iterator await state does not match its adapter.");
-            if (iterator.kind === "guest") {
-              fields(iterator, ["kind", "value", "next", "async"]);
-              if (typeof iterator.async !== "boolean") throw new TypeError("Invalid iterator protocol.");
-              if (depth > 0 && iterator.async) throw new TypeError("Invalid async-from-sync source.");
-              protocol ||= iterator.async;
-              reference(iterator.value);
-              callable(iterator.next);
-            } else if (iterator.kind === "builtin") {
-              fields(iterator, ["kind", "value", "index"]);
-              integer(iterator.index);
-              if (typeof iterator.value === "string" && iterator.index > iterator.value.length)
+            if (iterator2.kind === "guest") {
+              fields(iterator2, ["kind", "value", "next", "async"]);
+              if (typeof iterator2.async !== "boolean") throw new TypeError("Invalid iterator protocol.");
+              if (depth > 0 && iterator2.async) throw new TypeError("Invalid async-from-sync source.");
+              protocol ||= iterator2.async;
+              reference(iterator2.value);
+              callable(iterator2.next);
+            } else if (iterator2.kind === "builtin") {
+              fields(iterator2, ["kind", "value", "index"]);
+              integer(iterator2.index);
+              if (typeof iterator2.value === "string" && iterator2.index > iterator2.value.length)
                 throw new TypeError("Invalid string iterator cursor.");
-              if (typeof iterator.value !== "string") {
-                const target = reference(iterator.value, ["array", "guest-array", "map", "set", "guest-generator", "collection-iterator", "regexp-iterator"]);
-                if (["guest-generator", "collection-iterator", "regexp-iterator"].includes(String(target.kind)) && iterator.index !== 0)
+              if (typeof iterator2.value !== "string") {
+                const target = reference(iterator2.value, ["array", "guest-array", "map", "set", "guest-generator", "collection-iterator", "regexp-iterator"]);
+                if (["guest-generator", "collection-iterator", "regexp-iterator"].includes(String(target.kind)) && iterator2.index !== 0)
                   throw new TypeError("Invalid stateful iterator cursor.");
-                if (target.kind === "map" && iterator.index > array(target.entries).length || target.kind === "set" && iterator.index > array(target.values).length)
+                if (target.kind === "map" && iterator2.index > array(target.entries).length || target.kind === "set" && iterator2.index > array(target.values).length)
                   throw new TypeError("Invalid collection iterator cursor.");
                 if (target.kind === "guest-generator" && target.async === true) {
                   if (depth > 0) throw new TypeError("Invalid async-from-sync generator.");
@@ -43425,8 +43539,8 @@ function validateArgumentsProperties(record4, path) {
   }
   const properties = requireRecord(record4.properties, `${path}.properties`);
   if (record4.iterator !== null) {
-    const iterator = requireRecord(record4.iterator, `${path}.iterator`);
-    for (const key of Object.keys(iterator)) {
+    const iterator2 = requireRecord(record4.iterator, `${path}.iterator`);
+    for (const key of Object.keys(iterator2)) {
       if (!["configurable", "enumerable", "writable"].includes(key)) {
         fail(
           "invalidValue",
@@ -43436,7 +43550,7 @@ function validateArgumentsProperties(record4, path) {
       }
     }
     for (const flag of ["configurable", "enumerable", "writable"]) {
-      if (typeof iterator[flag] !== "boolean")
+      if (typeof iterator2[flag] !== "boolean")
         fail("invalidType", `${path}.iterator.${flag}`, "expected boolean");
     }
   }
@@ -43465,10 +43579,20 @@ function validateArgumentsProperties(record4, path) {
     }
   }
 }
-function validateGenericValue(value, path, depth, state) {
-  if (types21.isProxy(value) && (state.dataPropertiesOnly || getIntrinsicIdentity(value) === void 0 && !isSandboxModuleNamespace(value))) {
+function validateSnapshotProxy(value, path, dataPropertiesOnly = false) {
+  if (!types21.isProxy(value)) return;
+  if (!dataPropertiesOnly && isTrackedIntrinsicObject(value)) {
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== null && prototype !== (Array.isArray(value) ? Array.prototype : Object.prototype))
+      fail("invalidType", path, "runtime snapshot objects must not have a custom native prototype");
+    return;
+  }
+  if (dataPropertiesOnly || getIntrinsicIdentity(value) === void 0 && !isSandboxModuleNamespace(value)) {
     fail("invalidType", path, "proxy objects are not snapshot data");
   }
+}
+function validateGenericValue(value, path, depth, state) {
+  validateSnapshotProxy(value, path, state.dataPropertiesOnly);
   if (typeof value === "object" && value !== null && hasGuestObjectState(value) && !(state.allowHostFunctionState && (isSandboxModuleNamespace(value) || isSandboxClosure(value) && !isGuestClosure(value)))) {
     fail("invalidState", path, "guest function properties, prototype links and custom descriptors cannot be restored");
   }
@@ -43534,8 +43658,7 @@ function validateRuntimeSnapshotDescriptors(snapshot) {
   let entries = 0;
   while (pending.length > 0) {
     const { value, path, depth } = pending.pop();
-    if (types21.isProxy(value) && getIntrinsicIdentity(value) === void 0 && !isSandboxModuleNamespace(value))
-      fail("invalidType", path, "proxy objects are not snapshot data");
+    validateSnapshotProxy(value, path);
     if (seen.has(value)) continue;
     seen.add(value);
     if (depth > MAX_DATA_DEPTH)
@@ -45836,12 +45959,20 @@ import { types as nodeTypes } from "node:util";
 var frozenClosureData = /* @__PURE__ */ new WeakMap();
 var readFrozenClosureData = WeakMap.prototype.get.bind(frozenClosureData);
 var writeFrozenClosureData = WeakMap.prototype.set.bind(frozenClosureData);
-var freezeClosureShape = Object.freeze;
-var captureClosureSymbols = Object.getOwnPropertySymbols;
+var freezeValueShape = Object.freeze;
+var captureValueSymbols = Object.getOwnPropertySymbols;
+var sealValueShape = Object.seal;
+var sealedValueSymbols = /* @__PURE__ */ new WeakMap();
+var readSealedValueSymbols = WeakMap.prototype.get.bind(sealedValueSymbols);
+var writeSealedValueSymbols = WeakMap.prototype.set.bind(sealedValueSymbols);
 var captureClosureDescriptor = Object.getOwnPropertyDescriptor;
 var hasClosureDescriptorField = Object.hasOwn;
 var invokeClosureGetter = Reflect.apply;
-var closureGetterArguments = freezeClosureShape([]);
+var closureGetterArguments = freezeValueShape([]);
+function captureSealedValueSymbols(value) {
+  writeSealedValueSymbols(value, freezeValueShape(captureValueSymbols(value)));
+  return value;
+}
 function readClosureProperties(closure, data) {
   const getter = data?.propertiesGetter;
   return getter === void 0 ? closure.properties : invokeClosureGetter(getter, closure, closureGetterArguments);
@@ -45923,12 +46054,12 @@ function createSandboxClosure(input) {
       value: input.retainedValues
     });
   }
-  freezeClosureShape(closure);
+  freezeValueShape(closure);
   const properties = captureClosureDescriptor(closure, "properties");
   writeFrozenClosureData(
     closure,
-    freezeClosureShape({
-      symbols: freezeClosureShape(captureClosureSymbols(closure)),
+    freezeValueShape({
+      symbols: freezeValueShape(captureValueSymbols(closure)),
       closure: captureClosureDescriptor(closure, sandboxClosureBrand) !== void 0,
       propertiesGetter: properties !== void 0 && hasClosureDescriptorField(properties, "get") ? properties.get : void 0
     })
@@ -45939,7 +46070,13 @@ function registerDeferredClosureChargeIdentity(closure, identity) {
   const data = readFrozenClosureData(closure);
   if (data?.closure !== true || data.chargeIdentity !== void 0)
     throw new TypeError("Deferred initialization requires a fresh SDK-created function.");
-  writeFrozenClosureData(closure, freezeClosureShape({ ...data, chargeIdentity: identity }));
+  writeFrozenClosureData(closure, freezeValueShape({ ...data, chargeIdentity: identity }));
+}
+function registerClosureCaptureCollector(closure, provider, collect) {
+  if (readFrozenClosureData(closure)?.closure !== true) return;
+  const descriptor = captureClosureDescriptor(closure, sandboxRetainedValues);
+  if (descriptor !== void 0 && hasClosureDescriptorField(descriptor, "value") && descriptor.value === provider)
+    registerIndexedClosureCaptures(closure, collect);
 }
 function ownEnumerableSandboxEntries(value, excludedKeys) {
   if (isGuestHostObject(value)) {
@@ -46053,7 +46190,7 @@ function createSandboxPromise(promise, metadata = {}) {
   );
   trackSandboxPromise(sandboxPromise);
   registerPromiseCancellation(sandboxPromise);
-  return Object.freeze(sandboxPromise);
+  return captureSealedValueSymbols(freezeValueShape(sandboxPromise));
 }
 function createSandboxGenerator(channel, metadata = void 0) {
   const generator = {
@@ -46084,7 +46221,7 @@ function createSandboxMap(entries = []) {
     enumerable: false,
     value: true
   });
-  return Object.freeze(map);
+  return captureSealedValueSymbols(freezeValueShape(map));
 }
 function createSandboxSet(values = []) {
   const set3 = {};
@@ -46101,7 +46238,7 @@ function createSandboxSet(values = []) {
     enumerable: false,
     value: true
   });
-  return Object.freeze(set3);
+  return captureSealedValueSymbols(freezeValueShape(set3));
 }
 function createSandboxRegex(source, flags = "", lastIndex = 0, compilation) {
   if (typeof source !== "string" || typeof flags !== "string") {
@@ -46137,7 +46274,7 @@ function createSandboxRegex(source, flags = "", lastIndex = 0, compilation) {
     [sandboxRegexBrand]: { value: true },
     [sandboxRegexPattern]: { value: pattern, writable: true }
   });
-  return Object.seal(regex);
+  return captureSealedValueSymbols(sealValueShape(regex));
 }
 function getSandboxRegexPattern(regex) {
   return regex[sandboxRegexPattern];
@@ -46289,28 +46426,47 @@ function* cloneStructuredGraph(value, state, budget, depth = 0) {
 var nativeDataArrayAppend = Function.prototype.call.bind(Array.prototype.push);
 var nativeDataArraySetPrototype = Object.setPrototypeOf;
 var MAX_REUSABLE_CAPTURE_LENGTH = 64;
+var NativeMeasurementSet = Set;
+var retainedMeasurementCode;
+function createMeasurementCollector(target) {
+  return {
+    append(value) {
+      target?.(value);
+    },
+    close() {
+      target = void 0;
+    }
+  };
+}
 function measureSandboxData(values, options = {}) {
+  if (retainedMeasurementCode === void 0)
+    withMeasurementSeen((seen) => measureSandboxDataWithSeen([], {}, seen, true));
+  retainedMeasurementCode(void 0);
   return withMeasurementSeen((seen) => measureSandboxDataWithSeen(values, options, seen));
 }
-function measureSandboxDataWithSeen(values, options, seen) {
-  const seenSymbols = /* @__PURE__ */ new Set();
+function measureSandboxDataWithSeen(values, options, seen, retainCode = false) {
+  const seenSymbols = retainCode ? new NativeMeasurementSet() : /* @__PURE__ */ new Set();
   let usage = 0;
   const projectedPrimitives = [];
+  let pendingArguments;
+  let pendingFunctions;
+  let pendingFunctionDepths;
   let waiting;
   let ready;
   let pending;
   let pendingCount = 0;
-  const appendContinuation = (values2, depth, capture) => {
+  const appendContinuation = (values2, depth, capture, proxy) => {
     const frames = pending ??= nativeDataArraySetPrototype([], null);
     let frame = frames[pendingCount];
     if (frame === void 0) {
-      frame = { values: values2, index: 1, depth, capture };
+      frame = { values: values2, index: 1, depth, capture, proxy };
       nativeDataArrayAppend(frames, frame);
     } else {
       frame.values = values2;
       frame.index = 1;
       frame.depth = depth;
       frame.capture = capture;
+      frame.proxy = proxy;
     }
     pendingCount++;
   };
@@ -46351,6 +46507,47 @@ function measureSandboxDataWithSeen(values, options, seen) {
     }
     captures = appendCapture(captures, value);
   };
+  const collector = createMeasurementCollector(appendNativeCapture);
+  const visitTemporalIntl = (value, depth) => {
+    if (isSandboxTemporalInstant(value)) visit(temporalInstantEpoch(value), depth + 1);
+    if (isSandboxTemporalDuration(value)) usage += temporalDurationFieldNames.length * 8;
+    if (isSandboxTemporalPlainTime(value)) usage += temporalPlainTimeFieldNames.length * 8;
+    if (isSandboxTemporalPlainDateTime(value)) usage += temporalPlainDateTimeNumericFields.length * 8 + temporalPlainDateTimeFields(value).calendar.length;
+    if (isSandboxTemporalPlainDate(value)) usage += temporalPlainDateNumericFields.length * 8 + temporalPlainDateFields(value).calendar.length;
+    if (isSandboxTemporalPlainMonthDay(value)) usage += temporalPlainDateNumericFields.length * 8 + temporalPlainMonthDayFields(value).calendar.length;
+    if (isSandboxTemporalPlainYearMonth(value)) usage += temporalPlainDateNumericFields.length * 8 + temporalPlainYearMonthFields(value).calendar.length;
+    if (isSandboxTemporalZonedDateTime(value)) {
+      const fields2 = temporalZonedDateTimeFields(value);
+      visit(fields2.epochNanoseconds, depth + 1);
+      usage += fields2.timeZone.length + fields2.calendar.length;
+    }
+    if (isSandboxLocale(value)) usage += localeTag(value).length;
+    if (isSandboxListFormat(value)) visit(listFormatState(value).options, depth + 1);
+    if (isSandboxRelativeTimeFormat(value)) visit(relativeTimeFormatState(value).options, depth + 1);
+    if (isSandboxDisplayNames(value)) visit(displayNamesState(value).options, depth + 1);
+    if (isSandboxPluralRules(value)) visit(pluralRulesState(value).options, depth + 1);
+    if (isSandboxDurationFormat(value)) {
+      const state = durationFormatState(value);
+      visit(state.settings, depth + 1);
+      visit(state.options, depth + 1);
+    }
+    if (isSandboxNumberFormat(value)) {
+      const state = numberFormatState(value);
+      visit(state.options, depth + 1);
+      visit(state.format, depth + 1);
+    }
+    if (isSandboxDateTimeFormat(value)) {
+      const state = dateTimeFormatState(value);
+      visit(state.options, depth + 1);
+      visit(state.requestedOptions, depth + 1);
+      visit(state.format, depth + 1);
+    }
+    if (isSandboxCollator(value)) {
+      const state = collatorState(value);
+      visit(state.options, depth + 1);
+      visit(state.compare, depth + 1);
+    }
+  };
   const visit = (value, depth = 0) => {
     const floor = pendingCount;
     walk: while (true) {
@@ -46390,6 +46587,30 @@ function measureSandboxDataWithSeen(values, options, seen) {
         const bindingRoot = scopeDataRoots.get(value);
         if (bindingRoot !== void 0) {
           seen.add(value);
+          if ("arguments" in bindingRoot) {
+            const state = bindingRoot.arguments;
+            const current = state.read();
+            if (current !== void 0) {
+              value = current;
+              continue walk;
+            }
+            assertSandboxDataDepth(depth);
+            const snapshot = state.capture();
+            const includeIterator = !internalSymbols.has(snapshot.iterator);
+            const includeBrand = !internalSymbols.has(sandboxArgumentsBrand);
+            const units = snapshot.units + (includeIterator ? 1 : 0) + (includeBrand ? 1 : 0);
+            usage += units;
+            pendingArguments ??= nativeDataArraySetPrototype([], null);
+            nativeDataArrayAppend(pendingArguments, { state, units, depth });
+            if (includeIterator) visit(snapshot.iterator, depth + 1);
+            if (includeBrand) visit(sandboxArgumentsBrand, depth + 1);
+            const references = snapshot.references;
+            if (references.length === 0) break entry;
+            if (references.length > 1) appendContinuation(references, depth + 1);
+            value = references[0];
+            depth++;
+            continue walk;
+          }
           if ("deferred" in bindingRoot) {
             const deferred2 = bindingRoot.deferred;
             const current = deferred2.read();
@@ -46402,10 +46623,17 @@ function measureSandboxDataWithSeen(values, options, seen) {
               seen.add(deferred2.chargeIdentity);
               usage++;
             }
+            if (pendingFunctions === void 0) {
+              pendingFunctions = nativeDataArraySetPrototype([], null);
+              pendingFunctionDepths = nativeDataArraySetPrototype([], null);
+            }
+            const pendingIndex = pendingFunctions.length;
+            pendingFunctions[pendingIndex] = deferred2;
+            pendingFunctionDepths[pendingIndex] = depth;
             if (options.ignoreClosures || options.ignoreClosureCaptures) break entry;
             let roots2;
             try {
-              deferred2.collect(appendNativeCapture);
+              deferred2.collect(collector.append);
               roots2 = captures;
             } finally {
               if (roots2 === void 0 && captures !== void 0) releaseCaptures(captures);
@@ -46466,8 +46694,17 @@ function measureSandboxDataWithSeen(values, options, seen) {
           for (const cell of finalization.state.cells) visit(cell.heldValue, depth + 1);
         }
         if (proxyState !== void 0) {
-          if (proxyState.target !== null) visit(proxyState.target, depth + 1);
-          if (proxyState.handler !== null) visit(proxyState.handler, depth + 1);
+          if (proxyState.target !== null) {
+            value = proxyState.target;
+            appendContinuation(void 0, depth + 1, void 0, proxyState);
+            depth++;
+            continue walk;
+          }
+          if (proxyState.handler !== null) {
+            value = proxyState.handler;
+            depth++;
+            continue walk;
+          }
           break entry;
         }
         if (dynamicSourceRecords.has(value)) {
@@ -46504,9 +46741,22 @@ function measureSandboxDataWithSeen(values, options, seen) {
         const managedArray = arrayLength !== void 0 && hasManagedDescriptors(value);
         let arrayDescriptors;
         let arrayElements;
-        if (arrayLength !== void 0) {
+        const arrayData = arrayLength !== void 0 && !managedArray ? trackedArrayElementData(value) : void 0;
+        if (arrayLength !== void 0 && arrayData === void 0) {
           if (managedArray) arrayDescriptors = nativeDataArraySetPrototype([], null);
-          if (!managedArray && nodeTypes.isProxy(value)) {
+          const trackedDescriptors2 = trackedPropertyDataDescriptors(value);
+          if (trackedDescriptors2 !== void 0) {
+            for (let index = 0; index < trackedDescriptors2.length; index++) {
+              const entry = trackedDescriptors2[index];
+              const key = entry[0], descriptor = entry[1];
+              if (key === "length") {
+                if (!managedArray) break;
+                continue;
+              }
+              if (arrayDescriptors !== void 0) nativeDataArrayAppend(arrayDescriptors, [key, descriptor]);
+              else if ("value" in descriptor && typeof descriptor.value !== "number") arrayElements = appendCapture(arrayElements, descriptor.value);
+            }
+          } else if (!managedArray && nodeTypes.isProxy(value)) {
             for (let index = 0; index < arrayLength; index += 1) {
               const descriptor = Object.getOwnPropertyDescriptor(value, index);
               if (descriptor !== void 0 && "value" in descriptor) arrayElements = appendCapture(arrayElements, descriptor.value);
@@ -46541,23 +46791,54 @@ function measureSandboxDataWithSeen(values, options, seen) {
           }
         }
         if (knownClosure || !isGuestHostObject(value)) {
-          const ownedSymbols = closureData?.symbols ?? trackedPropertySymbols(value);
+          const ownedSymbols = closureData?.symbols ?? trackedPropertySymbols(value) ?? readSealedValueSymbols(value);
+          let firstSymbol;
+          let firstDescriptor;
           let descriptors2;
           if (ownedSymbols !== void 0) {
-            for (let index = 0; index < ownedSymbols.length; index++)
-              descriptors2 = captureRetainedSymbolProperty(value, ownedSymbols[index], descriptors2);
+            for (let index = 0; index < ownedSymbols.length; index++) {
+              const key = ownedSymbols[index];
+              if (internalSymbols.has(key)) continue;
+              const descriptor = Object.getOwnPropertyDescriptor(value, key);
+              if (descriptor === void 0) continue;
+              if (firstDescriptor === void 0) {
+                firstSymbol = key;
+                firstDescriptor = descriptor;
+              } else {
+                descriptors2 ??= nativeDataArraySetPrototype([], null);
+                nativeDataArrayAppend(descriptors2, key, descriptor);
+              }
+            }
           } else {
             const symbols = isNumericTypedArray(value) ? typedArraySymbolKeys(value) : Object.getOwnPropertySymbols(value);
-            for (const key of symbols) descriptors2 = captureRetainedSymbolProperty(value, key, descriptors2);
+            for (const key of symbols) {
+              if (internalSymbols.has(key)) continue;
+              const descriptor = Object.getOwnPropertyDescriptor(value, key);
+              if (descriptor === void 0) continue;
+              if (firstDescriptor === void 0) {
+                firstSymbol = key;
+                firstDescriptor = descriptor;
+              } else {
+                descriptors2 ??= nativeDataArraySetPrototype([], null);
+                nativeDataArrayAppend(descriptors2, key, descriptor);
+              }
+            }
           }
-          if (descriptors2 !== void 0) for (let index = 0; index < descriptors2.length; index += 2) {
-            const key = descriptors2[index];
-            const descriptor = descriptors2[index + 1];
+          if (firstDescriptor !== void 0) {
             usage += 1;
-            visit(key, depth + 1);
-            if ("value" in descriptor) visit(descriptor.value, depth + 1);
-            else for (const closure of retainedAccessorClosures(descriptor)) visit(closure, depth + 1);
+            visit(firstSymbol, depth + 1);
+            if ("value" in firstDescriptor) visit(firstDescriptor.value, depth + 1);
+            else for (const closure of retainedAccessorClosures(firstDescriptor)) visit(closure, depth + 1);
           }
+          if (descriptors2 !== void 0)
+            for (let index = 0; index < descriptors2.length; index += 2) {
+              const key = descriptors2[index];
+              const descriptor = descriptors2[index + 1];
+              usage += 1;
+              visit(key, depth + 1);
+              if ("value" in descriptor) visit(descriptor.value, depth + 1);
+              else for (const closure of retainedAccessorClosures(descriptor)) visit(closure, depth + 1);
+            }
         }
         if (knownClosure || isSandboxClosure(value)) {
           const closure = value;
@@ -46578,7 +46859,7 @@ function measureSandboxDataWithSeen(values, options, seen) {
             if (collect !== void 0) {
               let roots2;
               try {
-                collect(appendNativeCapture);
+                collect(collector.append);
                 roots2 = captures;
               } finally {
                 if (roots2 === void 0 && captures !== void 0) releaseCaptures(captures);
@@ -46592,7 +46873,11 @@ function measureSandboxDataWithSeen(values, options, seen) {
                 depth++;
                 continue walk;
               }
-            } else for (const root of closure[sandboxRetainedValues]?.() ?? []) visit(root, depth + 1);
+            } else {
+              const roots2 = closure[sandboxRetainedValues]?.();
+              if (roots2 !== void 0 && roots2 !== null)
+                for (const root of roots2) visit(root, depth + 1);
+            }
           }
           break entry;
         }
@@ -46650,44 +46935,7 @@ function measureSandboxDataWithSeen(values, options, seen) {
           visit(helperState.callback, depth + 1);
         }
         if (isSandboxDate(value)) usage += 8;
-        if (isSandboxTemporalInstant(value)) visit(temporalInstantEpoch(value), depth + 1);
-        if (isSandboxTemporalDuration(value)) usage += temporalDurationFieldNames.length * 8;
-        if (isSandboxTemporalPlainTime(value)) usage += temporalPlainTimeFieldNames.length * 8;
-        if (isSandboxTemporalPlainDateTime(value)) usage += temporalPlainDateTimeNumericFields.length * 8 + temporalPlainDateTimeFields(value).calendar.length;
-        if (isSandboxTemporalPlainDate(value)) usage += temporalPlainDateNumericFields.length * 8 + temporalPlainDateFields(value).calendar.length;
-        if (isSandboxTemporalPlainMonthDay(value)) usage += temporalPlainDateNumericFields.length * 8 + temporalPlainMonthDayFields(value).calendar.length;
-        if (isSandboxTemporalPlainYearMonth(value)) usage += temporalPlainDateNumericFields.length * 8 + temporalPlainYearMonthFields(value).calendar.length;
-        if (isSandboxTemporalZonedDateTime(value)) {
-          const fields2 = temporalZonedDateTimeFields(value);
-          visit(fields2.epochNanoseconds, depth + 1);
-          usage += fields2.timeZone.length + fields2.calendar.length;
-        }
-        if (isSandboxLocale(value)) usage += localeTag(value).length;
-        if (isSandboxListFormat(value)) visit(listFormatState(value).options, depth + 1);
-        if (isSandboxRelativeTimeFormat(value)) visit(relativeTimeFormatState(value).options, depth + 1);
-        if (isSandboxDisplayNames(value)) visit(displayNamesState(value).options, depth + 1);
-        if (isSandboxPluralRules(value)) visit(pluralRulesState(value).options, depth + 1);
-        if (isSandboxDurationFormat(value)) {
-          const state = durationFormatState(value);
-          visit(state.settings, depth + 1);
-          visit(state.options, depth + 1);
-        }
-        if (isSandboxNumberFormat(value)) {
-          const state = numberFormatState(value);
-          visit(state.options, depth + 1);
-          visit(state.format, depth + 1);
-        }
-        if (isSandboxDateTimeFormat(value)) {
-          const state = dateTimeFormatState(value);
-          visit(state.options, depth + 1);
-          visit(state.requestedOptions, depth + 1);
-          visit(state.format, depth + 1);
-        }
-        if (isSandboxCollator(value)) {
-          const state = collatorState(value);
-          visit(state.options, depth + 1);
-          visit(state.compare, depth + 1);
-        }
+        visitTemporalIntl(value, depth);
         if (isGuestHostObject(value)) {
           usage += measureHostObjectData(value);
           const root = hostObjectGuestRoot(value);
@@ -46722,6 +46970,15 @@ function measureSandboxDataWithSeen(values, options, seen) {
         }
         if (arrayLength !== void 0) {
           usage += arrayLength;
+          if (arrayData !== void 0) {
+            usage += arrayData.units;
+            const references = arrayData.references;
+            if (references.length === 0) break entry;
+            if (references.length > 1) appendContinuation(references, depth + 1);
+            value = references[0];
+            depth++;
+            continue walk;
+          }
           let retained = arrayElements;
           if (arrayDescriptors !== void 0) {
             for (let index = 0; index < arrayDescriptors.length; index++) {
@@ -46934,7 +47191,7 @@ function measureSandboxDataWithSeen(values, options, seen) {
         try {
           for (let index = 0; index < (trackedDescriptors?.length ?? keys.length); index++) {
             const key = trackedDescriptors === void 0 ? keys[index] : trackedDescriptors[index][0];
-            const descriptor = trackedDescriptors === void 0 ? proxyDescriptors === void 0 ? Object.getOwnPropertyDescriptor(value, key) : proxyDescriptors[index] : trackedDescriptors[index][1];
+            const descriptor = trackedDescriptors === void 0 || metadata !== void 0 && trackedPropertyDataDescriptors(value) !== trackedDescriptors ? proxyDescriptors === void 0 ? Object.getOwnPropertyDescriptor(value, key) : proxyDescriptors[index] : trackedDescriptors[index][1];
             if (descriptor === void 0) continue;
             if (!descriptor.enumerable && !includeNonEnumerable) continue;
             const initial = metadata?.get(key);
@@ -46963,6 +47220,18 @@ function measureSandboxDataWithSeen(values, options, seen) {
       while (pendingCount > floor) {
         const frame = pending[pendingCount - 1];
         const references = frame.values;
+        if (references === void 0) {
+          const proxy = frame.proxy;
+          const handlerDepth = frame.depth;
+          frame.proxy = void 0;
+          pendingCount--;
+          if (proxy.handler !== null) {
+            value = proxy.handler;
+            depth = handlerDepth;
+            continue walk;
+          }
+          continue;
+        }
         if (frame.index < (frame.capture?.length ?? references.length)) {
           value = references[frame.index++];
           depth = frame.depth;
@@ -46976,20 +47245,57 @@ function measureSandboxDataWithSeen(values, options, seen) {
       return;
     }
   };
+  if (retainCode) {
+    retainedMeasurementCode = visit;
+    collector.close();
+    return 0;
+  }
   try {
     for (const value of values) visit(value);
-    for (let index = 0; index < (ready?.length ?? 0); index++) {
-      const contribution = ready[index];
-      usage += 1;
-      visit(contribution.value, contribution.depth);
-    }
-    for (const projection of projectedPrimitives) {
-      if (seen.has(projection.target)) continue;
-      for (const item of projection.values)
-        if ((typeof item !== "object" || item === null) && typeof item !== "symbol") visit(item, projection.depth);
-    }
+    let readyIndex = 0;
+    let primitiveIndex = 0;
+    let materialized;
+    do {
+      materialized = false;
+      for (; readyIndex < (ready?.length ?? 0); readyIndex++) {
+        const contribution = ready[readyIndex];
+        usage += 1;
+        visit(contribution.value, contribution.depth);
+      }
+      for (let index = 0; index < (pendingArguments?.length ?? 0); index++) {
+        const projection = pendingArguments[index];
+        if (projection.units === void 0) continue;
+        const current = projection.state.read();
+        if (current === void 0) continue;
+        usage -= projection.units;
+        projection.units = void 0;
+        if (!seen.has(current)) {
+          visit(current, projection.depth);
+          materialized = true;
+        }
+      }
+      for (let index = 0; index < (pendingFunctions?.length ?? 0); index++) {
+        const state = pendingFunctions[index];
+        if (state === void 0) continue;
+        const current = state.read();
+        if (current === void 0) continue;
+        pendingFunctions[index] = void 0;
+        materialized = true;
+        if (!seen.has(current)) visit(current, pendingFunctionDepths[index]);
+      }
+      const previousPrimitiveIndex = primitiveIndex;
+      for (; primitiveIndex < projectedPrimitives.length; primitiveIndex++) {
+        const projection = projectedPrimitives[primitiveIndex];
+        if (seen.has(projection.target)) continue;
+        for (const item of projection.values)
+          if ((typeof item !== "object" || item === null) && typeof item !== "symbol") visit(item, projection.depth);
+      }
+      if ((pendingArguments !== void 0 || pendingFunctions !== void 0) && primitiveIndex !== previousPrimitiveIndex)
+        materialized = true;
+    } while ((pendingArguments !== void 0 || pendingFunctions !== void 0) && (materialized || readyIndex < (ready?.length ?? 0)));
     return usage;
   } finally {
+    collector.close();
     firstSeenCapture = void 0;
     secondSeenCapture = void 0;
     thirdSeenCapture = void 0;
@@ -46999,6 +47305,7 @@ function measureSandboxDataWithSeen(values, options, seen) {
       if (frame.capture !== void 0) releaseCaptures(frame.capture);
       frame.capture = void 0;
       frame.values = void 0;
+      frame.proxy = void 0;
     }
   }
 }
@@ -47031,15 +47338,6 @@ function reconcileCompiledValues(budget, values, compilation, parent, escaping =
   for (const ticket of retained) compilation?.tickets.delete(ticket);
   if (compilation !== void 0 && parent !== void 0) compilation.forward(included, parent);
 }
-function captureRetainedSymbolProperty(value, key, descriptors2) {
-  if (internalSymbols.has(key)) return descriptors2;
-  const descriptor = Object.getOwnPropertyDescriptor(value, key);
-  if (descriptor !== void 0) {
-    descriptors2 ??= nativeDataArraySetPrototype([], null);
-    nativeDataArrayAppend(descriptors2, key, descriptor);
-  }
-  return descriptors2;
-}
 function captureRegexData(value) {
   const source = Object.getOwnPropertyDescriptor(value, "source");
   const flags = Object.getOwnPropertyDescriptor(value, "flags");
@@ -48132,6 +48430,7 @@ var nativePropertyHasOwn = Object.hasOwn;
 var nativePropertyDescriptor = Object.getOwnPropertyDescriptor;
 var nativePropertyDescriptors = Object.getOwnPropertyDescriptors;
 var nativePropertyPrototype = Object.getPrototypeOf;
+var nativePropertySetPrototype = Object.setPrototypeOf;
 var nativePropertyFreeze = Object.freeze;
 var nativePropertyWrite = Reflect.defineProperty;
 var nativePropertyDelete = Reflect.deleteProperty;
@@ -48197,18 +48496,43 @@ function trackedPropertySymbols(value) {
 }
 function adjustScalarProperty(state, key, descriptor, direction) {
   if (descriptor === void 0) return;
+  if (state.array) {
+    const index = +key;
+    if (index < 0 || index >= 4294967295 || index % 1 !== 0 || `${index}` !== key) return;
+  }
   const hasValue = nativePropertyHasOwn(descriptor, "value");
   const item = hasValue ? descriptor.value : void 0;
   const scalar = hasValue && typeof item !== "bigint" && typeof item !== "symbol" && (typeof item !== "object" || item === null);
   if (!scalar) state.nonScalarProperties += direction;
-  const units = 1 + key.length + (typeof item === "string" ? item.length : 0);
+  const units = (state.array ? 0 : 1 + key.length) + (typeof item === "string" ? item.length : 0);
   state.allScalarUnits += direction * units;
   if (descriptor.enumerable) state.enumerableScalarUnits += direction * units;
 }
 var emptyPropertyReferences = nativePropertyFreeze([]);
+function trackedArrayElementData(value) {
+  const state = nativePropertyDataGet(value);
+  if (state === void 0 || !state.array) return void 0;
+  if (state.elements !== void 0) return state.elements;
+  if (state.nonScalarProperties === 0)
+    return state.elements = nativePropertyFreeze({ units: state.allScalarUnits, references: emptyPropertyReferences });
+  const descriptors2 = trackedPropertyDataDescriptors(value);
+  let units = 0;
+  const references = [];
+  for (let index = 0; index < descriptors2.length; index++) {
+    const entry = descriptors2[index];
+    if (entry[0] === "length") break;
+    const descriptor = entry[1];
+    if (!nativePropertyHasOwn(descriptor, "value")) return void 0;
+    const item = descriptor.value;
+    if (typeof item === "string") units += item.length;
+    else if (typeof item === "bigint" || typeof item === "symbol" || typeof item === "object" && item !== null)
+      nativePropertyWrite(references, references.length, { value: item, writable: true, enumerable: true, configurable: true });
+  }
+  return state.elements = nativePropertyFreeze({ units, references: nativePropertyFreeze(references) });
+}
 function trackedPropertyStringData(value, includeNonEnumerable) {
   const state = nativePropertyDataGet(value);
-  if (state === void 0 || state.strings === null) return void 0;
+  if (state === void 0 || state.array) return void 0;
   if (state.strings === void 0 && state.nonScalarProperties === 0) {
     state.strings = nativePropertyFreeze({
       all: nativePropertyFreeze({ units: state.allScalarUnits, references: emptyPropertyReferences }),
@@ -48223,8 +48547,16 @@ function trackedPropertyStringData(value, includeNonEnumerable) {
       const entry = descriptors2[index];
       const key = entry[0], descriptor = entry[1];
       if (!nativePropertyHasOwn(descriptor, "value")) {
-        state.strings = null;
-        return void 0;
+        const units2 = 1 + key.length;
+        allUnits += units2;
+        if (descriptor.enumerable) enumerableUnits += units2;
+        const closures2 = retainedAccessorClosures(descriptor);
+        for (let cursor = 0; cursor < closures2.length; cursor++) {
+          const item2 = closures2[cursor];
+          nativePropertyWrite(allReferences, allReferences.length, { value: item2, writable: true, enumerable: true, configurable: true });
+          if (descriptor.enumerable) nativePropertyWrite(enumerableReferences, enumerableReferences.length, { value: item2, writable: true, enumerable: true, configurable: true });
+        }
+        continue;
       }
       const item = descriptor.value;
       const units = 1 + key.length + (typeof item === "string" ? item.length : 0);
@@ -48291,37 +48623,63 @@ function createIntrinsicObject(initial = /* @__PURE__ */ Object.create(null)) {
   nativeIntrinsicObjectAdd(tracked);
   return tracked;
 }
+function createIntrinsicArray(initial) {
+  const properties = [];
+  if (initial !== void 0) {
+    nativePropertySetPrototype(properties, nativePropertyPrototype(initial));
+    nativePropertyDefine(properties, nativePropertyDescriptors(initial));
+  }
+  const tracked = trackPropertyTable(properties, true);
+  nativeIntrinsicObjectAdd(tracked);
+  return tracked;
+}
 function isTrackedIntrinsicObject(value) {
   return nativeIntrinsicObjectHas(value);
 }
-function trackPropertyTable(properties) {
+function trackPropertyTable(properties, array2 = false) {
   const state = { revision: 0 };
   const data = {
     backing: properties,
+    array: array2,
     allScalarUnits: 0,
     enumerableScalarUnits: 0,
     nonScalarProperties: 0,
     symbols: void 0,
     descriptors: void 0,
-    strings: void 0
+    strings: void 0,
+    elements: void 0
   };
   const keys = nativePropertyNames(properties);
   for (let index = 0; index < keys.length; index++) {
     const key = keys[index];
     adjustScalarProperty(data, key, nativePropertyDescriptor(properties, key), 1);
   }
-  const tracked = new NativePropertyProxy(properties, {
+  const tracked = new NativePropertyProxy(properties, nativePropertySetPrototype({
     defineProperty(target, key, descriptor) {
+      const ownDescriptor = { __proto__: null, ...descriptor };
       const previous = typeof key === "string" ? nativePropertyDescriptor(target, key) : void 0;
-      const changed = nativePropertyWrite(target, key, descriptor);
-      if (changed) {
+      const previousLength = array2 && key === "length" ? target.length : void 0;
+      const changed = nativePropertyWrite(target, key, ownDescriptor);
+      if (changed || array2) {
         if (typeof key === "string") {
-          adjustScalarProperty(data, key, previous, -1);
-          adjustScalarProperty(data, key, nativePropertyDescriptor(target, key), 1);
+          if (previousLength !== void 0 && target.length < previousLength) {
+            data.allScalarUnits = 0;
+            data.enumerableScalarUnits = 0;
+            data.nonScalarProperties = 0;
+            const keys2 = nativePropertyNames(target);
+            for (let index = 0; index < keys2.length; index++) {
+              const name = keys2[index];
+              adjustScalarProperty(data, name, nativePropertyDescriptor(target, name), 1);
+            }
+          } else {
+            adjustScalarProperty(data, key, previous, -1);
+            adjustScalarProperty(data, key, nativePropertyDescriptor(target, key), 1);
+          }
         } else data.symbols = void 0;
         state.revision++;
         data.descriptors = void 0;
         data.strings = void 0;
+        data.elements = void 0;
         state.measuredDescriptors = void 0;
         if (intrinsicRetentionTables.has(tracked)) intrinsicMutationToken = {};
       }
@@ -48338,12 +48696,13 @@ function trackPropertyTable(properties) {
         state.revision++;
         data.descriptors = void 0;
         data.strings = void 0;
+        data.elements = void 0;
         state.measuredDescriptors = void 0;
         if (intrinsicRetentionTables.has(tracked)) intrinsicMutationToken = {};
       }
       return changed;
     }
-  });
+  }, null));
   nativePropertyStateSet(tracked, state);
   nativePropertyDataSet(tracked, data);
   return tracked;
@@ -48811,6 +49170,7 @@ export {
   createReplayEncodingContext,
   encodeReplayData,
   decodeReplayData,
+  declareBudgetedHostOperation,
   declareHostOperation,
   wrapCallerInjectedBindings,
   copyHostValueToSandbox,
@@ -48920,4 +49280,4 @@ authorization of the copyright holder.
 SPDX-License-Identifier: Unicode-3.0
 
 */
-//# sourceMappingURL=chunk-BNIEPGDU.js.map
+//# sourceMappingURL=chunk-ZHJPXLUJ.js.map