@poe-platform/safe-js 0.1.734 → 0.1.736

package/dist/safe-js/chunks/{chunk-MDIWQFYU.js → chunk-SBFOCNNW.js}

@@ -40,7 +40,7 @@ import {
   sandboxErrorTypes,
   syntaxDiagnostics,
   templateRealms
-} from "./chunk-QKO4FATZ.js";
+} from "./chunk-VQGYRKM4.js";
 import {
   AsyncLocalStorage,
   cloneSharedBufferWrapper,
@@ -514,7 +514,7 @@ function getGeneratorProperties(value) {
 }
 
 // packages/safe-js/src/graph-depth.ts
-var MAX_DATA_DEPTH = 1024;
+var MAX_DATA_DEPTH = Infinity;
 var SnapshotBudgetError = class extends Error {
   code = "budgetExceeded";
   budget = "dataDepth";
@@ -530,19 +530,21 @@ var SnapshotBudgetError = class extends Error {
     replaceErrorStack(this);
   }
 };
-function assertSandboxDataDepth(depth) {
-  if (depth > MAX_DATA_DEPTH) {
-    throw new SandboxError({ budget: "dataDepth", current: depth, limit: MAX_DATA_DEPTH });
+function assertSandboxDataDepth(depth, limit = MAX_DATA_DEPTH) {
+  if (depth > limit) {
+    throw new SandboxError({ budget: "dataDepth", current: depth, limit });
   }
 }
-function assertSnapshotDataDepth(depth, path) {
-  if (depth > MAX_DATA_DEPTH) throw new SnapshotBudgetError(path, depth);
+function assertSnapshotDataDepth(depth, path, limit = MAX_DATA_DEPTH) {
+  if (depth > limit) throw new SnapshotBudgetError(path, depth, limit);
 }
-function assertSnapshotGraphDepth(value, rootPath = "$") {
-  walkGraphDepth(value, rootPath, (depth, path) => assertSnapshotDataDepth(depth, path));
+function assertSnapshotGraphDepth(value, rootPath = "$", limit = MAX_DATA_DEPTH) {
+  if (limit === Infinity) return;
+  walkGraphDepth(value, rootPath, (depth, path) => assertSnapshotDataDepth(depth, path, limit));
 }
-function assertSandboxGraphDepth(value) {
-  walkGraphDepth(value, "<root>", (depth) => assertSandboxDataDepth(depth));
+function assertSandboxGraphDepth(value, limit = MAX_DATA_DEPTH) {
+  if (limit === Infinity) return;
+  walkGraphDepth(value, "<root>", (depth) => assertSandboxDataDepth(depth, limit));
 }
 function walkGraphDepth(root, rootPath, assertDepth) {
   const ancestors = /* @__PURE__ */ new WeakSet();
@@ -2567,9 +2569,6 @@ function serializedDateTime(value) {
 }
 
 // packages/safe-js/src/interp/host-capabilities.ts
-var MAX_INDEXED_LENGTH = 65536;
-var MAX_NAMED_KEYS = 65536;
-var MAX_NAMED_KEY_CODE_UNITS = 1048576;
 var hostObjects = /* @__PURE__ */ new WeakMap();
 var guestObjects = /* @__PURE__ */ new WeakMap();
 var readHostObject = WeakMap.prototype.get.bind(hostObjects);
@@ -2617,6 +2616,12 @@ function revokeGuestReference(reference, owner) {
   if (state === void 0 || state.owner !== owner) throw new TypeError("Foreign guest reference.");
   state.root = void 0;
 }
+function hostObjectLimit(value, name) {
+  if (value === void 0 || value === Infinity) return Infinity;
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 1)
+    throw new RangeError(`${name} must be a positive integer or Infinity.`);
+  return value;
+}
 function createLiveHostObject(definition, controller) {
   const input = readDataRecord(definition, "Host object definition");
   if (Object.keys(input).some((key) => !["properties", "methods", "indexed", "named", "expandos"].includes(key)))
@@ -2626,17 +2631,15 @@ function createLiveHostObject(definition, controller) {
     const data = readDataRecord(input.expandos, "Guest expando definition");
     if (Object.keys(data).some((key) => !["maxKeys", "maxKeyCodeUnits", "assertActive"].includes(key)))
       throw new TypeError("Unknown guest expando field.");
-    for (const [key, maximum] of [["maxKeys", MAX_NAMED_KEYS], ["maxKeyCodeUnits", MAX_NAMED_KEY_CODE_UNITS]]) {
-      if (typeof data[key] !== "number" || !Number.isInteger(data[key]) || data[key] < 1 || data[key] > maximum)
-        throw new RangeError(`Guest expando ${key} must be an integer from 1 to ${maximum}.`);
-    }
+    const maxKeys = hostObjectLimit(data.maxKeys, "Guest expando maxKeys");
+    const maxKeyCodeUnits = hostObjectLimit(data.maxKeyCodeUnits, "Guest expando maxKeyCodeUnits");
     if (data.assertActive !== void 0 && (typeof data.assertActive !== "function" || types.isProxy(data.assertActive) || types.isAsyncFunction(data.assertActive) || types.isGeneratorFunction(data.assertActive)))
       throw new TypeError("Guest expando assertActive must be a synchronous function, not a proxy.");
     expandos = {
       // Owned writes invalidate descriptor projections; descendants stay live.
       values: createIntrinsicObject(),
-      maxKeys: data.maxKeys,
-      maxKeyCodeUnits: data.maxKeyCodeUnits,
+      maxKeys,
+      maxKeyCodeUnits,
       assertActive: data.assertActive
     };
   }
@@ -2647,12 +2650,11 @@ function createLiveHostObject(definition, controller) {
       throw new TypeError("Unknown indexed host capability field.");
     if (typeof data.length !== "function" || typeof data.get !== "function")
       throw new TypeError("Indexed length and get must be synchronous functions.");
-    if (typeof data.maxLength !== "number" || !Number.isInteger(data.maxLength) || data.maxLength < 1 || data.maxLength > MAX_INDEXED_LENGTH)
-      throw new RangeError(`Indexed maxLength must be an integer from 1 to ${MAX_INDEXED_LENGTH}.`);
+    const maxLength = hostObjectLimit(data.maxLength, "Indexed maxLength");
     indexed = {
       length: data.length,
       get: data.get,
-      maxLength: data.maxLength
+      maxLength
     };
   }
   let named;
@@ -2668,12 +2670,8 @@ function createLiveHostObject(definition, controller) {
       if (typeof operation !== "function" || types.isProxy(operation) || types.isAsyncFunction(operation) || types.isGeneratorFunction(operation))
         throw new TypeError(`Named ${name} must be a synchronous non-generator function, not a proxy.`);
     }
-    if (typeof data.maxKeys !== "number" || !Number.isInteger(data.maxKeys) || data.maxKeys < 1 || data.maxKeys > MAX_NAMED_KEYS)
-      throw new RangeError(`Named maxKeys must be an integer from 1 to ${MAX_NAMED_KEYS}.`);
-    if (typeof data.maxKeyCodeUnits !== "number" || !Number.isInteger(data.maxKeyCodeUnits) || data.maxKeyCodeUnits < 1 || data.maxKeyCodeUnits > MAX_NAMED_KEY_CODE_UNITS)
-      throw new RangeError(
-        `Named maxKeyCodeUnits must be an integer from 1 to ${MAX_NAMED_KEY_CODE_UNITS}.`
-      );
+    const maxKeys = hostObjectLimit(data.maxKeys, "Named maxKeys");
+    const maxKeyCodeUnits = hostObjectLimit(data.maxKeyCodeUnits, "Named maxKeyCodeUnits");
     if (data.enumerable !== void 0 && typeof data.enumerable !== "boolean")
       throw new TypeError("Named enumerable must be a boolean.");
     named = {
@@ -2681,8 +2679,8 @@ function createLiveHostObject(definition, controller) {
       get: data.get,
       set: data.set,
       delete: data.delete,
-      maxKeys: data.maxKeys,
-      maxKeyCodeUnits: data.maxKeyCodeUnits,
+      maxKeys,
+      maxKeyCodeUnits,
       enumerable: data.enumerable
     };
   }
@@ -19829,7 +19827,6 @@ async function numberFormatValue(value, budget, context) {
   }
   return Number(primitive);
 }
-var MAX_FORMAT_ALLOCATION = 16 * 1024 * 1024;
 function formatNumberValue(receiver, method, values, budget) {
   const { native, options } = numberFormatState(receiver);
   const magnitudes = values.map((value) => typeof value === "bigint" ? value.toString(16).length * 2 : typeof value === "string" ? value.length : 309);
@@ -19844,8 +19841,6 @@ function formatNumberValue(receiver, method, values, budget) {
     }
     const bytes = parts * 256 + characters * 2 + magnitudes.reduce((sum, digits2) => sum + digits2 * 16, 0);
     if (method.endsWith("ToParts")) budget.allocateArrayLength(parts);
-    const totalBytes = budget.currentDataSize + bytes;
-    if (totalBytes > MAX_FORMAT_ALLOCATION) throw new SandboxError({ budget: "dataSize", current: totalBytes, limit: MAX_FORMAT_ALLOCATION });
     const reservation = {};
     budget.setRetainedDataUsage(reservation, bytes);
     try {
@@ -21924,6 +21919,10 @@ var hostErrorMetadata = {
   syscall: "string"
 };
 var awaitedHostOperations = /* @__PURE__ */ new WeakSet();
+var scheduledCallbackOperations = /* @__PURE__ */ new WeakSet();
+function schedulesHostCallbacks(operation) {
+  return scheduledCallbackOperations.has(operation);
+}
 var budgetedHostOperations = /* @__PURE__ */ new WeakMap();
 function declareBudgetedHostOperation(operation, invoke) {
   budgetedHostOperations.set(operation, invoke);
@@ -21931,7 +21930,11 @@ function declareBudgetedHostOperation(operation, invoke) {
 var hostOperationPolicies = /* @__PURE__ */ new WeakMap();
 var hostOperationReplayHandlers = /* @__PURE__ */ new WeakMap();
 function declareHostOperation(operation, policy, options = {}) {
+  if (options.callbackScheduling !== void 0 && options.callbackScheduling !== "after-prefix") throw new TypeError("Host callbackScheduling must be after-prefix.");
+  if (options.callbackScheduling === "after-prefix" && options.awaitResult === true) throw new TypeError("Queued callbacks cannot be combined with awaitResult.");
   hostOperationPolicies.set(operation, policy);
+  if (options.callbackScheduling === "after-prefix") scheduledCallbackOperations.add(operation);
+  else scheduledCallbackOperations.delete(operation);
   if (options.awaitResult === true) awaitedHostOperations.add(operation);
   else awaitedHostOperations.delete(operation);
   if (options.onReplay !== void 0) hostOperationReplayHandlers.set(operation, options.onReplay);
@@ -21970,6 +21973,7 @@ function wrapCallerInjectedFunction(name, value, options, state) {
   const bindingName = typeof nativeName === "string" && nativeName.length > 0 ? nativeName : name;
   const callable = value;
   const awaitResult = awaitedHostOperations.has(value) || options.realm?.awaitResult(callable) === true;
+  if (awaitResult && schedulesHostCallbacks(callable)) throw new TypeError("Queued callbacks cannot be combined with awaitResult or nestedOperation.");
   return createSandboxClosure({
     ...isAsyncFunction(callable) && !awaitResult ? { async: true } : {},
     cancellationSignal: options.signal,
@@ -21981,6 +21985,7 @@ function wrapCallerInjectedFunction(name, value, options, state) {
         if (options.signal?.aborted) throw readAbortReason2(options.signal);
         const stackFrames = context?.stack ?? [];
         const callbacks = {
+          ...schedulesHostCallbacks(callable) ? { schedule: captureJobScheduler() } : {},
           journal: options.hostCalls,
           entries: /* @__PURE__ */ new Map(),
           hostFunctions: /* @__PURE__ */ new Map(),
@@ -22002,7 +22007,8 @@ function wrapCallerInjectedFunction(name, value, options, state) {
             stackFrames,
             options.budget,
             operationLease.owner,
-            callbacks
+            callbacks,
+            options.signal
           ))
         });
         const captured = options.realm?.captureArguments(callable, args, copyArguments);
@@ -22427,18 +22433,19 @@ function copyHostErrorMetadata(error, reason, budget, chargeBudget) {
     resumeChecks?.();
   }
 }
-function wrapSandboxClosureForHost(closure, stackFrames, budget, compileOwner, callbacks) {
+function wrapSandboxClosureForHost(closure, stackFrames, budget, compileOwner, callbacks, signal) {
   const existing = callbacks?.seen.get(closure);
   if (existing !== void 0) return existing;
   const id = (callbacks?.entries.size ?? 0) + 1;
-  const invoke = async (sandboxArgs, token, receiver) => {
+  const invokeNow = async (sandboxArgs, token, receiver) => {
     const operation = budget.acquireCompileOwner(false, compileOwner);
     const compilation = new CompileScope(operation.owner);
     let leaveRunning;
     let leaveCall;
-    const wrapClosure = (nestedClosure) => wrapSandboxClosureForHost(nestedClosure, stackFrames, budget, compileOwner, callbacks);
+    const wrapClosure = (nestedClosure) => wrapSandboxClosureForHost(nestedClosure, stackFrames, budget, compileOwner, callbacks, signal);
     const onSharedBuffer = callbacks?.journal?.markSharedCallbackExport.bind(callbacks.journal);
     try {
+      signal?.throwIfAborted();
       leaveRunning = enterRunningState(closure);
       leaveCall = budget.enterCall();
       let result;
@@ -22454,6 +22461,7 @@ function wrapSandboxClosureForHost(closure, stackFrames, budget, compileOwner, c
           invokeClosure: (target, values, receiver2, construct, newTarget) => invokeBuiltinClosure(target, values, budget, callerContext, receiver2, construct, newTarget)
         };
         result = guestProxyStates.has(closure) ? await callGuestProxy(closure, sandboxArgs, budget, bridge, receiver) : closure.call(sandboxArgs, { compilation, stack: stackFrames, thisValue: receiver });
+        if (callbacks?.schedule !== void 0) result = await result;
       } catch (error) {
         if (isSandboxLikeValue(error)) {
           throw deepCopyFromSandbox(error, {
@@ -22464,11 +22472,17 @@ function wrapSandboxClosureForHost(closure, stackFrames, budget, compileOwner, c
         }
         throw error;
       }
-      return await deepCopyFromSandbox(normalizeClosureResult(result, budget), {
+      const settlement = deepCopyFromSandbox(normalizeClosureResult(result, budget), {
         compilation,
         wrapClosure,
         onSharedBuffer
       });
+      if (callbacks?.schedule !== void 0) {
+        void settlement.catch(() => void 0);
+        if (isSandboxPromise(result) && result.synchronousPrefix !== void 0) await result.synchronousPrefix;
+        return await suspendJob(settlement);
+      }
+      return await settlement;
     } catch (error) {
       if (isFatalBridgeError(error)) promiseReplayContext.getStore()?.fail(error);
       throw error;
@@ -22480,6 +22494,7 @@ function wrapSandboxClosureForHost(closure, stackFrames, budget, compileOwner, c
       if (token !== void 0) promiseReplayContext.getStore()?.completeCallback(token);
     }
   };
+  const invoke = callbacks?.schedule === void 0 ? invokeNow : (args, token, receiver) => callbacks.schedule(() => invokeNow(args, token, receiver));
   const wrapped = async function(...args) {
     const operation = budget.acquireCompileOwner(false, compileOwner);
     try {
@@ -31327,7 +31342,6 @@ function admitJson(text, budget) {
       }
       if (character === '"') quoted = true;
       else if (character === "[" || character === "{") {
-        if (frames.length >= 256) throw new SandboxError({ budget: "dataDepth", current: frames.length + 1, limit: 256 });
         const leave = budget.enterCall();
         frames.push({ array: character === "[", entries: 0, expectingValue: true, leave });
       } else if (character === "]" || character === "}") frames.pop()?.leave();
@@ -41288,7 +41302,7 @@ function intrinsicCatalogue() {
     const kinds = /* @__PURE__ */ new Map();
     for (const id of listIntrinsicIdentities(budget)) {
       const value = resolveIntrinsicIdentity(budget, id);
-      if (getIntrinsicIdentity(value) === id) kinds.set(id, isSandboxClosure(value));
+      if (getIntrinsicIdentity(value) === id) kinds.set(id, { callable: isSandboxClosure(value), constructible: isSandboxClosure(value) && value.construct !== void 0 });
     }
     intrinsicKinds = kinds;
     return kinds;
@@ -41296,6 +41310,28 @@ function intrinsicCatalogue() {
     releaseObjectPrototype(budget);
   }
 }
+function targetFlags(node) {
+  if (node.kind === "bound-function") return void 0;
+  if (node.kind === "guest-proxy") return { callable: node.callable === true, constructible: node.constructible === true };
+  if (node.kind === "intrinsic") return intrinsicCatalogue().get(String(node.id));
+  if (node.kind === "guest-function" || node.kind === "module-function") return { callable: true };
+  if (node.kind === "guest-class") return { callable: true, constructible: true };
+  return { callable: [
+    "guest-proxy-revoker",
+    "async-generator-handler",
+    "async-function-handler",
+    "async-cleanup-handler",
+    "thenable-resolver",
+    "aggregate-handler",
+    "adoption-resolver",
+    "capability-executor",
+    "promise-resolver"
+  ].includes(String(node.kind)), constructible: false };
+}
+function validateProxyFlags(node, flags) {
+  if (node.callable !== flags.callable || flags.constructible !== void 0 && node.constructible !== flags.constructible)
+    throw new TypeError("Inconsistent Proxy callable flags.");
+}
 function record3(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) throw new TypeError("Expected a guest heap record.");
   return value;
@@ -41316,7 +41352,7 @@ function absent(value) {
   const node = record3(value);
   return node.kind === "undefined" && Object.keys(node).length === 1;
 }
-function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
+function validateGuestHeapNode(raw, heap, maxArrayLength = Infinity) {
   if (record3(raw).kind === "guest-script") {
     const source = record3(raw);
     fields(source, ["kind", "body", "context"]);
@@ -41420,7 +41456,7 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     const target = reference(value, ["guest-proxy", "guest-proxy-revoker", "module-function", "async-generator-handler", "async-function-handler", "async-cleanup-handler", "thenable-resolver", "aggregate-handler", "capability-executor", "intrinsic", "bound-function", "promise-resolver", "guest-function", "guest-class"]);
     if (target.kind === "guest-proxy" && target.callable !== true)
       throw new TypeError("Guest accessor Proxy is not callable.");
-    if (target.kind === "intrinsic" && intrinsicCatalogue().get(String(target.id)) !== true)
+    if (target.kind === "intrinsic" && intrinsicCatalogue().get(String(target.id))?.callable !== true)
       throw new TypeError("Guest accessor reference is not callable.");
   };
   if ((node.kind === "pending-promise" || node.kind === "guest-promise") && Object.hasOwn(node, "generatorOwner")) {
@@ -41511,17 +41547,9 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     if (node.target === null !== (node.handler === null)) throw new TypeError("Invalid revoked Proxy state.");
     if (node.target !== null) {
       reference(node.handler, objectKinds);
-      const seen = /* @__PURE__ */ new Set([node]);
-      let current = node;
-      while (current.kind === "guest-proxy" && current.target !== null) {
-        assertSnapshotDataDepth(seen.size, "Proxy target chain");
-        const target = reference(current.target, objectKinds);
-        if (seen.has(target)) throw new TypeError("Cyclic Proxy target chain.");
-        seen.add(target);
-        if (target.kind === "guest-proxy" && (target.callable !== current.callable || target.constructible !== current.constructible))
-          throw new TypeError("Inconsistent Proxy callable flags.");
-        current = target;
-      }
+      const target = reference(node.target, objectKinds);
+      const flags = targetFlags(target);
+      if (flags !== void 0) validateProxyFlags(node, flags);
     }
     if (node.privateElements !== void 0) privateState(node.privateElements);
   } else if (node.kind === "guest-proxy-revoker") {
@@ -42298,15 +42326,8 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     if (array(node.args).length > maxArrayLength) throw new TypeError("Bound arguments exceed allocation limit.");
     if (!absent(node.length) && !(typeof node.length === "number" && node.length >= 0) && !(record3(node.length).kind === "number" && record3(node.length).value === "Infinity"))
       throw new TypeError("Invalid bound function length.");
-    const visited = /* @__PURE__ */ new Set([raw]);
-    let current = node;
-    while (current.kind === "bound-function") {
-      assertSnapshotDataDepth(visited.size, "<bound-target>");
-      callable(current.target);
-      current = reference(current.target);
-      if (visited.has(current)) throw new TypeError("Cyclic bound function target.");
-      visited.add(current);
-    }
+    callable(node.target);
+    reference(node.target);
     state(node.state);
   } else if (node.kind === "guest-function") {
     fields(node, ["kind", "astNodeId", "scope", "state"], ["name", "environment", "dynamicSource", "realm"]);
@@ -42661,20 +42682,47 @@ function validateGuestHeapGraphs(heap) {
     ["scope-frame", "parent", "Cyclic guest scope parent graph."],
     ["promise-reaction", "source", "Cyclic promise reaction source graph."]
   ]) {
-    const finished = /* @__PURE__ */ new Set();
+    const finished2 = /* @__PURE__ */ new Set();
     for (const [id, raw] of Object.entries(heap)) {
-      if (record3(raw).kind !== kind || finished.has(id)) continue;
+      if (record3(raw).kind !== kind || finished2.has(id)) continue;
       const path = /* @__PURE__ */ new Set();
       let current = id;
-      while (current !== void 0 && !finished.has(current)) {
+      while (current !== void 0 && !finished2.has(current)) {
         if (path.has(current)) throw new TypeError(message);
         const node = record3(heap[current]);
         if (node.kind !== kind) break;
         path.add(current);
         const parent = node[edge];
-        current = absent(parent) ? void 0 : String(record3(parent).id);
+        current = parent === null || absent(parent) ? void 0 : String(record3(parent).id);
+      }
+      for (const visited of path) finished2.add(visited);
+    }
+  }
+  const finished = /* @__PURE__ */ new Map();
+  for (const [id, raw] of Object.entries(heap)) {
+    const root = record3(raw);
+    if (root.kind !== "guest-proxy" && root.kind !== "bound-function" || finished.has(id)) continue;
+    const path = /* @__PURE__ */ new Map();
+    let current = id;
+    let flags = finished.get(current);
+    while (flags === void 0) {
+      if (path.has(current)) throw new TypeError(root.kind === "guest-proxy" ? "Cyclic Proxy target chain." : "Cyclic bound function target.");
+      const node = record3(heap[current]);
+      if (node.kind !== "guest-proxy" && node.kind !== "bound-function" || node.target === null) {
+        flags = targetFlags(node);
+        if (flags === void 0) throw new TypeError("Invalid function target.");
+        break;
+      }
+      path.set(current, node);
+      current = String(record3(node.target).id);
+      flags = finished.get(current);
+    }
+    for (const [visited, node] of [...path].reverse()) {
+      if (node.kind === "guest-proxy") {
+        validateProxyFlags(node, flags);
+        flags = targetFlags(node);
       }
-      for (const visited of path) finished.add(visited);
+      finished.set(visited, flags);
     }
   }
 }
@@ -42956,9 +43004,6 @@ function checkArray(properties, values, cooked) {
 }
 
 // packages/safe-js/src/snapshot/validation.ts
-var DEFAULT_MAX_ENTRIES = 1e5;
-var DEFAULT_MAX_STRING_LENGTH = 1e6;
-var DEFAULT_MAX_DATA_SIZE = 16e6;
 var TAGGED_VALUE_KINDS = /* @__PURE__ */ new Set([
   "arguments",
   "array",
@@ -42989,23 +43034,21 @@ function validateSnapshotData(value) {
   validateGenericValue(value, "$", 0, {
     allowFunctions: false,
     allowUndefined: false,
-    entries: 0,
     dataSize: 0,
-    limits: defaultLimits(),
+    limits: limitsFromBudget(),
     validateTaggedPayloads: false,
     dataPropertiesOnly: true,
     dataPrototypes: /* @__PURE__ */ new WeakSet()
   });
 }
 function validateDumpEnvelope(snapshot, options = {}) {
-  const limits = defaultLimits();
+  const limits = limitsFromBudget();
   const root = requireRecord(snapshot, "$");
   const trusted = inMemoryRunSnapshots.has(root);
   const state = {
     allowHostFunctionState: trusted,
     allowFunctions: trusted,
     allowUndefined: true,
-    entries: 0,
     dataSize: 0,
     limits,
     validateTaggedPayloads: false,
@@ -43590,80 +43633,91 @@ function validateSnapshotProxy(value, path, dataPropertiesOnly = false) {
   }
 }
 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");
-  }
-  if (depth > state.limits.maxDepth)
-    fail("budgetExceeded", path, `exceeds nesting limit ${state.limits.maxDepth}`);
-  state.entries += 1;
-  if (state.entries > state.limits.maxAggregateEntries)
-    fail(
-      "budgetExceeded",
-      path,
-      `exceeds aggregate entry limit ${state.limits.maxAggregateEntries}`
-    );
-  if (typeof value === "string") {
-    requireString(value, path, state.limits);
-    state.dataSize += value.length;
-  } else if (Array.isArray(value)) {
-    if (value.length > state.limits.maxEntries) fail("budgetExceeded", path, "array is too large");
-    if (state.dataPropertiesOnly) {
-      const entries = snapshotDataEntries(value, path, state.dataPrototypes).filter(([key]) => key !== "length");
-      if (entries.length !== value.length)
-        fail("invalidType", path, "snapshot arrays must be dense");
-      for (const [key, entry] of entries) {
-        const index = Number(key);
-        if (!Number.isInteger(index) || index < 0 || index >= value.length || String(index) !== key) {
-          fail("invalidType", path, "snapshot arrays cannot have named properties");
+  const pending = [{ value, path, depth }];
+  const ancestors = /* @__PURE__ */ new WeakSet();
+  while (pending.length > 0) {
+    const frame = pending.pop();
+    if ("exit" in frame) {
+      ancestors.delete(frame.exit);
+      continue;
+    }
+    const { value: value2, path: path2, depth: depth2, key } = frame;
+    if (key !== void 0) {
+      requireString(key, path2, state.limits);
+      state.dataSize += key.length;
+    }
+    validateSnapshotProxy(value2, path2, state.dataPropertiesOnly);
+    if (typeof value2 === "object" && value2 !== null && hasGuestObjectState(value2) && !(state.allowHostFunctionState && (isSandboxModuleNamespace(value2) || isSandboxClosure(value2) && !isGuestClosure(value2)))) {
+      fail("invalidState", path2, "guest function properties, prototype links and custom descriptors cannot be restored");
+    }
+    if (depth2 > state.limits.maxDepth)
+      fail("budgetExceeded", path2, `exceeds nesting limit ${state.limits.maxDepth}`);
+    if (typeof value2 === "object" && value2 !== null) {
+      if (ancestors.has(value2)) {
+        if (state.dataPropertiesOnly) fail("invalidCycle", path2, "snapshot data cannot contain cycles");
+        continue;
+      }
+      ancestors.add(value2);
+      pending.push({ exit: value2 });
+    }
+    if (typeof value2 === "string") {
+      requireString(value2, path2, state.limits);
+      state.dataSize += value2.length;
+    } else if (Array.isArray(value2)) {
+      if (value2.length > state.limits.maxEntries) fail("budgetExceeded", path2, "array is too large");
+      if (state.dataPropertiesOnly) {
+        const entries = snapshotDataEntries(value2, path2, state.dataPrototypes).filter(([key2]) => key2 !== "length");
+        if (entries.length !== value2.length)
+          fail("invalidType", path2, "snapshot arrays must be dense");
+        for (const [key2, entry] of entries.reverse()) {
+          const index = Number(key2);
+          if (!Number.isInteger(index) || index < 0 || index >= value2.length || String(index) !== key2) {
+            fail("invalidType", path2, "snapshot arrays cannot have named properties");
+          }
+          pending.push({ value: entry, path: `${path2}[${key2}]`, depth: depth2 + 1 });
+        }
+      } else {
+        for (const [key2, entry] of ownSnapshotDataEntries(value2, path2, true).reverse()) {
+          const index = Number(key2);
+          if (Number.isInteger(index) && index >= 0 && index < value2.length && String(index) === key2)
+            pending.push({ value: entry, path: `${path2}[${index}]`, depth: depth2 + 1 });
         }
-        validateGenericValue(entry, `${path}[${key}]`, depth + 1, state);
       }
-    } else {
-      for (const [key, entry] of ownSnapshotDataEntries(value, path, true)) {
-        const index = Number(key);
-        if (Number.isInteger(index) && index >= 0 && index < value.length && String(index) === key)
-          validateGenericValue(entry, `${path}[${index}]`, depth + 1, state);
+    } else if (value2 !== null && typeof value2 === "object") {
+      const record4 = value2;
+      if (state.validateTaggedPayloads && isTaggedValueShape(record4)) {
+        validateTaggedValue(record4, path2, state);
       }
-    }
-  } else if (value !== null && typeof value === "object") {
-    const record4 = value;
-    if (state.validateTaggedPayloads && isTaggedValueShape(record4)) {
-      validateTaggedValue(record4, path, state);
-    }
-    const entries = state.dataPropertiesOnly ? snapshotDataEntries(value, path, state.dataPrototypes) : ownSnapshotDataEntries(value, path, true);
-    if (state.dataPropertiesOnly) {
-      for (const [key, entry] of entries) {
-        if (typeof entry === "object" && entry !== null && getIntrinsicIdentity(entry) !== void 0 && hasGuestObjectState(entry))
-          fail("invalidState", `${path}${formatKey(key)}`, "mutated intrinsics require a serialized snapshot");
+      const entries = state.dataPropertiesOnly ? snapshotDataEntries(value2, path2, state.dataPrototypes) : ownSnapshotDataEntries(value2, path2, true);
+      if (state.dataPropertiesOnly) {
+        for (const [key2, entry] of entries) {
+          if (typeof entry === "object" && entry !== null && getIntrinsicIdentity(entry) !== void 0 && hasGuestObjectState(entry))
+            fail("invalidState", `${path2}${formatKey(key2)}`, "mutated intrinsics require a serialized snapshot");
+        }
       }
+      for (const [key2, entry] of entries.reverse()) {
+        const entryPath = `${path2}${formatKey(key2)}`;
+        pending.push({ value: entry, path: entryPath, depth: depth2 + 1, key: key2 });
+      }
+    } else if (!["boolean", "number"].includes(typeof value2) && !(state.allowFunctions && typeof value2 === "function") && !(state.allowUndefined && value2 === void 0) && value2 !== null) {
+      fail("invalidType", path2, "contains an unsupported value");
     }
-    for (const [key, entry] of entries) {
-      const entryPath = `${path}${formatKey(key)}`;
-      requireString(key, entryPath, state.limits);
-      state.dataSize += key.length;
-      validateGenericValue(entry, entryPath, depth + 1, state);
-    }
-  } else if (!["boolean", "number"].includes(typeof value) && !(state.allowFunctions && typeof value === "function") && !(state.allowUndefined && value === void 0) && value !== null) {
-    fail("invalidType", path, "contains an unsupported value");
+    if (state.dataSize > state.limits.maxDataSize)
+      fail("budgetExceeded", path2, `exceeds aggregate data limit ${state.limits.maxDataSize}`);
   }
-  if (state.dataSize > state.limits.maxDataSize)
-    fail("budgetExceeded", path, `exceeds aggregate data limit ${state.limits.maxDataSize}`);
 }
-function validateRuntimeSnapshotDescriptors(snapshot) {
+function validateRuntimeSnapshotDescriptors(snapshot, budget) {
   const pending = [{ value: snapshot, path: "$", depth: 0 }];
   const seen = /* @__PURE__ */ new WeakSet();
-  let entries = 0;
+  const limits = limitsFromBudget(budget);
   while (pending.length > 0) {
     const { value, path, depth } = pending.pop();
     validateSnapshotProxy(value, path);
     if (seen.has(value)) continue;
     seen.add(value);
-    if (depth > MAX_DATA_DEPTH)
-      fail("budgetExceeded", path, `exceeds nesting limit ${MAX_DATA_DEPTH}`);
+    if (depth > limits.maxDepth)
+      fail("budgetExceeded", path, `exceeds nesting limit ${limits.maxDepth}`);
     for (const [key, entry] of ownSnapshotDataEntries(value, path, true, true)) {
-      if (++entries > DEFAULT_MAX_ENTRIES)
-        fail("budgetExceeded", path, `exceeds aggregate entry limit ${DEFAULT_MAX_ENTRIES}`);
       if (entry !== null && typeof entry === "object")
         pending.push({ value: entry, path: `${path}${formatKey(key)}`, depth: depth + 1 });
     }
@@ -43706,14 +43760,13 @@ function ownSnapshotDataEntries(value, path, runtime = false, guestDescriptors =
   }
   return entries;
 }
-function defaultLimits() {
+function limitsFromBudget(budget) {
   return {
-    maxAggregateEntries: DEFAULT_MAX_ENTRIES,
-    maxCallDepth: 1e4,
-    maxDepth: MAX_DATA_DEPTH,
-    maxEntries: DEFAULT_MAX_ENTRIES,
-    maxStringLength: DEFAULT_MAX_STRING_LENGTH,
-    maxDataSize: DEFAULT_MAX_DATA_SIZE
+    maxCallDepth: budget?.limits.maxCallDepth ?? Infinity,
+    maxDepth: budget?.limits.maxCallDepth ?? Infinity,
+    maxEntries: budget?.limits.arrayLength ?? Infinity,
+    maxStringLength: budget?.limits.stringLength ?? Infinity,
+    maxDataSize: budget?.limits.dataSize ?? Infinity
   };
 }
 function requireArray(value, path, state) {
@@ -49202,6 +49255,7 @@ export {
   createReplayEncodingContext,
   encodeReplayData,
   decodeReplayData,
+  schedulesHostCallbacks,
   declareBudgetedHostOperation,
   declareHostOperation,
   wrapCallerInjectedBindings,
@@ -49312,4 +49366,4 @@ authorization of the copyright holder.
 SPDX-License-Identifier: Unicode-3.0
 
 */
-//# sourceMappingURL=chunk-MDIWQFYU.js.map
+//# sourceMappingURL=chunk-SBFOCNNW.js.map