poe-code 14.0.6 → 14.0.7

package/packages/safe-js/dist/chunks/{chunk-2M6MNQBY.js → chunk-BWVASPJX.js}

@@ -4263,8 +4263,9 @@ var Parser = class {
       }
       break;
     }
-    this.expectPunctuator("(");
-    const args = this.parseArguments();
+    const optional = this.consumePunctuator("?.");
+    if (optional !== void 0) throw new DisallowedSyntaxError("new optional chain", optional.start);
+    const args = this.consumePunctuator("(") === void 0 ? [] : this.parseArguments();
     const end = this.previousToken();
     return {
       node: {
@@ -6207,10 +6208,151 @@ function copyFloat32Storage(value, state) {
   return new Float32Array(buffer, storage.byteOffset, storage.length);
 }
 
+// packages/safe-js/src/interp/date.ts
+import { types as types2 } from "node:util";
+var NativeDate = Date;
+var readTime = NativeDate.prototype.getTime;
+var writeTime = NativeDate.prototype.setTime;
+var dates = /* @__PURE__ */ new WeakSet();
+function isSandboxDate(value) {
+  return typeof value === "object" && value !== null && dates.has(value);
+}
+function createSandboxDate(time) {
+  const value = new NativeDate(time);
+  dates.add(value);
+  return Object.freeze(value);
+}
+function dateTime(value) {
+  return Reflect.apply(readTime, value, []);
+}
+function copyNativeDate(value) {
+  if (!types2.isDate(value)) return void 0;
+  if (Object.getPrototypeOf(value) !== NativeDate.prototype || Reflect.ownKeys(value).length > 0)
+    throw new TypeError("Date subclasses and own properties are not supported.");
+  return createSandboxDate(dateTime(value));
+}
+function exportDate(value) {
+  return new NativeDate(dateTime(value));
+}
+function dateNumber(value) {
+  if (isSandboxDate(value)) return dateTime(value);
+  if (typeof value === "object" && value !== null || typeof value === "function" || typeof value === "symbol" || typeof value === "bigint")
+    throw new TypeError("Date arguments require primitive values; custom coercion is unsupported.");
+  return Number(value);
+}
+function parseDate(value, budget) {
+  if (typeof value === "object" && value !== null || typeof value === "function")
+    throw new TypeError("Date parsing requires a primitive value.");
+  const text = String(value);
+  if (text.length > 4096) throw new RangeError("Date input exceeds the 4096 character limit.");
+  budget.allocateString(text);
+  for (let index = 0; index < text.length; index++) budget.visitNode();
+  return NativeDate.parse(text);
+}
+function dateFromParts(args, utc) {
+  const parts = args.slice(0, 7).map(dateNumber);
+  return utc ? Reflect.apply(NativeDate.UTC, NativeDate, parts) : dateTime(Reflect.construct(NativeDate, parts));
+}
+var methodNames = [
+  "getTime",
+  "valueOf",
+  "getDate",
+  "getDay",
+  "getFullYear",
+  "getHours",
+  "getMilliseconds",
+  "getMinutes",
+  "getMonth",
+  "getSeconds",
+  "getTimezoneOffset",
+  "getUTCDate",
+  "getUTCDay",
+  "getUTCFullYear",
+  "getUTCHours",
+  "getUTCMilliseconds",
+  "getUTCMinutes",
+  "getUTCMonth",
+  "getUTCSeconds",
+  "setTime",
+  "setDate",
+  "setFullYear",
+  "setHours",
+  "setMilliseconds",
+  "setMinutes",
+  "setMonth",
+  "setSeconds",
+  "setUTCDate",
+  "setUTCFullYear",
+  "setUTCHours",
+  "setUTCMilliseconds",
+  "setUTCMinutes",
+  "setUTCMonth",
+  "setUTCSeconds",
+  "toDateString",
+  "toISOString",
+  "toString",
+  "toTimeString",
+  "toUTCString",
+  "toJSON"
+];
+var dateMethods = new Map(
+  methodNames.map((name) => {
+    const native = NativeDate.prototype[name];
+    return [
+      name,
+      {
+        length: native.length,
+        invoke: (date, args) => {
+          if (name === "toJSON")
+            return Number.isNaN(dateTime(date)) ? null : Reflect.apply(NativeDate.prototype.toISOString, date, []);
+          return Reflect.apply(
+            native,
+            date,
+            name.startsWith("set") ? args.slice(0, native.length).map(dateNumber) : []
+          );
+        }
+      }
+    ];
+  })
+);
+function dateString(value) {
+  return dateMethods.get("toString").invoke(value, []);
+}
+function restoreDateTime(value) {
+  if (value !== null && (typeof value !== "number" || !Number.isInteger(value) || Math.abs(value) > 864e13 || Object.is(value, -0)))
+    throw new TypeError("Invalid serialized Date epoch.");
+  const date = createSandboxDate(0);
+  Reflect.apply(writeTime, date, [value === null ? NaN : value]);
+  return date;
+}
+function serializedDateTime(value) {
+  const time = dateTime(value);
+  return Number.isNaN(time) ? null : time;
+}
+
 // packages/safe-js/src/interp/host-capabilities.ts
 var hostObjects = /* @__PURE__ */ new WeakMap();
 var guestObjects = /* @__PURE__ */ new WeakMap();
 var guestCallbacks = /* @__PURE__ */ new WeakMap();
+var guestReferences = /* @__PURE__ */ new WeakMap();
+function createGuestReference(root, owner, assertActive) {
+  const reference = Object.freeze(/* @__PURE__ */ Object.create(null));
+  guestReferences.set(reference, { root, owner, assertActive });
+  return reference;
+}
+function readGuestReference(reference, owner) {
+  const state = typeof reference === "object" && reference !== null ? guestReferences.get(reference) : void 0;
+  if (state === void 0 || state.owner !== owner)
+    throw new TypeError("Foreign or invalid guest reference.");
+  state.assertActive();
+  if (state.root === void 0) throw new TypeError("Guest reference is revoked.");
+  return state.root[0];
+}
+function revokeGuestReference(reference, owner) {
+  const state = guestReferences.get(reference);
+  if (state === void 0 || state.owner !== owner) throw new TypeError("Foreign guest reference.");
+  state.root = void 0;
+}
 function createLiveHostObject(definition, controller) {
   const input = readDataRecord(definition, "Host object definition");
   if (Object.keys(input).some((key) => key !== "properties" && key !== "methods"))
@@ -6254,9 +6396,10 @@ function isGuestHostObject(value) {
   return typeof value === "object" && value !== null && guestObjects.has(value);
 }
 function isLiveCapability(value) {
-  return (typeof value === "object" && value !== null || typeof value === "function") && (hostObjects.has(value) || guestObjects.has(value) || guestCallbacks.has(value));
+  return (typeof value === "object" && value !== null || typeof value === "function") && (hostObjects.has(value) || guestObjects.has(value) || guestCallbacks.has(value) || guestReferences.has(value));
 }
 function importHostCapability(value, owner) {
+  if (guestReferences.has(value)) return readGuestReference(value, owner);
   const object = hostObjects.get(value);
   if (object !== void 0) {
     if (object.controller.owner !== owner) throw new TypeError("Foreign realm host capability.");
@@ -6445,7 +6588,7 @@ async function flushPromiseJobs() {
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
 
 // packages/safe-js/src/snapshot/validation.ts
-import { types as types2 } from "node:util";
+import { types as types3 } from "node:util";
 
 // packages/safe-js/src/interp/arguments.ts
 var sandboxArgumentsBrand = /* @__PURE__ */ Symbol("SandboxArguments");
@@ -6821,7 +6964,7 @@ function serializeDumpValue(value, path, state) {
   if (hasGuestObjectState(value)) {
     throw new TypeError("Guest function properties and prototype links cannot be serialized.");
   }
-  if (isFloat32Array(value)) return serializeHeapReference(value, path, state);
+  if (isSandboxDate(value) || isFloat32Array(value)) return serializeHeapReference(value, path, state);
   if (Array.isArray(value)) {
     const reference2 = serializeHeapReference(value, path, state);
     if (reference2 !== void 0) {
@@ -6845,7 +6988,9 @@ 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, (id2) => ({
         kind: "ref",
         id: id2
@@ -6902,7 +7047,7 @@ function indexHeapContainers(snapshot) {
   const heapIds = /* @__PURE__ */ new WeakMap();
   let nextId = 1;
   for (const [value, stat2] of stats.entries()) {
-    if (stat2.count > 1 || stat2.cyclic || isFloat32Array(value) || Array.isArray(value) && requiresArrayEntries(value) || isSandboxArguments(value) || sandboxErrorTypes.has(value)) {
+    if (stat2.count > 1 || stat2.cyclic || isSandboxDate(value) || isFloat32Array(value) || Array.isArray(value) && requiresArrayEntries(value) || isSandboxArguments(value) || sandboxErrorTypes.has(value)) {
       heapIds.set(value, nextId);
       nextId += 1;
     }
@@ -6913,7 +7058,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 stat2 = stats.get(value);
@@ -7049,6 +7194,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`);
@@ -7206,6 +7355,14 @@ function validateGeneratorShape(record2, path, state) {
     }
   });
 }
+function validateDateRecord(record2, path) {
+  if (Object.keys(record2).length !== 2) fail("invalidValue", path, "invalid Date fields");
+  try {
+    restoreDateTime(record2.time);
+  } catch {
+    fail("invalidValue", `${path}.time`, "invalid Date epoch");
+  }
+}
 function validateArrayHeap(record2, path, state) {
   if (Object.hasOwn(record2, "items")) {
     requireArray(record2.items, `${path}.items`, state);
@@ -7289,7 +7446,7 @@ function validateGenericValue(value, path, depth, state) {
   if (typeof value === "object" && value !== null && hasGuestObjectState(value)) {
     fail("invalidState", path, "guest function properties, prototype links and custom descriptors cannot be restored");
   }
-  if (state.dataPropertiesOnly && types2.isProxy(value)) {
+  if (state.dataPropertiesOnly && types3.isProxy(value)) {
     fail("invalidType", path, "proxy objects are not snapshot data");
   }
   if (depth > state.limits.maxDepth)
@@ -9532,6 +9689,10 @@ 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;
       return;
@@ -9726,6 +9887,13 @@ function copyToSandbox(value, state, path = "<root>", cloneSandboxCollections =
     }
     return sandboxPromise;
   }
+  if (nodeTypes.isDate(value)) {
+    const existing = state.seen.get(value);
+    if (existing !== void 0) return existing;
+    const copy = copyNativeDate(value);
+    state.seen.set(value, copy);
+    return copy;
+  }
   if (isFloat32Array(value)) {
     const existing = state.seen.get(value);
     if (existing !== void 0) return existing;
@@ -9885,6 +10053,13 @@ function copyFromSandbox(value, state, path = "<root>", options, depth = 0) {
     if (!Object.isExtensible(value)) Object.preventExtensions(copy);
     return copy;
   }
+  if (isSandboxDate(value)) {
+    const existing = state.seen.get(value);
+    if (existing !== void 0) return existing;
+    const copy = exportDate(value);
+    state.seen.set(value, copy);
+    return copy;
+  }
   if (isSandboxClosure(value)) {
     if (options.wrapClosure === void 0) {
       throw new TypeError(
@@ -10199,6 +10374,8 @@ function encodeReplayData(value, options = {}) {
         id: capabilityId,
         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, (id2) => ({
         tag: "ref",
@@ -10349,6 +10526,12 @@ 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 result3 = restoreDateTime(own(node, "time"));
+        restored.set(id, result3);
+        return result3;
+      }
       if (kind === "float32array") {
         if (typeof node.extensible !== "boolean")
           throw new TypeError("Invalid Float32Array extensibility.");
@@ -11039,6 +11222,8 @@ function normalize(value, seen) {
   if (seen.has(value)) throw new TypeError("Host call arguments cannot contain cycles.");
   seen.add(value);
   try {
+    const date = copyNativeDate(value);
+    if (date !== void 0) return Object.assign(/* @__PURE__ */ Object.create(null), { $type: "date", time: serializedDateTime(date) });
     if (isFloat32Array(value)) {
       const storage = float32Storage(value);
       const properties = /* @__PURE__ */ Object.create(null);
@@ -11994,6 +12179,7 @@ var KNOWN_RUNTIME_GLOBALS = [
   "AggregateError",
   "Array",
   "Boolean",
+  "Date",
   "Error",
   "Infinity",
   "isFinite",
@@ -17158,9 +17344,9 @@ var ASFloatingPromiseScanner = class {
   isPromiseFactoryCall(node) {
     return this.isPromiseStaticMethodCall(node, PROMISE_FACTORIES);
   }
-  isPromiseStaticMethodCall(node, methodNames) {
+  isPromiseStaticMethodCall(node, methodNames2) {
     const member = node.callee.type === "MemberExpression" ? node.callee : void 0;
-    return member !== void 0 && !member.computed && member.object.type === "Identifier" && member.object.name === "Promise" && member.property.type === "Identifier" && methodNames.has(member.property.name);
+    return member !== void 0 && !member.computed && member.object.type === "Identifier" && member.object.name === "Promise" && member.property.type === "Identifier" && methodNames2.has(member.property.name);
   }
   isPromiseChainCall(node) {
     const member = node.callee.type === "MemberExpression" ? node.callee : void 0;
@@ -24798,6 +24984,101 @@ function relativeIndex(value, length, fallback) {
   return integer < 0 ? Math.max(length + integer, 0) : Math.min(integer, length);
 }
 
+// packages/safe-js/src/interp/globals/date.ts
+var intrinsics = /* @__PURE__ */ new WeakMap();
+var constructors2 = /* @__PURE__ */ new WeakSet();
+function createDateGlobal(options) {
+  const validateClockTime = (value) => {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || Math.abs(value) > 864e13)
+      throw new TypeError("Date clock must return a finite integer epoch within the Date range.");
+    return value;
+  };
+  const readNow = declareHostOperation(
+    () => {
+      options.budget.visitNode();
+      const value = options.clock?.now === void 0 ? Date.now() : options.clock.now();
+      return validateClockTime(value);
+    },
+    "re-issue",
+    {
+      onReplay: (_args, outcome) => {
+        if (outcome.status === "fulfilled") {
+          const time = validateClockTime(outcome.value);
+          options.clock?.restore?.({ next: time + 1 });
+        }
+      }
+    }
+  );
+  const now = wrapCallerInjectedBindings({ now: readNow }, { ...options, moduleId: "<Date>" }).now;
+  const prototype = createSandboxDate(NaN);
+  const constructor = createSandboxClosure({
+    sandbox: true,
+    name: "Date",
+    length: 7,
+    call: async (_args, context) => options.budget.allocateString(
+      dateString(createSandboxDate(Number(await now.call([], context))))
+    ),
+    construct: async (args, context) => {
+      let time;
+      if (args.length === 0) time = Number(await now.call([], context));
+      else if (args.length > 1) time = dateFromParts(args, false);
+      else if (isSandboxDate(args[0])) time = dateTime(args[0]);
+      else if (typeof args[0] === "string") time = parseDate(args[0], options.budget);
+      else time = dateNumber(args[0]);
+      options.budget.chargeDataUsage(9);
+      return createSandboxDate(time);
+    },
+    properties: {
+      now,
+      prototype,
+      parse: createSandboxClosure({
+        sandbox: true,
+        name: "parse",
+        length: 1,
+        call: ([value]) => parseDate(value, options.budget)
+      }),
+      UTC: createSandboxClosure({
+        sandbox: true,
+        name: "UTC",
+        length: 7,
+        call: (args) => dateFromParts(args, true)
+      })
+    }
+  });
+  const methods = /* @__PURE__ */ new Map();
+  for (const [name, method] of dateMethods)
+    methods.set(
+      name,
+      createSandboxClosure({
+        sandbox: true,
+        name,
+        length: method.length,
+        call: (args, context) => {
+          const receiver = context?.thisValue;
+          if (!isSandboxDate(receiver))
+            throw new TypeError(`Date#${name} requires a Date receiver.`);
+          options.budget.visitNode();
+          const value = method.invoke(receiver, args);
+          return typeof value === "string" ? options.budget.allocateString(value) : value;
+        }
+      })
+    );
+  constructors2.add(constructor);
+  intrinsics.set(options.compileOwner ?? options.budget, { constructor, prototype, methods });
+  return constructor;
+}
+function isDateConstructor(value) {
+  return typeof value === "object" && value !== null && constructors2.has(value);
+}
+function getDateMember(property, budget, owner) {
+  const state = intrinsics.get(owner ?? budget);
+  return property === "constructor" ? state?.constructor : state?.methods.get(String(property));
+}
+function getDatePrototype(value, budget, owner) {
+  const prototype = intrinsics.get(owner ?? budget)?.prototype;
+  return prototype === value ? null : prototype ?? null;
+}
+
 // packages/safe-js/src/interp/scope.ts
 var uninitialized = /* @__PURE__ */ Symbol("uninitialized");
 var Scope = class _Scope {
@@ -26662,6 +26943,7 @@ function getPropertyValue(target, property, context) {
   if (typeof target === "number") return getNumberMember(target, property, context.budget);
   if (typeof target === "boolean") return void 0;
   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)) return getSetMember(target, property, createSetMethodOptions(context));
   if (isSandboxGenerator(target)) return getGeneratorMember(target, property, context.budget);
@@ -26898,6 +27180,9 @@ async function evaluateMemberCallExpression(node, 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,
@@ -27150,6 +27435,7 @@ function applyBinaryOperator(node, left, right, context) {
         return true;
       }
       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;
       }
@@ -27213,8 +27499,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 "<":
@@ -27297,6 +27583,7 @@ function toPrimitive(value) {
   return toString(value);
 }
 async function toNumericPrimitive(value, context) {
+  if (isSandboxDate(value)) return dateTime(value);
   if (isPrimitiveCoercionType(getCoercionType(value))) {
     return value;
   }
@@ -27326,6 +27613,7 @@ async function toNumericPrimitive(value, context) {
   return toString(value);
 }
 function toNumber(value) {
+  if (isSandboxDate(value)) return dateTime(value);
   if (typeof value === "number") {
     return value;
   }
@@ -27344,6 +27632,7 @@ 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 === void 0 ? "" : toString(entry)).join(",");
   }
@@ -27389,6 +27678,7 @@ function getArrayMemberValue(target, property, context) {
   return getArrayMember(target, property, createArrayMethodOptions(context));
 }
 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;
@@ -28043,7 +28333,7 @@ function wrapCallerInjectedFunction(name, value, options, state) {
           seen: /* @__PURE__ */ new WeakMap(),
           restored: []
         };
-        const hostArgs = deepCopyFromSandbox([...args], {
+        const copyArguments = (values) => deepCopyFromSandbox([...values], {
           compilation,
           unwrapHostObject: options.realm === void 0 ? void 0 : (object) => exportHostCapability(object, options.realm.owner),
           wrapClosure: (closure) => options.realm?.wrapCallback(closure) ?? wrapSandboxClosureForHost(
@@ -28054,13 +28344,21 @@ function wrapCallerInjectedFunction(name, value, options, state) {
             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>";
         const policy = readHostOperationPolicy(value) ?? readRegisteredPendingHostCallPolicy(moduleId, operation) ?? "re-issue";
         if (hostCalls === void 0) {
           if (options.realm !== void 0) {
-            const result = options.realm.invoke(callable, () => Reflect.apply(callable, void 0, hostArgs));
+            let result;
+            try {
+              result = options.realm.invoke(callable, () => Reflect.apply(callable, void 0, hostArgs));
+            } catch (error) {
+              captured.rollback();
+              throw error;
+            }
             if (options.realm.awaitResult(callable)) {
               return Promise.resolve(result).then((value2) => copyHostResultToSandbox(value2, stackFrames, options));
             }
@@ -28648,6 +28946,14 @@ function copyHostValueToSandbox(value, stackFrames, options, state, path) {
       state
     );
   }
+  const date = copyNativeDate(value);
+  if (date !== void 0) {
+    const existing = state.seen.get(value);
+    if (existing !== void 0) return existing;
+    budget.chargeDataUsage(9);
+    state.seen.set(value, date);
+    return date;
+  }
   if (isFloat32Array(value)) {
     const existing = state.seen.get(value);
     if (existing !== void 0) return existing;
@@ -29049,7 +29355,7 @@ function createReplayableRandom(options = {}) {
 
 // packages/safe-js/src/realm.ts
 import { AsyncLocalStorage as AsyncLocalStorage6 } from "node:async_hooks";
-import { types as types3 } from "node:util";
+import { types as types4 } from "node:util";
 
 // packages/safe-js/src/interp/globals/console-json.ts
 function createConsoleJsonGlobals(options) {
@@ -29163,7 +29469,9 @@ function toJsonParseText(input) {
 }
 async function stringifyProperty(key, holder, state, indent = "") {
   let value = getOwnDataValue(holder, key);
-  if (isStringifyContainer(value)) {
+  if (isSandboxDate(value)) {
+    value = dateMethods.get("toJSON").invoke(value, []);
+  } else if (isStringifyContainer(value)) {
     const toJSON = getOwnDataValue(value, "toJSON");
     if (isSandboxClosure(toJSON)) {
       value = await callStringifyClosure(toJSON, [key], value, state);
@@ -29475,6 +29783,7 @@ async function stringifyObject2(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");
@@ -29578,6 +29887,7 @@ function createObjectArrayGlobals(options) {
       getPrototypeOf: createSandboxClosure({
         sandbox: true,
         call: ([value]) => {
+          if (isSandboxDate(value)) return getDatePrototype(value, options.budget, options.compileOwner);
           objectProperties(value);
           return getSandboxPrototype(value);
         },
@@ -29702,7 +30012,7 @@ function createObjectArrayGlobals(options) {
     }),
     Number: createSandboxClosure({
       sandbox: true,
-      call: ([value]) => Number(value),
+      call: ([value]) => isSandboxDate(value) ? dateTime(value) : Number(value),
       name: "Number",
       properties: {
         isFinite: createSandboxClosure({
@@ -29802,6 +30112,10 @@ function assignSandboxValues(target, sources, budget) {
   return target;
 }
 function objectProperties(value, mutable = false) {
+  if (isSandboxDate(value)) {
+    if (mutable) throw new TypeError("Date own properties and prototypes are not supported.");
+    return value;
+  }
   if (isGuestHostObject(value)) throw new TypeError("Live host object descriptors are not supported.");
   if (isGuestClosure(value)) return materializeFunctionProperties(value);
   if (isSandboxClosure(value)) {
@@ -29923,6 +30237,7 @@ function createBuiltinBindings(options) {
     ...createConsoleJsonGlobals(options),
     ...createCollectionGlobals(options),
     Float32Array: createFloat32ArrayGlobal(options.budget),
+    Date: createDateGlobal(options),
     ...createErrorGlobals(options),
     ...createMathGlobals({ random: options.random }),
     ...createObjectArrayGlobals(options),
@@ -30095,6 +30410,7 @@ var RealmState = class {
       extensions: 32,
       hostObjects: 1024,
       callbacks: 1024,
+      guestReferences: 1024,
       cleanups: 1024,
       nestedEvaluations: 16
     };
@@ -30103,7 +30419,7 @@ var RealmState = class {
         throw new TypeError("Realm limits must be positive safe integers with supported names.");
       this.limits[name] = Number(value);
     }
-    if (options.extensions !== void 0 && (!Array.isArray(options.extensions) || types3.isProxy(options.extensions)))
+    if (options.extensions !== void 0 && (!Array.isArray(options.extensions) || types4.isProxy(options.extensions)))
       throw new TypeError("Extensions must be a registration array.");
     const registrations = options.extensions ?? [];
     const extensions = [];
@@ -30131,6 +30447,7 @@ var RealmState = class {
       owner: this,
       assertActive: this.assertOpen,
       wrapCallback: this.wrapCallback,
+      captureArguments: this.captureArguments,
       invoke: this.invokeHost,
       awaitResult: (operation) => this.nestedOperations.has(operation)
     };
@@ -30139,6 +30456,7 @@ var RealmState = class {
         budget: this.budget,
         compileOwner: this.lease.owner,
         sink: options.sink,
+        clock: options.clock,
         random: createReplayableRandom({ seed: options.randomSeed }).next
       });
       const names = /* @__PURE__ */ new Set();
@@ -30170,7 +30488,7 @@ var RealmState = class {
       }
       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) {
       this.compilation.dispose();
@@ -30194,6 +30512,8 @@ var RealmState = class {
   pendingCallbacks = /* @__PURE__ */ new Set();
   callbackCache = /* @__PURE__ */ new WeakMap();
   hostObjects = /* @__PURE__ */ new Set();
+  guestReferences = /* @__PURE__ */ new Map();
+  retainedOperations = /* @__PURE__ */ new WeakMap();
   nestedOperations = /* @__PURE__ */ new WeakMap();
   convertedModules = /* @__PURE__ */ new Map();
   nativeConversions = { seen: /* @__PURE__ */ new WeakMap() };
@@ -30213,10 +30533,56 @@ var RealmState = class {
     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 === void 0)
+      reconcileCompiledValues(
+        this.budget,
+        [...this.scope?.retainedValues() ?? [], ...this.retainedRoots()],
+        this.compilation
+      );
+  };
   assertOpen = () => {
     if (this.failure !== void 0) throw this.failure.reason;
     if (this.closed) throw new Error("SafeJS realm is closed; capabilities are revoked.");
@@ -30272,7 +30638,7 @@ var RealmState = class {
     return this.phase.run(phase, () => {
       try {
         const result = call();
-        if (types3.isPromise(result) || phase.pending.size > 0 || phase.failure !== void 0) {
+        if (types4.isPromise(result) || phase.pending.size > 0 || phase.failure !== void 0) {
           return Promise.resolve(result).then(
             async (value) => {
               await Promise.allSettled(phase.pending);
@@ -30329,7 +30695,7 @@ var RealmState = class {
       chargeWork: this.chargeWork,
       read: (operation) => {
         const value = this.invokeHost(operation, operation);
-        if (types3.isPromise(value)) {
+        if (types4.isPromise(value)) {
           void Promise.resolve(value).catch(() => void 0);
           throw new TypeError("Live property getters must be synchronous.");
         }
@@ -30337,7 +30703,7 @@ var RealmState = class {
       },
       write: (operation, value) => {
         const result = this.invokeHost(operation, () => operation(this.exportValue(value)));
-        if (types3.isPromise(result)) {
+        if (types4.isPromise(result)) {
           void Promise.resolve(result).catch(() => void 0);
           throw new TypeError("Live property setters must be synchronous.");
         }
@@ -30384,7 +30750,7 @@ var RealmState = class {
     });
     try {
       this.budget.reconcileDataUsage(
-        measureSandboxData([...this.scope?.retainedValues() ?? [], ...this.retainedCallbacks()])
+        measureSandboxData([...this.scope?.retainedValues() ?? [], ...this.retainedRoots()])
       );
     } catch (error) {
       this.poison(error);
@@ -30399,7 +30765,7 @@ var RealmState = class {
     if (this.active === void 0)
       reconcileCompiledValues(
         this.budget,
-        [...this.scope?.retainedValues() ?? [], ...this.retainedCallbacks()],
+        [...this.scope?.retainedValues() ?? [], ...this.retainedRoots()],
         this.compilation
       );
   };
@@ -30458,7 +30824,7 @@ var RealmState = class {
       if (!this.closed && this.active === void 0)
         reconcileCompiledValues(
           this.budget,
-          [...this.scope?.retainedValues() ?? [], ...this.retainedCallbacks()],
+          [...this.scope?.retainedValues() ?? [], ...this.retainedRoots()],
           this.compilation
         );
     }
@@ -30475,6 +30841,23 @@ var RealmState = class {
         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 !== void 0)
+            throw new TypeError("Retained operations must be registered during setup.");
+          const previous = this.retainedOperations.get(operation);
+          if (previous !== void 0 && (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"))
@@ -30513,7 +30896,7 @@ var RealmState = class {
         }
       });
       const output = getExtensionSetup(extension)(context);
-      if (types3.isPromise(output)) {
+      if (types4.isPromise(output)) {
         void Promise.resolve(output).catch(() => void 0);
         throw new TypeError("Extension setup must be synchronous.");
       }
@@ -30637,7 +31020,7 @@ var RealmState = class {
       if (!this.closed)
         reconcileCompiledValues(
           this.budget,
-          [...this.scope?.retainedValues() ?? [], ...this.retainedCallbacks()],
+          [...this.scope?.retainedValues() ?? [], ...this.retainedRoots()],
           this.compilation
         );
       return result;
@@ -30671,6 +31054,8 @@ var RealmState = class {
     this.callbacks.clear();
     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, void 0);
     this.disposal = (async () => {
       const errors = [];
@@ -30698,7 +31083,7 @@ var RealmState = class {
 };
 function readModules(input) {
   const entries = (value, label) => {
-    if (types3.isMap(value) && !types3.isProxy(value)) {
+    if (types4.isMap(value) && !types4.isProxy(value)) {
       const result = [...Map.prototype.entries.call(value)];
       if (result.length > 4096 || result.some(([key]) => typeof key !== "string" || key.length === 0))
         throw new TypeError(`${label} requires bounded string keys.`);
@@ -30726,6 +31111,7 @@ function createRealm(options = {}) {
     evaluate: state.evaluate,
     invokeCallback: state.invokeCallback,
     releaseCallback: state.releaseCallback,
+    releaseGuestReference: state.releaseGuestReference,
     close: state.close
   });
 }
@@ -30771,6 +31157,7 @@ function readRealmOptions(value, oneShot = false) {
     "signal",
     "sink",
     "randomSeed",
+    "clock",
     "limits"
   ]);
   for (const [key, entry] of Object.entries(options)) {
@@ -31417,7 +31804,7 @@ function run(source, options = {}) {
               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 ?? {})
           );
@@ -31920,4 +32307,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-2M6MNQBY.js.map
+//# sourceMappingURL=chunk-BWVASPJX.js.map