poe-code 14.0.6 → 14.0.7

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

@@ -1,6 +1,7 @@
 import { Budget, SandboxError } from "../interp/budget.js";
 import { CompileScope } from "../interp/regex/compile-guard.js";
 import { decodeFloat32Storage } from "./float32array.js";
+import { restoreDateTime } from "../interp/date.js";
 import { sandboxErrorTypes } from "../error/shape.js";
 import { SnapshotMismatchError } from "../restore.js";
 import { Scope, setSandboxProperty } from "../interp/interpreter.js";
@@ -339,6 +340,11 @@ function restoreHeapValue(id, state) {
     if (serialized === undefined) {
         throw new Error(`Snapshot references unknown heap value ${id}.`);
     }
+    if (serialized.kind === "date") {
+        const value = restoreDateTime(serialized.time);
+        state.heapValueById.set(id, value);
+        return value;
+    }
     if (serialized.kind === "float32array") {
         const value = decodeFloat32Storage(serialized, (reference) => deserializeValue(reference, state));
         state.heapValueById.set(id, value);

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

@@ -40,7 +40,10 @@ export type SerializedReferenceValue = {
     kind: "ref";
     id: number;
 };
-export type SerializedHeapValue = (Float32Data<SerializedReferenceValue> & {
+export type SerializedHeapValue = {
+    kind: "date";
+    time: number | null;
+} | (Float32Data<SerializedReferenceValue> & {
     entries: Record<string, SerializedSnapshotValue>;
 }) | SerializedArguments<SerializedSnapshotValue> | SerializedArray<SerializedSnapshotValue> | {
     kind: "object";
@@ -72,7 +75,7 @@ export type RuntimePromiseValue = {
     id: SnapshotId;
     promise?: Promise<unknown>;
 };
-export type RuntimeSnapshotValue = Float32Array | boolean | null | number | string | undefined | RuntimeClosureValue | SandboxGenerator | RuntimePromiseValue | SandboxMap | SandboxRegex | SandboxSet | RuntimeSnapshotValue[] | {
+export type RuntimeSnapshotValue = Date | Float32Array | boolean | null | number | string | undefined | RuntimeClosureValue | SandboxGenerator | RuntimePromiseValue | SandboxMap | SandboxRegex | SandboxSet | RuntimeSnapshotValue[] | {
     [key: string]: RuntimeSnapshotValue;
 };
 export type RuntimeScopeFrame = {

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

@@ -6,6 +6,7 @@ import { serializeArguments } from "./arguments.js";
 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 { isSandboxArguments, isSandboxGenerator, isSandboxMap, isSandboxRegex, isSandboxSet } from "../interp/values.js";
 export class UnsnapshotableValueError extends Error {
     path;
@@ -161,7 +162,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) || isFloat32Array(value)) {
+    if (isSandboxDate(value) || 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}.`);
@@ -190,7 +191,10 @@ function serializeHeapReference(value, path, state) {
     }
     if (!state.serializedHeapIds.has(id)) {
         state.serializedHeapIds.add(id);
-        if (isFloat32Array(value)) {
+        if (isSandboxDate(value)) {
+            state.heap[String(id)] = { kind: "date", time: serializedDateTime(value) };
+        }
+        else if (isFloat32Array(value)) {
             const storage = encodeFloat32Storage(value, id, state.float32Buffers, (id) => ({
                 kind: "ref",
                 id
@@ -297,6 +301,7 @@ function indexHeapContainers(input) {
     for (const [value, stat] of stats.entries()) {
         if (stat.count > 1 ||
             stat.cyclic ||
+            isSandboxDate(value) ||
             isFloat32Array(value) ||
             (Array.isArray(value) && requiresArrayEntries(value)) ||
             sandboxErrorTypes.has(value) ||
@@ -319,6 +324,7 @@ function collectContainerStats(value, stats, ancestors) {
     }
     if (!Array.isArray(value) &&
         !isPlainObject(value) &&
+        !isSandboxDate(value) &&
         !isFloat32Array(value) &&
         !isSandboxMap(value) &&
         !isSandboxSet(value)) {

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

@@ -3,6 +3,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 { restoreDateTime } from "../interp/date.js";
 import { hasGuestObjectState } from "../interp/object-model.js";
 const DEFAULT_MAX_DEPTH = MAX_DATA_DEPTH;
 const DEFAULT_MAX_ENTRIES = 100_000;
@@ -80,6 +81,10 @@ function validateDumpHeap(root, state) {
         addUnique(heapIds, id, path);
         const entry = requireRecord(value, path);
         validateErrorType(entry, path);
+        if (entry.kind === "date") {
+            validateDateRecord(entry, path);
+            continue;
+        }
         if (entry.kind === "float32array") {
             validateFloat32Storage(entry);
             requireRecord(entry.entries, `${path}.entries`);
@@ -402,7 +407,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"].includes(String(record.kind)))
+    if (!["arguments", "array", "object", "map", "set", "float32array", "date"].includes(String(record.kind)))
         fail("unknownTag", `${path}.kind`, "unknown heap tag");
     validateValue(record, path, 1, state);
     if (record.kind === "arguments")
@@ -411,6 +416,8 @@ function validateHeapValue(value, path, state) {
         validateArrayHeap(record, path, state);
     if (record.kind === "object")
         requireRecord(record.entries, `${path}.entries`);
+    if (record.kind === "date")
+        validateDateRecord(record, path);
     if (record.kind === "float32array") {
         validateFloat32Storage(record);
         requireRecord(record.entries, `${path}.entries`);
@@ -425,6 +432,16 @@ function validateHeapValue(value, path, state) {
     if (record.kind === "set")
         requireArray(record.values, `${path}.values`, state);
 }
+function validateDateRecord(record, path) {
+    if (Object.keys(record).length !== 2)
+        fail("invalidValue", path, "invalid Date fields");
+    try {
+        restoreDateTime(record.time);
+    }
+    catch {
+        fail("invalidValue", `${path}.time`, "invalid Date epoch");
+    }
+}
 function validateArrayHeap(record, path, state) {
     if (Object.hasOwn(record, "items")) {
         requireArray(record.items, `${path}.items`, state);