poe-code 14.0.82 → 14.0.84

package/packages/safe-js/dist/snapshot/array-buffer.js

@@ -0,0 +1,40 @@
+import { arrayBufferLength, arrayBufferOptions, isSandboxArrayBuffer } from "../interp/array-buffer.js";
+import { float32Storage, isFloat32Array } from "../interp/float32.js";
+import { getSandboxPrototype, hasExplicitSandboxPrototype } from "../interp/object-model.js";
+import { serializePropertyDescriptors } from "./property-descriptors.js";
+export function captureArrayBufferState(value, encode) {
+    return { properties: serializePropertyDescriptors(value, encode),
+        ...(hasExplicitSandboxPrototype(value) ? { prototype: encode(getSandboxPrototype(value)) } : {}) };
+}
+export function encodeArrayBufferStorage(value, id, buffers, reference) {
+    arrayBufferLength(value);
+    const existing = buffers.get(value);
+    if (existing === undefined)
+        buffers.set(value, id);
+    return { kind: "arraybuffer", ...(existing === undefined ? { bytes: Array.from(new Uint8Array(value)), ...arrayBufferOptions(value) } : { buffer: reference(existing) }) };
+}
+export function validateArrayBufferStorage(value) {
+    if (Object.hasOwn(value, "bytes") === Object.hasOwn(value, "buffer"))
+        throw new TypeError("ArrayBuffer requires one backing storage description.");
+    if (Object.hasOwn(value, "bytes") && (!Array.isArray(value.bytes) ||
+        value.bytes.some(byte => !Number.isInteger(byte) || byte < 0 || byte > 255)))
+        throw new TypeError("Invalid ArrayBuffer bytes.");
+    if (Object.hasOwn(value, "maxByteLength") && (!Array.isArray(value.bytes) ||
+        !Number.isSafeInteger(value.maxByteLength) || Number(value.maxByteLength) < value.bytes.length))
+        throw new TypeError("Invalid ArrayBuffer maximum length.");
+}
+export function decodeArrayBufferStorage(value, resolve) {
+    validateArrayBufferStorage(value);
+    if (Array.isArray(value.bytes)) {
+        const buffer = Reflect.construct(ArrayBuffer, [value.bytes.length,
+            Object.hasOwn(value, "maxByteLength") ? { maxByteLength: value.maxByteLength } : undefined]);
+        new Uint8Array(buffer).set(value.bytes);
+        return buffer;
+    }
+    const referenced = resolve(value.buffer);
+    if (isSandboxArrayBuffer(referenced))
+        return referenced;
+    if (isFloat32Array(referenced))
+        return float32Storage(referenced).buffer;
+    throw new TypeError("Invalid ArrayBuffer backing reference.");
+}

package/packages/safe-js/dist/snapshot/dump-format.js

@@ -12,8 +12,10 @@ import { sandboxErrorTypes } from "../error/shape.js";
 import { getSandboxArgumentEntries, isSandboxArguments } from "../interp/arguments.js";
 import { serializeArguments } from "./arguments.js";
 import { requiresArrayEntries, serializeArray } from "./arrays.js";
