@poe-platform/safe-js 0.1.221 → 0.1.223

package/dist/safe-js/chunks/{chunk-VVZQNTZ6.js → chunk-JJKJAB53.js}

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-7DK7CIUK.js";
+} from "./chunk-PEHO3DVD.js";
 
 // packages/safe-js/src/migrate.ts
 import { createHash } from "node:crypto";
@@ -8249,4 +8249,4 @@ export {
   parseMcpConfig,
   makeMcpModule
 };
-//# sourceMappingURL=chunk-VVZQNTZ6.js.map
+//# sourceMappingURL=chunk-JJKJAB53.js.map

package/dist/safe-js/chunks/{chunk-7DK7CIUK.js → chunk-PEHO3DVD.js}

@@ -138,6 +138,47 @@ function findSourceOffset(source, line, column) {
   return source.length;
 }
 
+// packages/safe-js/src/interp/template-objects.ts
+var realms = /* @__PURE__ */ new WeakMap();
+var templateOrigins = /* @__PURE__ */ new WeakMap();
+var templateRawArrays = /* @__PURE__ */ new WeakMap();
+var templateCookedArrays = /* @__PURE__ */ new WeakMap();
+function templateObject(node, budget) {
+  const cached = realms.get(budget)?.get(node);
+  if (cached !== void 0) return cached;
+  budget.allocateArrayLength(node.quasis.length);
+  const strings = node.quasis.map((quasi) => quasi.value.cooked === void 0 ? void 0 : budget.allocateString(quasi.value.cooked));
+  const raw = node.quasis.map((quasi) => budget.allocateString(quasi.value.raw));
+  Object.freeze(raw);
+  Object.defineProperty(strings, "raw", { value: raw });
+  Object.freeze(strings);
+  registerTemplateObject(node, strings, budget);
+  return strings;
+}
+function registerTemplateObject(node, value, budget) {
+  const raw = Object.getOwnPropertyDescriptor(value, "raw")?.value;
+  if (!Object.isFrozen(value) || !Array.isArray(raw) || !Object.isFrozen(raw) || value.length !== node.quasis.length || raw.length !== node.quasis.length || node.quasis.some((quasi, index) => Object.getOwnPropertyDescriptor(value, String(index))?.value !== quasi.value.cooked || Object.getOwnPropertyDescriptor(raw, String(index))?.value !== quasi.value.raw))
+    throw new TypeError("Invalid template object contents.");
+  let realm = realms.get(budget);
+  const existing = realm?.get(node);
+  if (existing !== void 0 && existing !== value) throw new TypeError("Conflicting template object identity.");
+  if (realm === void 0) {
+    realm = /* @__PURE__ */ new Map();
+    realms.set(budget, realm);
+    const retained = realm;
+    budget.setRetainedValues(realm, () => retained.values());
+  }
+  realm.set(node, value);
+  templateOrigins.set(value, node);
+  templateRawArrays.set(value, raw);
+  templateCookedArrays.set(raw, value);
+}
+function releaseTemplateObjects(budget) {
+  const realm = realms.get(budget);
+  if (realm !== void 0) budget.setRetainedValues(realm, void 0);
+  realms.delete(budget);
+}
+
 // packages/safe-js/src/interp/budget.ts
 var REGEX_STEP_LIMIT = 2e3;
 var REGEX_COMPILE_LIMITS = Object.freeze({
@@ -391,6 +432,7 @@ var Budget = class {
   }
   reset() {
     if (this.compileUses !== 0) throw new SandboxError("reentry");
+    releaseTemplateObjects(this);
     this.compileGeneration += 1;
     this.defaultCompileOwner = void 0;
     this.provisionalScopes = 0;
@@ -6860,9 +6902,9 @@ function exportDate(value) {
   return new NativeDate(dateTime(value));
 }
 function dateDataProperties(value) {
-  const descriptors = Object.getOwnPropertyDescriptors(value);
-  return Reflect.ownKeys(descriptors).map((key) => {
-    const descriptor = Object.getOwnPropertyDescriptor(descriptors, key).value;
+  const descriptors2 = Object.getOwnPropertyDescriptors(value);
+  return Reflect.ownKeys(descriptors2).map((key) => {
+    const descriptor = Object.getOwnPropertyDescriptor(descriptors2, key).value;
     if (!("value" in descriptor)) throw new TypeError("Date accessor properties cannot be copied as data.");
     return [key, descriptor];
   });
@@ -7159,9 +7201,9 @@ function primitiveReceiver(value, kind) {
 }
 function boxedDataProperties(value, includeSymbols = false) {
   const primitive = nativeBoxedValue(value);
-  const descriptors = Object.getOwnPropertyDescriptors(value);
-  const keys = includeSymbols ? Reflect.ownKeys(descriptors) : Object.keys(descriptors);
-  return keys.map((key) => [key, Object.getOwnPropertyDescriptor(descriptors, key).value]).filter(([key]) => {
+  const descriptors2 = Object.getOwnPropertyDescriptors(value);
+  const keys = includeSymbols ? Reflect.ownKeys(descriptors2) : Object.keys(descriptors2);
+  return keys.map((key) => [key, Object.getOwnPropertyDescriptor(descriptors2, key).value]).filter(([key]) => {
     if (typeof key === "symbol") return true;
     if (typeof primitive !== "string") return true;
     if (key === "length") return false;
@@ -7910,10 +7952,10 @@ function getGeneratorOrigin(value) {
 
 // packages/safe-js/src/interp/intrinsics.ts
 var identities = /* @__PURE__ */ new WeakMap();
-var realms = /* @__PURE__ */ new WeakMap();
+var realms2 = /* @__PURE__ */ new WeakMap();
 function registerBuiltinIdentities(budget, bindings) {
-  let realm = realms.get(budget);
-  if (realm === void 0) realms.set(budget, realm = /* @__PURE__ */ new Map());
+  let realm = realms2.get(budget);
+  if (realm === void 0) realms2.set(budget, realm = /* @__PURE__ */ new Map());
   const pending = Object.entries(bindings).map(([name, value]) => [[name], value]);
   const visited = /* @__PURE__ */ new WeakSet();
   for (let index = 0; index < pending.length; index++) {
@@ -7948,15 +7990,15 @@ function getIntrinsicIdentity(value) {
   return identities.get(value);
 }
 function resolveIntrinsicIdentity(budget, id) {
-  const value = realms.get(budget)?.get(id);
+  const value = realms2.get(budget)?.get(id);
   if (value === void 0) throw new TypeError(`Unknown intrinsic identity: ${id}`);
   return value;
 }
 function listIntrinsicIdentities(budget) {
-  return [...realms.get(budget)?.keys() ?? []];
+  return [...realms2.get(budget)?.keys() ?? []];
 }
 function releaseIntrinsicIdentities(budget) {
-  realms.delete(budget);
+  realms2.delete(budget);
 }
 
 // packages/safe-js/src/interp/object-model.ts
@@ -8074,23 +8116,24 @@ function registerIntrinsicPrototype(budget, prototype, constructor) {
   const unchanged = (before, after) => before !== void 0 && after !== void 0 && Object.is(before.value, after.value) && before.get === after.get && before.set === after.set && before.writable === after.writable && before.configurable === after.configurable && before.enumerable === after.enumerable;
   intrinsicConstructors.set(
     constructor,
-    () => records.every(({ target, value, descriptors, prototype: parent, explicit, extensible }) => {
+    () => records.every(({ target, value, descriptors: descriptors2, prototype: parent, explicit, extensible }) => {
       const current = Object.getOwnPropertyDescriptors(value);
-      return getSandboxPrototype(target) === parent && Object.isExtensible(value) === extensible && hasExplicitSandboxPrototype(target) === explicit && Reflect.ownKeys(current).length === descriptors.size && Reflect.ownKeys(value).every((key) => unchanged(descriptors.get(key), Object.getOwnPropertyDescriptor(value, key)));
+      return getSandboxPrototype(target) === parent && Object.isExtensible(value) === extensible && hasExplicitSandboxPrototype(target) === explicit && Reflect.ownKeys(current).length === descriptors2.size && Reflect.ownKeys(value).every((key) => unchanged(descriptors2.get(key), Object.getOwnPropertyDescriptor(value, key)));
     })
   );
   budget.setRetainedValues(
     prototype,
-    () => records.flatMap(({ target, value, descriptors, prototype: parent }) => [
+    () => records.flatMap(({ target, value, descriptors: descriptors2, prototype: parent }) => [
       ...getSandboxPrototype(target) === parent ? [] : [getSandboxPrototype(target)],
       ...Reflect.ownKeys(value).flatMap((key) => {
         const descriptor = Object.getOwnPropertyDescriptor(value, key);
-        return unchanged(descriptors.get(key), descriptor) ? [] : [key, descriptor.value, ...retainedAccessorClosures(descriptor)];
+        return unchanged(descriptors2.get(key), descriptor) ? [] : [key, descriptor.value, ...retainedAccessorClosures(descriptor)];
       })
     ])
   );
 }
 function releaseObjectPrototype(budget) {
+  releaseTemplateObjects(budget);
   releaseIntrinsicIdentities(budget);
   for (const prototype of intrinsicPrototypeRoots.get(budget) ?? []) budget.setRetainedValues(prototype, void 0);
   intrinsicPrototypeRoots.delete(budget);
@@ -8555,6 +8598,20 @@ function captureGuestHeapNode(value, encode) {
   }
   const origin = getClosureOrigin(value);
   if (origin === void 0) {
+    if (Array.isArray(value) && Object.values(Object.getOwnPropertyDescriptors(value)).some((descriptor) => !("value" in descriptor) && retainedAccessorClosures(descriptor).length !== Number(descriptor.get !== void 0) + Number(descriptor.set !== void 0))) return void 0;
+    if (Array.isArray(value) && (!Object.isExtensible(value) || hasExplicitSandboxPrototype(value) || Reflect.ownKeys(value).some((key) => {
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      return key === "length" ? descriptor.writable !== true : !("value" in descriptor) || !descriptor.enumerable || !descriptor.configurable || !descriptor.writable;
+    }))) {
+      const templateNodeId = templateOrigins.get(value)?.nodeId;
+      const templateOwner = templateCookedArrays.get(value);
+      return {
+        kind: "guest-array",
+        state: captureObjectState(value, encode),
+        ...templateNodeId === void 0 ? {} : { templateNodeId },
+        ...templateOwner === void 0 ? {} : { templateOwner: encode(templateOwner) }
+      };
+    }
     if (isLiveCapability(value) || isSandboxClosure(value) || isSandboxBox(value) || isSandboxDate(value) || isSandboxRegex(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxPromise(value) || isSandboxGenerator(value) || isSandboxArguments(value) || isSandboxCollectionIterator(value) || isSandboxRegExpIterator(value)) return void 0;
     const prototype = Object.getPrototypeOf(value);
     if ((prototype === null || prototype === Object.prototype) && hasGuestObjectState(value))
@@ -13512,11 +13569,11 @@ function createObjectArrayGlobals(options) {
         getOwnPropertyDescriptors: createSandboxClosure({
           sandbox: true,
           call: ([value]) => {
-            const descriptors = /* @__PURE__ */ Object.create(null);
+            const descriptors2 = /* @__PURE__ */ Object.create(null);
             const properties = objectProperties(value);
             for (const key of [...Object.getOwnPropertyNames(properties), ...ownSandboxSymbolKeys(value)])
-              defineOwnDataProperty(descriptors, key, exposePropertyDescriptor(Object.getOwnPropertyDescriptor(properties, key)));
-            return allocateProducedSandboxValue(descriptors, options.budget);
+              defineOwnDataProperty(descriptors2, key, exposePropertyDescriptor(Object.getOwnPropertyDescriptor(properties, key)));
+            return allocateProducedSandboxValue(descriptors2, options.budget);
           },
           name: "getOwnPropertyDescriptors"
         }),
@@ -13547,8 +13604,8 @@ function createObjectArrayGlobals(options) {
         }),
         defineProperties: createSandboxClosure({
           sandbox: true,
-          call: async ([value, descriptors], context) => {
-            await definePropertiesFromObject(value, descriptors, options.budget, context);
+          call: async ([value, descriptors2], context) => {
+            await definePropertiesFromObject(value, descriptors2, options.budget, context);
             return value;
           },
           name: "defineProperties"
@@ -13577,12 +13634,12 @@ function createObjectArrayGlobals(options) {
         }),
         create: createSandboxClosure({
           sandbox: true,
-          call: async ([prototype, descriptors], context) => {
+          call: async ([prototype, descriptors2], context) => {
             if (prototype !== null) objectProperties(prototype);
             const value = /* @__PURE__ */ Object.create(null);
             setSandboxPrototype(value, prototype, options.budget);
-            if (descriptors !== void 0) {
-              await definePropertiesFromObject(value, descriptors, options.budget, context);
+            if (descriptors2 !== void 0) {
+              await definePropertiesFromObject(value, descriptors2, options.budget, context);
             }
             return allocateProducedSandboxValue(value, options.budget);
           },
@@ -13931,19 +13988,19 @@ async function propertyDescriptor(input, budget, context) {
     release();
   }
 }
-async function definePropertiesFromObject(target, descriptors, budget, context) {
+async function definePropertiesFromObject(target, descriptors2, budget, context) {
   objectProperties(target, true);
   const properties = [];
   const release = retainValues(budget, () => [
     target,
-    descriptors,
+    descriptors2,
     properties,
     ...properties.flatMap(([, descriptor]) => retainedAccessorClosures(descriptor))
   ]);
   try {
-    for (const key of ownEnumerableSandboxKeys(descriptors, true)) {
-      if (!hasOwnSandboxProperty(descriptors, key, true)) continue;
-      const descriptor = await (context?.getProperty !== void 0 ? context.getProperty(descriptors, key) : getSandboxDataProperty(descriptors, key, budget));
+    for (const key of ownEnumerableSandboxKeys(descriptors2, true)) {
+      if (!hasOwnSandboxProperty(descriptors2, key, true)) continue;
+      const descriptor = await (context?.getProperty !== void 0 ? context.getProperty(descriptors2, key) : getSandboxDataProperty(descriptors2, key, budget));
       properties.push([key, await propertyDescriptor(descriptor, budget, context)]);
     }
     for (const [key, descriptor] of properties) defineDataProperty(target, key, descriptor, budget);
@@ -16174,7 +16231,6 @@ function relativeIndex(value, length, fallback) {
 }
 
 // packages/safe-js/src/interp/interpreter.ts
-var taggedTemplateRawArrays = /* @__PURE__ */ new WeakMap();
 var dispatchTable = {
   ArrayExpression: evaluateArrayExpression,
   AssignmentExpression: evaluateAssignmentExpression,
@@ -16649,7 +16705,7 @@ async function evaluateTaggedTemplateExpression(node, context) {
         hasValue: true,
         value: await invokeSandboxClosure(
           tag2,
-          [createTaggedTemplateStrings(node.quasi, context), ...values.value],
+          [templateObject(node.quasi, context.budget), ...values.value],
           context,
           [...context.callStack, formatStackFrame(node, tag2.name)],
           node.span,
@@ -16674,24 +16730,6 @@ async function evaluateTaggedTemplateExpression(node, context) {
   const tag = await evaluateNode(node.tag, context);
   return tag.kind === "normal" ? invokeTag(tag.value, void 0) : tag;
 }
-function createTaggedTemplateStrings(node, context) {
-  context.budget.allocateArrayLength(node.quasis.length);
-  const strings = node.quasis.map(
-    (quasi) => quasi.value.cooked === void 0 ? void 0 : context.budget.allocateString(quasi.value.cooked)
-  );
-  context.budget.allocateArrayLength(node.quasis.length);
-  const raw = node.quasis.map(
-    (quasi) => context.budget.allocateString(quasi.value.raw)
-  );
-  Object.defineProperty(strings, "raw", {
-    configurable: false,
-    enumerable: false,
-    value: raw,
-    writable: false
-  });
-  taggedTemplateRawArrays.set(strings, raw);
-  return strings;
-}
 async function evaluateArrowFunction(node, context) {
   return evaluateArrowFunctionExpression(node, context, evaluateNode);
 }
@@ -18891,8 +18929,8 @@ function getMemberValue(target, property, context) {
 }
 function getArrayMemberValue(target, property, context) {
   if (hasExplicitSandboxPrototype(target)) return void 0;
-  if (property === "raw" && taggedTemplateRawArrays.has(target)) {
-    return taggedTemplateRawArrays.get(target);
+  if (property === "raw" && templateRawArrays.has(target)) {
+    return templateRawArrays.get(target);
   }
   return getArrayMember(target, property, createArrayMethodOptions(context));
 }
@@ -22290,9 +22328,9 @@ function absent(value) {
   const node = record2(value);
   return node.kind === "undefined" && Object.keys(node).length === 1;
 }
-function validateGuestHeapNode(raw, heap) {
+function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
   const node = record2(raw);
-  if (!["intrinsic", "guest-function", "guest-generator", "scope-frame", "guest-object"].includes(String(node.kind))) return false;
+  if (!["intrinsic", "guest-function", "guest-generator", "scope-frame", "guest-object", "guest-array"].includes(String(node.kind))) return false;
   const reference = (value, kinds) => {
     const ref = record2(value);
     fields(ref, ["kind", "id"]);
@@ -22342,9 +22380,25 @@ function validateGuestHeapNode(raw, heap) {
     fields(node, ["kind", "id"], ["state"]);
     if (typeof node.id !== "string" || !intrinsicCatalogue().has(node.id)) throw new TypeError("Unknown intrinsic identity.");
     if (Object.hasOwn(node, "state")) state(node.state);
-  } else if (node.kind === "guest-object") {
-    fields(node, ["kind", "state"]);
+  } else if (node.kind === "guest-object" || node.kind === "guest-array") {
+    fields(node, ["kind", "state"], node.kind === "guest-array" ? ["templateNodeId", "templateOwner"] : []);
+    if (Object.hasOwn(node, "templateOwner")) reference(node.templateOwner, ["guest-array"]);
+    if (Object.hasOwn(node, "templateNodeId") && integer(node.templateNodeId) < 1)
+      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 length = properties.find((entry) => entry[0] === "length");
+      if (length === void 0) throw new TypeError("Missing guest array length.");
+      const descriptor = record2(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) {
+        if (typeof key !== "string") continue;
+        const index = Number(key);
+        if (Number.isInteger(index) && index >= 0 && index < 4294967295 && String(index) === key && index >= descriptor.value) throw new TypeError("Guest array index exceeds length.");
+      }
+    }
   } else if (node.kind === "guest-function") {
     fields(node, ["kind", "astNodeId", "scope", "state"], ["name", "environment"]);
     if (integer(node.astNodeId) < 1) throw new TypeError("Invalid guest AST identity.");
@@ -22387,17 +22441,17 @@ function validateGuestHeapNode(raw, heap) {
         } else if (expression.kind === "array") {
           fields(expression, ["kind", "values", "index"]);
           integer(expression.index);
-          reference(expression.values, ["array"]);
+          reference(expression.values, ["array", "guest-array"]);
         } else if (expression.kind === "call" || expression.kind === "new" || expression.kind === "tagged") {
           fields(expression, ["kind", "callee", "thisValue", "args", "index"]);
           integer(expression.index);
-          reference(expression.args, ["array"]);
+          reference(expression.args, ["array", "guest-array"]);
         } else if (expression.kind === "array-call") {
           fields(expression, ["kind", "target", "method", "args", "index"]);
           if (typeof expression.method !== "string") throw new TypeError("Invalid array method.");
           integer(expression.index);
-          reference(expression.args, ["array"]);
-          reference(expression.target, ["array"]);
+          reference(expression.args, ["array", "guest-array"]);
+          reference(expression.target, ["array", "guest-array"]);
         } else throw new TypeError("Invalid expression continuation.");
       }
     }
@@ -22582,6 +22636,61 @@ function validateGuestFunctionAst(record3, origin) {
   }
 }
 
+// packages/safe-js/src/snapshot/template-validation.ts
+function validateTemplateObjects(heap, nodes) {
+  const sites = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    if (node.type === "TaggedTemplateExpression" && node.quasi.nodeId !== void 0)
+      sites.set(node.quasi.nodeId, node.quasi);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const rawOwners = /* @__PURE__ */ new Map();
+  for (const raw of Object.values(heap)) {
+    const entry = raw;
+    if (entry.kind !== "guest-array" || entry.templateNodeId === void 0) continue;
+    const node = sites.get(entry.templateNodeId);
+    if (node === void 0 || seen.has(entry.templateNodeId)) throw new TypeError("Invalid or duplicate template source identity.");
+    seen.add(entry.templateNodeId);
+    const cooked = descriptors(entry.state);
+    const rawReference = cooked.get("raw")?.value;
+    const rawArray = rawReference?.kind === "ref" ? heap[String(rawReference.id)] : void 0;
+    if (rawArray?.kind !== "guest-array") throw new TypeError("Invalid template raw array.");
+    if (rawOwners.has(rawArray) && rawOwners.get(rawArray) !== raw) throw new TypeError("Conflicting template raw identity.");
+    rawOwners.set(rawArray, raw);
+    checkArray(cooked, node.quasis.map((quasi) => quasi.value.cooked), true);
+    checkArray(descriptors(rawArray.state), node.quasis.map((quasi) => quasi.value.raw), false);
+  }
+  for (const [raw, owner] of rawOwners) {
+    const reference = raw.templateOwner;
+    if (reference === void 0 || heap[String(reference.id)] !== owner)
+      throw new TypeError("Missing or invalid template owner identity.");
+  }
+  for (const raw of Object.values(heap)) {
+    const entry = raw;
+    if (entry.templateOwner !== void 0 && rawOwners.get(raw) !== heap[String(entry.templateOwner.id)])
+      throw new TypeError("Invalid template owner identity.");
+  }
+}
+function descriptors(raw) {
+  const state = raw;
+  if (Object.hasOwn(state, "prototype") || state.properties.extensible !== false)
+    throw new TypeError("Invalid template object state.");
+  return new Map(state.properties.properties);
+}
+function checkArray(properties, values, cooked) {
+  if (properties.size !== values.length + (cooked ? 2 : 1)) throw new TypeError("Invalid template property count.");
+  const expected = new Map(values.map((value, index) => [String(index), value]));
+  expected.set("length", values.length);
+  if (cooked) expected.set("raw", properties.get("raw")?.value);
+  for (const [key, value] of expected) {
+    const descriptor = properties.get(key);
+    const actual = descriptor?.value;
+    const equal = value === void 0 ? actual !== null && typeof actual === "object" && actual.kind === "undefined" : actual === value;
+    if (descriptor?.kind !== "data" || descriptor.configurable !== false || descriptor.writable !== false || descriptor.enumerable !== (key !== "length" && key !== "raw") || !equal)
+      throw new TypeError("Invalid template property descriptor or contents.");
+  }
+}
+
 // packages/safe-js/src/snapshot/validation.ts
 var DEFAULT_MAX_DEPTH = MAX_DATA_DEPTH;
 var DEFAULT_MAX_ENTRIES = 1e5;
@@ -22660,7 +22769,7 @@ function validateDumpHeap(root, state) {
     validateErrorType(entry, path);
     validateSymbolEntries(entry, path, state, heap);
     try {
-      if (validateGuestHeapNode(entry, heap)) {
+      if (validateGuestHeapNode(entry, heap, state.limits.maxEntries)) {
         if (root.version !== 2) fail("unsupportedVersion", path, "guest heap records require dump version 2");
         continue;
       }
@@ -22889,7 +22998,7 @@ function validateGeneratorShape(record3, path, state) {
 function validateHeapValue(value, path, state, heap) {
   const record3 = requireRecord(value, path);
   try {
-    if (validateGuestHeapNode(record3, heap)) {
+    if (validateGuestHeapNode(record3, heap, state.limits.maxEntries)) {
       const tagged = state.validateTaggedPayloads;
       state.validateTaggedPayloads = false;
       try {
@@ -23853,8 +23962,8 @@ function measureSandboxData(values, options = {}) {
     seen.add(value);
     usage += 1;
     if (!isGuestHostObject(value)) {
-      const descriptors2 = Object.getOwnPropertySymbols(value).filter((key) => !internalSymbols.has(key)).map((key) => [key, Object.getOwnPropertyDescriptor(value, key)]);
-      for (const [key, descriptor] of descriptors2) {
+      const descriptors3 = Object.getOwnPropertySymbols(value).filter((key) => !internalSymbols.has(key)).map((key) => [key, Object.getOwnPropertyDescriptor(value, key)]);
+      for (const [key, descriptor] of descriptors3) {
         usage += 1;
         visit(key, depth + 1);
         if ("value" in descriptor) visit(descriptor.value, depth + 1);
@@ -23990,16 +24099,16 @@ function measureSandboxData(values, options = {}) {
       }
       return;
     }
-    const descriptors = Object.getOwnPropertyDescriptors(value);
-    const keys = Object.keys(descriptors);
+    const descriptors2 = Object.getOwnPropertyDescriptors(value);
+    const keys = Object.keys(descriptors2);
     const includeNonEnumerable = isSandboxDate(value) || hasManagedDescriptors(value);
     let entryCount = 0;
     for (const key of keys) {
-      if (descriptors[key].enumerable || includeNonEnumerable) entryCount += 1;
+      if (descriptors2[key].enumerable || includeNonEnumerable) entryCount += 1;
     }
     usage += entryCount;
     for (const key of keys) {
-      const descriptor = descriptors[key];
+      const descriptor = descriptors2[key];
       if (!descriptor.enumerable && !includeNonEnumerable) continue;
       usage += key.length;
       if ("value" in descriptor) visit(descriptor.value, depth + 1);
@@ -24607,11 +24716,11 @@ function defineOwnDataProperty(target, key, value) {
   });
 }
 function getEnumerableObjectEntries(value, path) {
-  const descriptors = Object.getOwnPropertyDescriptors(value);
+  const descriptors2 = Object.getOwnPropertyDescriptors(value);
   const entries = [];
-  for (const key of Reflect.ownKeys(descriptors)) {
+  for (const key of Reflect.ownKeys(descriptors2)) {
     if (typeof key === "symbol" && internalSymbols.has(key)) continue;
-    const descriptor = Object.getOwnPropertyDescriptor(descriptors, key).value;
+    const descriptor = Object.getOwnPropertyDescriptor(descriptors2, key).value;
     if (!descriptor.enumerable) {
       continue;
     }
@@ -24626,11 +24735,11 @@ function getEnumerableObjectEntries(value, path) {
   return entries;
 }
 function getEnumerableArrayEntries(value, path) {
-  const descriptors = Object.getOwnPropertyDescriptors(value);
+  const descriptors2 = Object.getOwnPropertyDescriptors(value);
   const entries = [];
-  for (const key of Reflect.ownKeys(descriptors)) {
+  for (const key of Reflect.ownKeys(descriptors2)) {
     if (typeof key === "symbol" && internalSymbols.has(key)) continue;
-    const descriptor = Object.getOwnPropertyDescriptor(descriptors, key).value;
+    const descriptor = Object.getOwnPropertyDescriptor(descriptors2, key).value;
     if (key === "length" || !descriptor.enumerable) {
       continue;
     }
@@ -25292,9 +25401,9 @@ function normalize(value, seen) {
       return normalized2;
     }
     const normalized = /* @__PURE__ */ Object.create(null);
-    const descriptors = Object.getOwnPropertyDescriptors(value);
-    for (const key of Object.keys(descriptors).sort()) {
-      const descriptor = descriptors[key];
+    const descriptors2 = Object.getOwnPropertyDescriptors(value);
+    for (const key of Object.keys(descriptors2).sort()) {
+      const descriptor = descriptors2[key];
       if (!descriptor.enumerable) continue;
       if (!("value" in descriptor)) {
         throw new TypeError("Host call arguments cannot contain accessor properties.");
@@ -25536,7 +25645,7 @@ function restore(snapshot, options, owner) {
     throw new SnapshotMismatchError(snapshot.sourceHash, currentSourceHash);
   }
   if (snapshot.heap !== void 0 && typeof snapshot.heap === "object" && snapshot.heap !== null) {
-    const closures = Object.entries(snapshot.heap).filter(([, value]) => value !== null && typeof value === "object" && ["guest-function", "guest-generator"].includes(String(value.kind)));
+    const closures = Object.entries(snapshot.heap).filter(([, value]) => value !== null && typeof value === "object" && (["guest-function", "guest-generator"].includes(String(value.kind)) || value.templateNodeId !== void 0));
     if (closures.length > 0) {
       const functions = /* @__PURE__ */ new Map();
       const pending = [parseModule(options.source, "<input>", owner)];
@@ -25544,13 +25653,14 @@ function restore(snapshot, options, owner) {
         const value = pending.pop();
         if (value === null || typeof value !== "object") continue;
         const node = value;
-        if (["ArrowFunctionExpression", "FunctionExpression", "FunctionDeclaration"].includes(String(node.type)) && typeof node.nodeId === "number") {
+        if (typeof node.nodeId === "number") {
           functions.set(node.nodeId, node);
         }
         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);
         try {
           validateGuestFunctionAst(record3, origin);
@@ -25558,6 +25668,11 @@ function restore(snapshot, options, owner) {
           throw new SnapshotValidationError("invalidValue", `$.heap[${JSON.stringify(id)}].astNodeId`, error instanceof Error ? error.message : String(error));
         }
       }
+      try {
+        validateTemplateObjects(snapshot.heap, functions.values());
+      } catch (error) {
+        throw new SnapshotValidationError("invalidValue", "$.heap", String(error));
+      }
     }
   }
   return snapshot;
@@ -38762,4 +38877,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-7DK7CIUK.js.map
+//# sourceMappingURL=chunk-PEHO3DVD.js.map