poe-code 14.0.5 → 14.0.7

package/packages/safe-js/dist/run.d.ts

@@ -1,10 +1,11 @@
+import { type RealmOptions } from "./realm.js";
 import { type ErrorSourceSpan } from "./error/shape.js";
 import { type SourceSpan } from "./parse/parser.js";
 import { type SafeJSSnapshot } from "./restore.js";
 import { Budget } from "./interp/budget.js";
 import { type PromiseReplaySnapshot } from "./interp/promise-replay.js";
 import { type HostCallRecord, type HostCallReplay, type HostCallResumeProvider } from "./interp/host-call.js";
-import { type ConsoleSink } from "./interp/globals/console-json.js";
+import type { ConsoleSink } from "./interp/globals/console-json.js";
 import { type CallerInjectedBinding } from "./interp/host-bridge.js";
 import { type InterpreterResult, type LoopIterationSnapshot } from "./interp/interpreter.js";
 import { type ModuleRegistry } from "./modules/registry.js";
@@ -12,6 +13,9 @@ import { type OtelSink } from "./observability/otel.js";
 import type { SnapshotBackend } from "./snapshot/backend.js";
 import { type ReplayData } from "./snapshot/replay-data.js";
 export type RunOptions = {
+    extensions?: RealmOptions["extensions"];
+    grants?: RealmOptions["grants"];
+    limits?: RealmOptions["limits"];
     bindings?: Record<string, CallerInjectedBinding>;
     budget?: Budget;
     clock?: RunClock;
@@ -59,6 +63,8 @@ export type RunClockSnapshot = {
     next: number;
 };
 export type RunClock = {
+    now?: () => number;
+    restore?: (snapshot: RunClockSnapshot) => void;
     snapshot: () => RunClockSnapshot | undefined;
 };
 export type RunRandom = {

package/packages/safe-js/dist/run.js

@@ -1,4 +1,5 @@
 import { AsyncLocalStorage } from "node:async_hooks";
+import { runWithExtensions } from "./realm.js";
 import { hashParsedAst, hashSource } from "./parse/hash.js";
 import { withRunResources } from "./interp/resources.js";
 import { createReplayableRandom } from "./random.js";
@@ -12,17 +13,10 @@ import { wrapCancelableBindings } from "./interp/cancel.js";
 import { enterSnapshotRun } from "./interp/running-state.js";
 import { createSandboxPromiseRejectionTracker, observeSandboxPromise, withSandboxPromiseRejectionTracker } from "./interp/promise-tracker.js";
 import { HostCallJournal } from "./interp/host-call.js";
-import { createConsoleJsonGlobals } from "./interp/globals/console-json.js";
-import { createCollectionGlobals } from "./interp/globals/collections.js";
-import { createFloat32ArrayGlobal } from "./interp/globals/float32array.js";
-import { createErrorGlobals } from "./interp/globals/error.js";
-import { createMathGlobals } from "./interp/globals/math.js";
-import { createRegexGlobals } from "./interp/globals/regex.js";
-import { createMiscGlobals } from "./interp/globals/misc.js";
-import { createObjectArrayGlobals } from "./interp/globals/object-array.js";
+import { createBuiltinBindings } from "./interp/globals.js";
 import { declareHostOperation, wrapCallerInjectedBindings } from "./interp/host-bridge.js";
 import { interpret, Scope } from "./interp/interpreter.js";
-import { consumeSettledHostCall, createPromiseGlobals } from "./interp/promise.js";
+import { consumeSettledHostCall } from "./interp/promise.js";
 import { deepCopyToSandbox, isSandboxClosure, isSandboxPromise, measureSandboxData, reconcileCompiledValues } from "./interp/values.js";
 import { resolveModuleImports } from "./modules/registry.js";
 import { activateOtelSink, getActiveOtelSpan, safeAddEvent } from "./observability/otel.js";
@@ -44,6 +38,8 @@ export class UnhandledRejectionError extends Error {
 }
 const DEFAULT_MAX_CALL_DEPTH = 1_000;
 export function run(source, options = {}) {
+    if (options.extensions !== undefined)
+        return runWithExtensions(source, options);
     const lifecycle = {
         hostCallbackDepth: 0,
         hostCallbackContext: new AsyncLocalStorage()
@@ -113,32 +109,7 @@ export function run(source, options = {}) {
                             signal: options.signal,
                             lifecycle
                         }));
-                    const builtinBindings = {
-                        ...createConsoleJsonGlobals({
-                            compileOwner: operation.owner,
-                            budget,
-                            hostCalls,
-                            sink: options.sink
-                        }),
-                        ...createCollectionGlobals({ budget }),
-                        Float32Array: createFloat32ArrayGlobal(budget),
-                        ...createErrorGlobals({
-                            budget
-                        }),
-                        ...createMathGlobals({
-                            random: random?.generator.next
-                        }),
-                        ...createObjectArrayGlobals({
-                            budget
-                        }),
-                        ...createMiscGlobals({
-                            budget
-                        }),
-                        ...createPromiseGlobals({
-                            budget
-                        }),
-                        ...createRegexGlobals(operation.owner)
-                    };
+                    const builtinBindings = createBuiltinBindings({ compileOwner: operation.owner, budget, hostCalls, sink: options.sink, random: random?.generator.next, clock: options.clock });
                     const importMeta = convertInitialInput(() => deepCopyToSandbox(options.importMeta ?? {}));
                     if (restoredSnapshot?.migration !== undefined) {
                         if (Object.hasOwn(importMeta, "migration"))

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

@@ -8,6 +8,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";
 const SKIP_VALUE = Symbol("SafeJS.skip-dump-value");
 export function serializeSafeJSSnapshot(snapshot) {
     const replayError = Object.getOwnPropertyDescriptor(snapshot, "replayError");
@@ -72,7 +73,7 @@ function serializeDumpValue(value, path, state) {
     if (hasGuestObjectState(value)) {
         throw new TypeError("Guest function properties and prototype links cannot be serialized.");
     }
-    if (isFloat32Array(value))
+    if (isSandboxDate(value) || isFloat32Array(value))
         return serializeHeapReference(value, path, state);
     if (Array.isArray(value)) {
         const reference = serializeHeapReference(value, path, state);
@@ -97,7 +98,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
@@ -159,6 +163,7 @@ function indexHeapContainers(snapshot) {
     for (const [value, stat] of stats.entries()) {
         if (stat.count > 1 ||
             stat.cyclic ||
+            isSandboxDate(value) ||
             isFloat32Array(value) ||
             (Array.isArray(value) && requiresArrayEntries(value)) ||
             isSandboxArguments(value) ||
@@ -173,7 +178,7 @@ function collectContainerStats(value, stats, ancestors) {
     if (value === null || typeof value !== "object") {
         return;
     }
-    if (!Array.isArray(value) && !isPlainObject(value) && !isFloat32Array(value)) {
+    if (!Array.isArray(value) && !isPlainObject(value) && !isFloat32Array(value) && !isSandboxDate(value)) {
         return;
     }
     let stat = stats.get(value);

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

@@ -24,7 +24,10 @@ type Properties = Record<string, {
     enumerable: boolean;
     writable: boolean;
 }>;
-type DataNode = (Float32Data<Atom> & {
+type DataNode = {
+    kind: "date";
+    time: number | null;
+} | (Float32Data<Atom> & {
     properties: Properties;
     extensible: boolean;
 }) | {

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

@@ -3,6 +3,7 @@ import { hasGuestObjectState } 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 { isSandboxDate, restoreDateTime, serializedDateTime } from "../interp/date.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";
@@ -63,6 +64,9 @@ export function encodeReplayData(value, options = {}) {
                 properties: child(entry.properties, "properties")
             };
         }
+        else if (isSandboxDate(entry)) {
+            nodes[id] = { kind: "date", time: serializedDateTime(entry) };
+        }
         else if (isFloat32Array(entry)) {
             const storage = encodeFloat32Storage(entry, id, float32Buffers, (id) => ({
                 tag: "ref",
@@ -231,6 +235,13 @@ export function decodeReplayData(input, options = {}, parent) {
                 options.onCapabilityRestored?.(capability, copy);
                 return copy;
             }
+            if (kind === "date") {
+                if (Object.keys(node).length !== 2)
+                    throw new TypeError("Invalid serialized Date fields.");
+                const result = restoreDateTime(own(node, "time"));
+                restored.set(id, result);
+                return result;
+            }
             if (kind === "float32array") {
                 if (typeof node.extensible !== "boolean")
                     throw new TypeError("Invalid Float32Array extensibility.");

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);