poe-code 12.0.3 → 12.0.4

package/packages/safejs/dist/snapshot/float32array.js

@@ -0,0 +1,46 @@
+import { float32Storage, isFloat32Array } from "../interp/float32.js";
+export function encodeFloat32Storage(value, id, buffers, reference) {
+    const storage = float32Storage(value);
+    const existing = buffers.get(storage.buffer);
+    if (existing === undefined)
+        buffers.set(storage.buffer, id);
+    return {
+        kind: "float32array",
+        byteOffset: storage.byteOffset,
+        length: storage.length,
+        ...(existing === undefined
+            ? { bytes: Array.from(new Uint8Array(storage.buffer)) }
+            : { buffer: reference(existing) })
+    };
+}
+export function validateFloat32Storage(value) {
+    if (!Number.isSafeInteger(value.length) ||
+        Number(value.length) < 0 ||
+        !Number.isSafeInteger(value.byteOffset) ||
+        Number(value.byteOffset) < 0 ||
+        Number(value.byteOffset) % 4 !== 0)
+        throw new TypeError("Invalid Float32Array view dimensions.");
+    if (Object.hasOwn(value, "bytes") === Object.hasOwn(value, "buffer"))
+        throw new TypeError("Float32Array requires one backing storage description.");
+    if (Object.hasOwn(value, "bytes")) {
+        if (!Array.isArray(value.bytes) ||
+            value.bytes.some((byte) => !Number.isInteger(byte) || byte < 0 || byte > 255) ||
+            Number(value.length) > Math.floor((value.bytes.length - Number(value.byteOffset)) / 4))
+            throw new TypeError("Invalid Float32Array backing bytes.");
+    }
+}
+export function decodeFloat32Storage(value, resolve) {
+    validateFloat32Storage(value);
+    let buffer;
+    if (Array.isArray(value.bytes)) {
+        buffer = new ArrayBuffer(value.bytes.length);
+        new Uint8Array(buffer).set(value.bytes);
+    }
+    else {
+        const referenced = resolve(value.buffer);
+        if (!isFloat32Array(referenced))
+            throw new TypeError("Invalid Float32Array backing reference.");
+        buffer = float32Storage(referenced).buffer;
+    }
+    return new Float32Array(buffer, Number(value.byteOffset), Number(value.length));
+}

package/packages/safejs/dist/snapshot/replay-data.d.ts

@@ -1,3 +1,4 @@
+import { type Float32Data } from "./float32array.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";
@@ -22,7 +23,10 @@ type Properties = Record<string, {
     enumerable: boolean;
     writable: boolean;
 }>;
