poe-code 14.0.6 → 14.0.8

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

@@ -3,6 +3,7 @@ import { types } from "node:util";
 import { Budget, SandboxError } from "./interp/budget.js";
 import { CompileScope } from "./interp/regex/compile-guard.js";
 import { createBuiltinBindings } from "./interp/globals.js";
+import { releaseObjectPrototype } from "./interp/object-model.js";
 import { interpret, Scope } from "./interp/interpreter.js";
 import { SandboxJobQueue, runAsyncPrefix, suspendJob } from "./interp/jobs.js";
 import { withCancellationSignal, awaitSandboxValue } from "./interp/cancel.js";
@@ -10,7 +11,7 @@ import { enterRunningState } from "./interp/running-state.js";
 import { runResources } from "./interp/resources.js";
 import { createSandboxPromiseRejectionTracker, withSandboxPromiseRejectionTracker } from "./interp/promise-tracker.js";
 import { copyHostValueToSandbox, wrapCallerInjectedBindings } from "./interp/host-bridge.js";
-import { createLiveHostObject, exportHostCapability, readGuestCallback, registerGuestCallback, revokeGuestCallback, revokeHostObject } from "./interp/host-capabilities.js";
+import { createLiveHostObject, createGuestReference, exportHostCapability, readGuestReference, readGuestCallback, registerGuestCallback, revokeGuestCallback, revokeHostObject, revokeGuestReference } from "./interp/host-capabilities.js";
 import { deepCopyFromSandbox, isSandboxClosure, measureSandboxData, reconcileCompiledValues } from "./interp/values.js";
 import { getExtensionSetup, readDataRecord, readStringList } from "./extensions.js";
 import { resolveModuleImports } from "./modules/registry.js";
@@ -36,6 +37,8 @@ class RealmState {
     pendingCallbacks = new Set();
     callbackCache = new WeakMap();
     hostObjects = new Set();
+    guestReferences = new Map();
+    retainedOperations = new WeakMap();
     nestedOperations = new WeakMap();
     convertedModules = new Map();
     nativeConversions = { seen: new WeakMap() };
@@ -56,6 +59,7 @@ class RealmState {
             extensions: 32,
             hostObjects: 1024,
             callbacks: 1024,
+            guestReferences: 1024,
             cleanups: 1024,
             nestedEvaluations: 16
         };
@@ -94,6 +98,7 @@ class RealmState {
             owner: this,
             assertActive: this.assertOpen,
             wrapCallback: this.wrapCallback,
+            captureArguments: this.captureArguments,
             invoke: this.invokeHost,
             awaitResult: (operation) => this.nestedOperations.has(operation)
         };
@@ -102,6 +107,7 @@ class RealmState {
                 budget: this.budget,
                 compileOwner: this.lease.owner,
                 sink: options.sink,
+                clock: options.clock,
                 random: createReplayableRandom({ seed: options.randomSeed }).next
             });
             const names = new Set();
@@ -134,10 +140,11 @@ class RealmState {
             options.signal?.addEventListener("abort", this.abort, { once: true });
             if (options.signal?.aborted)
                 this.abort();
-            this.budget.setRetainedValues(this, this.retainedCallbacks);
+            this.budget.setRetainedValues(this, this.retainedRoots);
             this.tracker.onFatalRejection((error) => this.poison(error));
         }
         catch (error) {
+            releaseObjectPrototype(this.budget);
             this.compilation.dispose();
             this.lease.release();
             throw error;
@@ -149,10 +156,48 @@ class RealmState {
         signal: this.controller.signal,
         realm: this.bridge
     });