-import { float32DataProperties, isFloat32Array } from "../interp/float32.js";
-import { encodeFloat32Storage } from "./float32array.js";
+import { float32DataProperties, float32Storage, isFloat32Array } from "../interp/float32.js";
+import { 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";
@@ -109,7 +111,7 @@ function serializeDumpValue(value, path, state) {
     if (hasGuestObjectState(value) && !(state.trustedRunReplay && (isSandboxDate(value) || isSandboxPromise(value) || isPromiseResolvingFunction(value)))) {
         throw new TypeError("Guest function properties and prototype links cannot be serialized.");
     }
-    if (isSandboxRegExpIterator(value) || (isSandboxRegex(value) && hasCustomRegexProperties(value)) || isSandboxBox(value) || isSandboxDate(value) || isFloat32Array(value))
+    if (isSandboxArrayBuffer(value) || isSandboxRegExpIterator(value) || (isSandboxRegex(value) && hasCustomRegexProperties(value)) || isSandboxBox(value) || isSandboxDate(value) || isFloat32Array(value))
         return serializeHeapReference(value, path, state);
     if (Array.isArray(value)) {
         const reference = serializeHeapReference(value, path, state);
@@ -186,11 +188,17 @@ function serializeHeapReference(value, path, state) {
                 return serialized === SKIP_VALUE ? { kind: "undefined" } : serialized;
             });
         }
+        else if (isSandboxArrayBuffer(value)) {
+            state.heap[String(id)] = { ...encodeArrayBufferStorage(value, id, state.float32Buffers, id => ({ kind: "ref", id })),
+                state: captureArrayBufferState(value, entry => {
+                    const serialized = serializeDumpValue(entry, `${path}.<buffer>`, state);
+                    return serialized === SKIP_VALUE ? { kind: "undefined" } : serialized;
+                }) };
+        }
         else if (isFloat32Array(value)) {
-            const storage = encodeFloat32Storage(value, id, state.float32Buffers, (id) => ({
-                kind: "ref",
-                id
-            }));
+            const backing = float32Storage(value);
+            const storage = { kind: "float32array", ...encodeFloat32Layout(value),
+                buffer: serializeHeapReference(backing.buffer, `${path}.buffer`, state) };
             const entries = Object.create(null);
             state.heap[String(id)] = { ...storage, entries };
             for (const [key, descriptor] of float32DataProperties(value)) {
@@ -271,6 +279,7 @@ function indexHeapContainers(snapshot) {
             (isSandboxRegex(value) && hasCustomRegexProperties(value)) ||
             isSandboxDate(value) ||
             isFloat32Array(value) ||
+            isSandboxArrayBuffer(value) ||
             (Array.isArray(value) && requiresArrayEntries(value)) ||
             isSandboxArguments(value) ||
             sandboxErrorTypes.has(value)) {
@@ -305,9 +314,14 @@ function collectContainerStats(value, stats, ancestors, guestValues, depth = 0)
     stat.expanded = true;
     ancestors.add(value);
     const guestEntries = [];
-    const guest = captureGuestHeapNode(value, entry => { guestEntries.push(entry); return null; });
+    if (isFloat32Array(value))
+        guestEntries.push(float32Storage(value).buffer);
+    const guest = isSandboxArrayBuffer(value)
+        ? { kind: "arraybuffer", state: captureArrayBufferState(value, entry => { guestEntries.push(entry); return null; }) }
+        : captureGuestHeapNode(value, entry => { guestEntries.push(entry); return null; });
     if (guest !== undefined) {
-        guestValues.add(value);
+        if (!isSandboxArrayBuffer(value))
+            guestValues.add(value);
         for (const entry of guestEntries) {
             collectContainerStats(entry, stats, ancestors, guestValues, depth + 1);
             if (entry !== null && typeof entry === "object")
@@ -316,6 +330,8 @@ function collectContainerStats(value, stats, ancestors, guestValues, depth = 0)
         ancestors.delete(value);
         return;
     }
+    for (const entry of guestEntries)
+        collectContainerStats(entry, stats, ancestors, guestValues, depth + 1);
     if (!Array.isArray(value) && !isPlainObject(value) && !isFloat32Array(value) && !isSandboxDate(value)) {
         ancestors.delete(value);
         return;

package/packages/safe-js/dist/snapshot/float32array.d.ts

@@ -1,12 +1,22 @@
+import type { GuestObjectState } from "./guest-heap.js";
+import type { Budget } from "../interp/budget.js";
+export declare function captureFloat32State<T>(value: Float32Array, encode: (value: unknown) => T): GuestObjectState<T>;
+export declare function restoreFloat32Properties<T>(value: Float32Array, state: GuestObjectState<T>, decode: (value: T) => unknown): void;
 export type Float32Data<TReference> = {
     kind: "float32array";
     byteOffset: number;
     length: number;
+    lengthTracking?: true;
 } & ({
     bytes: number[];
 } | {
     buffer: TReference;
 });
+export declare function encodeFloat32Layout(value: Float32Array): {
+    byteOffset: number;
+    length: number;
+    lengthTracking?: true;
+};
 export declare function encodeFloat32Storage<TReference>(value: Float32Array, id: number, buffers: WeakMap<ArrayBuffer, number>, reference: (id: number) => TReference): Float32Data<TReference>;
 export declare function validateFloat32Storage(value: Record<string, unknown>): void;
-export declare function decodeFloat32Storage(value: Record<string, unknown>, resolve: (reference: unknown) => unknown): Float32Array;
+export declare function decodeFloat32Storage(value: Record<string, unknown>, resolve: (reference: unknown) => unknown, budget?: Budget): Float32Array;

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

@@ -1,4 +1,34 @@
-import { float32Storage, isFloat32Array } from "../interp/float32.js";
+import { float32Properties, float32Storage, float32ViewLayouts, restoreFloat32View, isFloat32Array, isFloat32Index } from "../interp/float32.js";
+import { getSandboxPrototype, hasExplicitSandboxPrototype } from "../interp/object-model.js";
+import { restorePropertyDescriptors, serializePropertyDescriptors } from "./property-descriptors.js";
+import { arrayBufferOptions, isSandboxArrayBuffer } from "../interp/array-buffer.js";
+export function captureFloat32State(value, encode) {
+    const metadata = Object.defineProperties(Object.create(null), Object.fromEntries(float32Properties(value)));
+    if (!Object.isExtensible(value))
+        Object.preventExtensions(metadata);
+    return { properties: serializePropertyDescriptors(metadata, encode),
+        ...(hasExplicitSandboxPrototype(value) ? { prototype: encode(getSandboxPrototype(value)) } : {}) };
+}
+export function restoreFloat32Properties(value, state, decode) {
+    const metadata = Object.create(null);
+    restorePropertyDescriptors(metadata, state.properties, decode);
+    const descriptors = Object.getOwnPropertyDescriptors(metadata);
+    if (Object.keys(descriptors).some(isFloat32Index))
+        throw new TypeError("Float32Array metadata cannot replace numeric storage.");
+    Object.defineProperties(value, descriptors);
+    if (!Object.isExtensible(metadata))
+        Object.preventExtensions(value);
+}
+export function encodeFloat32Layout(value) {
+    const storage = float32Storage(value);
+    if (arrayBufferOptions(storage.buffer) === undefined)
+        return { byteOffset: storage.byteOffset, length: storage.length };
+    const layout = float32ViewLayouts.get(value);
+    if (layout === undefined)
+        throw new TypeError("Resizable Float32Array snapshots require known view layout.");
+    return { byteOffset: layout.byteOffset, length: layout.length ?? 0,
+        ...(layout.length === undefined ? { lengthTracking: true } : {}) };
+}
 export function encodeFloat32Storage(value, id, buffers, reference) {
     const storage = float32Storage(value);
     const existing = buffers.get(storage.buffer);
@@ -14,6 +44,8 @@ export function encodeFloat32Storage(value, id, buffers, reference) {
     };
 }
 export function validateFloat32Storage(value) {
+    if (Object.hasOwn(value, "lengthTracking") && (value.lengthTracking !== true || value.length !== 0 || Object.hasOwn(value, "bytes")))
+        throw new TypeError("Invalid Float32Array length-tracking layout.");
     if (!Number.isSafeInteger(value.length) ||
         Number(value.length) < 0 ||
         !Number.isSafeInteger(value.byteOffset) ||
@@ -29,7 +61,7 @@ export function validateFloat32Storage(value) {
             throw new TypeError("Invalid Float32Array backing bytes.");
     }
 }
-export function decodeFloat32Storage(value, resolve) {
+export function decodeFloat32Storage(value, resolve, budget) {
     validateFloat32Storage(value);
     let buffer;
     if (Array.isArray(value.bytes)) {
@@ -38,9 +70,14 @@ export function decodeFloat32Storage(value, resolve) {
     }
     else {
         const referenced = resolve(value.buffer);
-        if (!isFloat32Array(referenced))
+        if (isSandboxArrayBuffer(referenced))
+            buffer = referenced;
+        else if (isFloat32Array(referenced))
+            buffer = float32Storage(referenced).buffer;
+        else
             throw new TypeError("Invalid Float32Array backing reference.");
-        buffer = float32Storage(referenced).buffer;
     }
-    return new Float32Array(buffer, Number(value.byteOffset), Number(value.length));
+    if (value.lengthTracking === true && arrayBufferOptions(buffer) === undefined)
+        throw new TypeError("Length-tracking layout requires resizable backing storage.");
+    return restoreFloat32View(buffer, Number(value.byteOffset), value.lengthTracking === true ? undefined : Number(value.length), budget);
 }

package/packages/safe-js/dist/snapshot/replay-data.d.ts

@@ -4,6 +4,7 @@ import { type SerializedSymbol, type SerializedSymbolProperty } from "./symbols.
 import { type CollectionIterationMethod } from "../interp/collection-iterator.js";
 import { CompileScope } from "../interp/regex/compile-guard.js";
 import { type Float32Data } from "./float32array.js";
+import { type ArrayBufferData } from "./array-buffer.js";
 import { type SandboxErrorName } from "../error/shape.js";
 import { type SandboxClosure, type SandboxPromise, type SandboxValue } from "../interp/values.js";
 import { type SerializedArguments } from "./arguments.js";
@@ -69,6 +70,10 @@ type DataNode = {
 } | (Float32Data<Atom> & {
     properties: Properties;
     extensible: boolean;
+}) | (ArrayBufferData<Atom> & {
+    properties: Properties;
+    extensible: boolean;
+    symbolEntries?: Array<SerializedSymbolProperty<Atom>>;
 }) | {
     kind: "capability";
     id: string;

package/packages/safe-js/dist/snapshot/replay-data.js

@@ -10,8 +10,10 @@ import { isSandboxCollectionIterator, restoreSandboxCollectionIterator, snapshot
 import { isSandboxRegExpIterator, regexpIteratorState, restoreSandboxRegExpIterator } from "../interp/regexp-iterator.js";
 import { hasGuestObjectState, hasNullObjectPrototype, setSandboxPrototype } from "../interp/object-model.js";
 import { CompileScope } from "../interp/regex/compile-guard.js";
-import { float32DataProperties, isFloat32Array } from "../interp/float32.js";
-import { decodeFloat32Storage, encodeFloat32Storage } from "./float32array.js";
+import { float32DataProperties, float32Storage, isFloat32Array } from "../interp/float32.js";
+import { decodeFloat32Storage, encodeFloat32Layout } from "./float32array.js";
+import { arrayBufferDataProperties, isSandboxArrayBuffer } from "../interp/array-buffer.js";
+import { decodeArrayBufferStorage, encodeArrayBufferStorage } from "./array-buffer.js";
 import { dateDataProperties, isSandboxDate, restoreDateTime, serializedDateTime } from "../interp/date.js";
 import { createRawJson, isRawJson } from "../interp/raw-json.js";
 import { boxedDataProperties, createSandboxBox, nativeBoxedValue } from "../interp/boxed.js";
@@ -119,11 +121,22 @@ export function encodeReplayData(value, options = {}) {
                 ...(Object.isExtensible(entry) ? {} : { extensible: false })
             };
         }
+        else if (isSandboxArrayBuffer(entry)) {
+            const storage = encodeArrayBufferStorage(entry, id, float32Buffers, id => ({ tag: "ref", id }));
+            const properties = Object.create(null);
+            for (const [key, descriptor] of arrayBufferDataProperties(entry)) {
+                if (typeof key === "symbol")
+                    continue;
+                properties[key] = { value: child(descriptor.value, key), configurable: descriptor.configurable === true,
+                    enumerable: descriptor.enumerable === true, writable: descriptor.writable === true };
+            }
+            let symbolIndex = 0;
+            const symbolEntries = serializeSymbolProperties(entry, value => encode(value, depth + 1, [...path, { symbol: Math.floor(symbolIndex++ / 2) }]));
+            nodes[id] = { ...storage, properties, extensible: Object.isExtensible(entry), symbolEntries };
+        }
         else if (isFloat32Array(entry)) {
-            const storage = encodeFloat32Storage(entry, id, float32Buffers, (id) => ({
-                tag: "ref",
-                id
-            }));
+            const backing = float32Storage(entry);
+            const storage = { kind: "float32array", ...encodeFloat32Layout(entry), buffer: child(backing.buffer, "<buffer>") };
             const properties = Object.create(null);
             for (const [key, descriptor] of float32DataProperties(entry)) {
                 properties[key] = {
@@ -227,7 +240,7 @@ export function decodeReplayData(input, options = {}, parent) {
         const graph = record(input);
         const nodes = list(own(graph, "nodes"));
         const restored = new Map();
-        const initializeIterators = [];
+        const initializeValues = [];
         const decode = (entry, depth = 0) => {
             if (depth > MAX_DATA_DEPTH)
                 throw new TypeError("Replay data exceeds the nesting limit.");
@@ -378,10 +391,22 @@ export function decodeReplayData(input, options = {}, parent) {
                     Object.preventExtensions(result);
                 return result;
             }
+            if (kind === "arraybuffer") {
+                if (typeof node.extensible !== "boolean")
+                    throw new TypeError("Invalid ArrayBuffer extensibility.");
+                const result = decodeArrayBufferStorage(node, child);
+                restored.set(id, result);
+                initializeValues.push(() => {
+                    defineProperties(result, record(own(node, "properties")), child, node.symbolEntries);
+                    if (!node.extensible)
+                        Object.preventExtensions(result);
+                });
+                return result;
+            }
             if (kind === "float32array") {
                 if (typeof node.extensible !== "boolean")
                     throw new TypeError("Invalid Float32Array extensibility.");
-                const result = decodeFloat32Storage(node, child);
+                const result = decodeFloat32Storage(node, child, compilation.owner?.budget);
                 restored.set(id, result);
                 defineProperties(result, record(own(node, "properties")), child);
                 if (!node.extensible)
@@ -421,7 +446,7 @@ export function decodeReplayData(input, options = {}, parent) {
                 const collection = child(own(node, "collection"));
                 if (collection !== undefined && !isSandboxMap(collection) && !isSandboxSet(collection))
                     throw new TypeError("Invalid replay collection iterator source.");
-                initializeIterators.push(() => { restoreSandboxCollectionIterator({ collection, collectionKind, method, index, exhausted }, result); });
+                initializeValues.push(() => { restoreSandboxCollectionIterator({ collection, collectionKind, method, index, exhausted }, result); });
                 defineProperties(result, record(own(node, "properties")), child);
                 if (!node.extensible)
                     Object.preventExtensions(result);
@@ -503,7 +528,7 @@ export function decodeReplayData(input, options = {}, parent) {
             return result;
         };
         const result = decode(own(graph, "root"));
-        for (const initialize of initializeIterators)
+        for (const initialize of initializeValues)
             initialize();
         if (parent !== undefined)
             compilation.forward(compilation.tickets, parent);

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

@@ -17,7 +17,8 @@ import { awaitSandboxValue } from "../interp/cancel.js";
 import { runAsyncPrefix } from "../interp/jobs.js";
 import { toPropertyKey } from "../interp/property-key.js";
 import { CompileScope } from "../interp/regex/compile-guard.js";
-import { decodeFloat32Storage } from "./float32array.js";
+import { decodeFloat32Storage, restoreFloat32Properties } from "./float32array.js";
+import { decodeArrayBufferStorage } from "./array-buffer.js";
 import { restoreDateTime } from "../interp/date.js";
 import { createRawJson } from "../interp/raw-json.js";
 import { createSandboxBox } from "../interp/boxed.js";
@@ -411,7 +412,11 @@ function initializeIntrinsicRealm(state) {
             return prototype?.kind === "intrinsic" &&
                 prototype.id === JSON.stringify([...JSON.parse(node.id), "prototype"]);
         }));
-    createBuiltinBindings({ budget: state.budget, compileOwner: state.compilation.owner, functionHasInstance, errorPrototypes });
+    const float32 = Object.values(state.heap).find(node => node.kind === "intrinsic" && node.id === '["Float32Array"]');
+    const float32Prototypes = float32?.kind !== "intrinsic" ||
+        float32.state?.properties.properties.some(([key, descriptor]) => key === "prototype" && descriptor.kind === "data" &&
+            !descriptor.writable && !descriptor.enumerable && !descriptor.configurable) === true;
+    createBuiltinBindings({ budget: state.budget, compileOwner: state.compilation.owner, functionHasInstance, errorPrototypes, float32Prototypes });
     state.intrinsicsInitialized = true;
 }
 function restoreHeapValue(id, state) {
@@ -452,9 +457,31 @@ function restoreHeapValue(id, state) {
         restoreRegexProperties(value, serialized, entry => deserializeValue(entry, state));
         return value;
     }
+    if (serialized.kind === "arraybuffer") {
+        initializeIntrinsicRealm(state);
+        const value = decodeArrayBufferStorage(serialized, reference => deserializeValue(reference, state));
+        state.heapValueById.set(id, value);
+        state.initializeIterators.push(() => {
+            if (serialized.state.prototype !== undefined)
+                setSandboxPrototype(value, deserializeValue(serialized.state.prototype, state), state.budget);
+            restorePropertyDescriptors(value, serialized.state.properties, entry => deserializeValue(entry, state));
+        });
+        return value;
+    }
     if (serialized.kind === "float32array") {
-        const value = decodeFloat32Storage(serialized, (reference) => deserializeValue(reference, state));
+        if (serialized.state !== undefined)
+            initializeIntrinsicRealm(state);
+        const value = decodeFloat32Storage(serialized, (reference) => deserializeValue(reference, state), state.budget);
         state.heapValueById.set(id, value);
+        if (serialized.state !== undefined) {
+            const objectState = serialized.state;
+            state.initializeIterators.push(() => {
+                if (objectState.prototype !== undefined)
+                    setSandboxPrototype(value, deserializeValue(objectState.prototype, state), state.budget);
+                restoreFloat32Properties(value, objectState, entry => deserializeValue(entry, state));
+            });
+            return value;
+        }
         for (const [key, entry] of Object.entries(serialized.entries)) {
             Object.defineProperty(value, key, {
                 value: deserializeValue(entry, state),

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

@@ -4,10 +4,11 @@ import { type SerializedSymbol, type SerializedSymbolProperty } from "./symbols.
 import { type CollectionIterationMethod, type SandboxCollectionIterator } from "../interp/collection-iterator.js";
 import { type SandboxRegExpIterator } from "../interp/regexp-iterator.js";
 import { type SandboxErrorName } from "../error/shape.js";
-import { type GuestHeapNode } from "./guest-heap.js";
+import { type GuestHeapNode, type GuestObjectState } from "./guest-heap.js";
 import { type SerializedArguments } from "./arguments.js";
 import { type SerializedArray } from "./arrays.js";
 import { type Float32Data } from "./float32array.js";
+import { type ArrayBufferData } from "./array-buffer.js";
 import { type SerializedDate } from "./date-properties.js";
 import { type SandboxBox } from "../interp/boxed.js";
 import { type BoxedData } from "./boxed.js";
@@ -51,7 +52,9 @@ export type SerializedReferenceValue = {
     kind: "ref";
     id: number;
 };
-export type SerializedHeapValue = GuestHeapNode<SerializedSnapshotValue> | {
+export type SerializedHeapValue = (ArrayBufferData<SerializedReferenceValue> & {
+    state: GuestObjectState<SerializedSnapshotValue>;
+}) | GuestHeapNode<SerializedSnapshotValue> | {
     kind: "regexp-iterator";
     matcher: SerializedSnapshotValue;
     input: SerializedSnapshotValue;
@@ -75,6 +78,7 @@ export type SerializedHeapValue = GuestHeapNode<SerializedSnapshotValue> | {
     entries: Record<string, SerializedSnapshotValue>;
 } | SerializedDate<SerializedSnapshotValue> | (Float32Data<SerializedReferenceValue> & {
     entries: Record<string, SerializedSnapshotValue>;
+    state?: GuestObjectState<SerializedSnapshotValue>;
 }) | SerializedArguments<SerializedSnapshotValue> | SerializedArray<SerializedSnapshotValue> | {
     kind: "object";
     sandboxNullPrototype?: true;
@@ -111,7 +115,7 @@ export type RuntimePromiseValue = {
     id: SnapshotId;
     promise?: Promise<unknown>;
 };
-export type RuntimeSnapshotValue = bigint | symbol | SandboxBox | Date | Float32Array | boolean | null | number | string | undefined | RuntimeClosureValue | SandboxClosure | SandboxGenerator | SandboxCollectionIterator | SandboxRegExpIterator | RuntimePromiseValue | SandboxMap | SandboxRegex | SandboxSet | RuntimeSnapshotValue[] | {
+export type RuntimeSnapshotValue = bigint | symbol | SandboxBox | Date | Float32Array | ArrayBuffer | boolean | null | number | string | undefined | RuntimeClosureValue | SandboxClosure | SandboxGenerator | SandboxCollectionIterator | SandboxRegExpIterator | RuntimePromiseValue | SandboxMap | SandboxRegex | SandboxSet | RuntimeSnapshotValue[] | {
     [key: string]: RuntimeSnapshotValue;
 };
 export type RuntimeScopeFrame = {

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 { float32DataProperties, isFloat32Array } from "../interp/float32.js";
-import { 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)) {
+    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,15 +262,15 @@ 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
-            }));
-            const entries = Object.create(null);
-            state.heap[String(id)] = { ...storage, entries };
-            for (const [key, descriptor] of float32DataProperties(value))
-                entries[key] = serializeValue(descriptor.value, `${path}.${key}`, state);
+            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)) {
             state.heap[String(id)] = serializeArguments(value, (entry, key) => serializeValue(entry, `${path}.${key}`, state));
@@ -389,6 +391,7 @@ function indexHeapContainers(input) {
             isSandboxBox(value) ||
             isSandboxDate(value) ||
             isFloat32Array(value) ||
+            isSandboxArrayBuffer(value) ||
             (Array.isArray(value) && requiresArrayEntries(value)) ||
             sandboxErrorTypes.has(value) ||
             isSandboxArguments(value) ||
@@ -431,9 +434,16 @@ function collectContainerStats(value, stats, ancestors, guestValues, depth = 0)
     stat.expanded = true;
     ancestors.add(value);
     const guestEntries = [];
-    const guest = captureGuestHeapNode(value, entry => { guestEntries.push(entry); return null; });
+    if (isFloat32Array(value))
+        guestEntries.push(float32Storage(value).buffer);
+    const guest = isFloat32Array(value)
+        ? { kind: "float32array", state: captureFloat32State(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) {
-        guestValues.add(value);
+        if (!isFloat32Array(value) && !isSandboxArrayBuffer(value))
+            guestValues.add(value);
         for (const entry of guestEntries) {
             collectContainerStats(entry, stats, ancestors, guestValues, depth + 1);
             if (entry !== null && typeof entry === "object") {

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,9 +118,19 @@ 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`);
+            if (Object.hasOwn(entry, "state")) {
+                if (Object.keys(entry.entries).length !== 0)
+                    fail("invalidValue", path, "ambiguous Float32Array property state");
+                validateGuestHeapNode({ kind: "guest-object", state: entry.state }, heap, state.limits.maxEntries);
+            }
             continue;
         }
         if (entry.kind === "arguments") {
@@ -533,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")
@@ -548,9 +559,18 @@ 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`);
+        if (Object.hasOwn(record, "state")) {
+            if (Object.keys(record.entries).length !== 0)
+                fail("invalidValue", path, "ambiguous Float32Array property state");
+            validateGuestHeapNode({ kind: "guest-object", state: record.state }, heap, state.limits.maxEntries);
+        }
     }
     if (record.kind === "map") {
         const entries = requireArray(record.entries, `${path}.entries`, state);