poe-code 14.0.83 → 14.0.84

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

@@ -11,8 +11,10 @@ import { captureGuestHeapNode } from "./guest-heap.js";
 import { getGeneratorOrigin } from "../interp/closure-origin.js";
 import { serializeArguments } from "./arguments.js";
 import { requiresArrayEntries, serializeArray } from "./arrays.js";
-import { isFloat32Array } from "../interp/float32.js";
-import { captureFloat32State, encodeFloat32Storage } from "./float32array.js";
+import { float32Storage, isFloat32Array } from "../interp/float32.js";
+import { captureFloat32State, encodeFloat32Layout } from "./float32array.js";
+import { isSandboxArrayBuffer } from "../interp/array-buffer.js";
+import { captureArrayBufferState, encodeArrayBufferStorage } from "./array-buffer.js";
 import { dateDataProperties, isSandboxDate } from "../interp/date.js";
 import { serializeDate } from "./date-properties.js";
 import { boxedDataProperties, isSandboxBox } from "../interp/boxed.js";
@@ -104,7 +106,7 @@ function serializeValue(value, path, state) {
         }
         return { kind: "ref", id };
     }
-    if (typeof value === "object" && value !== null && hasGuestObjectState(value) && !isSandboxMap(value) && !isSandboxSet(value) && !isFloat32Array(value)) {
+    if (typeof value === "object" && value !== null && hasGuestObjectState(value) && !isSandboxMap(value) && !isSandboxSet(value) && !isFloat32Array(value) && !isSandboxArrayBuffer(value)) {
         throw new TypeError("Guest function properties and prototype links cannot be serialized.");
     }
     if (value === null || typeof value === "string" || typeof value === "boolean") {
@@ -197,7 +199,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 (isSandboxBox(value) || isSandboxDate(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxRegExpIterator(value) || isSandboxCollectionIterator(value) || isFloat32Array(value)) {
+    if (isSandboxArrayBuffer(value) || isSandboxBox(value) || isSandboxDate(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxRegExpIterator(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}.`);
@@ -260,12 +262,14 @@ function serializeHeapReference(value, path, state) {
         else if (isSandboxDate(value)) {
             state.heap[String(id)] = serializeDate(value, entry => serializeValue(entry, `${path}.<date-property>`, state));
         }
+        else if (isSandboxArrayBuffer(value)) {
+            state.heap[String(id)] = { ...encodeArrayBufferStorage(value, id, state.float32Buffers, id => ({ kind: "ref", id })),
+                state: captureArrayBufferState(value, entry => serializeValue(entry, `${path}.<buffer>`, state)) };
+        }
         else if (isFloat32Array(value)) {
-            const storage = encodeFloat32Storage(value, id, state.float32Buffers, (id) => ({
-                kind: "ref",
-                id
-            }));
-            state.heap[String(id)] = { ...storage, entries: {},
+            const storage = float32Storage(value);
+            state.heap[String(id)] = { kind: "float32array", ...encodeFloat32Layout(value),
+                buffer: serializeHeapReference(storage.buffer, `${path}.buffer`, state), entries: {},
                 state: captureFloat32State(value, entry => serializeValue(entry, `${path}.<typed-array>`, state)) };
         }
         else if (isSandboxArguments(value)) {
@@ -387,6 +391,7 @@ function indexHeapContainers(input) {
             isSandboxBox(value) ||
             isSandboxDate(value) ||
             isFloat32Array(value) ||
+            isSandboxArrayBuffer(value) ||
             (Array.isArray(value) && requiresArrayEntries(value)) ||
             sandboxErrorTypes.has(value) ||
             isSandboxArguments(value) ||
@@ -429,11 +434,15 @@ function collectContainerStats(value, stats, ancestors, guestValues, depth = 0)
     stat.expanded = true;
     ancestors.add(value);
     const guestEntries = [];
+    if (isFloat32Array(value))
+        guestEntries.push(float32Storage(value).buffer);
     const guest = isFloat32Array(value)
         ? { kind: "float32array", state: captureFloat32State(value, entry => { guestEntries.push(entry); return null; }) }
-        : captureGuestHeapNode(value, entry => { guestEntries.push(entry); return null; });
+        : isSandboxArrayBuffer(value)
+            ? { kind: "arraybuffer", state: captureArrayBufferState(value, entry => { guestEntries.push(entry); return null; }) }
+            : captureGuestHeapNode(value, entry => { guestEntries.push(entry); return null; });
     if (guest !== undefined) {
-        if (!isFloat32Array(value))
+        if (!isFloat32Array(value) && !isSandboxArrayBuffer(value))
             guestValues.add(value);
         for (const entry of guestEntries) {
             collectContainerStats(entry, stats, ancestors, guestValues, depth + 1);

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

@@ -6,6 +6,7 @@ import { types } from "node:util";
 import { DUMP_FORMAT_VERSION } from "./dump-format.js";
 import { MAX_DATA_DEPTH } from "../graph-depth.js";
 import { validateFloat32Storage } from "./float32array.js";
+import { validateArrayBufferStorage } from "./array-buffer.js";
 import { restoreDateTime } from "../interp/date.js";
 import { validateBoxedProperties } from "./boxed.js";
 import { hasGuestObjectState } from "../interp/object-model.js";
@@ -117,6 +118,11 @@ function validateDumpHeap(root, state) {
             validateDateRecord(entry, path);
             continue;
         }
+        if (entry.kind === "arraybuffer") {
+            validateArrayBufferStorage(entry);
+            validateGuestHeapNode({ kind: "guest-object", state: entry.state }, heap, state.limits.maxEntries);
+            continue;
+        }
         if (entry.kind === "float32array") {
             validateFloat32Storage(entry);
             requireRecord(entry.entries, `${path}.entries`);
@@ -538,7 +544,7 @@ function validateHeapValue(value, path, state, heap) {
         fail("invalidValue", path, String(error));
     }
     validateErrorType(record, path);
-    if (!["symbol", "arguments", "array", "object", "map", "set", "float32array", "date", "boxed", "collection-iterator", "regexp-iterator", "regex-object"].includes(String(record.kind)))
+    if (!["symbol", "arguments", "array", "object", "map", "set", "float32array", "arraybuffer", "date", "boxed", "collection-iterator", "regexp-iterator", "regex-object"].includes(String(record.kind)))
         fail("unknownTag", `${path}.kind`, "unknown heap tag");
     validateValue(record, path, 1, state);
     if (record.kind === "symbol")
@@ -553,6 +559,10 @@ function validateHeapValue(value, path, state, heap) {
         validateBoxedRecord(record, path, heap);
     if (record.kind === "date")
         validateDateRecord(record, path);
+    if (record.kind === "arraybuffer") {
+        validateArrayBufferStorage(record);
+        validateGuestHeapNode({ kind: "guest-object", state: record.state }, heap, state.limits.maxEntries);
+    }
     if (record.kind === "float32array") {
         validateFloat32Storage(record);
         requireRecord(record.entries, `${path}.entries`);