@poe-platform/safe-js 0.1.257 → 0.1.258

package/dist/safe-js/chunks/{chunk-A2FDFKJ6.js → chunk-KBUVHGDL.js}

@@ -7015,6 +7015,23 @@ function getRegexProperties(value) {
   return properties;
 }
 
+// packages/safe-js/src/interp/collection-properties.ts
+var collectionGuestProperties = /* @__PURE__ */ new WeakMap();
+function getCollectionProperties(value) {
+  const properties = collectionGuestProperties.get(value);
+  if (properties === void 0) throw new TypeError("Invalid sandbox collection storage.");
+  return properties;
+}
+function copyCollectionProperties(source, target, encode) {
+  const properties = collectionGuestProperties.get(source) ?? source;
+  for (const key of Reflect.ownKeys(properties)) {
+    const descriptor = Object.getOwnPropertyDescriptor(properties, key);
+    if (!("value" in descriptor)) throw new TypeError("Collection accessor properties cannot be copied as data.");
+    Object.defineProperty(target, key, { ...descriptor, value: encode(descriptor.value) });
+  }
+  if (!Object.isExtensible(properties)) Object.preventExtensions(target);
+}
+
 // packages/safe-js/src/interp/accessors.ts
 var accessorClosures = /* @__PURE__ */ new WeakMap();
 var getterAdapters = /* @__PURE__ */ new WeakMap();
@@ -7886,10 +7903,10 @@ function trackIntrinsicState(budget, root, owner, targets) {
     value: isGuestClosure(target) ? materializeFunctionProperties(target) : target,
     prototype: getSandboxPrototype(target),
     explicit: hasExplicitSandboxPrototype(target)
-  })).map((record3) => ({
-    ...record3,
-    extensible: Object.isExtensible(record3.value),
-    descriptors: new Map(Reflect.ownKeys(record3.value).map((key) => [key, Object.getOwnPropertyDescriptor(record3.value, key)]))
+  })).map((record4) => ({
+    ...record4,
+    extensible: Object.isExtensible(record4.value),
+    descriptors: new Map(Reflect.ownKeys(record4.value).map((key) => [key, Object.getOwnPropertyDescriptor(record4.value, key)]))
   }));
   for (const { target } of records)
     if (isGuestClosure(target)) intrinsicFunctions.add(target);
