poe-code 14.0.62 → 14.0.63

package/packages/safe-js/dist/snapshot/serialize.js

@@ -8,6 +8,8 @@ import { requiresArrayEntries, serializeArray } from "./arrays.js";
 import { float32DataProperties, isFloat32Array } from "../interp/float32.js";
 import { encodeFloat32Storage } from "./float32array.js";
 import { isSandboxDate, serializedDateTime } from "../interp/date.js";
+import { boxedDataProperties, isSandboxBox } from "../interp/boxed.js";
+import { encodeBoxedData } from "./boxed.js";
 import { isSandboxArguments, isSandboxGenerator, isSandboxMap, isSandboxRegex, isSandboxSet } from "../interp/values.js";
 export class UnsnapshotableValueError extends Error {
     path;
@@ -170,7 +172,7 @@ function serializeValue(value, path, state) {
             throw new TypeError(`Missing regex heap reference at ${path}.`);
         return { kind: "regex", source: value.source, flags: value.flags, lastIndex: value.lastIndex };
     }
-    if (isSandboxDate(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxCollectionIterator(value) || isFloat32Array(value)) {
+    if (isSandboxBox(value) || isSandboxDate(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxCollectionIterator(value) || isFloat32Array(value)) {
         const reference = serializeHeapReference(value, path, state);
         if (reference === undefined) {
             throw new TypeError(`Cannot serialize collection without a heap reference at ${path}.`);
@@ -214,6 +216,9 @@ function serializeHeapReference(value, path, state) {
             for (const [key, entry] of Object.entries(value))
                 entries[key] = serializeValue(entry, `${path}.${key}`, state);
         }
+        else if (isSandboxBox(value)) {
+            state.heap[String(id)] = encodeBoxedData(value, (entry, key) => serializeValue(entry, `${path}.${key}`, state));
+        }
         else if (isSandboxDate(value)) {
             state.heap[String(id)] = { kind: "date", time: serializedDateTime(value) };
         }
@@ -326,6 +331,7 @@ function indexHeapContainers(input) {
             stat.cyclic ||
             (isSandboxRegex(value) && (!Number.isSafeInteger(value.lastIndex) ||
                 (typeof value.lastIndex === "number" && value.lastIndex < 0) || Object.is(value.lastIndex, -0))) ||
+            isSandboxBox(value) ||
             isSandboxDate(value) ||
             isFloat32Array(value) ||
             (Array.isArray(value) && requiresArrayEntries(value)) ||
@@ -376,15 +382,17 @@ function collectContainerStats(value, stats, ancestors) {
     }
     stat.expanded = true;
     ancestors.add(value);
-    const entries = isSandboxCollectionIterator(value)
-        ? [collectionIteratorState(value).collection, ...Object.values(value)]
-        : isSandboxArguments(value)
-            ? Object.values(Object.getOwnPropertyDescriptors(value)).flatMap((descriptor) => "value" in descriptor ? [descriptor.value] : [])
-            : isSandboxMap(value)
-                ? [...value.entries].flatMap(([key, entry]) => [key, entry])
-                : isSandboxSet(value)
-                    ? [...value.values]
-                    : Object.values(value);
+    const entries = isSandboxBox(value)
+        ? boxedDataProperties(value).map(([, descriptor]) => descriptor.value)
+        : isSandboxCollectionIterator(value)
+            ? [collectionIteratorState(value).collection, ...Object.values(value)]
+            : isSandboxArguments(value)
+                ? Object.values(Object.getOwnPropertyDescriptors(value)).flatMap((descriptor) => "value" in descriptor ? [descriptor.value] : [])
+                : isSandboxMap(value)
+                    ? [...value.entries].flatMap(([key, entry]) => [key, entry])
+                    : isSandboxSet(value)
+                        ? [...value.values]
+                        : Object.values(value);
     for (const entry of entries) {
         collectContainerStats(entry, stats, ancestors);
     }

package/packages/safe-js/dist/snapshot/validation.js

@@ -4,6 +4,7 @@ import { DUMP_FORMAT_VERSION } from "./dump-format.js";
 import { MAX_DATA_DEPTH } from "../graph-depth.js";
 import { validateFloat32Storage } from "./float32array.js";
 import { restoreDateTime } from "../interp/date.js";
+import { validateBoxedProperties } from "./boxed.js";
 import { hasGuestObjectState } from "../interp/object-model.js";
 const DEFAULT_MAX_DEPTH = MAX_DATA_DEPTH;
 const DEFAULT_MAX_ENTRIES = 100_000;
@@ -81,6 +82,10 @@ function validateDumpHeap(root, state) {
         addUnique(heapIds, id, path);
         const entry = requireRecord(value, path);
         validateErrorType(entry, path);
+        if (entry.kind === "boxed") {
+            validateBoxedRecord(entry, path);
+            continue;
+        }
         if (entry.kind === "date") {
             validateDateRecord(entry, path);
             continue;
@@ -414,7 +419,7 @@ function validateGeneratorShape(record, path, state) {
 function validateHeapValue(value, path, state) {
     const record = requireRecord(value, path);
     validateErrorType(record, path);
-    if (!["arguments", "array", "object", "map", "set", "float32array", "date", "collection-iterator", "regex-object"].includes(String(record.kind)))
+    if (!["arguments", "array", "object", "map", "set", "float32array", "date", "boxed", "collection-iterator", "regex-object"].includes(String(record.kind)))
         fail("unknownTag", `${path}.kind`, "unknown heap tag");
     validateValue(record, path, 1, state);
     if (record.kind === "arguments")
@@ -423,6 +428,8 @@ function validateHeapValue(value, path, state) {
         validateArrayHeap(record, path, state);
     if (record.kind === "object")
         requireRecord(record.entries, `${path}.entries`);
+    if (record.kind === "boxed")
+        validateBoxedRecord(record, path);
     if (record.kind === "date")
         validateDateRecord(record, path);
     if (record.kind === "float32array") {
@@ -451,6 +458,20 @@ function validateHeapValue(value, path, state) {
         requireRecord(record.entries, `${path}.entries`);
     }
 }
+function validateBoxedRecord(record, path) {
+    try {
+        validateBoxedProperties(record);
+    }
+    catch {
+        fail("invalidValue", path, "invalid boxed primitive properties");
+    }
+    const value = record.value;
+    if (typeof value === "number" || typeof value === "string" || typeof value === "boolean")
+        return;
+    const number = requireRecord(value, `${path}.value`);
+    if (number.kind !== "number" || !["NaN", "Infinity", "-Infinity", "-0"].includes(String(number.value)))
+        fail("invalidValue", `${path}.value`, "invalid boxed primitive payload");
+}
 function validateDateRecord(record, path) {
     if (Object.keys(record).length !== 2)
         fail("invalidValue", path, "invalid Date fields");