-type DataNode = {
+type DataNode = (Float32Data<Atom> & {
+    properties: Properties;
+    extensible: boolean;
+}) | {
     kind: "capability";
     id: string;
     properties: Atom;

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

@@ -1,4 +1,6 @@
 import { MAX_DATA_DEPTH } from "../graph-depth.js";
+import { float32DataProperties, isFloat32Array } from "../interp/float32.js";
+import { decodeFloat32Storage, encodeFloat32Storage } from "./float32array.js";
 import { sandboxErrorNames, sandboxErrorTypes } from "../error/shape.js";
 import { createSandboxArguments, createSandboxClosure, createSandboxMap, createSandboxRegex, createSandboxSet, isSandboxArguments, isSandboxClosure, isSandboxGenerator, isSandboxMap, isSandboxPromise, isSandboxRegex, isSandboxSet } from "../interp/values.js";
 import { serializeArguments } from "./arguments.js";
@@ -8,6 +10,7 @@ export class MissingReplayCapabilityError extends TypeError {
 export function encodeReplayData(value, options = {}) {
     const nodes = [];
     const seen = new WeakMap();
+    const float32Buffers = new WeakMap();
     const encode = (entry, depth, path) => {
         if (depth > MAX_DATA_DEPTH)
             throw new TypeError("Replay data exceeds the nesting limit.");
@@ -55,6 +58,22 @@ export function encodeReplayData(value, options = {}) {
                 properties: child(entry.properties, "properties")
             };
         }
+        else if (isFloat32Array(entry)) {
+            const storage = encodeFloat32Storage(entry, id, float32Buffers, (id) => ({
+                tag: "ref",
+                id
+            }));
+            const properties = Object.create(null);
+            for (const [key, descriptor] of float32DataProperties(entry)) {
+                properties[key] = {
+                    value: child(descriptor.value, key),
+                    configurable: descriptor.configurable === true,
+                    enumerable: descriptor.enumerable === true,
+                    writable: descriptor.writable === true
+                };
+            }
+            nodes[id] = { ...storage, properties, extensible: Object.isExtensible(entry) };
+        }
         else if (isSandboxMap(entry)) {
             nodes[id] = {
                 kind: "map",
@@ -205,6 +224,16 @@ export function decodeReplayData(input, options = {}) {
             options.onCapabilityRestored?.(capability, copy);
             return copy;
         }
+        if (kind === "float32array") {
+            if (typeof node.extensible !== "boolean")
+                throw new TypeError("Invalid Float32Array extensibility.");
+            const result = decodeFloat32Storage(node, child);
+            restored.set(id, result);
+            defineProperties(result, record(own(node, "properties")), child);
+            if (!node.extensible)
+                Object.preventExtensions(result);
+            return result;
+        }
         if (kind === "map") {
             const result = createSandboxMap();
             restored.set(id, result);

package/packages/safejs/dist/snapshot/restore.js

@@ -1,4 +1,5 @@
 import { Budget } from "../interp/budget.js";
+import { decodeFloat32Storage } from "./float32array.js";
 import { sandboxErrorTypes } from "../error/shape.js";
 import { SnapshotMismatchError } from "../restore.js";
 import { Scope } from "../interp/interpreter.js";
@@ -321,6 +322,19 @@ function restoreHeapValue(id, state) {
     if (serialized === undefined) {
         throw new Error(`Snapshot references unknown heap value ${id}.`);
     }
+    if (serialized.kind === "float32array") {
+        const value = decodeFloat32Storage(serialized, (reference) => deserializeValue(reference, state));
+        state.heapValueById.set(id, value);
+        for (const [key, entry] of Object.entries(serialized.entries)) {
+            Object.defineProperty(value, key, {
+                value: deserializeValue(entry, state),
+                enumerable: true,
+                configurable: true,
+                writable: true
+            });
+        }
+        return value;
+    }
     if (serialized.kind === "array") {
         const array = new Array("items" in serialized ? serialized.items.length : serialized.length);
         state.heapValueById.set(id, array);

package/packages/safejs/dist/snapshot/serialize.d.ts

@@ -1,6 +1,7 @@
 import { type SandboxErrorName } from "../error/shape.js";
 import { type SerializedArguments } from "./arguments.js";
 import { type SerializedArray } from "./arrays.js";
+import { type Float32Data } from "./float32array.js";
 import { type SandboxMap, type SandboxGenerator, type SandboxRegex, type SandboxSet } from "../interp/values.js";
 type SnapshotId = number | string;
 type SerializedUndefinedValue = {
@@ -39,7 +40,9 @@ export type SerializedReferenceValue = {
     kind: "ref";
     id: number;
 };
-export type SerializedHeapValue = SerializedArguments<SerializedSnapshotValue> | SerializedArray<SerializedSnapshotValue> | {
+export type SerializedHeapValue = (Float32Data<SerializedReferenceValue> & {
+    entries: Record<string, SerializedSnapshotValue>;
+}) | SerializedArguments<SerializedSnapshotValue> | SerializedArray<SerializedSnapshotValue> | {
     kind: "object";
     entries: Record<string, SerializedSnapshotValue>;
     errorType?: SandboxErrorName;
@@ -69,7 +72,7 @@ export type RuntimePromiseValue = {
     id: SnapshotId;
     promise?: Promise<unknown>;
 };
-export type RuntimeSnapshotValue = boolean | null | number | string | undefined | RuntimeClosureValue | SandboxGenerator | RuntimePromiseValue | SandboxMap | SandboxRegex | SandboxSet | RuntimeSnapshotValue[] | {
+export type RuntimeSnapshotValue = Float32Array | boolean | null | number | string | undefined | RuntimeClosureValue | SandboxGenerator | RuntimePromiseValue | SandboxMap | SandboxRegex | SandboxSet | RuntimeSnapshotValue[] | {
     [key: string]: RuntimeSnapshotValue;
 };
 export type RuntimeScopeFrame = {

package/packages/safejs/dist/snapshot/serialize.js

@@ -3,6 +3,8 @@ import { sandboxErrorTypes } from "../error/shape.js";
 import { assertSnapshotGraphDepth } from "../graph-depth.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 { isSandboxArguments, isSandboxGenerator, isSandboxMap, isSandboxRegex, isSandboxSet } from "../interp/values.js";
 export class UnsnapshotableValueError extends Error {
     path;
@@ -26,6 +28,7 @@ export function serialize(input) {
         }
     }
     const state = {
+        float32Buffers: new WeakMap(),
         ancestors: new WeakMap(),
         heap: Object.create(null),
         heapIds: indexHeapContainers(input),
@@ -154,7 +157,7 @@ function serializeValue(value, path, state) {
     if (isSandboxRegex(value)) {
         return { kind: "regex", source: value.source, flags: value.flags, lastIndex: value.lastIndex };
     }
-    if (isSandboxMap(value) || isSandboxSet(value)) {
+    if (isSandboxMap(value) || isSandboxSet(value) || isFloat32Array(value)) {
         const reference = serializeHeapReference(value, path, state);
         if (reference === undefined) {
             throw new TypeError(`Cannot serialize collection without a heap reference at ${path}.`);
@@ -183,7 +186,17 @@ function serializeHeapReference(value, path, state) {
     }
     if (!state.serializedHeapIds.has(id)) {
         state.serializedHeapIds.add(id);
-        if (isSandboxArguments(value)) {
+        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);
+        }
+        else if (isSandboxArguments(value)) {
             state.heap[String(id)] = serializeArguments(value, (entry, key) => serializeValue(entry, `${path}.${key}`, state));
         }
         else if (isSandboxMap(value)) {
@@ -280,6 +293,7 @@ function indexHeapContainers(input) {
     for (const [value, stat] of stats.entries()) {
         if (stat.count > 1 ||
             stat.cyclic ||
+            isFloat32Array(value) ||
             (Array.isArray(value) && requiresArrayEntries(value)) ||
             sandboxErrorTypes.has(value) ||
             isSandboxArguments(value) ||
@@ -301,6 +315,7 @@ function collectContainerStats(value, stats, ancestors) {
     }
     if (!Array.isArray(value) &&
         !isPlainObject(value) &&
+        !isFloat32Array(value) &&
         !isSandboxMap(value) &&
         !isSandboxSet(value)) {
         return;

package/packages/safejs/dist/snapshot/validation.js

@@ -2,6 +2,7 @@ import { replaceErrorStack, sandboxErrorNames } from "../error/shape.js";
 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";
 const DEFAULT_MAX_DEPTH = MAX_DATA_DEPTH;
 const DEFAULT_MAX_ENTRIES = 100_000;
 const DEFAULT_MAX_STRING_LENGTH = 1_000_000;
@@ -78,6 +79,11 @@ function validateDumpHeap(root, state) {
         addUnique(heapIds, id, path);
         const entry = requireRecord(value, path);
         validateErrorType(entry, path);
+        if (entry.kind === "float32array") {
+            validateFloat32Storage(entry);
+            requireRecord(entry.entries, `${path}.entries`);
+            continue;
+        }
         if (entry.kind === "arguments") {
             validateArgumentsProperties(entry, path);
             continue;
@@ -395,7 +401,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"].includes(String(record.kind)))
+    if (!["arguments", "array", "object", "map", "set", "float32array"].includes(String(record.kind)))
         fail("unknownTag", `${path}.kind`, "unknown heap tag");
     validateValue(record, path, 1, state);
     if (record.kind === "arguments")
@@ -404,6 +410,10 @@ function validateHeapValue(value, path, state) {
         validateArrayHeap(record, path, state);
     if (record.kind === "object")
         requireRecord(record.entries, `${path}.entries`);
+    if (record.kind === "float32array") {
+        validateFloat32Storage(record);
+        requireRecord(record.entries, `${path}.entries`);
+    }
     if (record.kind === "map") {
         const entries = requireArray(record.entries, `${path}.entries`, state);
         entries.forEach((entry, index) => {