poe-code 14.0.6 → 14.0.7

package/packages/safe-js/dist/interp/host-bridge.js

@@ -1,4 +1,5 @@
 import { normalizeClosureResult } from "./async.js";
+import { copyNativeDate } from "./date.js";
 import { exportHostCapability, importHostCapability, isLiveCapability } from "./host-capabilities.js";
 import { attachErrorSpan, replaceErrorStack } from "../error/shape.js";
 import { SandboxError } from "./budget.js";
@@ -77,11 +78,13 @@ function wrapCallerInjectedFunction(name, value, options, state) {
                     seen: new WeakMap(),
                     restored: []
                 };
-                const hostArgs = deepCopyFromSandbox([...args], {
+                const copyArguments = (values) => deepCopyFromSandbox([...values], {
                     compilation,
                     unwrapHostObject: options.realm === undefined ? undefined : object => exportHostCapability(object, options.realm.owner),
                     wrapClosure: (closure) => options.realm?.wrapCallback(closure) ?? wrapSandboxClosureForHost(closure, stackFrames, options.budget, operationLease.owner, callbacks)
                 });
+                const captured = options.realm?.captureArguments(callable, args, copyArguments);
+                const hostArgs = captured?.args ?? copyArguments(args);
                 const hostCalls = options.hostCalls;
                 const operation = options.operation ?? bindingName;
                 const moduleId = options.moduleId ?? "<bindings>";
@@ -90,7 +93,14 @@ function wrapCallerInjectedFunction(name, value, options, state) {
                     "re-issue";
                 if (hostCalls === undefined) {
                     if (options.realm !== undefined) {
-                        const result = options.realm.invoke(callable, () => Reflect.apply(callable, undefined, hostArgs));
+                        let result;
+                        try {
+                            result = options.realm.invoke(callable, () => Reflect.apply(callable, undefined, hostArgs));
+                        }
+                        catch (error) {
+                            captured.rollback();
+                            throw error;
+                        }
                         if (options.realm.awaitResult(callable)) {
                             return Promise.resolve(result).then(value => copyHostResultToSandbox(value, stackFrames, options));
                         }
@@ -658,6 +668,15 @@ export function copyHostValueToSandbox(value, stackFrames, options, state, path)
                 : path
         }, state);
     }
+    const date = copyNativeDate(value);
+    if (date !== undefined) {
+        const existing = state.seen.get(value);
+        if (existing !== undefined)
+            return existing;
+        budget.chargeDataUsage(9);
+        state.seen.set(value, date);
+        return date;
+    }
     if (isFloat32Array(value)) {
         const existing = state.seen.get(value);
         if (existing !== undefined)

package/packages/safe-js/dist/interp/host-call.js

@@ -1,5 +1,6 @@
 import { createHash, randomUUID } from "node:crypto";
 import { float32DataProperties, float32Storage, isFloat32Array } from "./float32.js";
+import { copyNativeDate, serializedDateTime } from "./date.js";
 import { cloneSandboxValue, createSandboxClosure, defineOwnDataProperty, isArrayIndexKey, measureSandboxData } from "./values.js";
 import { CompileScope } from "./regex/compile-guard.js";
 import { decodeReplayData, encodeReplayData } from "../snapshot/replay-data.js";
@@ -581,6 +582,9 @@ function normalize(value, seen) {
         throw new TypeError("Host call arguments cannot contain cycles.");
     seen.add(value);
     try {
+        const date = copyNativeDate(value);
+        if (date !== undefined)
+            return Object.assign(Object.create(null), { $type: "date", time: serializedDateTime(date) });
         if (isFloat32Array(value)) {
             const storage = float32Storage(value);
             const properties = Object.create(null);

package/packages/safe-js/dist/interp/host-capabilities.d.ts

@@ -1,6 +1,7 @@
 import { type HostOperation } from "../extensions.js";
 import type { SandboxClosure, SandboxObject, SandboxValue } from "./values.js";
 declare const hostObjectBrand: unique symbol;
+declare const guestReferenceBrand: unique symbol;
 declare const sandboxHostObjectBrand: unique symbol;
 type SandboxHostObject = SandboxObject & {
     readonly [sandboxHostObjectBrand]: true;
@@ -8,6 +9,9 @@ type SandboxHostObject = SandboxObject & {
 export type HostObject = Readonly<Record<string, never>> & {
     readonly [hostObjectBrand]: true;
 };
+export type GuestReference = Readonly<Record<string, never>> & {
+    readonly [guestReferenceBrand]: true;
+};
 export type HostObjectDefinition = {
     properties?: Record<string, {
         get?: () => unknown;
@@ -28,6 +32,9 @@ type GuestCallbackState = {
     closure?: SandboxClosure;
     assertActive(): void;
 };
+export declare function createGuestReference(root: [SandboxValue], owner: object, assertActive: () => void): GuestReference;
+export declare function readGuestReference(reference: unknown, owner: object): SandboxValue;
+export declare function revokeGuestReference(reference: GuestReference, owner: object): void;
 export declare function createLiveHostObject(definition: HostObjectDefinition, controller: HostObjectController): HostObject;
 export declare function isGuestHostObject(value: unknown): value is SandboxHostObject;
 export declare function isLiveCapability(value: unknown): boolean;

package/packages/safe-js/dist/interp/host-capabilities.js

@@ -2,6 +2,29 @@ import { readDataRecord } from "../extensions.js";
 const hostObjects = new WeakMap();
 const guestObjects = new WeakMap();
 const guestCallbacks = new WeakMap();
+const guestReferences = new WeakMap();
+export function createGuestReference(root, owner, assertActive) {
+    const reference = Object.freeze(Object.create(null));
+    guestReferences.set(reference, { root, owner, assertActive });
+    return reference;
+}
+export function readGuestReference(reference, owner) {
+    const state = typeof reference === "object" && reference !== null
+        ? guestReferences.get(reference)
+        : undefined;
+    if (state === undefined || state.owner !== owner)
+        throw new TypeError("Foreign or invalid guest reference.");
+    state.assertActive();
+    if (state.root === undefined)
+        throw new TypeError("Guest reference is revoked.");
+    return state.root[0];
+}
+export function revokeGuestReference(reference, owner) {
+    const state = guestReferences.get(reference);
+    if (state === undefined || state.owner !== owner)
+        throw new TypeError("Foreign guest reference.");
+    state.root = undefined;
+}
 export function createLiveHostObject(definition, controller) {
     const input = readDataRecord(definition, "Host object definition");
     if (Object.keys(input).some((key) => key !== "properties" && key !== "methods"))
@@ -45,9 +68,14 @@ export function isGuestHostObject(value) {
 }
 export function isLiveCapability(value) {
     return (((typeof value === "object" && value !== null) || typeof value === "function") &&
-        (hostObjects.has(value) || guestObjects.has(value) || guestCallbacks.has(value)));
+        (hostObjects.has(value) ||
+            guestObjects.has(value) ||
+            guestCallbacks.has(value) ||
+            guestReferences.has(value)));
 }
 export function importHostCapability(value, owner) {
+    if (guestReferences.has(value))
+        return readGuestReference(value, owner);
     const object = hostObjects.get(value);
     if (object !== undefined) {
         if (object.controller.owner !== owner)

package/packages/safe-js/dist/interp/interpreter.js

@@ -27,6 +27,8 @@ import { isSandboxErrorConstructorInstance } from "./globals/error.js";
 import { isSandboxMapConstructor, isSandboxSetConstructor } from "./globals/collections.js";
 import { getFloat32Member, isFloat32ArrayConstructor, setFloat32Member } from "./globals/float32array.js";
 import { isFloat32Array } from "./float32.js";
+import { dateString, dateTime, isSandboxDate } from "./date.js";
+import { getDateMember, getDatePrototype, isDateConstructor } from "./globals/date.js";
 import { createSandboxRegex, allocateProducedSandboxValue, isSandboxClosure, isSandboxGenerator, isSandboxMap, isSandboxPromise, isSandboxRegex, isSandboxSet, reconcileCompiledValues } from "./values.js";
 import { Scope } from "./scope.js";
 import { hoistVarDeclarations } from "./var-hoist.js";
@@ -1648,6 +1650,8 @@ function getPropertyValue(target, property, context) {
         return undefined;
     if (isFloat32Array(target))
         return getFloat32Member(target, property, context.budget);
+    if (isSandboxDate(target))
+        return getDateMember(property, context.budget, context.compilation?.owner);
     if (isSandboxMap(target))
         return getMapMember(target, property, createMapMethodOptions(context));
     if (isSandboxSet(target))
@@ -1864,6 +1868,9 @@ async function evaluateMemberCallExpression(node, context) {
     if (isSandboxMap(member.object)) {
         return evaluatePrimitiveMemberCall(node, "Map", member.property, getMapMember(member.object, member.property, createMapMethodOptions(context)), context);
     }
+    if (isSandboxDate(member.object)) {
+        return evaluateResolvedCallExpression(node, getDateMember(member.property, context.budget, context.compilation?.owner), context, member.object);
+    }
     if (isFloat32Array(member.object)) {
         return evaluateResolvedCallExpression(node, getFloat32Member(member.object, member.property, context.budget), context, member.object);
     }
@@ -2076,6 +2083,8 @@ function applyBinaryOperator(node, left, right, context) {
             }
             if (isFloat32ArrayConstructor(right))
                 return isFloat32Array(left);
+            if (isDateConstructor(right))
+                return isSandboxDate(left) && getDatePrototype(left, context.budget, context.compilation?.owner) !== null;
             if (isSandboxSetConstructor(right) && isSandboxSet(left)) {
                 return true;
             }
@@ -2141,8 +2150,8 @@ function applyAdditionOperator(left, right, context) {
     return toNumber(leftPrimitive) + toNumber(rightPrimitive);
 }
 function compareRelational(left, right, operator) {
-    const leftPrimitive = toPrimitive(left);
-    const rightPrimitive = toPrimitive(right);
+    const leftPrimitive = isSandboxDate(left) ? dateTime(left) : toPrimitive(left);
+    const rightPrimitive = isSandboxDate(right) ? dateTime(right) : toPrimitive(right);
     if (typeof leftPrimitive === "string" && typeof rightPrimitive === "string") {
         switch (operator) {
             case "<":
@@ -2225,6 +2234,8 @@ function toPrimitive(value) {
     return toString(value);
 }
 async function toNumericPrimitive(value, context) {
+    if (isSandboxDate(value))
+        return dateTime(value);
     if (isPrimitiveCoercionType(getCoercionType(value))) {
         return value;
     }
@@ -2247,6 +2258,8 @@ async function toNumericPrimitive(value, context) {
     return toString(value);
 }
 function toNumber(value) {
+    if (isSandboxDate(value))
+        return dateTime(value);
     if (typeof value === "number") {
         return value;
     }
@@ -2265,6 +2278,8 @@ function toNumber(value) {
     return toNumber(toPrimitive(value));
 }
 function toString(value) {
+    if (isSandboxDate(value))
+        return dateString(value);
     if (Array.isArray(value)) {
         return value
             .map((entry) => (entry === null || entry === undefined ? "" : toString(entry)))
@@ -2323,6 +2338,8 @@ function getArrayMemberValue(target, property, context) {
     return getArrayMember(target, property, createArrayMethodOptions(context));
 }
 export function setSandboxProperty(target, property, value, budget) {
+    if (isSandboxDate(target))
+        throw new TypeError("Date own properties are not supported.");
     if (isGuestHostObject(target)) {
         setHostObjectMember(target, String(property), value);
         return;

package/packages/safe-js/dist/interp/string-coercion.js

@@ -1,4 +1,5 @@
 import { sandboxErrorTypes } from "../error/shape.js";
+import { dateString, isSandboxDate } from "./date.js";
 import { float32Storage, isFloat32Array } from "./float32.js";
 import { isSandboxClosure, isSandboxPromise } from "./values.js";
 export function sandboxString(value, budget, context, joining = new Set()) {
@@ -41,6 +42,8 @@ async function stringifyObject(value, budget, context, joining) {
     }
 }
 async function defaultToString(value, budget, context, joining) {
+    if (isSandboxDate(value))
+        return budget.allocateString(dateString(value));
     if (Array.isArray(value) || isFloat32Array(value)) {
         if (Object.hasOwn(value, "join")) {
             const join = ownDataValue(value, "join");

package/packages/safe-js/dist/interp/values.d.ts

@@ -12,7 +12,7 @@ declare const sandboxRegexPattern: unique symbol;
 declare const sandboxSetBrand: unique symbol;
 declare const sandboxRetainedValues: unique symbol;
 export type SandboxPrimitive = string | number | boolean | null | undefined;
-export type SandboxValue = SandboxPrimitive | Float32Array | SandboxObject | SandboxArray | SandboxClosure | SandboxGenerator | SandboxMap | SandboxSet | SandboxPromise | SandboxRegex;
+export type SandboxValue = SandboxPrimitive | Date | Float32Array | SandboxObject | SandboxArray | SandboxClosure | SandboxGenerator | SandboxMap | SandboxSet | SandboxPromise | SandboxRegex;
 export type SandboxObject = {
     [key: string]: SandboxValue;
 };

package/packages/safe-js/dist/interp/values.js

@@ -1,4 +1,5 @@
 import { bindOtelSpan, getBoundOtelSpan } from "../observability/otel.js";
+import { copyNativeDate, exportDate, isSandboxDate } from "./date.js";
 import { getHostObjectKeys, getHostObjectMember, isGuestHostObject, isLiveCapability } from "./host-capabilities.js";
 import { types as nodeTypes } from "node:util";
 import { CompileScope, RegexCompileGuard, regexCompiledData } from "./regex/compile-guard.js";
@@ -225,6 +226,10 @@ export function measureSandboxData(values, options = {}) {
         assertSandboxDataDepth(depth);
         seen.add(value);
         usage += 1;
+        if (isSandboxDate(value)) {
+            usage += 8;
+            return;
+        }
         if (isGuestHostObject(value)) {
             for (const key of getHostObjectKeys(value))
                 usage += key.length + 1;
@@ -435,6 +440,14 @@ function copyToSandbox(value, state, path = "<root>", cloneSandboxCollections =
         }
         return sandboxPromise;
     }
+    if (nodeTypes.isDate(value)) {
+        const existing = state.seen.get(value);
+        if (existing !== undefined)
+            return existing;
+        const copy = copyNativeDate(value);
+        state.seen.set(value, copy);
+        return copy;
+    }
     if (isFloat32Array(value)) {
         const existing = state.seen.get(value);
         if (existing !== undefined)
@@ -567,6 +580,14 @@ function copyFromSandbox(value, state, path = "<root>", options, depth = 0) {
             Object.preventExtensions(copy);
         return copy;
     }
+    if (isSandboxDate(value)) {
+        const existing = state.seen.get(value);
+        if (existing !== undefined)
+            return existing;
+        const copy = exportDate(value);
+        state.seen.set(value, copy);
+        return copy;
+    }
     if (isSandboxClosure(value)) {
         if (options.wrapClosure === undefined) {
             throw new TypeError("Sandbox closures cannot cross into host values without an explicit wrapper.");

package/packages/safe-js/dist/lint/rules/known-globals.d.ts

@@ -1 +1 @@
-export declare const KNOWN_RUNTIME_GLOBALS: readonly ["AggregateError", "Array", "Boolean", "Error", "Infinity", "isFinite", "isNaN", "JSON", "Map", "Float32Array", "Math", "NaN", "Number", "Object", "parseFloat", "parseInt", "Promise", "RangeError", "ReferenceError", "RegExp", "Set", "String", "structuredClone", "SyntaxError", "TypeError", "console"];
+export declare const KNOWN_RUNTIME_GLOBALS: readonly ["AggregateError", "Array", "Boolean", "Date", "Error", "Infinity", "isFinite", "isNaN", "JSON", "Map", "Float32Array", "Math", "NaN", "Number", "Object", "parseFloat", "parseInt", "Promise", "RangeError", "ReferenceError", "RegExp", "Set", "String", "structuredClone", "SyntaxError", "TypeError", "console"];

package/packages/safe-js/dist/lint/rules/known-globals.js

@@ -2,6 +2,7 @@ export const KNOWN_RUNTIME_GLOBALS = [
     "AggregateError",
     "Array",
     "Boolean",
+    "Date",
     "Error",
     "Infinity",
     "isFinite",

package/packages/safe-js/dist/parse/parser.js

@@ -1832,8 +1832,10 @@ class Parser {
             }
             break;
         }
-        this.expectPunctuator("(");
-        const args = this.parseArguments();
+        const optional = this.consumePunctuator("?.");
+        if (optional !== undefined)
+            throw new DisallowedSyntaxError("new optional chain", optional.start);
+        const args = this.consumePunctuator("(") === undefined ? [] : this.parseArguments();
         const end = this.previousToken();
         return {
             node: {

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

@@ -4,15 +4,17 @@ import { type CallerInjectedBinding } from "./interp/host-bridge.js";
 import { type CallbackOptions, type SafeJSExtension } from "./extensions.js";
 import { type ModuleRegistry } from "./modules/registry.js";
 import type { ConsoleSink } from "./interp/globals/console-json.js";
-import type { RunOptions, RunResult } from "./run.js";
+import type { RunClock, RunOptions, RunResult } from "./run.js";
 export type RealmLimits = {
     extensions?: number;
     hostObjects?: number;
     callbacks?: number;
+    guestReferences?: number;
     cleanups?: number;
     nestedEvaluations?: number;
 };
 export type RealmOptions = {
+    clock?: RunClock;
     bindings?: Record<string, CallerInjectedBinding>;
     modules?: ModuleRegistry;
     extensions?: readonly SafeJSExtension[];
@@ -37,6 +39,7 @@ export type SafeJSRealm = {
     }): Promise<RealmResult>;
     invokeCallback(callback: unknown, options?: CallbackOptions): Promise<unknown>;
     releaseCallback(callback: unknown): void;
+    releaseGuestReference(reference: unknown): void;
     close(): Promise<void>;
 };
 export declare function createRealm(options?: RealmOptions): SafeJSRealm;

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

@@ -10,7 +10,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 +36,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 +58,7 @@ class RealmState {
             extensions: 32,
             hostObjects: 1024,
             callbacks: 1024,
+            guestReferences: 1024,
             cleanups: 1024,
             nestedEvaluations: 16
         };
@@ -94,6 +97,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 +106,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,7 +139,7 @@ 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) {
@@ -149,10 +154,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;
@@ -321,7 +364,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 +377,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 +427,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 +443,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 +613,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,6 +652,9 @@ 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);
         this.disposal = (async () => {
             const errors = [];
@@ -651,6 +715,7 @@ export function createRealm(options = {}) {
         evaluate: state.evaluate,
         invokeCallback: state.invokeCallback,
         releaseCallback: state.releaseCallback,
+        releaseGuestReference: state.releaseGuestReference,
         close: state.close
     });
 }
@@ -702,6 +767,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

@@ -109,7 +109,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"))

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