-    retainedCallbacks = () => [
+    retainedRoots = () => [
         ...this.callbacks.values(),
-        ...Array.from(this.pendingCallbacks, (pending) => pending.closure)
+        ...Array.from(this.pendingCallbacks, (pending) => pending.closure),
+        ...this.guestReferences.values()
     ];
+    captureArguments = (operation, args, copy) => {
+        const from = this.retainedOperations.get(operation)?.from ?? args.length;
+        const values = copy(args.slice(0, from));
+        const captured = [];
+        const rollback = () => {
+            for (const reference of captured) {
+                revokeGuestReference(reference, this);
+                this.guestReferences.delete(reference);
+            }
+        };
+        try {
+            for (const value of args.slice(from)) {
+                this.checkCollection(this.guestReferences.size + 1, this.limits.guestReferences, "guest reference");
+                const root = [value];
+                const reference = createGuestReference(root, this, this.assertOpen);
+                this.guestReferences.set(reference, root);
+                captured.push(reference);
+                values.push(reference);
+            }
+            if (captured.length > 0)
+                this.budget.reconcileDataUsage(measureSandboxData([...(this.scope?.retainedValues() ?? []), ...this.retainedRoots()]));
+            return { args: values, rollback };
+        }
+        catch (error) {
+            rollback();
+            if (error instanceof SandboxError)
+                this.poison(error);
+            throw error;
+        }
+    };
+    releaseGuestReference = (reference) => {
+        readGuestReference(reference, this);
+        revokeGuestReference(reference, this);
+        this.guestReferences.delete(reference);
+        if (this.active === undefined)
+            reconcileCompiledValues(this.budget, [...(this.scope?.retainedValues() ?? []), ...this.retainedRoots()], this.compilation);
+    };
     assertOpen = () => {
         if (this.failure !== undefined)
             throw this.failure.reason;
@@ -267,13 +312,23 @@ class RealmState {
             owner: this,
             assertActive: this.assertOpen,
             chargeWork: this.chargeWork,
-            read: (operation) => {
+            checkLength: (length) => this.budget.allocateArrayLength(length),
+            checkTemporaryDataSize: (size) => {
+                const temporary = {};
+                try {
+                    this.budget.setRetainedDataUsage(temporary, size);
+                }
+                finally {
+                    this.budget.setRetainedDataUsage(temporary, 0);
+                }
+            },
+            read: (operation, validate) => {
                 const value = this.invokeHost(operation, operation);
                 if (types.isPromise(value)) {
                     void Promise.resolve(value).catch(() => undefined);
                     throw new TypeError("Live property getters must be synchronous.");
                 }
-                return this.importValue(value);
+                return this.importValue(validate === undefined ? value : validate(value));
             },
             write: (operation, value) => {
                 const result = this.invokeHost(operation, () => operation(this.exportValue(value)));
@@ -321,7 +376,7 @@ class RealmState {
             }
         });
         try {
-            this.budget.reconcileDataUsage(measureSandboxData([...(this.scope?.retainedValues() ?? []), ...this.retainedCallbacks()]));
+            this.budget.reconcileDataUsage(measureSandboxData([...(this.scope?.retainedValues() ?? []), ...this.retainedRoots()]));
         }
         catch (error) {
             this.poison(error);
@@ -334,7 +389,7 @@ class RealmState {
         revokeGuestCallback(callback, this);
         this.callbacks.delete(callback);
         if (this.active === undefined)
-            reconcileCompiledValues(this.budget, [...(this.scope?.retainedValues() ?? []), ...this.retainedCallbacks()], this.compilation);
+            reconcileCompiledValues(this.budget, [...(this.scope?.retainedValues() ?? []), ...this.retainedRoots()], this.compilation);
     };
     invokeCallback = async (callback, options = {}) => {
         if (this.closed || this.failure !== undefined)
@@ -384,7 +439,7 @@ class RealmState {
         finally {
             this.pendingCallbacks.delete(record);
             if (!this.closed && this.active === undefined)
-                reconcileCompiledValues(this.budget, [...(this.scope?.retainedValues() ?? []), ...this.retainedCallbacks()], this.compilation);
+                reconcileCompiledValues(this.budget, [...(this.scope?.retainedValues() ?? []), ...this.retainedRoots()], this.compilation);
         }
     };
     initialize() {
@@ -400,6 +455,24 @@ class RealmState {
                 createHostObject: this.createHostObject,
                 invokeCallback: this.invokeCallback,
                 releaseCallback: this.releaseCallback,
+                releaseGuestReference: this.releaseGuestReference,
+                retainGuestArguments: (operation, from) => {
+                    this.assertOpen();
+                    if (!extension.manifest.capabilities?.includes("guest:retain"))
+                        throw new TypeError("Retaining arguments requires the guest:retain grant.");
+                    if (typeof operation !== "function")
+                        throw new TypeError("Retained operation must be a function.");
+                    if (!Number.isSafeInteger(from) || from < 0)
+                        throw new TypeError("Argument index must be a non-negative safe integer.");
+                    if (this.scope !== undefined)
+                        throw new TypeError("Retained operations must be registered during setup.");
+                    const previous = this.retainedOperations.get(operation);
+                    if (previous !== undefined &&
+                        (previous.extension !== extension || previous.from !== from))
+                        throw new TypeError("Conflicting retained operation declaration.");
+                    this.retainedOperations.set(operation, { extension, from });
+                    return operation;
+                },
                 nestedOperation: (operation) => {
                     this.assertOpen();
                     if (!extension.manifest.capabilities?.includes("source:nested"))
@@ -552,7 +625,7 @@ class RealmState {
             if (this.failure !== undefined)
                 throw this.failure.reason;
             if (!this.closed)
-                reconcileCompiledValues(this.budget, [...(this.scope?.retainedValues() ?? []), ...this.retainedCallbacks()], this.compilation);
+                reconcileCompiledValues(this.budget, [...(this.scope?.retainedValues() ?? []), ...this.retainedRoots()], this.compilation);
             return result;
         }
         catch (error) {
@@ -591,7 +664,11 @@ class RealmState {
         for (const object of this.hostObjects)
             revokeHostObject(object, this);
         this.hostObjects.clear();
+        for (const reference of this.guestReferences.keys())
+            revokeGuestReference(reference, this);
+        this.guestReferences.clear();
         this.budget.setRetainedValues(this, undefined);
+        releaseObjectPrototype(this.budget);
         this.disposal = (async () => {
             const errors = [];
             for (const cleanup of this.cleanups.splice(0).reverse()) {
@@ -651,6 +728,7 @@ export function createRealm(options = {}) {
         evaluate: state.evaluate,
         invokeCallback: state.invokeCallback,
         releaseCallback: state.releaseCallback,
+        releaseGuestReference: state.releaseGuestReference,
         close: state.close
     });
 }
@@ -702,6 +780,7 @@ function readRealmOptions(value, oneShot = false) {
         "signal",
         "sink",
         "randomSeed",
+        "clock",
         "limits"
     ]);
     for (const [key, entry] of Object.entries(options)) {

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

@@ -63,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

@@ -14,6 +14,7 @@ import { enterSnapshotRun } from "./interp/running-state.js";
 import { createSandboxPromiseRejectionTracker, observeSandboxPromise, withSandboxPromiseRejectionTracker } from "./interp/promise-tracker.js";
 import { HostCallJournal } from "./interp/host-call.js";
 import { createBuiltinBindings } from "./interp/globals.js";
+import { releaseObjectPrototype } from "./interp/object-model.js";
 import { declareHostOperation, wrapCallerInjectedBindings } from "./interp/host-bridge.js";
 import { interpret, Scope } from "./interp/interpreter.js";
 import { consumeSettledHostCall } from "./interp/promise.js";
@@ -109,7 +110,7 @@ export function run(source, options = {}) {
                             signal: options.signal,
                             lifecycle
                         }));
-                    const builtinBindings = createBuiltinBindings({ compileOwner: operation.owner, budget, hostCalls, sink: options.sink, random: random?.generator.next });
+                    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"))
@@ -349,6 +350,7 @@ export function run(source, options = {}) {
             });
         }
         finally {
+            releaseObjectPrototype(budget);
             compilation.dispose();
             operation.release();
         }

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