@@ -7947,7 +7964,7 @@ function getSandboxPropertyDescriptor(value, key, budget) {
   let current = value;
   let depth = 0;
   while (typeof current === "object" && current !== null && (Array.isArray(current) || isSandboxDate(current) || isSandboxRegex(current) || isSandboxMap(current) || isSandboxSet(current) || isPrototypeRecord(current))) {
-    const properties = isGuestClosure(current) ? getGuestFunctionProperties(current) : isSandboxRegex(current) ? getRegexProperties(current) : isSandboxMap(current) || isSandboxSet(current) ? void 0 : current;
+    const properties = isGuestClosure(current) ? getGuestFunctionProperties(current) : isSandboxRegex(current) ? getRegexProperties(current) : isSandboxMap(current) || isSandboxSet(current) ? getCollectionProperties(current) : current;
     const descriptor = properties === void 0 ? void 0 : Object.getOwnPropertyDescriptor(properties, key);
     if (descriptor !== void 0) return descriptor;
     current = getSandboxPrototype(current, budget);
@@ -7964,6 +7981,7 @@ function getSandboxDataProperty(value, key, budget) {
   while (typeof current === "object" && current !== null) {
     if (isGuestHostObject(current)) return typeof key === "symbol" ? void 0 : getHostObjectMember(current, String(key));
     if (isSandboxRegex(current)) return Object.getOwnPropertyDescriptor(getRegexProperties(current), key)?.value;
+    if (isSandboxMap(current) || isSandboxSet(current)) return Object.getOwnPropertyDescriptor(getCollectionProperties(current), key)?.value;
     if (isGuestClosure(current)) {
       const entry = getGuestFunctionProperty(current, key);
       if (entry !== void 0 || Object.hasOwn(current.properties ?? {}, key)) return entry;
@@ -8079,9 +8097,9 @@ var SandboxPromiseRejectionTracker = class {
     });
   }
   observe(promise) {
-    const record3 = this.recordsByPromise.get(promise);
-    if (record3 !== void 0) {
-      record3.observed = true;
+    const record4 = this.recordsByPromise.get(promise);
+    if (record4 !== void 0) {
+      record4.observed = true;
     }
   }
   track(promise, outcome) {
@@ -8089,13 +8107,13 @@ var SandboxPromiseRejectionTracker = class {
     if (existing !== void 0 && outcome === void 0) {
       return;
     }
-    const record3 = existing ?? {
+    const record4 = existing ?? {
       observed: false,
       promise,
       rejected: false
     };
-    this.records.add(record3);
-    this.recordsByPromise.set(promise, record3);
+    this.records.add(record4);
+    this.recordsByPromise.set(promise, record4);
     const pending = outcome ?? promise.promise;
     pending.then(
       () => void 0,
@@ -8105,9 +8123,9 @@ var SandboxPromiseRejectionTracker = class {
           for (const interrupt of this.fatalWaiters) interrupt(reason);
           this.fatalWaiters.clear();
         }
-        if (record3.rejected) return;
-        record3.rejected = true;
-        record3.rejectionReason = reason;
+        if (record4.rejected) return;
+        record4.rejected = true;
+        record4.rejectionReason = reason;
       }
     );
     pending.catch(() => void 0);
@@ -8115,11 +8133,11 @@ var SandboxPromiseRejectionTracker = class {
   async findUnhandledRejection() {
     await flushPromiseJobs();
     if (this.fatalRejection !== void 0) throw this.fatalRejection;
-    for (const record3 of this.records) {
-      if (record3.rejected && !record3.observed) {
+    for (const record4 of this.records) {
+      if (record4.rejected && !record4.observed) {
         return {
-          reason: record3.rejectionReason,
-          span: record3.promise.span
+          reason: record4.rejectionReason,
+          span: record4.promise.span
         };
       }
     }
@@ -8569,6 +8587,81 @@ function serializePropertyDescriptors(target, encode) {
     extensible: Object.isExtensible(target)
   };
 }
+function record(value, names) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    throw new TypeError("Invalid property descriptor record.");
+  const descriptors2 = Object.getOwnPropertyDescriptors(value);
+  if (Reflect.ownKeys(descriptors2).length !== names.length || names.some((name) => !Object.hasOwn(descriptors2, name) || !("value" in descriptors2[name])))
+    throw new TypeError("Invalid property descriptor fields.");
+  return Object.fromEntries(names.map((name) => [name, descriptors2[name].value]));
+}
+function restorePropertyDescriptors(target, raw, decode) {
+  const data = record(raw, ["properties", "extensible"]);
+  if (!Array.isArray(data.properties) || typeof data.extensible !== "boolean")
+    throw new TypeError("Invalid property descriptor state.");
+  const decoded = /* @__PURE__ */ new Map();
+  for (const entry of data.properties) {
+    if (!Array.isArray(entry) || entry.length !== 2)
+      throw new TypeError("Invalid property descriptor entry.");
+    const key = decode(entry[0]);
+    if (typeof key !== "string" && typeof key !== "symbol" || typeof key === "symbol" && internalSymbols.has(key))
+      throw new TypeError("Invalid property key.");
+    if (decoded.has(key)) throw new TypeError("Duplicate property key.");
+    const kind = entry[1] !== null && typeof entry[1] === "object" ? Object.getOwnPropertyDescriptor(entry[1], "kind")?.value : void 0;
+    if (kind !== "data" && kind !== "accessor") throw new TypeError("Invalid property descriptor kind.");
+    const descriptor = record(entry[1], kind === "data" ? ["kind", "value", "writable", "enumerable", "configurable"] : ["kind", "get", "set", "enumerable", "configurable"]);
+    if (typeof descriptor.enumerable !== "boolean" || typeof descriptor.configurable !== "boolean" || kind === "data" && typeof descriptor.writable !== "boolean")
+      throw new TypeError("Invalid property descriptor flags.");
+    const result = { enumerable: descriptor.enumerable, configurable: descriptor.configurable };
+    if (kind === "data") {
+      result.value = decode(descriptor.value);
+      result.writable = descriptor.writable;
+    } else {
+      for (const accessor of ["get", "set"]) {
+        const closure = decode(descriptor[accessor]);
+        if (closure !== void 0 && !isSandboxClosure(closure))
+          throw new TypeError("Property accessors require a sandbox closure.");
+        result[accessor] = closure === void 0 ? void 0 : accessorAdapter(closure, accessor);
+      }
+    }
+    decoded.set(key, result);
+  }
+  const trial = Object.defineProperties(Array.isArray(target) ? [] : /* @__PURE__ */ Object.create(null), Object.getOwnPropertyDescriptors(target));
+  if (!Object.isExtensible(target)) Object.preventExtensions(trial);
+  applyDescriptors(trial, decoded, data.extensible);
+  applyDescriptors(target, decoded, data.extensible);
+  markDescriptorObject(target);
+}
+function keyGroup(key) {
+  if (typeof key === "symbol") return "symbol";
+  const index = Number(key);
+  return Number.isInteger(index) && index >= 0 && index < 4294967295 && String(index) === key ? "index" : "string";
+}
+function applyDescriptors(target, descriptors2, extensible) {
+  if (extensible && !Object.isExtensible(target)) throw new TypeError("Cannot restore extensibility.");
+  const original = Reflect.ownKeys(target).filter((key) => typeof key !== "symbol" || !internalSymbols.has(key));
+  const keep = /* @__PURE__ */ new Set();
+  for (const group of ["index", "string", "symbol"]) {
+    const positions = new Map(original.filter((key) => keyGroup(key) === group).map((key, index) => [key, index]));
+    let previous = -1;
+    for (const key of descriptors2.keys()) {
+      if (keyGroup(key) !== group) continue;
+      const position = positions.get(key);
+      if (group === "index") {
+        if (position !== void 0) keep.add(key);
+      } else {
+        if (position === void 0 || position <= previous) break;
+        keep.add(key);
+        previous = position;
+      }
+    }
+  }
+  for (const key of original)
+    if (!keep.has(key) && !Reflect.deleteProperty(target, key))
+      throw new TypeError("Cannot restore nonconfigurable property order or deletion.");
+  for (const [key, descriptor] of descriptors2) Object.defineProperty(target, key, descriptor);
+  if (!extensible) Object.preventExtensions(target);
+}
 
 // packages/safe-js/src/interp/running-state.ts
 var runningObjects = /* @__PURE__ */ new WeakSet();
@@ -9842,7 +9935,8 @@ function hasOwnSandboxProperty(value, key, enumerable) {
   else if (isSandboxClosure(value)) {
     if (key === "length" || key === "name") return !enumerable;
     properties = value.properties ?? /* @__PURE__ */ Object.create(null);
-  } else if (isSandboxMap(value) || isSandboxSet(value) || isSandboxPromise(value) || isSandboxGenerator(value))
+  } else if (isSandboxMap(value) || isSandboxSet(value)) properties = getCollectionProperties(value);
+  else if (isSandboxPromise(value) || isSandboxGenerator(value))
     return false;
   else if (isSandboxRegex(value)) properties = getRegexProperties(value);
   else properties = Object(value);
@@ -12486,14 +12580,14 @@ function createObjectArrayGlobals(options) {
           call: ([value]) => {
             if (isGuestHostObject(value))
               throw new TypeError("Live host objects cannot be made non-extensible.");
-            Object.preventExtensions(isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : value);
+            Object.preventExtensions(isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value);
             return value;
           },
           name: "preventExtensions"
         }),
         isExtensible: createSandboxClosure({
           sandbox: true,
-          call: ([value]) => Object.isExtensible(isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : value),
+          call: ([value]) => Object.isExtensible(isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value),
           name: "isExtensible"
         }),
         seal: createSandboxClosure({
@@ -12501,14 +12595,14 @@ function createObjectArrayGlobals(options) {
           call: ([value]) => {
             if (isGuestHostObject(value))
               throw new TypeError("Live host objects cannot be sealed.");
-            Object.seal(isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : value);
+            Object.seal(isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value);
             return value;
           },
           name: "seal"
         }),
         isSealed: createSandboxClosure({
           sandbox: true,
-          call: ([value]) => Object.isSealed(isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : value),
+          call: ([value]) => Object.isSealed(isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value),
           name: "isSealed"
         }),
         freeze: createSandboxClosure({
@@ -12517,7 +12611,7 @@ function createObjectArrayGlobals(options) {
             if (isGuestHostObject(value))
               throw new TypeError("Live host objects cannot be frozen.");
             if (typeof value === "object" && value !== null) {
-              Object.freeze(isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : value);
+              Object.freeze(isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value);
             }
             return value;
           },
@@ -12525,7 +12619,7 @@ function createObjectArrayGlobals(options) {
         }),
         isFrozen: createSandboxClosure({
           sandbox: true,
-          call: ([value]) => Object.isFrozen(isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : value),
+          call: ([value]) => Object.isFrozen(isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value),
           name: "isFrozen"
         }),
         assign: createSandboxClosure({
@@ -12733,6 +12827,7 @@ function assignSandboxValues(target, sources, budget, context) {
   })();
 }
 function objectProperties(value, mutable = false) {
+  if (isSandboxMap(value) || isSandboxSet(value)) return getCollectionProperties(value);
   if (isSandboxRegex(value)) return getRegexProperties(value);
   if (isSandboxDate(value)) {
     return value;
@@ -17076,7 +17171,7 @@ async function evaluateDeleteExpression(node, context) {
       }
       throw new TypeError("Cannot delete properties of null or undefined.");
     }
-    if (!isIndexableSandboxValue(member.object) && !isSandboxRegex(member.object)) {
+    if (!isIndexableSandboxValue(member.object) && !isSandboxRegex(member.object) && !isSandboxMap(member.object) && !isSandboxSet(member.object)) {
       throw new TypeError("Unary operator 'delete' requires a sandbox object property.");
     }
     const property = await toPropertyKey(member.property, context.budget, createCoercionContext(context));
@@ -18052,6 +18147,7 @@ function setSandboxProperty(target, property, value, budget, checkInherited = tr
       return writePropertyDescriptor(descriptor2, target, value, context);
   }
   if (isGuestClosure(target)) target = materializeFunctionProperties(target);
+  if (isSandboxMap(target) || isSandboxSet(target)) target = getCollectionProperties(target);
   if (isFloat32Array(target)) {
     if (typeof property === "symbol") throw new TypeError("Typed array symbol properties are not yet supported.");
     setFloat32Member(target, property, value);
@@ -18120,6 +18216,7 @@ function deleteSandboxProperty(target, property) {
   if (isGuestHostObject(target)) return deleteHostObjectMember(target, String(property));
   if (isGuestClosure(target)) target = materializeFunctionProperties(target);
   if (isSandboxRegex(target)) target = getRegexProperties(target);
+  if (isSandboxMap(target) || isSandboxSet(target)) target = getCollectionProperties(target);
   if (Array.isArray(target)) {
     assertCollectionMutable(target);
   }
@@ -18736,6 +18833,15 @@ function normalizeClosureResult(result, budget) {
   });
 }
 
+// packages/safe-js/src/snapshot/collection-properties.ts
+function serializeCollectionProperties(value, encode, dataOnly = false) {
+  const properties = getCollectionProperties(value);
+  if (Reflect.ownKeys(properties).length === 0 && Object.isExtensible(properties)) return {};
+  if (dataOnly && Reflect.ownKeys(properties).some((key) => !("value" in Object.getOwnPropertyDescriptor(properties, key))))
+    throw new TypeError("Collection accessor properties cannot be serialized as replay data.");
+  return { propertyState: serializePropertyDescriptors(properties, encode) };
+}
+
 // packages/safe-js/src/snapshot/float32array.ts
 function encodeFloat32Storage(value, id, buffers, reference) {
   const storage = float32Storage(value);
@@ -18967,6 +19073,7 @@ function encodeReplayData(value, options = {}) {
     } else if (isSandboxMap(entry)) {
       nodes[id] = {
         kind: "map",
+        ...serializeCollectionProperties(entry, (value2) => child(value2, "<collection-property>"), true),
         entries: [...entry.entries].map(([key, value2], index) => [
           child(key, `key:${index}`),
           child(value2, `value:${index}`)
@@ -18975,6 +19082,7 @@ function encodeReplayData(value, options = {}) {
     } else if (isSandboxSet(entry)) {
       nodes[id] = {
         kind: "set",
+        ...serializeCollectionProperties(entry, (value2) => child(value2, "<collection-property>"), true),
         values: [...entry.values].map((value2, index) => child(value2, String(index)))
       };
     } else if (isSandboxRegex(entry)) {
@@ -19024,7 +19132,7 @@ function decodeReplayData(input, options = {}, parent) {
   const compilation = new CompileScope(parent?.owner);
   try {
     validateSnapshotData(input);
-    const graph = record(input);
+    const graph = record2(input);
     const nodes = list(own(graph, "nodes"));
     const restored = /* @__PURE__ */ new Map();
     const initializeIterators = [];
@@ -19032,7 +19140,7 @@ function decodeReplayData(input, options = {}, parent) {
       if (depth > MAX_DATA_DEPTH) throw new TypeError("Replay data exceeds the nesting limit.");
       if (entry === null || typeof entry === "boolean" || typeof entry === "string") return entry;
       if (typeof entry === "number" && Number.isFinite(entry)) return entry;
-      const atom = record(entry);
+      const atom = record2(entry);
       if (own(atom, "tag") === "promise-capability") {
         const id2 = own(atom, "id");
         if (typeof id2 !== "string" || id2.length === 0)
@@ -19076,7 +19184,7 @@ function decodeReplayData(input, options = {}, parent) {
       }
       const id = Number(atom.id);
       if (restored.has(id)) return restored.get(id);
-      const node = record(nodes[id]);
+      const node = record2(nodes[id]);
       const kind = own(node, "kind");
       if (Object.hasOwn(node, "errorType") && (kind !== "object" || !sandboxErrorNames.includes(node.errorType))) {
         throw new TypeError("Invalid replay error metadata.");
@@ -19100,7 +19208,7 @@ function decodeReplayData(input, options = {}, parent) {
         const capability = options.resolveCapability?.(capabilityId);
         if (!isSandboxClosure(capability))
           throw new TypeError(`Missing replay capability '${capabilityId}'.`);
-        if (record(own(node, "properties")).tag === "undefined") {
+        if (record2(own(node, "properties")).tag === "undefined") {
           restored.set(id, capability);
           return capability;
         }
@@ -19124,13 +19232,13 @@ function decodeReplayData(input, options = {}, parent) {
       if (kind === "boxed") {
         validateBoxedProperties(node);
         const payload = own(node, "value");
-        const payloadRecord = payload !== null && typeof payload === "object" ? record(payload) : void 0;
-        const symbolReference = payloadRecord !== void 0 && own(payloadRecord, "tag") === "ref" && Number.isSafeInteger(payloadRecord.id) && Number(payloadRecord.id) >= 0 && Number(payloadRecord.id) < nodes.length && own(record(nodes[Number(payloadRecord.id)]), "kind") === "symbol";
-        if (typeof payload !== "number" && typeof payload !== "string" && typeof payload !== "boolean" && !symbolReference && (payload === null || typeof payload !== "object" || !["number", "bigint"].includes(String(own(record(payload), "tag")))))
+        const payloadRecord = payload !== null && typeof payload === "object" ? record2(payload) : void 0;
+        const symbolReference = payloadRecord !== void 0 && own(payloadRecord, "tag") === "ref" && Number.isSafeInteger(payloadRecord.id) && Number(payloadRecord.id) >= 0 && Number(payloadRecord.id) < nodes.length && own(record2(nodes[Number(payloadRecord.id)]), "kind") === "symbol";
+        if (typeof payload !== "number" && typeof payload !== "string" && typeof payload !== "boolean" && !symbolReference && (payload === null || typeof payload !== "object" || !["number", "bigint"].includes(String(own(record2(payload), "tag")))))
           throw new TypeError("Invalid boxed primitive payload.");
         const result3 = createSandboxBox(child(payload));
         restored.set(id, result3);
-        defineProperties(result3, record(own(node, "properties")), child, node.symbolEntries);
+        defineProperties(result3, record2(own(node, "properties")), child, node.symbolEntries);
         if (!node.extensible) Object.preventExtensions(result3);
         return result3;
       }
@@ -19146,7 +19254,7 @@ function decodeReplayData(input, options = {}, parent) {
         if (node.extensible !== void 0 && typeof node.extensible !== "boolean") throw new TypeError("Invalid replay Date extensibility.");
         const result3 = restoreDateTime(own(node, "time"));
         restored.set(id, result3);
-        defineProperties(result3, node.properties === void 0 ? {} : record(node.properties), child, node.symbolProperties);
+        defineProperties(result3, node.properties === void 0 ? {} : record2(node.properties), child, node.symbolProperties);
         if (node.extensible === false) Object.preventExtensions(result3);
         return result3;
       }
@@ -19155,7 +19263,7 @@ function decodeReplayData(input, options = {}, parent) {
           throw new TypeError("Invalid Float32Array extensibility.");
         const result3 = decodeFloat32Storage(node, child);
         restored.set(id, result3);
-        defineProperties(result3, record(own(node, "properties")), child);
+        defineProperties(result3, record2(own(node, "properties")), child);
         if (!node.extensible) Object.preventExtensions(result3);
         return result3;
       }
@@ -19175,7 +19283,7 @@ function decodeReplayData(input, options = {}, parent) {
           exhausted,
           ...node.global === void 0 ? {} : { global: node.global, unicode: node.unicode }
         }, result3);
-        defineProperties(result3, record(own(node, "properties")), child, node.symbolEntries);
+        defineProperties(result3, record2(own(node, "properties")), child, node.symbolEntries);
         if (!node.extensible) Object.preventExtensions(result3);
         return result3;
       }
@@ -19192,13 +19300,14 @@ function decodeReplayData(input, options = {}, parent) {
         initializeIterators.push(() => {
           restoreSandboxCollectionIterator({ collection, collectionKind, method, index, exhausted }, result3);
         });
-        defineProperties(result3, record(own(node, "properties")), child);
+        defineProperties(result3, record2(own(node, "properties")), child);
         if (!node.extensible) Object.preventExtensions(result3);
         return result3;
       }
       if (kind === "map") {
         const result3 = createSandboxMap();
         restored.set(id, result3);
+        restoreCollectionDataProperties(result3, node, child);
         for (const pair of list(own(node, "entries"))) {
           const entries = list(pair);
           if (entries.length !== 2) throw new TypeError("Invalid replay map entry.");
@@ -19209,6 +19318,7 @@ function decodeReplayData(input, options = {}, parent) {
       if (kind === "set") {
         const result3 = createSandboxSet();
         restored.set(id, result3);
+        restoreCollectionDataProperties(result3, node, child);
         for (const value of list(own(node, "values"))) result3.values.add(child(value));
         return result3;
       }
@@ -19223,17 +19333,17 @@ function decodeReplayData(input, options = {}, parent) {
         return result3;
       }
       if (kind === "arguments") {
-        const data = record(own(node, "data"));
+        const data = record2(own(node, "data"));
         validateArgumentsProperties(data, "arguments");
         if (data.kind !== "arguments") throw new TypeError("Invalid replay arguments.");
         const args = createSandboxArguments([]);
         restored.set(id, args);
         if (!data.lengthBeforeCallee) delete args.length;
-        defineProperties(args, record(data.properties), child);
+        defineProperties(args, record2(data.properties), child);
         if (data.iterator === null) Reflect.deleteProperty(args, Symbol.iterator);
         else
           Object.defineProperty(args, Symbol.iterator, {
-            ...record(data.iterator),
+            ...record2(data.iterator),
             value: Array.prototype.values
           });
         if (!data.extensible) Object.preventExtensions(args);
@@ -19253,7 +19363,7 @@ function decodeReplayData(input, options = {}, parent) {
       }
       if (kind === "array" && node.nullPrototype) Object.setPrototypeOf(result2, null);
       restored.set(id, result2);
-      defineProperties(result2, record(own(node, "properties")), child, node.symbolProperties);
+      defineProperties(result2, record2(own(node, "properties")), child, node.symbolProperties);
       if (!node.extensible) Object.preventExtensions(result2);
       return result2;
     };
@@ -19279,7 +19389,7 @@ function defineProperties(target, properties, decode, symbolProperties) {
     }
   }
   for (const [key, value] of entries) {
-    const descriptor = record(value);
+    const descriptor = record2(value);
     for (const field of Object.keys(descriptor)) {
       if (!["value", "writable", "enumerable", "configurable"].includes(field))
         throw new TypeError("Invalid replay property descriptor.");
@@ -19295,7 +19405,16 @@ function defineProperties(target, properties, decode, symbolProperties) {
     });
   }
 }
-function record(value) {
+function restoreCollectionDataProperties(value, node, decode) {
+  if (!Object.hasOwn(node, "propertyState")) return;
+  const properties = record2(node.propertyState);
+  for (const entry of list(own(properties, "properties"))) {
+    const descriptor = record2(list(entry)[1]);
+    if (own(descriptor, "kind") !== "data") throw new TypeError("Replay collection properties must be data descriptors.");
+  }
+  restorePropertyDescriptors(getCollectionProperties(value), properties, decode);
+}
+function record2(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value))
     throw new TypeError("Expected replay data object.");
   return value;
@@ -19549,21 +19668,21 @@ function invokeHostCallback(invoke, options) {
     throw error;
   }
 }
-function executeHostCall(record3, restored, invoke, stackFrames, options, span, callbacks, onReplay) {
+function executeHostCall(record4, restored, invoke, stackFrames, options, span, callbacks, onReplay) {
   const hostCalls = options.hostCalls;
   let replayed;
   try {
-    replayed = restored ? hostCalls.replayOutcome(record3) : void 0;
+    replayed = restored ? hostCalls.replayOutcome(record4) : void 0;
   } catch (error) {
-    if (!(error instanceof UnresolvedReplayCapabilityError) || !record3.asynchronous) throw error;
+    if (!(error instanceof UnresolvedReplayCapabilityError) || !record4.asynchronous) throw error;
     const promise = (async () => {
       let missing = error;
       while (true) {
         await hostCalls.waitForCapability(missing.id);
         try {
-          const outcome2 = hostCalls.replayOutcome(record3);
+          const outcome2 = hostCalls.replayOutcome(record4);
           if (outcome2 === void 0) throw new TypeError("Missing restored host outcome.");
-          restoreReplayedHostState(record3, outcome2, onReplay);
+          restoreReplayedHostState(record4, outcome2, onReplay);
           if (outcome2.status === "rejected") throw outcome2.reason;
           return outcome2.value;
         } catch (error2) {
@@ -19573,28 +19692,28 @@ function executeHostCall(record3, restored, invoke, stackFrames, options, span,
       }
     })();
     void promise.catch(() => void 0);
-    return createSandboxPromise(promise, { hostCall: record3, hostCallJournal: hostCalls });
+    return createSandboxPromise(promise, { hostCall: record4, hostCallJournal: hostCalls });
   }
   if (replayed !== void 0) {
-    restoreReplayedHostState(record3, replayed, onReplay);
-    if (record3.asynchronous) return createReplayedHostCallResult(replayed, record3, hostCalls);
+    restoreReplayedHostState(record4, replayed, onReplay);
+    if (record4.asynchronous) return createReplayedHostCallResult(replayed, record4, hostCalls);
     if (replayed.status === "rejected") throw replayed.reason;
     return replayed.value;
   }
-  if (restored && record3.policy === "read-side-effect" && record3.lifecycle === "consumed" && record3.outcome !== void 0) {
-    return createReplayedHostCallResult(record3.outcome, record3, hostCalls);
+  if (restored && record4.policy === "read-side-effect" && record4.lifecycle === "consumed" && record4.outcome !== void 0) {
+    return createReplayedHostCallResult(record4.outcome, record4, hostCalls);
   }
-  if (restored && record3.policy === "read-side-effect" && record3.lifecycle === "settled" && record3.outcome !== void 0) {
-    return createHostCallPromise(record3, Promise.resolve(record3.outcome), hostCalls);
+  if (restored && record4.policy === "read-side-effect" && record4.lifecycle === "settled" && record4.outcome !== void 0) {
+    return createHostCallPromise(record4, Promise.resolve(record4.outcome), hostCalls);
   }
-  if (restored && record3.lifecycle === "cancelled" && record3.policy === "read-side-effect") {
+  if (restored && record4.lifecycle === "cancelled" && record4.policy === "read-side-effect") {
     throw new HostCallResumabilityError(
-      record3,
+      record4,
       "reset",
-      `Host call ${record3.id} was cancelled; reset is required.`
+      `Host call ${record4.id} was cancelled; reset is required.`
     );
   }
-  if (restored && record3.policy === "read-side-effect" && record3.lifecycle !== "created") {
+  if (restored && record4.policy === "read-side-effect" && record4.lifecycle !== "created") {
     let active = true;
     const context = callbacks === void 0 ? void 0 : {
       callbacks: new Map(callbacks.hostFunctions),
@@ -19617,13 +19736,13 @@ function executeHostCall(record3, restored, invoke, stackFrames, options, span,
         );
       }
     };
-    const outcome2 = hostCalls.reconcile(record3, context).finally(() => {
+    const outcome2 = hostCalls.reconcile(record4, context).finally(() => {
       active = false;
     });
-    return createHostCallPromise(record3, outcome2, hostCalls);
+    return createHostCallPromise(record4, outcome2, hostCalls);
   }
   if (restored && callbacks !== void 0) callbacks.nextReissuedInvocation = 0;
-  hostCalls.start(record3);
+  hostCalls.start(record4);
   let result;
   try {
     result = invoke();
@@ -19632,17 +19751,17 @@ function executeHostCall(record3, restored, invoke, stackFrames, options, span,
       throw error;
     }
     const reason = createHostErrorValue(error, stackFrames, options.budget, span);
-    hostCalls.settle(record3, { status: "rejected", reason });
+    hostCalls.settle(record4, { status: "rejected", reason });
     throw error;
   }
   if (!isPromiseLike3(result)) {
-    record3.asynchronous = false;
+    record4.asynchronous = false;
     const value = copyHostResultToSandbox(result, stackFrames, options);
-    hostCalls.settle(record3, { status: "fulfilled", value });
-    hostCalls.consume(record3);
+    hostCalls.settle(record4, { status: "fulfilled", value });
+    hostCalls.consume(record4);
     return value;
   }
-  record3.asynchronous = true;
+  record4.asynchronous = true;
   const outcome = wrapHostPromiseWithSignal(Promise.resolve(result), options.signal).then(
     (value) => {
       try {
@@ -19670,9 +19789,9 @@ function executeHostCall(record3, restored, invoke, stackFrames, options, span,
       };
     }
   );
-  return createHostCallPromise(record3, outcome, hostCalls);
+  return createHostCallPromise(record4, outcome, hostCalls);
 }
-function restoreReplayedHostState(record3, outcome, onReplay) {
+function restoreReplayedHostState(record4, outcome, onReplay) {
   try {
     const result = onReplay?.(outcome);
     if (isPromiseLike3(result)) {
@@ -19681,30 +19800,30 @@ function restoreReplayedHostState(record3, outcome, onReplay) {
     }
   } catch (reason) {
     const error = new HostCallResumabilityError(
-      record3,
+      record4,
       "reset",
-      `Cannot restore host-local state for ${record3.id}: ${reason instanceof Error ? reason.message : String(reason)}`
+      `Cannot restore host-local state for ${record4.id}: ${reason instanceof Error ? reason.message : String(reason)}`
     );
     promiseReplayContext.getStore()?.fail(error);
     throw error;
   }
 }
-function createReplayedHostCallResult(outcome, record3, hostCalls) {
+function createReplayedHostCallResult(outcome, record4, hostCalls) {
   const promise = outcome.status === "fulfilled" ? Promise.resolve(outcome.value) : Promise.reject(outcome.reason);
   promise.catch(() => void 0);
-  return createSandboxPromise(promise, { hostCall: record3, hostCallJournal: hostCalls });
+  return createSandboxPromise(promise, { hostCall: record4, hostCallJournal: hostCalls });
 }
-function createHostCallPromise(record3, outcomePromise, hostCalls) {
+function createHostCallPromise(record4, outcomePromise, hostCalls) {
   const promise = outcomePromise.then((outcome) => {
     if (outcome.status === "rejected" && isAbortReason(outcome.reason)) {
-      hostCalls.cancel(record3, outcome.reason);
+      hostCalls.cancel(record4, outcome.reason);
     } else {
-      hostCalls.settle(record3, outcome);
+      hostCalls.settle(record4, outcome);
     }
     return outcome.status === "fulfilled" ? outcome.value : Promise.reject(outcome.reason);
   });
   promise.catch(() => void 0);
-  return createSandboxPromise(promise, { hostCall: record3, hostCallJournal: hostCalls });
+  return createSandboxPromise(promise, { hostCall: record4, hostCallJournal: hostCalls });
 }
 function isAbortReason(reason) {
   return typeof reason === "object" && reason !== null && ("name" in reason && reason.name === "AbortError" || "code" in reason && reason.code === "aborted");
@@ -20506,7 +20625,7 @@ function conversionHook(value, name, budget, context) {
   let current = value;
   let depth = 0;
   while (current !== null) {
-    const properties = isGuestClosure(current) ? getGuestFunctionProperties(current) : isSandboxRegex(current) ? getRegexProperties(current) : current;
+    const properties = isGuestClosure(current) ? getGuestFunctionProperties(current) : isSandboxRegex(current) ? getRegexProperties(current) : isSandboxMap(current) || isSandboxSet(current) ? getCollectionProperties(current) : current;
     const descriptor = properties === void 0 ? void 0 : Object.getOwnPropertyDescriptor(properties, name);
     if (descriptor !== void 0) {
       return readPropertyDescriptor(descriptor, value, context);
@@ -21816,7 +21935,7 @@ async function parseJsonWithReviver(text, reviver, budget, context) {
       leave();
     }
   }
-  async function internalize(holder2, key, record3) {
+  async function internalize(holder2, key, record4) {
     budget.visitNode();
     const leave = budget.enterCall();
     let value;
@@ -21828,7 +21947,7 @@ async function parseJsonWithReviver(text, reviver, budget, context) {
         const descriptor = getSandboxPropertyDescriptor(holder2, key, budget);
         value = descriptor === void 0 ? void 0 : await readPropertyDescriptor(descriptor, holder2, context);
       }
-      const original = record3 !== void 0 && Object.is(value, record3.value) ? record3 : void 0;
+      const original = record4 !== void 0 && Object.is(value, record4.value) ? record4 : void 0;
       if (original?.source !== void 0) callbackContext.source = budget.allocateString(original.source);
       if (typeof value === "object" && value !== null) {
         if (Array.isArray(value)) budget.allocateArrayLength(value.length);
@@ -22109,7 +22228,7 @@ async function stringifyObject(value, state, indent) {
   const release = retainValues(state.budget, () => entries);
   try {
     const nextIndent = indent + state.gap;
-    for (const key of state.propertyList ?? Object.keys(value)) {
+    for (const key of state.propertyList ?? ownEnumerableSandboxKeys(value)) {
       const serialized = await stringifyProperty(key, value, state, nextIndent);
       if (serialized !== void 0) {
         entries.push(`${quoteJsonString(key)}:${state.gap === "" ? "" : " "}${serialized}`);
@@ -22246,9 +22365,9 @@ async function sumPrecise(source, budget, context) {
       if (typeof result !== "object" && typeof result !== "function" || result === null)
         throw new TypeError("Iterator result must be an object.");
       recordValue = result;
-      const record3 = result;
-      if ((await readIteratorResult(iterator, record3, "done")).value) break;
-      current = (await readIteratorResult(iterator, record3, "value")).value;
+      const record4 = result;
+      if ((await readIteratorResult(iterator, record4, "done")).value) break;
+      current = (await readIteratorResult(iterator, 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);
@@ -23120,7 +23239,7 @@ function intrinsicCatalogue() {
     releaseObjectPrototype(budget);
   }
 }
-function record2(value) {
+function record3(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) throw new TypeError("Expected a guest heap record.");
   return value;
 }
@@ -23137,23 +23256,23 @@ function integer(value) {
 }
 function absent(value) {
   if (value === null || typeof value !== "object") return false;
-  const node = record2(value);
+  const node = record3(value);
   return node.kind === "undefined" && Object.keys(node).length === 1;
 }
 function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
-  const node = record2(raw);
+  const node = record3(raw);
   if (node.kind === "raw-json") {
     fields(node, ["kind", "text"]);
     if (typeof node.text !== "string") throw new TypeError("Invalid raw JSON source.");
     createRawJson(node.text);
     return true;
   }
-  if (!["intrinsic", "guest-function", "guest-generator", "scope-frame", "guest-object", "guest-array"].includes(String(node.kind))) return false;
+  if (!["intrinsic", "guest-function", "guest-generator", "scope-frame", "guest-object", "guest-array", "map", "set"].includes(String(node.kind))) return false;
   const reference = (value, kinds) => {
-    const ref = record2(value);
+    const ref = record3(value);
     fields(ref, ["kind", "id"]);
     if (ref.kind !== "ref" || integer(ref.id) < 1 || !Object.hasOwn(heap, String(ref.id))) throw new TypeError("Invalid guest heap reference.");
-    const target = record2(heap[String(ref.id)]);
+    const target = record3(heap[String(ref.id)]);
     if (kinds !== void 0 && !kinds.includes(String(target.kind))) throw new TypeError("Wrong guest heap reference kind.");
     return target;
   };
@@ -23164,10 +23283,10 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
       throw new TypeError("Guest accessor reference is not callable.");
   };
   const state = (value) => {
-    const object = record2(value);
+    const object = record3(value);
     fields(object, ["properties"], ["prototype"]);
     if (Object.hasOwn(object, "prototype") && object.prototype !== null) reference(object.prototype);
-    const properties = record2(object.properties);
+    const properties = record3(object.properties);
     fields(properties, ["properties", "extensible"]);
     if (typeof properties.extensible !== "boolean") throw new TypeError("Invalid guest extensibility.");
     const keys = /* @__PURE__ */ new Set();
@@ -23178,11 +23297,11 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
       if (typeof entry[0] === "string") key = `string:${entry[0]}`;
       else {
         const symbol = reference(entry[0], ["symbol"]);
-        key = symbol.wellKnown === void 0 ? `symbol:${record2(entry[0]).id}` : `well-known:${symbol.wellKnown}`;
+        key = symbol.wellKnown === void 0 ? `symbol:${record3(entry[0]).id}` : `well-known:${symbol.wellKnown}`;
       }
       if (keys.has(key)) throw new TypeError("Duplicate guest property key.");
       keys.add(key);
-      const descriptor = record2(entry[1]);
+      const descriptor = record3(entry[1]);
       if (descriptor.kind === "data") {
         fields(descriptor, ["kind", "value", "writable", "enumerable", "configurable"]);
         if (typeof descriptor.writable !== "boolean") throw new TypeError("Invalid guest writable flag.");
@@ -23194,6 +23313,11 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
       if (typeof descriptor.enumerable !== "boolean" || typeof descriptor.configurable !== "boolean") throw new TypeError("Invalid guest descriptor flags.");
     }
   };
+  if (node.kind === "map" || node.kind === "set") {
+    fields(node, ["kind", node.kind === "map" ? "entries" : "values"], ["propertyState"]);
+    if (Object.hasOwn(node, "propertyState")) state({ properties: node.propertyState });
+    return false;
+  }
   if (node.kind === "intrinsic") {
     fields(node, ["kind", "id"], ["state"]);
     if (typeof node.id !== "string" || !intrinsicCatalogue().has(node.id)) throw new TypeError("Unknown intrinsic identity.");
@@ -23205,10 +23329,10 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
       throw new TypeError("Invalid template source identity.");
     state(node.state);
     if (node.kind === "guest-array") {
-      const properties = array(record2(record2(node.state).properties).properties).map((entry) => array(entry));
+      const properties = array(record3(record3(node.state).properties).properties).map((entry) => array(entry));
       const length = properties.find((entry) => entry[0] === "length");
       if (length === void 0) throw new TypeError("Missing guest array length.");
-      const descriptor = record2(length[1]);
+      const descriptor = record3(length[1]);
       if (descriptor.kind !== "data" || descriptor.configurable !== false || descriptor.enumerable !== false || integer(descriptor.value) > 4294967295) throw new TypeError("Invalid guest array length.");
       if (descriptor.value > maxArrayLength) throw new TypeError("Guest array length exceeds allocation limit.");
       for (const [key] of properties) {
@@ -23223,7 +23347,7 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     reference(node.scope, ["scope-frame"]);
     if (Object.hasOwn(node, "name") && typeof node.name !== "string") throw new TypeError("Invalid guest function name.");
     if (Object.hasOwn(node, "environment")) {
-      const environment = record2(node.environment);
+      const environment = record3(node.environment);
       fields(environment, [], ["homeObject", "newTarget"]);
       if (Object.hasOwn(environment, "homeObject")) reference(environment.homeObject);
       if (Object.hasOwn(environment, "newTarget")) callable(environment.newTarget);
@@ -23237,15 +23361,15 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     reference(node.closureScope, ["scope-frame"]);
     if (Object.hasOwn(node, "suspendedScope")) reference(node.suspendedScope, ["scope-frame"]);
     if (Object.hasOwn(node, "blockScopes")) {
-      for (const [id, scope] of Object.entries(record2(node.blockScopes))) {
+      for (const [id, scope] of Object.entries(record3(node.blockScopes))) {
         if (integer(Number(id)) < 1 || String(Number(id)) !== id) throw new TypeError("Invalid generator block identity.");
         reference(scope, ["scope-frame"]);
       }
     }
     if (Object.hasOwn(node, "expressionStates")) {
-      for (const [id, raw2] of Object.entries(record2(node.expressionStates))) {
+      for (const [id, raw2] of Object.entries(record3(node.expressionStates))) {
         if (integer(Number(id)) < 1 || String(Number(id)) !== id) throw new TypeError("Invalid expression identity.");
-        const expression = record2(raw2);
+        const expression = record3(raw2);
         if (expression.kind === "binary") {
           fields(expression, ["kind", "left"]);
         } else if (expression.kind === "declaration") {
@@ -23284,13 +23408,13 @@ 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 = record2(expression.iterator);
+            let iterator = record3(expression.iterator);
             let depth = 0;
             let protocol = false;
             while (iterator.kind === "async-from-sync") {
               if (++depth > 1) throw new TypeError("Invalid nested async iterator adapter.");
               fields(iterator, ["kind", "inner"]);
-              iterator = record2(iterator.inner);
+              iterator = record3(iterator.inner);
               protocol = true;
             }
             if (iterator.kind === "guest") {
@@ -23369,9 +23493,9 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
       }
     }
     if (Object.hasOwn(node, "finallyCompletions")) {
-      for (const [id, raw2] of Object.entries(record2(node.finallyCompletions))) {
+      for (const [id, raw2] of Object.entries(record3(node.finallyCompletions))) {
         if (integer(Number(id)) < 1 || String(Number(id)) !== id) throw new TypeError("Invalid finally identity.");
-        const completion = record2(raw2);
+        const completion = record3(raw2);
         fields(completion, ["kind", "hasValue", "value"], ["nodeId", "label", "span", "stackFrames"]);
         if (!["normal", "return", "throw", "break", "continue"].includes(String(completion.kind)) || typeof completion.hasValue !== "boolean")
           throw new TypeError("Invalid finally completion.");
@@ -23383,12 +23507,12 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     if (Object.hasOwn(node, "yieldNodeId") && integer(node.yieldNodeId) < 1) throw new TypeError("Invalid generator yield identity.");
     if (node.state === "suspended" && (!Object.hasOwn(node, "yieldNodeId") || !Object.hasOwn(node, "suspendedScope"))) throw new TypeError("Missing suspended generator state.");
     for (const rawCompletion of array(node.sent)) {
-      const completion = record2(rawCompletion);
+      const completion = record3(rawCompletion);
       fields(completion, ["type", "value"]);
       if (!["normal", "return", "throw"].includes(String(completion.type))) throw new TypeError("Invalid generator completion type.");
     }
     if (Object.hasOwn(node, "environment")) {
-      const environment = record2(node.environment);
+      const environment = record3(node.environment);
       fields(environment, [], ["homeObject", "newTarget"]);
       if (Object.hasOwn(environment, "homeObject")) reference(environment.homeObject);
       if (Object.hasOwn(environment, "newTarget")) callable(environment.newTarget);
@@ -23399,7 +23523,7 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     if (typeof node.functionBoundary !== "boolean" || typeof node.chargeData !== "boolean") throw new TypeError("Invalid guest frame flags.");
     const cells = array(node.cells);
     for (const rawCell of cells) {
-      const cell = record2(rawCell);
+      const cell = record3(rawCell);
       if (typeof cell.initialized !== "boolean" || !["var", "let", "const"].includes(String(cell.kind))) throw new TypeError("Invalid guest binding cell.");
       fields(cell, cell.initialized ? ["kind", "initialized", "value"] : ["kind", "initialized"]);
     }
@@ -23429,26 +23553,26 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
 function validateGuestScopeParents(heap) {
   const finished = /* @__PURE__ */ new Set();
   for (const [id, raw] of Object.entries(heap)) {
-    if (record2(raw).kind !== "scope-frame" || finished.has(id)) continue;
+    if (record3(raw).kind !== "scope-frame" || finished.has(id)) continue;
     const path = /* @__PURE__ */ new Set();
     let current = id;
     while (current !== void 0 && !finished.has(current)) {
       if (path.has(current)) throw new TypeError("Cyclic guest scope parent graph.");
       path.add(current);
-      const parent = record2(heap[current]).parent;
-      current = absent(parent) ? void 0 : String(record2(parent).id);
+      const parent = record3(heap[current]).parent;
+      current = absent(parent) ? void 0 : String(record3(parent).id);
     }
     for (const visited of path) finished.add(visited);
   }
 }
 
 // packages/safe-js/src/snapshot/guest-ast-validation.ts
-function validateGuestFunctionAst(record3, origin) {
+function validateGuestFunctionAst(record4, origin) {
   if (origin === null || typeof origin !== "object" || !["ArrowFunctionExpression", "FunctionExpression", "FunctionDeclaration"].includes(String(origin.type)))
     throw new TypeError("Unknown guest function AST identity");
-  if (record3.kind !== "guest-generator") return;
+  if (record4.kind !== "guest-generator") return;
   const functionNode = origin;
-  if (functionNode.generator !== true || functionNode.async === true !== record3.async)
+  if (functionNode.generator !== true || functionNode.async === true !== record4.async)
     throw new TypeError("Invalid generator AST identity");
   let yieldBlocks;
   let yieldFinalizers;
@@ -23463,10 +23587,10 @@ function validateGuestFunctionAst(record3, origin) {
     if (["ArrowFunctionExpression", "FunctionExpression", "FunctionDeclaration"].includes(String(node.type))) continue;
     let blocks = frame.blocks;
     if (node.type === "BlockStatement" && typeof node.nodeId === "number") blocks = /* @__PURE__ */ new Set([...blocks, node.nodeId]);
-    if (node.type === "YieldExpression" && node.nodeId === record3.yieldNodeId) {
+    if (node.type === "YieldExpression" && node.nodeId === record4.yieldNodeId) {
       yieldBlocks = blocks;
       yieldFinalizers = frame.finalizers;
-      yieldExpressions = node.delegate === true && typeof node.nodeId === "number" ? new Map([...frame.expressions, [node.nodeId, { kind: "yield-delegate", async: record3.async === true }]]) : frame.expressions;
+      yieldExpressions = node.delegate === true && typeof node.nodeId === "number" ? new Map([...frame.expressions, [node.nodeId, { kind: "yield-delegate", async: record4.async === true }]]) : frame.expressions;
     }
     for (const [key, value] of Object.entries(node)) {
       if (node.type === "SwitchStatement" && key === "cases" && typeof node.nodeId === "number" && Array.isArray(value)) {
@@ -23568,23 +23692,23 @@ function validateGuestFunctionAst(record3, origin) {
       });
     }
   }
-  if (record3.yieldNodeId !== void 0 && yieldBlocks === void 0)
+  if (record4.yieldNodeId !== void 0 && yieldBlocks === void 0)
     throw new TypeError("Invalid generator AST identity");
-  if (record3.state === "suspended" && Object.keys(record3.blockScopes ?? {}).length !== yieldBlocks?.size)
-    throw new TypeError(`Invalid generator AST identity: expected blocks ${[...yieldBlocks ?? []]}, received ${Object.keys(record3.blockScopes ?? {})}.`);
-  if (record3.blockScopes !== void 0) {
-    for (const id of Object.keys(record3.blockScopes)) {
+  if (record4.state === "suspended" && Object.keys(record4.blockScopes ?? {}).length !== yieldBlocks?.size)
+    throw new TypeError(`Invalid generator AST identity: expected blocks ${[...yieldBlocks ?? []]}, received ${Object.keys(record4.blockScopes ?? {})}.`);
+  if (record4.blockScopes !== void 0) {
+    for (const id of Object.keys(record4.blockScopes)) {
       if (!yieldBlocks?.has(Number(id))) throw new TypeError("Invalid generator AST identity");
     }
   }
-  const completions = Object.keys(record3.finallyCompletions ?? {});
-  if (record3.state === "suspended" && completions.length !== yieldFinalizers?.size)
+  const completions = Object.keys(record4.finallyCompletions ?? {});
+  if (record4.state === "suspended" && completions.length !== yieldFinalizers?.size)
     throw new TypeError("Invalid generator AST identity: missing finally completion");
   for (const id of completions) {
     if (!yieldFinalizers?.has(Number(id))) throw new TypeError("Invalid generator AST identity: unrelated finally completion");
   }
-  const expressions = Object.entries(record3.expressionStates ?? {});
-  if (record3.state === "suspended" && expressions.length !== yieldExpressions?.size)
+  const expressions = Object.entries(record4.expressionStates ?? {});
+  if (record4.state === "suspended" && expressions.length !== yieldExpressions?.size)
     throw new TypeError("Invalid generator AST identity: missing expression continuation");
   for (const [id, expression] of expressions) {
     const expected = yieldExpressions?.get(Number(id));
@@ -23793,16 +23917,16 @@ function validateDumpReferences(value, path, depth, state, heapIds, heap, role =
     );
     return;
   }
-  const record3 = value;
-  if (record3.kind === "ref") {
-    const id = requireSafeInteger(record3.id, `${path}.id`, 1);
+  const record4 = value;
+  if (record4.kind === "ref") {
+    const id = requireSafeInteger(record4.id, `${path}.id`, 1);
     if (!heapIds.has(id)) fail("danglingReference", `${path}.id`, `unknown heap value ${id}`);
     if (heap[String(id)].kind === "scope-frame" && !allowScopeReference)
       fail("invalidValue", path, "Internal scopes cannot be guest data");
   }
-  for (const [key, entry] of Object.entries(record3)) {
-    const childRole = role === "root" && key === "heap" ? "heap" : role === "heap" ? "heap-node" : role === "heap-node" && record3.kind === "guest-generator" && key === "blockScopes" ? "scope-map" : role === "heap-node" && record3.kind === "guest-generator" && key === "expressionStates" ? "expressions" : role === "expressions" ? "expression" : "data";
-    const scopeField = role === "scope-map" || role === "expression" && (record3.kind === "for" && ["loopScope", "activeScope"].includes(key) || ["switch", "for-in", "for-of-array", "for-of-iterator"].includes(String(record3.kind)) && key === "scope") || role === "heap-node" && (record3.kind === "scope-frame" && key === "parent" || record3.kind === "guest-function" && key === "scope" || record3.kind === "guest-generator" && ["scope", "closureScope", "suspendedScope"].includes(key));
+  for (const [key, entry] of Object.entries(record4)) {
+    const childRole = role === "root" && key === "heap" ? "heap" : role === "heap" ? "heap-node" : role === "heap-node" && record4.kind === "guest-generator" && key === "blockScopes" ? "scope-map" : role === "heap-node" && record4.kind === "guest-generator" && key === "expressionStates" ? "expressions" : role === "expressions" ? "expression" : "data";
+    const scopeField = role === "scope-map" || role === "expression" && (record4.kind === "for" && ["loopScope", "activeScope"].includes(key) || ["switch", "for-in", "for-of-array", "for-of-iterator"].includes(String(record4.kind)) && key === "scope") || role === "heap-node" && (record4.kind === "scope-frame" && key === "parent" || record4.kind === "guest-function" && key === "scope" || record4.kind === "guest-generator" && ["scope", "closureScope", "suspendedScope"].includes(key));
     validateDumpReferences(entry, `${path}${formatKey(key)}`, depth + 1, state, heapIds, heap, childRole, scopeField);
   }
 }
@@ -23857,12 +23981,12 @@ function validatePosition(value, path) {
 function validateValue(value, path, depth, state) {
   validateGenericValue(value, path, depth, state);
 }
-function validateTaggedValue(record3, path, state) {
-  switch (record3.kind) {
+function validateTaggedValue(record4, path, state) {
+  switch (record4.kind) {
     case "bigint":
-      requireString(record3.value, `${path}.value`, state.limits);
+      requireString(record4.value, `${path}.value`, state.limits);
       try {
-        validateBigIntData(record3.value);
+        validateBigIntData(record4.value);
       } catch {
         fail("invalidValue", `${path}.value`, "invalid BigInt value");
       }
@@ -23870,34 +23994,34 @@ function validateTaggedValue(record3, path, state) {
     case "undefined":
       return;
     case "number":
-      if (!["-Infinity", "Infinity", "NaN", "-0"].includes(String(record3.value))) {
+      if (!["-Infinity", "Infinity", "NaN", "-0"].includes(String(record4.value))) {
         fail("invalidValue", `${path}.value`, "unknown non-finite number value");
       }
       return;
     case "fn":
-      requireSafeInteger(record3.astNodeId, `${path}.astNodeId`, 0);
-      requireSnapshotId(record3.capturedScopeId, `${path}.capturedScopeId`);
+      requireSafeInteger(record4.astNodeId, `${path}.astNodeId`, 0);
+      requireSnapshotId(record4.capturedScopeId, `${path}.capturedScopeId`);
       return;
     case "generator":
-      validateGeneratorShape(record3, path, state);
+      validateGeneratorShape(record4, path, state);
       return;
     case "promise":
-      requireSnapshotId(record3.id, `${path}.id`);
+      requireSnapshotId(record4.id, `${path}.id`);
       return;
     case "ref":
-      requireSafeInteger(record3.id, `${path}.id`, 1);
+      requireSafeInteger(record4.id, `${path}.id`, 1);
       return;
     case "regex":
-      requireString(record3.source, `${path}.source`, state.limits);
-      requireString(record3.flags, `${path}.flags`, state.limits);
-      requireSafeInteger(record3.lastIndex, `${path}.lastIndex`, 0);
+      requireString(record4.source, `${path}.source`, state.limits);
+      requireString(record4.flags, `${path}.flags`, state.limits);
+      requireSafeInteger(record4.lastIndex, `${path}.lastIndex`, 0);
       return;
     case "regex-object":
-      requireString(record3.source, `${path}.source`, state.limits);
-      requireString(record3.flags, `${path}.flags`, state.limits);
-      if (!Object.hasOwn(record3, "lastIndex")) fail("invalidValue", `${path}.lastIndex`, "missing regex cursor");
+      requireString(record4.source, `${path}.source`, state.limits);
+      requireString(record4.flags, `${path}.flags`, state.limits);
+      if (!Object.hasOwn(record4, "lastIndex")) fail("invalidValue", `${path}.lastIndex`, "missing regex cursor");
       try {
-        validateRegexProperties(record3);
+        validateRegexProperties(record4);
       } catch {
         fail("invalidValue", path, "invalid RegExp property data");
       }
@@ -23906,7 +24030,7 @@ function validateTaggedValue(record3, path, state) {
     case "arguments":
       return;
     case "object":
-      if (Object.hasOwn(record3, "sandboxNullPrototype") && record3.sandboxNullPrototype !== true)
+      if (Object.hasOwn(record4, "sandboxNullPrototype") && record4.sandboxNullPrototype !== true)
         fail("invalidValue", `${path}.sandboxNullPrototype`, "invalid object prototype");
       return;
     case "map":
@@ -23916,29 +24040,29 @@ function validateTaggedValue(record3, path, state) {
       return;
   }
 }
-function validateGeneratorShape(record3, path, state) {
-  if (record3.async !== void 0 && typeof record3.async !== "boolean") {
+function validateGeneratorShape(record4, path, state) {
+  if (record4.async !== void 0 && typeof record4.async !== "boolean") {
     fail("invalidType", `${path}.async`, "generator async flag must be a boolean");
   }
-  if (!["start", "suspended", "done"].includes(String(record3.state))) {
+  if (!["start", "suspended", "done"].includes(String(record4.state))) {
     fail("invalidState", `${path}.state`, "unknown generator state");
   }
-  if (record3.state === "done") {
-    if (record3.astNodeId !== void 0 || record3.capturedScopeId !== void 0 || record3.sent !== void 0 || record3.yieldNodeId !== void 0) {
+  if (record4.state === "done") {
+    if (record4.astNodeId !== void 0 || record4.capturedScopeId !== void 0 || record4.sent !== void 0 || record4.yieldNodeId !== void 0) {
       fail("invalidState", path, "done generator cannot contain resume state");
     }
     return;
   }
-  requireSafeInteger(record3.astNodeId, `${path}.astNodeId`, 0);
-  requireSnapshotId(record3.capturedScopeId, `${path}.capturedScopeId`);
-  if (record3.state === "start") {
-    if (record3.sent !== void 0 || record3.yieldNodeId !== void 0) {
+  requireSafeInteger(record4.astNodeId, `${path}.astNodeId`, 0);
+  requireSnapshotId(record4.capturedScopeId, `${path}.capturedScopeId`);
+  if (record4.state === "start") {
+    if (record4.sent !== void 0 || record4.yieldNodeId !== void 0) {
       fail("invalidState", path, "unstarted generator cannot contain a resume cursor");
     }
     return;
   }
-  requireSafeInteger(record3.yieldNodeId, `${path}.yieldNodeId`, 0);
-  const sent = requireArray(record3.sent, `${path}.sent`, state);
+  requireSafeInteger(record4.yieldNodeId, `${path}.yieldNodeId`, 0);
+  const sent = requireArray(record4.sent, `${path}.sent`, state);
   sent.forEach((completion, index) => {
     const completionPath = `${path}.sent[${index}]`;
     const candidate = requireRecord(completion, completionPath);
@@ -23954,13 +24078,13 @@ function validateGeneratorShape(record3, path, state) {
   });
 }
 function validateHeapValue(value, path, state, heap) {
-  const record3 = requireRecord(value, path);
+  const record4 = requireRecord(value, path);
   try {
-    if (validateGuestHeapNode(record3, heap, state.limits.maxEntries)) {
+    if (validateGuestHeapNode(record4, heap, state.limits.maxEntries)) {
       const tagged = state.validateTaggedPayloads;
       state.validateTaggedPayloads = false;
       try {
-        validateValue(record3, path, 1, state);
+        validateValue(record4, path, 1, state);
       } finally {
         state.validateTaggedPayloads = tagged;
       }
@@ -23969,49 +24093,49 @@ function validateHeapValue(value, path, state, heap) {
   } catch (error) {
     fail("invalidValue", path, String(error));
   }
-  validateErrorType(record3, path);
-  if (!["symbol", "arguments", "array", "object", "map", "set", "float32array", "date", "boxed", "collection-iterator", "regexp-iterator", "regex-object"].includes(String(record3.kind)))
+  validateErrorType(record4, path);
+  if (!["symbol", "arguments", "array", "object", "map", "set", "float32array", "date", "boxed", "collection-iterator", "regexp-iterator", "regex-object"].includes(String(record4.kind)))
     fail("unknownTag", `${path}.kind`, "unknown heap tag");
-  validateValue(record3, path, 1, state);
-  if (record3.kind === "symbol") validateSymbolRecord(record3, path, state);
-  if (record3.kind === "arguments") validateArgumentsProperties(record3, path);
-  if (record3.kind === "array") validateArrayHeap(record3, path, state);
-  if (record3.kind === "object") requireRecord(record3.entries, `${path}.entries`);
-  if (record3.kind === "boxed") validateBoxedRecord(record3, path, heap);
-  if (record3.kind === "date") validateDateRecord(record3, path);
-  if (record3.kind === "float32array") {
-    validateFloat32Storage(record3);
-    requireRecord(record3.entries, `${path}.entries`);
-  }
-  if (record3.kind === "map") {
-    const entries = requireArray(record3.entries, `${path}.entries`, state);
+  validateValue(record4, path, 1, state);
+  if (record4.kind === "symbol") validateSymbolRecord(record4, path, state);
+  if (record4.kind === "arguments") validateArgumentsProperties(record4, path);
+  if (record4.kind === "array") validateArrayHeap(record4, path, state);
+  if (record4.kind === "object") requireRecord(record4.entries, `${path}.entries`);
+  if (record4.kind === "boxed") validateBoxedRecord(record4, path, heap);
+  if (record4.kind === "date") validateDateRecord(record4, path);
+  if (record4.kind === "float32array") {
+    validateFloat32Storage(record4);
+    requireRecord(record4.entries, `${path}.entries`);
+  }
+  if (record4.kind === "map") {
+    const entries = requireArray(record4.entries, `${path}.entries`, state);
     entries.forEach((entry, index) => {
       if (!Array.isArray(entry) || entry.length !== 2)
         fail("invalidValue", `${path}.entries[${index}]`, "map entry must contain two values");
     });
   }
-  if (record3.kind === "set") requireArray(record3.values, `${path}.values`, state);
-  if (record3.kind === "regexp-iterator") {
-    if ((record3.global !== void 0 || record3.unicode !== void 0) && (typeof record3.global !== "boolean" || typeof record3.unicode !== "boolean"))
+  if (record4.kind === "set") requireArray(record4.values, `${path}.values`, state);
+  if (record4.kind === "regexp-iterator") {
+    if ((record4.global !== void 0 || record4.unicode !== void 0) && (typeof record4.global !== "boolean" || typeof record4.unicode !== "boolean"))
       fail("invalidValue", path, "invalid RegExp iterator modes");
-    if (typeof record3.exhausted !== "boolean") fail("invalidValue", `${path}.exhausted`, "invalid iterator exhaustion");
-    if (!Object.hasOwn(record3, "matcher") || !Object.hasOwn(record3, "input")) fail("invalidValue", path, "missing RegExp iterator state");
-    requireRecord(record3.entries, `${path}.entries`);
-  }
-  if (record3.kind === "collection-iterator") {
-    if (record3.collectionKind !== "map" && record3.collectionKind !== "set") fail("invalidValue", `${path}.collectionKind`, "invalid iterator brand");
-    if (record3.method !== "keys" && record3.method !== "values" && record3.method !== "entries") fail("invalidValue", `${path}.method`, "invalid iteration method");
-    if (typeof record3.exhausted !== "boolean") fail("invalidValue", `${path}.exhausted`, "invalid iterator exhaustion");
-    requireSafeInteger(record3.index, `${path}.index`, 0);
-    if (!Object.hasOwn(record3, "collection")) fail("invalidValue", `${path}.collection`, "missing iterator source");
-    requireRecord(record3.entries, `${path}.entries`);
-  }
-}
-function validateSymbolEntries(record3, path, state, heap) {
-  if (record3.symbolEntries === void 0) return;
-  if (record3.kind !== "object" && record3.kind !== "array" && record3.kind !== "date" && record3.kind !== "boxed" && record3.kind !== "regex-object" && record3.kind !== "regexp-iterator")
+    if (typeof record4.exhausted !== "boolean") fail("invalidValue", `${path}.exhausted`, "invalid iterator exhaustion");
+    if (!Object.hasOwn(record4, "matcher") || !Object.hasOwn(record4, "input")) fail("invalidValue", path, "missing RegExp iterator state");
+    requireRecord(record4.entries, `${path}.entries`);
+  }
+  if (record4.kind === "collection-iterator") {
+    if (record4.collectionKind !== "map" && record4.collectionKind !== "set") fail("invalidValue", `${path}.collectionKind`, "invalid iterator brand");
+    if (record4.method !== "keys" && record4.method !== "values" && record4.method !== "entries") fail("invalidValue", `${path}.method`, "invalid iteration method");
+    if (typeof record4.exhausted !== "boolean") fail("invalidValue", `${path}.exhausted`, "invalid iterator exhaustion");
+    requireSafeInteger(record4.index, `${path}.index`, 0);
+    if (!Object.hasOwn(record4, "collection")) fail("invalidValue", `${path}.collection`, "missing iterator source");
+    requireRecord(record4.entries, `${path}.entries`);
+  }
+}
+function validateSymbolEntries(record4, path, state, heap) {
+  if (record4.symbolEntries === void 0) return;
+  if (record4.kind !== "object" && record4.kind !== "array" && record4.kind !== "date" && record4.kind !== "boxed" && record4.kind !== "regex-object" && record4.kind !== "regexp-iterator")
     fail("invalidValue", `${path}.symbolEntries`, "symbol properties are unsupported for this heap kind");
-  const entries = requireArray(record3.symbolEntries, `${path}.symbolEntries`, state);
+  const entries = requireArray(record4.symbolEntries, `${path}.symbolEntries`, state);
   const keys = /* @__PURE__ */ new Set();
   entries.forEach((entry, index) => {
     const entryPath = `${path}.symbolEntries[${index}]`;
@@ -24027,24 +24151,24 @@ function validateSymbolEntries(record3, path, state, heap) {
     validateDataDescriptor(requireRecord(entry[1], `${entryPath}[1]`), `${entryPath}[1]`);
   });
 }
-function validateSymbolRecord(record3, path, state) {
-  if (record3.description !== void 0)
-    requireString(record3.description, `${path}.description`, state.limits);
-  if (record3.wellKnown !== void 0) {
-    requireString(record3.wellKnown, `${path}.wellKnown`, state.limits);
-    if (!Object.hasOwn(wellKnownSymbols, String(record3.wellKnown)))
+function validateSymbolRecord(record4, path, state) {
+  if (record4.description !== void 0)
+    requireString(record4.description, `${path}.description`, state.limits);
+  if (record4.wellKnown !== void 0) {
+    requireString(record4.wellKnown, `${path}.wellKnown`, state.limits);
+    if (!Object.hasOwn(wellKnownSymbols, String(record4.wellKnown)))
       fail("invalidValue", `${path}.wellKnown`, "unknown well-known symbol");
-    if (Object.hasOwn(record3, "description"))
+    if (Object.hasOwn(record4, "description"))
       fail("invalidValue", path, "well-known symbol cannot specify a description");
   }
 }
-function validateBoxedRecord(record3, path, heap) {
+function validateBoxedRecord(record4, path, heap) {
   try {
-    validateBoxedProperties(record3);
+    validateBoxedProperties(record4);
   } catch {
     fail("invalidValue", path, "invalid boxed primitive properties");
   }
-  const value = record3.value;
+  const value = record4.value;
   if (typeof value === "number" || typeof value === "string" || typeof value === "boolean") return;
   const number = requireRecord(value, `${path}.value`);
   if (number.kind === "bigint") {
@@ -24064,16 +24188,16 @@ function validateBoxedRecord(record3, path, heap) {
   if (number.kind !== "number" || !["NaN", "Infinity", "-Infinity", "-0"].includes(String(number.value)))
     fail("invalidValue", `${path}.value`, "invalid boxed primitive payload");
 }
-function validateDateRecord(record3, path) {
-  if (Object.keys(record3).some((key) => !["kind", "time", "properties", "symbolEntries", "extensible"].includes(key))) fail("invalidValue", path, "invalid Date fields");
+function validateDateRecord(record4, path) {
+  if (Object.keys(record4).some((key) => !["kind", "time", "properties", "symbolEntries", "extensible"].includes(key))) fail("invalidValue", path, "invalid Date fields");
   try {
-    restoreDateTime(record3.time);
+    restoreDateTime(record4.time);
   } catch {
     fail("invalidValue", `${path}.time`, "invalid Date epoch");
   }
-  if (record3.extensible !== void 0 && typeof record3.extensible !== "boolean") fail("invalidType", `${path}.extensible`, "invalid Date extensibility");
-  if (record3.properties !== void 0) {
-    for (const [key, value] of Object.entries(requireRecord(record3.properties, `${path}.properties`))) {
+  if (record4.extensible !== void 0 && typeof record4.extensible !== "boolean") fail("invalidType", `${path}.extensible`, "invalid Date extensibility");
+  if (record4.properties !== void 0) {
+    for (const [key, value] of Object.entries(requireRecord(record4.properties, `${path}.properties`))) {
       const propertyPath = `${path}.properties${formatKey(key)}`;
       validateDataDescriptor(requireRecord(value, propertyPath), propertyPath);
     }
@@ -24087,14 +24211,14 @@ function validateDataDescriptor(descriptor, path) {
   if (Object.keys(descriptor).some((key) => !["value", "enumerable", "writable", "configurable"].includes(key)))
     fail("invalidValue", path, "unsupported property descriptor field");
 }
-function validateArrayHeap(record3, path, state) {
-  if (Object.hasOwn(record3, "items")) {
-    requireArray(record3.items, `${path}.items`, state);
-    if (Object.hasOwn(record3, "length") || Object.hasOwn(record3, "entries"))
+function validateArrayHeap(record4, path, state) {
+  if (Object.hasOwn(record4, "items")) {
+    requireArray(record4.items, `${path}.items`, state);
+    if (Object.hasOwn(record4, "length") || Object.hasOwn(record4, "entries"))
       fail("invalidValue", path, "array must use either items or length and entries");
     return;
   }
-  const length = requireSafeInteger(record3.length, `${path}.length`, 0);
+  const length = requireSafeInteger(record4.length, `${path}.length`, 0);
   if (length > 4294967295) fail("invalidValue", `${path}.length`, "exceeds maximum array length");
   if (length > state.limits.maxEntries)
     fail(
@@ -24102,7 +24226,7 @@ function validateArrayHeap(record3, path, state) {
       `${path}.length`,
       `exceeds collection entry limit ${state.limits.maxEntries}`
     );
-  const entries = requireRecord(record3.entries, `${path}.entries`);
+  const entries = requireRecord(record4.entries, `${path}.entries`);
   for (const key of Object.keys(entries)) {
     if (key === "length")
       fail("invalidValue", `${path}.entries.length`, "array length is stored separately");
@@ -24111,22 +24235,22 @@ function validateArrayHeap(record3, path, state) {
       fail("invalidValue", `${path}.entries${formatKey(key)}`, "array index exceeds its length");
   }
 }
-function validateErrorType(record3, path) {
-  if (!Object.hasOwn(record3, "errorType")) return;
-  if (record3.kind !== "object" || !sandboxErrorNames.includes(record3.errorType)) {
+function validateErrorType(record4, path) {
+  if (!Object.hasOwn(record4, "errorType")) return;
+  if (record4.kind !== "object" || !sandboxErrorNames.includes(record4.errorType)) {
     fail("invalidValue", `${path}.errorType`, "invalid error metadata");
   }
 }
-function validateArgumentsProperties(record3, path) {
-  if (typeof record3.extensible !== "boolean") {
+function validateArgumentsProperties(record4, path) {
+  if (typeof record4.extensible !== "boolean") {
     fail("invalidType", `${path}.extensible`, "expected boolean");
   }
-  if (typeof record3.lengthBeforeCallee !== "boolean") {
+  if (typeof record4.lengthBeforeCallee !== "boolean") {
     fail("invalidType", `${path}.lengthBeforeCallee`, "expected boolean");
   }
-  const properties = requireRecord(record3.properties, `${path}.properties`);
-  if (record3.iterator !== null) {
-    const iterator = requireRecord(record3.iterator, `${path}.iterator`);
+  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)) {
       if (!["configurable", "enumerable", "writable"].includes(key)) {
         fail(
@@ -24141,7 +24265,7 @@ function validateArgumentsProperties(record3, path) {
         fail("invalidType", `${path}.iterator.${flag}`, "expected boolean");
     }
   }
-  if (record3.lengthBeforeCallee && !Object.hasOwn(properties, "length")) {
+  if (record4.lengthBeforeCallee && !Object.hasOwn(properties, "length")) {
     fail("invalidValue", `${path}.properties`, "initial length property is required");
   }
   for (const [key, value] of Object.entries(properties)) {
@@ -24204,9 +24328,9 @@ function validateGenericValue(value, path, depth, state) {
       );
     }
   } else if (value !== null && typeof value === "object") {
-    const record3 = value;
-    if (state.validateTaggedPayloads && isTaggedValueShape(record3)) {
-      validateTaggedValue(record3, path, state);
+    const record4 = value;
+    if (state.validateTaggedPayloads && isTaggedValueShape(record4)) {
+      validateTaggedValue(record4, path, state);
     }
     const entries = state.dataPropertiesOnly ? snapshotDataEntries(value, path) : Object.entries(value);
     for (const [key, entry] of entries) {
@@ -24715,6 +24839,7 @@ function ownEnumerableSandboxEntries(value, excludedKeys) {
   let entries;
   if (isGuestClosure(value)) entries = Object.entries(value.properties ?? {});
   else if (isSandboxRegex(value)) entries = Object.entries(getRegexProperties(value));
+  else if (isSandboxMap(value) || isSandboxSet(value)) entries = Object.entries(getCollectionProperties(value));
   else if (isSandboxClosure(value) || isSandboxGenerator(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxPromise(value) || isSandboxRegex(value)) return [];
   else entries = Object.entries(Object(value));
   return excludedKeys === void 0 ? entries : entries.filter(([key]) => !excludedKeys.has(key));
@@ -24724,18 +24849,20 @@ function ownSandboxSymbolKeys(value) {
   if (isGuestHostObject(value)) return [];
   if (isSandboxClosure(value)) value = value.properties ?? {};
   else if (isSandboxRegex(value)) value = getRegexProperties(value);
+  else if (isSandboxMap(value) || isSandboxSet(value)) value = getCollectionProperties(value);
   else if (isSandboxGenerator(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxPromise(value) || isSandboxRegex(value)) return [];
   return Object.getOwnPropertySymbols(Object(value)).filter((key) => !internalSymbols.has(key));
 }
 function ownEnumerableSandboxKeys(value, includeSymbols = false) {
   if (includeSymbols) {
-    const properties = isSandboxClosure(value) ? value.properties ?? {} : isSandboxRegex(value) ? getRegexProperties(value) : Object(value);
+    const properties = isSandboxClosure(value) ? value.properties ?? {} : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : Object(value);
     return [...ownEnumerableSandboxKeys(value), ...ownSandboxSymbolKeys(value).filter((key) => Object.getOwnPropertyDescriptor(properties, key)?.enumerable === true)];
   }
   if (isGuestHostObject(value)) return getHostObjectKeys(value);
   if (value === null || value === void 0) throw new TypeError("Cannot convert undefined or null to object.");
   if (isGuestClosure(value)) return Object.keys(value.properties ?? {});
   if (isSandboxRegex(value)) return Object.keys(getRegexProperties(value));
+  if (isSandboxMap(value) || isSandboxSet(value)) return Object.keys(getCollectionProperties(value));
   if (isSandboxClosure(value) || isSandboxGenerator(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxPromise(value) || isSandboxRegex(value)) return [];
   return Object.keys(Object(value));
 }
@@ -24789,6 +24916,7 @@ function createSandboxGenerator(channel, metadata = void 0) {
 }
 function createSandboxMap(entries = []) {
   const map = {};
+  collectionGuestProperties.set(map, /* @__PURE__ */ Object.create(null));
   Object.defineProperties(map, {
     kind: {
       value: "map"
@@ -24805,6 +24933,7 @@ function createSandboxMap(entries = []) {
 }
 function createSandboxSet(values = []) {
   const set = {};
+  collectionGuestProperties.set(set, /* @__PURE__ */ Object.create(null));
   Object.defineProperties(set, {
     kind: {
       value: "set"
@@ -24977,6 +25106,16 @@ function measureSandboxData(values, options = {}) {
       }
       return;
     }
+    if (isSandboxMap(value) || isSandboxSet(value)) {
+      const properties = getCollectionProperties(value);
+      for (const key of Reflect.ownKeys(properties)) {
+        const descriptor = Object.getOwnPropertyDescriptor(properties, key);
+        usage += 1 + (typeof key === "string" ? key.length : 0);
+        if (typeof key === "symbol") 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 (isSandboxMap(value)) {
       usage += value.entries.size;
       for (const [key, entry] of value.entries) {
@@ -25220,6 +25359,7 @@ function copyToSandbox(value, state, path = "<root>", cloneSandboxCollections =
     if (existing !== void 0) return existing;
     const copy = createSandboxMap();
     state.seen.set(value, copy);
+    if (!state.structuredClone) copyCollectionProperties(value, getCollectionProperties(copy), (entry) => copyToSandbox(entry, state, `${path}.<property>`, true, depth + 1));
     for (const [key, entry] of value.entries) {
       copy.entries.set(
         copyToSandbox(key, state, `${path}.<key>`, true, depth + 1),
@@ -25234,6 +25374,7 @@ function copyToSandbox(value, state, path = "<root>", cloneSandboxCollections =
     if (existing !== void 0) return existing;
     const copy = createSandboxSet();
     state.seen.set(value, copy);
+    if (!state.structuredClone) copyCollectionProperties(value, getCollectionProperties(copy), (entry) => copyToSandbox(entry, state, `${path}.<property>`, true, depth + 1));
     for (const entry of value.values) {
       copy.values.add(copyToSandbox(entry, state, `${path}.<value>`, true, depth + 1));
     }
@@ -25292,6 +25433,7 @@ function copyToSandbox(value, state, path = "<root>", cloneSandboxCollections =
     }
     const copy = createSandboxMap();
     state.seen.set(value, copy);
+    if (!state.structuredClone) copyCollectionProperties(value, getCollectionProperties(copy), (entry) => copyToSandbox(entry, state, `${path}.<property>`, cloneSandboxCollections, depth + 1));
     for (const [key, entry] of value) {
       copy.entries.set(
         copyToSandbox(key, state, `${path}.<key>`, cloneSandboxCollections, depth + 1),
@@ -25307,6 +25449,7 @@ function copyToSandbox(value, state, path = "<root>", cloneSandboxCollections =
     }
     const copy = createSandboxSet();
     state.seen.set(value, copy);
+    if (!state.structuredClone) copyCollectionProperties(value, getCollectionProperties(copy), (entry) => copyToSandbox(entry, state, `${path}.<property>`, cloneSandboxCollections, depth + 1));
     for (const entry of value) {
       copy.values.add(
         copyToSandbox(entry, state, `${path}.<value>`, cloneSandboxCollections, depth + 1)
@@ -25515,6 +25658,7 @@ function copyFromSandbox(value, state, path = "<root>", options, depth = 0) {
     }
     const copy = /* @__PURE__ */ new Map();
     state.seen.set(value, copy);
+    copyCollectionProperties(value, copy, (entry) => copyFromSandbox(entry, state, `${path}.<property>`, options, depth + 1));
     for (const [key, entry] of value.entries) {
       copy.set(
         copyFromSandbox(key, state, `${path}.<key>`, options, depth + 1),
@@ -25530,6 +25674,7 @@ function copyFromSandbox(value, state, path = "<root>", options, depth = 0) {
     }
     const copy = /* @__PURE__ */ new Set();
     state.seen.set(value, copy);
+    copyCollectionProperties(value, copy, (entry) => copyFromSandbox(entry, state, `${path}.<property>`, options, depth + 1));
     for (const entry of value.values) {
       copy.add(copyFromSandbox(entry, state, `${path}.<value>`, options, depth + 1));
     }
@@ -25757,12 +25902,12 @@ var HostCallResumabilityError = class extends Error {
   static [Symbol.hasInstance](value) {
     return typeof value === "object" && value !== null && #nativeInstance in value && Function.prototype[Symbol.hasInstance].call(this, value);
   }
-  constructor(record3, action, message) {
+  constructor(record4, action, message) {
     super(message);
     this.name = "HostCallResumabilityError";
     this.action = action;
-    this.callId = record3.id;
-    this.lifecycle = record3.lifecycle;
+    this.callId = record4.id;
+    this.lifecycle = record4.lifecycle;
   }
 };
 var UnresolvedReplayCapabilityError = class extends TypeError {
@@ -25794,33 +25939,33 @@ var HostCallJournal = class {
         );
         const restoredRunId = replayRecords[0]?.runId ?? records[0]?.runId ?? randomUUID();
         validateRestoredRecords(records, restoredRunId, sourceHash);
-        for (const record3 of records) {
-          const replayRecord = replayRecords[readCallOrdinal(record3) - 1];
-          if (replayRecord === void 0 || !callIdentityMatches(record3, replayRecord) || record3.lifecycle !== replayRecord.lifecycle) {
+        for (const record4 of records) {
+          const replayRecord = replayRecords[readCallOrdinal(record4) - 1];
+          if (replayRecord === void 0 || !callIdentityMatches(record4, replayRecord) || record4.lifecycle !== replayRecord.lifecycle) {
             throw new HostCallResumabilityError(
-              record3,
+              record4,
               "reset",
-              `Host call ${record3.id} conflicts with the replay journal; reset is required.`
+              `Host call ${record4.id} conflicts with the replay journal; reset is required.`
             );
           }
         }
         records = replayRecords;
       }
       this.runId = records[0]?.runId ?? randomUUID();
-      this.records = records.map((record3) => ({
-        ...record3,
-        ...record3.functions === void 0 ? {} : { functions: [...record3.functions] },
-        ...record3.callbacks === void 0 ? {} : { callbacks: structuredClone(record3.callbacks) },
-        ...record3.outcome === void 0 ? {} : { outcome: copyOutcome(record3.outcome) }
+      this.records = records.map((record4) => ({
+        ...record4,
+        ...record4.functions === void 0 ? {} : { functions: [...record4.functions] },
+        ...record4.callbacks === void 0 ? {} : { callbacks: structuredClone(record4.callbacks) },
+        ...record4.outcome === void 0 ? {} : { outcome: copyOutcome(record4.outcome) }
       }));
       validateRestoredRecords(this.records, this.runId, sourceHash);
       this.retainedSize = this.records.length;
       try {
         this.budget?.setRetainedDataUsage(this, this.retainedSize);
-        for (const record3 of this.records) {
-          if (record3.outcome !== void 0) this.retainOutcome(record3, record3.outcome);
-          for (const [index, callback] of (record3.callbacks ?? []).entries()) {
-            let size = this.callbackSizes.get(`${record3.id}/callback/${index + 1}`);
+        for (const record4 of this.records) {
+          if (record4.outcome !== void 0) this.retainOutcome(record4, record4.outcome);
+          for (const [index, callback] of (record4.callbacks ?? []).entries()) {
+            let size = this.callbackSizes.get(`${record4.id}/callback/${index + 1}`);
             if (size === void 0) {
               const validation = new CompileScope(operation?.owner);
               try {
@@ -25894,7 +26039,7 @@ var HostCallJournal = class {
   createRecord(input) {
     this.budget?.setRetainedDataUsage(this, this.retainedSize + 1);
     this.retainedSize += 1;
-    const record3 = {
+    const record4 = {
       id: `${this.runId}:${this.nextCall++}`,
       runId: this.runId,
       sourceHash: this.sourceHash,
@@ -25904,65 +26049,65 @@ var HostCallJournal = class {
       policy: input.policy,
       lifecycle: "created"
     };
-    this.records.push(record3);
+    this.records.push(record4);
     this.records.sort((left, right) => readCallOrdinal(left) - readCallOrdinal(right));
-    return record3;
+    return record4;
   }
-  start(record3) {
-    record3.lifecycle = "running";
+  start(record4) {
+    record4.lifecycle = "running";
   }
-  settle(record3, outcome) {
-    if (record3.lifecycle === "cancelled") return;
-    this.retainOutcome(record3, outcome);
-    record3.lifecycle = "settled";
+  settle(record4, outcome) {
+    if (record4.lifecycle === "cancelled") return;
+    this.retainOutcome(record4, outcome);
+    record4.lifecycle = "settled";
   }
-  consume(record3) {
-    if (record3.lifecycle === "consumed") {
+  consume(record4) {
+    if (record4.lifecycle === "consumed") {
       throw new HostCallResumabilityError(
-        record3,
+        record4,
         "reset",
-        `Host call ${record3.id} result was already consumed; reset is required.`
+        `Host call ${record4.id} result was already consumed; reset is required.`
       );
     }
-    if (record3.lifecycle !== "settled") return;
-    record3.lifecycle = "consumed";
+    if (record4.lifecycle !== "settled") return;
+    record4.lifecycle = "consumed";
   }
-  cancel(record3, reason) {
-    if (record3.lifecycle === "settled" || record3.lifecycle === "consumed") return;
-    this.retainOutcome(record3, { status: "rejected", reason });
-    record3.lifecycle = "cancelled";
+  cancel(record4, reason) {
+    if (record4.lifecycle === "settled" || record4.lifecycle === "consumed") return;
+    this.retainOutcome(record4, { status: "rejected", reason });
+    record4.lifecycle = "cancelled";
   }
-  async reconcile(record3, context) {
-    if (record3.lifecycle === "settled" && record3.outcome !== void 0) return record3.outcome;
-    if (record3.lifecycle === "consumed") {
+  async reconcile(record4, context) {
+    if (record4.lifecycle === "settled" && record4.outcome !== void 0) return record4.outcome;
+    if (record4.lifecycle === "consumed") {
       throw new HostCallResumabilityError(
-        record3,
+        record4,
         "reset",
-        `Host call ${record3.id} result was already consumed; reset is required.`
+        `Host call ${record4.id} result was already consumed; reset is required.`
       );
     }
-    if (record3.lifecycle === "cancelled") {
+    if (record4.lifecycle === "cancelled") {
       throw new HostCallResumabilityError(
-        record3,
+        record4,
         "reset",
-        `Host call ${record3.id} was cancelled; reset is required.`
+        `Host call ${record4.id} was cancelled; reset is required.`
       );
     }
-    if (record3.policy === "re-issue") {
+    if (record4.policy === "re-issue") {
       throw new HostCallResumabilityError(
-        record3,
+        record4,
         "reset",
-        `Host call ${record3.id} must be re-issued by the runtime.`
+        `Host call ${record4.id} must be re-issued by the runtime.`
       );
     }
     if (this.resumeProvider === void 0) {
       throw new HostCallResumabilityError(
-        record3,
+        record4,
         "external-reconciliation",
-        `Host call ${record3.id} may have executed before process death; external reconciliation is required.`
+        `Host call ${record4.id} may have executed before process death; external reconciliation is required.`
       );
     }
-    const { id, outcome: ignoredOutcome, ...request } = record3;
+    const { id, outcome: ignoredOutcome, ...request } = record4;
     void ignoredOutcome;
     const proof = await this.resumeProvider(
       {
@@ -25972,23 +26117,23 @@ var HostCallJournal = class {
       },
       context
     );
-    validateProof(record3, proof);
+    validateProof(record4, proof);
     if (context !== void 0 && context.callbacks.size > 0 && proof.callbackDisposition === void 0) {
       throw new HostCallResumabilityError(
-        record3,
+        record4,
         "external-reconciliation",
-        `Host call ${record3.id} has sandbox callbacks; its proof must specify callbackDisposition as joined or detached.`
+        `Host call ${record4.id} has sandbox callbacks; its proof must specify callbackDisposition as joined or detached.`
       );
     }
     if (proof.callbackDisposition === "joined") await context?.waitForCallbacks();
-    this.settle(record3, proof.outcome);
+    this.settle(record4, proof.outcome);
     return proof.outcome;
   }
   snapshot() {
     return this.records.filter(
-      (record3) => record3.policy === "read-side-effect" || record3.lifecycle === "created" || record3.lifecycle === "running" || record3.lifecycle === "cancelled"
-    ).map(({ outcome, ...record3 }) => ({
-      ...structuredClone(record3),
+      (record4) => record4.policy === "read-side-effect" || record4.lifecycle === "created" || record4.lifecycle === "running" || record4.lifecycle === "cancelled"
+    ).map(({ outcome, ...record4 }) => ({
+      ...structuredClone(record4),
       ...outcome === void 0 ? {} : { outcome: copyOutcome(outcome) }
     }));
   }
@@ -26001,12 +26146,12 @@ var HostCallJournal = class {
     this.capabilityWaiters.clear();
     this.budget = void 0;
   }
-  registerCallbackFunction(record3, id, closure, native) {
-    const identity = `${record3.id}/function/${id}`;
+  registerCallbackFunction(record4, id, closure, native) {
+    const identity = `${record4.id}/function/${id}`;
     const existing = this.capabilities.get(identity);
     if (existing !== void 0 && existing !== closure)
       throw new TypeError(`Conflicting replay capability '${identity}'.`);
-    if (!(record3.functions ?? []).includes(id)) (record3.functions ??= []).push(id);
+    if (!(record4.functions ?? []).includes(id)) (record4.functions ??= []).push(id);
     this.capabilities.set(identity, closure);
     this.capabilityWaiters.get(identity)?.resolve();
     this.capabilityWaiters.delete(identity);
@@ -26056,11 +26201,11 @@ var HostCallJournal = class {
     }
     return waiter.promise;
   }
-  trackCallbackCompletion(record3, callbacks) {
+  trackCallbackCompletion(record4, callbacks) {
     const complete = () => {
-      this.completedCallbackOwners.add(record3.id);
+      this.completedCallbackOwners.add(record4.id);
       for (const [id, waiter] of this.capabilityWaiters) {
-        if (!id.startsWith(`${record3.id}/function/`)) continue;
+        if (!id.startsWith(`${record4.id}/function/`)) continue;
         waiter.reject(new UnresolvedReplayCapabilityError(id));
         this.capabilityWaiters.delete(id);
       }
@@ -26068,7 +26213,7 @@ var HostCallJournal = class {
     if (callbacks.length === 0) complete();
     else void Promise.allSettled(callbacks).then(complete);
   }
-  recordCallback(record3, id, args, step) {
+  recordCallback(record4, id, args, step) {
     const retainedSize = this.retainedSize + 1 + measureSandboxData([args], { ignoreClosures: true });
     this.budget?.setRetainedDataUsage(this, retainedSize);
     let data;
@@ -26079,25 +26224,25 @@ var HostCallJournal = class {
       throw error;
     }
     this.retainedSize = retainedSize;
-    (record3.callbacks ??= []).push({ id, step, arguments: data });
-    return `${record3.id}/callback/${record3.callbacks.length}`;
+    (record4.callbacks ??= []).push({ id, step, arguments: data });
+    return `${record4.id}/callback/${record4.callbacks.length}`;
   }
   callbackPositions() {
     const positions = /* @__PURE__ */ new Map();
-    for (const record3 of this.records) {
-      for (const [index, callback] of (record3.callbacks ?? []).entries()) {
-        positions.set(`${record3.id}/callback/${index + 1}`, callback.step);
+    for (const record4 of this.records) {
+      for (const [index, callback] of (record4.callbacks ?? []).entries()) {
+        positions.set(`${record4.id}/callback/${index + 1}`, callback.step);
       }
     }
     return positions;
   }
-  retainOutcome(record3, outcome, budget = this.budget) {
+  retainOutcome(record4, outcome, budget = this.budget) {
     const included = /* @__PURE__ */ new Set();
     const size = measureSandboxData(
       [outcome.status === "fulfilled" ? outcome.value : outcome.reason],
       { ignoreClosures: true, compileTickets: included }
     );
-    const retainedSize = this.retainedSize + size - (this.outcomeSizes.get(record3.id) ?? 0);
+    const retainedSize = this.retainedSize + size - (this.outcomeSizes.get(record4.id) ?? 0);
     budget?.reconcileCompileData(retainedSize, included, included, this);
     let copied;
     try {
@@ -26107,14 +26252,14 @@ var HostCallJournal = class {
       throw error;
     }
     this.retainedSize = retainedSize;
-    this.outcomeSizes.set(record3.id, size);
-    this.outcomes.set(record3.id, copied);
-    record3.outcome = copied;
+    this.outcomeSizes.set(record4.id, size);
+    this.outcomes.set(record4.id, copied);
+    record4.outcome = copied;
   }
-  replayOutcome(record3) {
-    if (!this.recordedReplay || record3.lifecycle !== "settled" && record3.lifecycle !== "consumed")
+  replayOutcome(record4) {
+    if (!this.recordedReplay || record4.lifecycle !== "settled" && record4.lifecycle !== "consumed")
       return void 0;
-    const encoded = this.encodedOutcomes.get(record3.id);
+    const encoded = this.encodedOutcomes.get(record4.id);
     if (encoded !== void 0) {
       const budget = this.compileOwner?.budget ?? this.budget;
       const operation = budget?.acquireCompileOwner(false, this.compileOwner);
@@ -26126,29 +26271,29 @@ var HostCallJournal = class {
           compilation
         );
         const outcome2 = encoded.status === "fulfilled" ? { status: "fulfilled", value } : { status: "rejected", reason: value };
-        this.retainOutcome(record3, outcome2, budget);
+        this.retainOutcome(record4, outcome2, budget);
         return outcome2;
       } finally {
         compilation.dispose();
         operation?.release();
       }
     }
-    const outcome = this.outcomes.get(record3.id);
+    const outcome = this.outcomes.get(record4.id);
     return outcome === void 0 ? void 0 : copyOutcome(outcome);
   }
   snapshotReplay() {
     return structuredClone({
       version: 1,
-      calls: this.records.map(({ outcome: ignoredOutcome, asynchronous, ...record3 }) => {
+      calls: this.records.map(({ outcome: ignoredOutcome, asynchronous, ...record4 }) => {
         void ignoredOutcome;
-        const outcome = this.outcomes.get(record3.id);
+        const outcome = this.outcomes.get(record4.id);
         return {
-          ...record3,
+          ...record4,
           asynchronous: asynchronous === true,
           ...outcome === void 0 ? {} : {
             outcome: {
               status: outcome.status,
-              data: this.encodedOutcomes.get(record3.id)?.data ?? encodeReplayData(
+              data: this.encodedOutcomes.get(record4.id)?.data ?? encodeReplayData(
                 outcome.status === "fulfilled" ? outcome.value : outcome.reason,
                 { identifyCapability: this.identifyCapability }
               )
@@ -26245,79 +26390,79 @@ function restoreReplayCalls(input, encodedOutcomes, callbackSizes, requiredHostC
 function validateRestoredRecords(records, runId, sourceHash) {
   const ids = /* @__PURE__ */ new Set();
   let previousOrdinal = 0;
-  for (const record3 of records) {
-    if (record3.runId !== runId || !record3.id.startsWith(`${runId}:`)) {
+  for (const record4 of records) {
+    if (record4.runId !== runId || !record4.id.startsWith(`${runId}:`)) {
       throw new HostCallResumabilityError(
-        record3,
+        record4,
         "reset",
-        `Host call ${record3.id} does not belong to restored run ${runId}; reset is required.`
+        `Host call ${record4.id} does not belong to restored run ${runId}; reset is required.`
       );
     }
-    if (record3.sourceHash !== sourceHash) {
+    if (record4.sourceHash !== sourceHash) {
       throw new HostCallResumabilityError(
-        record3,
+        record4,
         "reset",
-        `Host call ${record3.id} does not match the restored source; reset is required.`
+        `Host call ${record4.id} does not match the restored source; reset is required.`
       );
     }
-    if (ids.has(record3.id)) {
+    if (ids.has(record4.id)) {
       throw new HostCallResumabilityError(
-        record3,
+        record4,
         "reset",
-        `Host call ${record3.id} appears more than once; reset is required.`
+        `Host call ${record4.id} appears more than once; reset is required.`
       );
     }
-    const ordinal = readCallOrdinal(record3);
+    const ordinal = readCallOrdinal(record4);
     if (ordinal <= previousOrdinal) {
       throw new HostCallResumabilityError(
-        record3,
+        record4,
         "reset",
-        `Host call ${record3.id} is out of order; reset is required.`
+        `Host call ${record4.id} is out of order; reset is required.`
       );
     }
     previousOrdinal = ordinal;
-    ids.add(record3.id);
+    ids.add(record4.id);
   }
 }
-function readCallOrdinal(record3) {
-  const ordinal = Number(record3.id.slice(record3.id.lastIndexOf(":") + 1));
+function readCallOrdinal(record4) {
+  const ordinal = Number(record4.id.slice(record4.id.lastIndexOf(":") + 1));
   if (!Number.isSafeInteger(ordinal) || ordinal < 1) {
     throw new HostCallResumabilityError(
-      record3,
+      record4,
       "reset",
-      `Host call ${record3.id} has an invalid ordinal; reset is required.`
+      `Host call ${record4.id} has an invalid ordinal; reset is required.`
     );
   }
   return ordinal;
 }
-function callIdentityMatches(record3, input) {
-  return record3.moduleId === input.moduleId && record3.operation === input.operation && record3.argumentDigest === input.argumentDigest && record3.policy === input.policy;
+function callIdentityMatches(record4, input) {
+  return record4.moduleId === input.moduleId && record4.operation === input.operation && record4.argumentDigest === input.argumentDigest && record4.policy === input.policy;
 }
 function digestHostCallArguments(args) {
   return createHash("sha256").update(stableStringify(args)).digest("hex");
 }
-function validateProof(record3, proof) {
+function validateProof(record4, proof) {
   if (proof.callbackDisposition !== void 0 && proof.callbackDisposition !== "joined" && proof.callbackDisposition !== "detached") {
     throw new HostCallResumabilityError(
-      record3,
+      record4,
       "external-reconciliation",
       "Invalid callbackDisposition in external result proof."
     );
   }
   if (!pendingHostCallResumeIdentityMatches(
     {
-      argumentDigest: record3.argumentDigest,
-      callId: record3.id,
-      moduleId: record3.moduleId,
-      operation: record3.operation,
-      sourceHash: record3.sourceHash
+      argumentDigest: record4.argumentDigest,
+      callId: record4.id,
+      moduleId: record4.moduleId,
+      operation: record4.operation,
+      sourceHash: record4.sourceHash
     },
     proof
   )) {
     throw new HostCallResumabilityError(
-      record3,
+      record4,
       "external-reconciliation",
-      `External result proof does not match host call ${record3.id}.`
+      `External result proof does not match host call ${record4.id}.`
     );
   }
 }
@@ -26426,7 +26571,7 @@ function hashParsedAst(ast, includeFunctionSource = true) {
         write(JSON.stringify(value));
         return;
       case "object": {
-        const record3 = value;
+        const record4 = value;
         const source = includeFunctionSource ? functionSources.get(value) : void 0;
         if (source !== void 0 && !(enclosingSource !== void 0 && source.text === enclosingSource.text && source.start >= enclosingSource.start && source.end <= enclosingSource.end)) {
           write("function-source:");
@@ -26434,14 +26579,14 @@ function hashParsedAst(ast, includeFunctionSource = true) {
           write(":");
           write(source.text, source.start, source.end);
         }
-        const keys = Object.keys(value).filter((key) => shouldHashKey(record3, key, includeTemplateRaw)).sort();
+        const keys = Object.keys(value).filter((key) => shouldHashKey(record4, key, includeTemplateRaw)).sort();
         write("{");
         for (const key of keys) {
           write(JSON.stringify(key));
           write(":");
           visit(
-            record3[key],
-            shouldIncludeTemplateRaw(record3, key, includeTemplateRaw),
+            record4[key],
+            shouldIncludeTemplateRaw(record4, key, includeTemplateRaw),
             source ?? enclosingSource
           );
           write(",");
@@ -26460,20 +26605,20 @@ function hashParsedAst(ast, includeFunctionSource = true) {
     }
   }
 }
-function shouldHashKey(record3, key, includeTemplateRaw) {
+function shouldHashKey(record4, key, includeTemplateRaw) {
   if (key !== "raw") {
     return !IGNORED_KEYS.has(key);
   }
-  return includeTemplateRaw || record3.type === "RegexLiteral";
+  return includeTemplateRaw || record4.type === "RegexLiteral";
 }
-function shouldIncludeTemplateRaw(record3, key, includeTemplateRaw) {
-  if (record3.type === "TaggedTemplateExpression" && key === "quasi") {
+function shouldIncludeTemplateRaw(record4, key, includeTemplateRaw) {
+  if (record4.type === "TaggedTemplateExpression" && key === "quasi") {
     return true;
   }
-  if (includeTemplateRaw && record3.type === "TemplateLiteral" && key === "quasis") {
+  if (includeTemplateRaw && record4.type === "TemplateLiteral" && key === "quasis") {
     return true;
   }
-  if (includeTemplateRaw && record3.type === "TemplateElement" && key === "value") {
+  if (includeTemplateRaw && record4.type === "TemplateElement" && key === "value") {
     return true;
   }
   return false;
@@ -26630,11 +26775,11 @@ function restore(snapshot, options, owner) {
         for (const entry of Object.values(node)) pending.push(entry);
       }
       for (const [id, value] of closures) {
-        const record3 = value;
-        if (record3.kind === "guest-array") continue;
-        const origin = functions.get(record3.astNodeId);
+        const record4 = value;
+        if (record4.kind === "guest-array") continue;
+        const origin = functions.get(record4.astNodeId);
         try {
-          validateGuestFunctionAst(record3, origin);
+          validateGuestFunctionAst(record4, origin);
         } catch (error) {
           throw new SnapshotValidationError("invalidValue", `$.heap[${JSON.stringify(id)}].astNodeId`, error instanceof Error ? error.message : String(error));
         }
@@ -38229,8 +38374,8 @@ var RealmState = class {
     this.assertOpen();
     const closure = readGuestCallback(callback, this);
     this.checkCollection(this.pendingCallbacks.size + 1, this.limits.callbacks, "pending callback");
-    const record3 = { closure };
-    this.pendingCallbacks.add(record3);
+    const record4 = { closure };
+    this.pendingCallbacks.add(record4);
     const invoke = async () => {
       this.assertOpen();
       readGuestCallback(callback, this);
@@ -38271,13 +38416,13 @@ var RealmState = class {
           )
         )
       );
-      record3.promise = active ? pending : this.perform(() => pending);
-      return await record3.promise;
+      record4.promise = active ? pending : this.perform(() => pending);
+      return await record4.promise;
     } catch (error) {
       if (error instanceof SandboxError) this.poison(error);
       throw error;
     } finally {
-      this.pendingCallbacks.delete(record3);
+      this.pendingCallbacks.delete(record4);
       if (!this.closed && this.active === void 0)
         reconcileCompiledValues(
           this.budget,
@@ -39727,7 +39872,7 @@ function readHostCallSnapshot(snapshot) {
     if (typeof value !== "object" || value === null) {
       throw new TypeError(`Snapshot hostCalls[${index}] must be an object.`);
     }
-    const record3 = value;
+    const record4 = value;
     const requiredStrings = [
       "id",
       "runId",
@@ -39737,23 +39882,23 @@ function readHostCallSnapshot(snapshot) {
       "argumentDigest"
     ];
     for (const key of requiredStrings) {
-      if (typeof record3[key] !== "string" || record3[key].length === 0) {
+      if (typeof record4[key] !== "string" || record4[key].length === 0) {
         throw new TypeError(`Snapshot hostCalls[${index}].${key} must be a non-empty string.`);
       }
     }
-    if (record3.sourceHash !== snapshot.sourceHash) {
+    if (record4.sourceHash !== snapshot.sourceHash) {
       throw new TypeError(`Snapshot hostCalls[${index}].sourceHash must match the snapshot.`);
     }
-    if (record3.policy !== "re-issue" && record3.policy !== "read-side-effect") {
+    if (record4.policy !== "re-issue" && record4.policy !== "read-side-effect") {
       throw new TypeError(`Snapshot hostCalls[${index}].policy is invalid.`);
     }
-    if (record3.lifecycle !== "created" && record3.lifecycle !== "running" && record3.lifecycle !== "settled" && record3.lifecycle !== "consumed" && record3.lifecycle !== "cancelled") {
+    if (record4.lifecycle !== "created" && record4.lifecycle !== "running" && record4.lifecycle !== "settled" && record4.lifecycle !== "consumed" && record4.lifecycle !== "cancelled") {
       throw new TypeError(`Snapshot hostCalls[${index}].lifecycle is invalid.`);
     }
-    if ((record3.lifecycle === "settled" || record3.lifecycle === "cancelled") && record3.outcome === void 0) {
+    if ((record4.lifecycle === "settled" || record4.lifecycle === "cancelled") && record4.outcome === void 0) {
       throw new TypeError(`Snapshot hostCalls[${index}].outcome is required.`);
     }
-    return record3;
+    return record4;
   });
 }
 function hasLoopIterationSnapshot(snapshot) {
@@ -39815,4 +39960,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-A2FDFKJ6.js.map
+//# sourceMappingURL=chunk-KBUVHGDL.js.map