poe-code 14.0.6 → 14.0.8

package/dist/index.js

@@ -50271,8 +50271,8 @@ function assertNonNegativeInteger3(value, keyword) {
 }
 function validateSchemaObject(schema, dialect) {
   if (schema.type !== void 0) {
-    const types4 = Array.isArray(schema.type) ? schema.type : [schema.type];
-    if (types4.length === 0 || !types4.every((type) => typeof type === "string" && draftTypeSet.has(type)) || new Set(types4).size !== types4.length) {
+    const types6 = Array.isArray(schema.type) ? schema.type : [schema.type];
+    if (types6.length === 0 || !types6.every((type) => typeof type === "string" && draftTypeSet.has(type)) || new Set(types6).size !== types6.length) {
       throw new Error("type must be a JSON Schema type or a unique array of JSON Schema types.");
     }
   }
@@ -50991,9 +50991,9 @@ function evaluateValidationKeywords(node, schema, value, path193) {
   if (schema.nullable === true && value === null) {
     return results;
   }
-  const types4 = typeof schema.type === "string" ? [schema.type] : Array.isArray(schema.type) ? schema.type : [];
-  if (types4.length > 0 && !types4.some((type) => typeof type === "string" && typeMatches(type, value))) {
-    results.push(invalidResult(issue(path193, types4.join(","), value, `must be ${types4.join(",")}`)));
+  const types6 = typeof schema.type === "string" ? [schema.type] : Array.isArray(schema.type) ? schema.type : [];
+  if (types6.length > 0 && !types6.some((type) => typeof type === "string" && typeMatches(type, value))) {
+    results.push(invalidResult(issue(path193, types6.join(","), value, `must be ${types6.join(",")}`)));
     return results;
   }
   if (schema.const !== void 0 && !deepEqual(schema.const, value)) {
@@ -124460,8 +124460,9 @@ var init_parser3 = __esm({
           }
           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: {
@@ -125592,10 +125593,69 @@ var init_extensions = __esm({
 });
 
 // packages/safe-js/src/interp/host-capabilities.ts
+import { types as types2 } from "node:util";
+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((key3) => key3 !== "properties" && key3 !== "methods"))
+  if (Object.keys(input).some((key3) => !["properties", "methods", "indexed", "named"].includes(key3)))
     throw new TypeError("Unknown host object definition field.");
+  let indexed;
+  if (input.indexed !== void 0) {
+    const data = readDataRecord(input.indexed, "Indexed host capability");
+    if (Object.keys(data).some((key3) => !["length", "get", "maxLength"].includes(key3)))
+      throw new TypeError("Unknown indexed host capability field.");
+    if (typeof data.length !== "function" || typeof data.get !== "function")
+      throw new TypeError("Indexed length and get must be synchronous functions.");
+    if (typeof data.maxLength !== "number" || !Number.isInteger(data.maxLength) || data.maxLength < 1 || data.maxLength > MAX_INDEXED_LENGTH)
+      throw new RangeError(`Indexed maxLength must be an integer from 1 to ${MAX_INDEXED_LENGTH}.`);
+    indexed = {
+      length: data.length,
+      get: data.get,
+      maxLength: data.maxLength
+    };
+  }
+  let named;
+  if (input.named !== void 0) {
+    const data = readDataRecord(input.named, "Named host capability");
+    if (Object.keys(data).some(
+      (key3) => !["keys", "get", "maxKeys", "maxKeyCodeUnits", "enumerable"].includes(key3)
+    ))
+      throw new TypeError("Unknown named host capability field.");
+    if (typeof data.keys !== "function" || typeof data.get !== "function")
+      throw new TypeError("Named keys and get must be synchronous functions.");
+    if (typeof data.maxKeys !== "number" || !Number.isInteger(data.maxKeys) || data.maxKeys < 1 || data.maxKeys > MAX_NAMED_KEYS)
+      throw new RangeError(`Named maxKeys must be an integer from 1 to ${MAX_NAMED_KEYS}.`);
+    if (typeof data.maxKeyCodeUnits !== "number" || !Number.isInteger(data.maxKeyCodeUnits) || data.maxKeyCodeUnits < 1 || data.maxKeyCodeUnits > MAX_NAMED_KEY_CODE_UNITS)
+      throw new RangeError(
+        `Named maxKeyCodeUnits must be an integer from 1 to ${MAX_NAMED_KEY_CODE_UNITS}.`
+      );
+    if (data.enumerable !== void 0 && typeof data.enumerable !== "boolean")
+      throw new TypeError("Named enumerable must be a boolean.");
+    named = {
+      keys: data.keys,
+      get: data.get,
+      maxKeys: data.maxKeys,
+      maxKeyCodeUnits: data.maxKeyCodeUnits,
+      enumerable: data.enumerable
+    };
+  }
   const properties = /* @__PURE__ */ new Map();
   for (const [name, inputProperty] of Object.entries(
     readDataRecord(input.properties ?? {}, "Host properties")
@@ -125615,6 +125675,8 @@ function createLiveHostObject(definition, controller) {
   for (const name of [...properties.keys(), ...Object.keys(operations)]) {
     if (["constructor", "prototype", "__proto__"].includes(name))
       throw new TypeError(`Reserved host member '${name}'.`);
+    if (indexed !== void 0 && (name === "length" || canonicalIndex(name) !== void 0))
+      throw new TypeError(`Conflicting indexed host member '${name}'.`);
   }
   controller.assertActive();
   controller.chargeWork(properties.size + Object.keys(operations).length + 1);
@@ -125626,7 +125688,7 @@ function createLiveHostObject(definition, controller) {
       controller.method(operation)
     ])
   );
-  const state = { host, guest, controller, properties, methods };
+  const state = { host, guest, controller, properties, methods, indexed, named };
   hostObjects.set(host, state);
   guestObjects.set(guest, state);
   return host;
@@ -125635,9 +125697,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.");
@@ -125682,15 +125745,29 @@ function revokeHostObject(value, owner) {
     throw new TypeError("Foreign host object.");
   state.properties.clear();
   state.methods.clear();
+  state.indexed = void 0;
+  state.named = void 0;
 }
 function getHostObjectMember(value, key3) {
   const state = guestObjects.get(value);
   state.controller.assertActive();
   state.controller.chargeWork();
+  if (state.indexed !== void 0) {
+    if (key3 === "length") return indexedLength(state);
+    const index = canonicalIndex(key3);
+    if (index !== void 0) {
+      if (index >= state.indexed.maxLength || index >= indexedLength(state)) return void 0;
+      return state.controller.read(() => state.indexed.get(index));
+    }
+  }
   const property = state.properties.get(key3);
   if (property !== void 0)
     return property.get === void 0 ? void 0 : state.controller.read(property.get);
-  return state.methods.get(key3);
+  const method = state.methods.get(key3);
+  if (method !== void 0) return method;
+  if (state.named !== void 0 && namedKeys2(state).includes(key3))
+    return state.controller.read(() => state.named.get(key3));
+  return void 0;
 }
 function setHostObjectMember(value, key3, entry) {
   const state = guestObjects.get(value);
@@ -125703,16 +125780,119 @@ function setHostObjectMember(value, key3, entry) {
 function getHostObjectKeys(value) {
   const state = guestObjects.get(value);
   state.controller.assertActive();
-  return [...state.properties.keys(), ...state.methods.keys()];
+  const length = state.indexed === void 0 ? 0 : indexedLength(state);
+  const names = state.named === void 0 || state.named.enumerable === false ? [] : namedKeys2(state).filter(
+    (key3) => !state.properties.has(key3) && !state.methods.has(key3) && !(state.indexed !== void 0 && (key3 === "length" || canonicalIndex(key3) !== void 0))
+  );
+  const size = length + state.properties.size + state.methods.size + names.length;
+  state.controller.checkLength(size);
+  state.controller.chargeWork(size + 1);
+  return [
+    ...Array.from({ length }, (_entry, index) => String(index)),
+    ...state.properties.keys(),
+    ...state.methods.keys(),
+    ...names
+  ];
+}
+function hasHostObjectMember(value, key3, enumerableOnly = false) {
+  const state = guestObjects.get(value);
+  state.controller.assertActive();
+  state.controller.chargeWork();
+  if (state.indexed !== void 0) {
+    if (key3 === "length") return !enumerableOnly;
+    const index = canonicalIndex(key3);
+    if (index !== void 0) return index < state.indexed.maxLength && index < indexedLength(state);
+  }
+  if (state.properties.has(key3) || state.methods.has(key3)) return true;
+  return state.named !== void 0 && !(enumerableOnly && state.named.enumerable === false) && namedKeys2(state).includes(key3);
+}
+function measureHostObjectData(value) {
+  const state = guestObjects.get(value);
+  let size = state.indexed === void 0 ? 0 : 16;
+  if (state.named !== void 0) size += 24;
+  for (const key3 of state.properties.keys()) size += key3.length + 1;
+  for (const key3 of state.methods.keys()) size += key3.length + 1;
+  return size;
 }
-var hostObjects, guestObjects, guestCallbacks;
+function getHostObjectIterator(value) {
+  const state = guestObjects.get(value);
+  state.controller.assertActive();
+  if (state.indexed === void 0) return void 0;
+  let index = 0;
+  let exhausted = false;
+  return {
+    next: () => {
+      state.controller.assertActive();
+      state.controller.chargeWork();
+      if (exhausted) return { done: true, value: void 0 };
+      if (index >= indexedLength(state)) {
+        exhausted = true;
+        return { done: true, value: void 0 };
+      }
+      const position = index++;
+      return { done: false, value: state.controller.read(() => state.indexed.get(position)) };
+    }
+  };
+}
+function indexedLength(state) {
+  state.controller.chargeWork();
+  const length = state.controller.read(state.indexed.length);
+  if (typeof length !== "number" || !Number.isInteger(length) || length < 0 || length > state.indexed.maxLength)
+    throw new RangeError("Indexed length must be a non-negative integer within maxLength.");
+  state.controller.checkLength(length);
+  return length;
+}
+function canonicalIndex(key3) {
+  const index = Number(key3);
+  return Number.isInteger(index) && index >= 0 && index < 4294967295 && String(index) === key3 ? index : void 0;
+}
+function namedKeys2(state) {
+  const named = state.named;
+  return state.controller.read(named.keys, (value) => {
+    if (!Array.isArray(value) || types2.isProxy(value))
+      throw new TypeError("Named keys must be a dense own-data array of strings, not a proxy.");
+    const length = Object.getOwnPropertyDescriptor(value, "length").value;
+    if (length > named.maxKeys) throw new RangeError("Named keys exceed maxKeys.");
+    state.controller.checkLength(length);
+    state.controller.chargeWork(length + 1);
+    if (Reflect.ownKeys(value).length !== length + 1)
+      throw new TypeError("Named keys must contain only dense own-data indices and length.");
+    const result = [];
+    const seen = /* @__PURE__ */ new Set();
+    let units = 0;
+    for (let index = 0; index < length; index++) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+      if (descriptor === void 0 || !("value" in descriptor) || typeof descriptor.value !== "string")
+        throw new TypeError(
+          "Named keys require dense own string data, not accessors or sparse arrays."
+        );
+      const key3 = descriptor.value;
+      units += key3.length;
+      if (units > named.maxKeyCodeUnits)
+        throw new RangeError("Named keys exceed maximum UTF-16 code units.");
+      state.controller.chargeWork(key3.length);
+      if (seen.has(key3)) throw new TypeError("Named keys must be distinct.");
+      if (["constructor", "prototype", "__proto__"].includes(key3))
+        throw new TypeError(`Reserved named host member '${key3}'.`);
+      seen.add(key3);
+      result.push(key3);
+    }
+    state.controller.checkTemporaryDataSize(1 + length + units);
+    return result;
+  });
+}
+var MAX_INDEXED_LENGTH, MAX_NAMED_KEYS, MAX_NAMED_KEY_CODE_UNITS, hostObjects, guestObjects, guestCallbacks, guestReferences;
 var init_host_capabilities = __esm({
   "packages/safe-js/src/interp/host-capabilities.ts"() {
     "use strict";
     init_extensions();
+    MAX_INDEXED_LENGTH = 65536;
+    MAX_NAMED_KEYS = 65536;
+    MAX_NAMED_KEY_CODE_UNITS = 1048576;
     hostObjects = /* @__PURE__ */ new WeakMap();
     guestObjects = /* @__PURE__ */ new WeakMap();
     guestCallbacks = /* @__PURE__ */ new WeakMap();
+    guestReferences = /* @__PURE__ */ new WeakMap();
   }
 });
 
@@ -125809,6 +125989,134 @@ var init_otel2 = __esm({
   }
 });
 
+// packages/safe-js/src/interp/date.ts
+import { types as types3 } from "node:util";
+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 (!types3.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 parseDate2(value, budget) {
+  if (typeof value === "object" && value !== null || typeof value === "function")
+    throw new TypeError("Date parsing requires a primitive value.");
+  const text5 = String(value);
+  if (text5.length > 4096) throw new RangeError("Date input exceeds the 4096 character limit.");
+  budget.allocateString(text5);
+  for (let index = 0; index < text5.length; index++) budget.visitNode();
+  return NativeDate.parse(text5);
+}
+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));
+}
+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;
+}
+var NativeDate, readTime, writeTime, dates, methodNames, dateMethods;
+var init_date = __esm({
+  "packages/safe-js/src/interp/date.ts"() {
+    "use strict";
+    NativeDate = Date;
+    readTime = NativeDate.prototype.getTime;
+    writeTime = NativeDate.prototype.setTime;
+    dates = /* @__PURE__ */ new WeakSet();
+    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"
+    ];
+    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) : []
+              );
+            }
+          }
+        ];
+      })
+    );
+  }
+});
+
 // packages/safe-js/src/interp/float32.ts
 function isFloat32Array(value) {
   return ArrayBuffer.isView(value) && Object.getPrototypeOf(value) === Float32Array.prototype && Reflect.apply(readTag, value, []) === "Float32Array";
@@ -126479,6 +126787,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 storage2 = encodeFloat32Storage(entry, id, float32Buffers, (id2) => ({
         tag: "ref",
@@ -126629,6 +126939,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.");
@@ -126740,6 +127056,7 @@ var init_replay_data = __esm({
     init_compile_guard();
     init_float32();
     init_float32array();
+    init_date();
     init_shape();
     init_values();
     init_arguments2();
@@ -126969,6 +127286,8 @@ function normalize2(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 storage2 = float32Storage(value);
       const properties = /* @__PURE__ */ Object.create(null);
@@ -127017,6 +127336,7 @@ var init_host_call = __esm({
   "packages/safe-js/src/interp/host-call.ts"() {
     "use strict";
     init_float32();
+    init_date();
     init_values();
     init_compile_guard();
     init_replay_data();
@@ -127912,6 +128232,7 @@ var init_running_state = __esm({
 
 // packages/safe-js/src/interp/iteration.ts
 function getSandboxIterator(value) {
+  if (isGuestHostObject(value)) return getHostObjectIterator(value);
   if (isFloat32Array(value)) {
     return syncIterator(Float32Array.prototype.values.call(value));
   }
@@ -128013,6 +128334,7 @@ var init_iteration = __esm({
     init_values();
     init_running_state();
     init_float32();
+    init_host_capabilities();
   }
 });
 
@@ -129067,6 +129389,7 @@ function createSandboxClosure(input) {
   if (input.sandbox === true) {
     Object.defineProperty(closure, "sandbox", { value: true });
   }
+  if (input.generator === true) Object.defineProperty(closure, "generator", { value: true });
   if (input.length !== void 0) {
     Object.defineProperty(closure, "length", { value: input.length });
   }
@@ -129099,7 +129422,13 @@ function createSandboxClosure(input) {
   return Object.freeze(closure);
 }
 function ownEnumerableSandboxEntries(value) {
-  if (isGuestHostObject(value)) return getHostObjectKeys(value).map((key3) => [key3, getHostObjectMember(value, key3)]);
+  if (isGuestHostObject(value)) {
+    const entries = [];
+    for (const key3 of getHostObjectKeys(value)) {
+      if (hasHostObjectMember(value, key3, true)) entries.push([key3, getHostObjectMember(value, key3)]);
+    }
+    return entries;
+  }
   if (value === null || value === void 0) throw new TypeError("Cannot convert undefined or null to object.");
   if (isGuestClosure(value)) return Object.entries(value.properties ?? {});
   if (isSandboxClosure(value) || isSandboxGenerator(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxPromise(value) || isSandboxRegex(value)) return [];
@@ -129252,8 +129581,12 @@ function measureSandboxData(values, options = {}) {
     assertSandboxDataDepth(depth);
     seen.add(value);
     usage += 1;
+    if (isSandboxDate(value)) {
+      usage += 8;
+      return;
+    }
     if (isGuestHostObject(value)) {
-      for (const key3 of getHostObjectKeys(value)) usage += key3.length + 1;
+      usage += measureHostObjectData(value);
       return;
     }
     const prototype = getSandboxPrototype(value);
@@ -129350,7 +129683,7 @@ function measureSandboxData(values, options = {}) {
 function reconcileCompiledValues(budget, values, compilation, parent, escaping = []) {
   while (parent?.closed) parent = parent.parent;
   const included = /* @__PURE__ */ new Set();
-  const usage = measureSandboxData(values, { compileTickets: included });
+  const usage = measureSandboxData([...values, ...budget.retainedValues()], { compileTickets: included });
   const kept = /* @__PURE__ */ new Set();
   if (parent !== void 0) measureSandboxData(escaping, { compileTickets: kept });
   const transferred = /* @__PURE__ */ new Set();
@@ -129446,6 +129779,13 @@ function copyToSandbox(value, state, path193 = "<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;
@@ -129605,6 +129945,13 @@ function copyFromSandbox(value, state, path193 = "<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(
@@ -129873,6 +130220,7 @@ var init_values = __esm({
   "packages/safe-js/src/interp/values.ts"() {
     "use strict";
     init_otel2();
+    init_date();
     init_host_capabilities();
     init_compile_guard();
     init_float32();
@@ -129941,27 +130289,49 @@ function getGuestFunctionProperty(closure, key3) {
   }
   return properties === void 0 ? void 0 : Object.getOwnPropertyDescriptor(properties, key3)?.value;
 }
-function getSandboxPrototype(value) {
-  return prototypes.get(value) ?? null;
+function installObjectPrototype(budget, prototype, constructor) {
+  prototypes.set(prototype, null);
+  intrinsicPrototypes.set(budget, prototype);
+  const records = [prototype, materializeFunctionProperties(constructor)].map((value) => ({
+    value,
+    descriptors: new Map(Object.entries(Object.getOwnPropertyDescriptors(value)))
+  }));
+  const unchanged = (before, after) => before !== void 0 && after !== void 0 && before.value === after.value && before.writable === after.writable && before.configurable === after.configurable && before.enumerable === after.enumerable;
+  intrinsicConstructors.set(constructor, () => records.every(({ value, descriptors }) => {
+    const current = Object.getOwnPropertyDescriptors(value);
+    return Object.keys(current).length === descriptors.size && Object.keys(current).every((key3) => unchanged(descriptors.get(key3), current[key3]));
+  }));
+  budget.setRetainedValues(prototype, () => records.flatMap(({ value, descriptors }) => Object.entries(Object.getOwnPropertyDescriptors(value)).flatMap(([key3, descriptor]) => unchanged(descriptors.get(key3), descriptor) ? [] : [key3, descriptor.value])));
+}
+function releaseObjectPrototype(budget) {
+  const prototype = intrinsicPrototypes.get(budget);
+  if (prototype !== void 0) budget.setRetainedValues(prototype, void 0);
+  intrinsicPrototypes.delete(budget);
+}
+function getSandboxPrototype(value, budget) {
+  if (prototypes.has(value)) return prototypes.get(value) ?? null;
+  return budget !== void 0 && isPrototypeRecord(value) ? intrinsicPrototypes.get(budget) ?? null : null;
 }
 function setSandboxPrototype(value, prototype, budget) {
+  if (budget !== void 0 && intrinsicPrototypes.get(budget) === value && prototype !== null) {
+    throw new TypeError("Object.prototype has an immutable null prototype.");
+  }
   if (!isPrototypeRecord(value) || prototype !== null && !isPrototypeRecord(prototype)) {
     throw new TypeError(
       "Prototype links require ordinary sandbox objects; callable and exotic prototype chains are not supported."
     );
   }
-  if (getSandboxPrototype(value) === prototype) return;
+  if (prototypes.has(value) && getSandboxPrototype(value, budget) === prototype) return;
   if (!Object.isExtensible(isGuestClosure(value) ? materializeFunctionProperties(value) : value)) {
     throw new TypeError("Cannot change the prototype of a non-extensible object.");
   }
   let depth = 0;
-  for (let current = prototype; current !== null; current = getSandboxPrototype(current)) {
+  for (let current = prototype; current !== null; current = getSandboxPrototype(current, budget)) {
     budget?.visitNode();
     assertSandboxDataDepth(depth++);
     if (current === value) throw new TypeError("Cyclic prototype value.");
   }
-  if (prototype === null) prototypes.delete(value);
-  else prototypes.set(value, prototype);
+  prototypes.set(value, prototype);
 }
 function isPrototypeRecord(value) {
   if (isGuestHostObject(value)) return false;
@@ -129977,13 +130347,15 @@ function hasManagedDescriptors(value) {
   return descriptorObjects.has(value);
 }
 function hasGuestObjectState(value) {
+  const intrinsicUnchanged = intrinsicConstructors.get(value);
+  if (intrinsicUnchanged !== void 0) return !intrinsicUnchanged();
   if (isLiveCapability(value)) return true;
   if (functionProperties.has(value) || prototypes.has(value)) return true;
   return descriptorObjects.has(value) && Object.values(Object.getOwnPropertyDescriptors(value)).some(
     (descriptor) => !descriptor.enumerable || !descriptor.configurable || !descriptor.writable
   );
 }
-var guestClosures, functionProperties, prototypes, descriptorObjects;
+var guestClosures, functionProperties, prototypes, intrinsicPrototypes, intrinsicConstructors, descriptorObjects;
 var init_object_model = __esm({
   "packages/safe-js/src/interp/object-model.ts"() {
     "use strict";
@@ -129993,6 +130365,8 @@ var init_object_model = __esm({
     guestClosures = /* @__PURE__ */ new WeakSet();
     functionProperties = /* @__PURE__ */ new WeakMap();
     prototypes = /* @__PURE__ */ new WeakMap();
+    intrinsicPrototypes = /* @__PURE__ */ new WeakMap();
+    intrinsicConstructors = /* @__PURE__ */ new WeakMap();
     descriptorObjects = /* @__PURE__ */ new WeakSet();
   }
 });
@@ -130089,7 +130463,7 @@ function serializeDumpValue(value, path193, state) {
   if (hasGuestObjectState(value)) {
     throw new TypeError("Guest function properties and prototype links cannot be serialized.");
   }
-  if (isFloat32Array(value)) return serializeHeapReference(value, path193, state);
+  if (isSandboxDate(value) || isFloat32Array(value)) return serializeHeapReference(value, path193, state);
   if (Array.isArray(value)) {
     const reference2 = serializeHeapReference(value, path193, state);
     if (reference2 !== void 0) {
@@ -130113,7 +130487,9 @@ function serializeHeapReference(value, path193, 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 storage2 = encodeFloat32Storage(value, id, state.float32Buffers, (id2) => ({
         kind: "ref",
         id: id2
@@ -130170,7 +130546,7 @@ function indexHeapContainers(snapshot2) {
   const heapIds = /* @__PURE__ */ new WeakMap();
   let nextId = 1;
   for (const [value, stat35] of stats2.entries()) {
-    if (stat35.count > 1 || stat35.cyclic || isFloat32Array(value) || Array.isArray(value) && requiresArrayEntries(value) || isSandboxArguments(value) || sandboxErrorTypes.has(value)) {
+    if (stat35.count > 1 || stat35.cyclic || isSandboxDate(value) || isFloat32Array(value) || Array.isArray(value) && requiresArrayEntries(value) || isSandboxArguments(value) || sandboxErrorTypes.has(value)) {
       heapIds.set(value, nextId);
       nextId += 1;
     }
@@ -130181,7 +130557,7 @@ function collectContainerStats(value, stats2, ancestors) {
   if (value === null || typeof value !== "object") {
     return;
   }
-  if (!Array.isArray(value) && !isPlainObject10(value) && !isFloat32Array(value)) {
+  if (!Array.isArray(value) && !isPlainObject10(value) && !isFloat32Array(value) && !isSandboxDate(value)) {
     return;
   }
   let stat35 = stats2.get(value);
@@ -130252,6 +130628,7 @@ var init_dump_format = __esm({
     init_arrays();
     init_float32();
     init_float32array();
+    init_date();
     DUMP_FORMAT_VERSION = 1;
     EXECUTION_SEMANTICS = "jobs-v7";
     SKIP_VALUE = /* @__PURE__ */ Symbol("SafeJS.skip-dump-value");
@@ -130259,7 +130636,7 @@ var init_dump_format = __esm({
 });
 
 // packages/safe-js/src/snapshot/validation.ts
-import { types as types2 } from "node:util";
+import { types as types4 } from "node:util";
 function validateSnapshotData(value) {
   validateGenericValue(value, "$", 0, {
     allowFunctions: false,
@@ -130305,6 +130682,10 @@ function validateDumpHeap(root, state) {
     addUnique2(heapIds, id, path193);
     const entry = requireRecord3(value, path193);
     validateErrorType(entry, path193);
+    if (entry.kind === "date") {
+      validateDateRecord(entry, path193);
+      continue;
+    }
     if (entry.kind === "float32array") {
       validateFloat32Storage(entry);
       requireRecord3(entry.entries, `${path193}.entries`);
@@ -130462,6 +130843,14 @@ function validateGeneratorShape(record2, path193, state) {
     }
   });
 }
+function validateDateRecord(record2, path193) {
+  if (Object.keys(record2).length !== 2) fail2("invalidValue", path193, "invalid Date fields");
+  try {
+    restoreDateTime(record2.time);
+  } catch {
+    fail2("invalidValue", `${path193}.time`, "invalid Date epoch");
+  }
+}
 function validateArrayHeap(record2, path193, state) {
   if (Object.hasOwn(record2, "items")) {
     requireArray(record2.items, `${path193}.items`, state);
@@ -130545,7 +130934,7 @@ function validateGenericValue(value, path193, depth, state) {
   if (typeof value === "object" && value !== null && hasGuestObjectState(value)) {
     fail2("invalidState", path193, "guest function properties, prototype links and custom descriptors cannot be restored");
   }
-  if (state.dataPropertiesOnly && types2.isProxy(value)) {
+  if (state.dataPropertiesOnly && types4.isProxy(value)) {
     fail2("invalidType", path193, "proxy objects are not snapshot data");
   }
   if (depth > state.limits.maxDepth)
@@ -130679,6 +131068,7 @@ var init_validation = __esm({
     init_dump_format();
     init_graph_depth();
     init_float32array();
+    init_date();
     init_object_model();
     DEFAULT_MAX_DEPTH = MAX_DATA_DEPTH;
     DEFAULT_MAX_ENTRIES = 1e5;
@@ -131577,6 +131967,7 @@ var init_known_globals = __esm({
       "AggregateError",
       "Array",
       "Boolean",
+      "Date",
       "Error",
       "Infinity",
       "isFinite",
@@ -136840,9 +137231,9 @@ var init_AS_floating_promise = __esm({
       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;
@@ -142572,6 +142963,95 @@ var init_var_hoist = __esm({
   }
 });
 
+// packages/safe-js/src/interp/string-coercion.ts
+function sandboxString(value, budget, context, joining = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value !== "object") {
+    if (typeof value === "function") throw new TypeError("Expected a sandbox value.");
+    return budget.allocateString(String(value));
+  }
+  return stringifyObject(value, budget, context, joining);
+}
+async function stringifyObject(value, budget, context, joining) {
+  const leaveCall = budget.enterCall();
+  try {
+    budget.visitNode();
+    for (const name of ["toString", "valueOf"]) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, name);
+      let result;
+      if (descriptor === void 0) {
+        if (name === "valueOf") continue;
+        result = await defaultToString(value, budget, context, joining);
+      } else {
+        const hook = ownDataValue(value, name);
+        if (!isSandboxClosure(hook)) continue;
+        if (context?.invokeClosure === void 0) {
+          throw new TypeError("String hooks require a sandbox call context.");
+        }
+        result = await context.invokeClosure(hook, [], value);
+      }
+      if (result === null || typeof result !== "object") {
+        return sandboxString(result, budget, context, joining);
+      }
+    }
+    throw new TypeError("Cannot convert object to primitive value");
+  } finally {
+    leaveCall();
+  }
+}
+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 join21 = ownDataValue(value, "join");
+      if (!isSandboxClosure(join21))
+        return isFloat32Array(value) ? "[object Float32Array]" : "[object Array]";
+      if (context?.invokeClosure === void 0) {
+        throw new TypeError("String hooks require a sandbox call context.");
+      }
+      return context.invokeClosure(join21, [], value);
+    }
+    if (joining.has(value)) return "";
+    joining.add(value);
+    try {
+      const length = isFloat32Array(value) ? float32Storage(value).length : value.length;
+      let text5 = "";
+      for (let index = 0; index < length; index++) {
+        budget.visitNode();
+        const element = ownDataValue(value, String(index));
+        const part = element === null || element === void 0 ? "" : await sandboxString(element, budget, context, joining);
+        text5 = budget.allocateString(text5 + (index === 0 ? "" : ",") + part);
+      }
+      return text5;
+    } finally {
+      joining.delete(value);
+    }
+  }
+  if (sandboxErrorTypes.has(value)) {
+    const nameValue = ownDataValue(value, "name");
+    const name = nameValue === void 0 ? "Error" : await sandboxString(nameValue, budget, context, joining);
+    const messageValue2 = ownDataValue(value, "message");
+    const message2 = messageValue2 === void 0 ? "" : await sandboxString(messageValue2, budget, context, joining);
+    return name === "" ? message2 : message2 === "" ? name : `${name}: ${message2}`;
+  }
+  return isSandboxPromise(value) ? "[object Promise]" : "[object Object]";
+}
+function ownDataValue(value, name) {
+  const descriptor = Object.getOwnPropertyDescriptor(value, name);
+  if (descriptor !== void 0 && !Object.hasOwn(descriptor, "value")) {
+    throw new TypeError("String conversion requires sandbox data properties.");
+  }
+  return descriptor?.value;
+}
+var init_string_coercion = __esm({
+  "packages/safe-js/src/interp/string-coercion.ts"() {
+    "use strict";
+    init_shape();
+    init_date();
+    init_float32();
+    init_values();
+  }
+});
+
 // packages/safe-js/src/interp/methods/array.ts
 function getArrayMember(value, property, options) {
   const index = getArrayIndex(property);
@@ -144724,6 +145204,110 @@ var init_float32array2 = __esm({
   }
 });
 
+// packages/safe-js/src/interp/globals/date.ts
+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 = parseDate2(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]) => parseDate2(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;
+}
+var intrinsics, constructors2;
+var init_date2 = __esm({
+  "packages/safe-js/src/interp/globals/date.ts"() {
+    "use strict";
+    init_date();
+    init_host_bridge();
+    init_values();
+    intrinsics = /* @__PURE__ */ new WeakMap();
+    constructors2 = /* @__PURE__ */ new WeakSet();
+  }
+});
+
 // packages/safe-js/src/interp/scope.ts
 function defineSnapshotBinding(target, name, value) {
   Object.defineProperty(target, name, {
@@ -145230,6 +145814,9 @@ async function evaluateObjectExpression(node, context) {
       return value;
     }
     if (isObjectPrototypeSetterProperty(property, key3.value)) {
+      if (value.value === null || typeof value.value === "object") {
+        setSandboxPrototype(object, value.value, context.budget);
+      }
       continue;
     }
     defineSandboxProperty(object, String(key3.value), value.value);
@@ -145351,7 +145938,11 @@ async function evaluateBinaryExpression(node, context) {
   if (right.kind !== "normal") {
     return right;
   }
-  const value = applyBinaryOperator(node, left.value, right.value, context);
+  const value = node.operator === "in" && isGuestHostObject(right.value) ? hasHostObjectMember(right.value, await sandboxString(left.value, context.budget, {
+    stack: context.callStack,
+    thisValue: void 0,
+    invokeClosure: (closure, args, thisValue) => invokeSandboxClosure(closure, args, context, context.callStack, void 0, thisValue)
+  })) : applyBinaryOperator(node, left.value, right.value, context);
   return {
     kind: "normal",
     hasValue: true,
@@ -146034,7 +146625,7 @@ function forInKeys(object, budget) {
   const keys = [];
   const seen = /* @__PURE__ */ new Set();
   let depth = 0;
-  for (let current = object; current !== null; current = getSandboxPrototype(current)) {
+  for (let current = object; current !== null; current = getSandboxPrototype(current, budget)) {
     if (depth > 0) budget.visitNode();
     assertSandboxDataDepth(depth++);
     const properties = isGuestClosure(current) ? materializeFunctionProperties(current) : isSandboxClosure(current) ? current.properties ?? {} : current;
@@ -146048,9 +146639,9 @@ function forInKeys(object, budget) {
   return keys;
 }
 function hasForInProperty(object, key3, budget) {
-  if (isGuestHostObject(object)) return getHostObjectKeys(object).includes(key3);
+  if (isGuestHostObject(object)) return hasHostObjectMember(object, key3, true);
   let depth = 0;
-  for (let current = object; current !== null; current = getSandboxPrototype(current)) {
+  for (let current = object; current !== null; current = getSandboxPrototype(current, budget)) {
     if (depth > 0) budget.visitNode();
     assertSandboxDataDepth(depth++);
     const properties = isGuestClosure(current) ? materializeFunctionProperties(current) : isSandboxClosure(current) ? current.properties ?? {} : current;
@@ -146545,6 +147136,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);
@@ -146781,6 +147373,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,
@@ -147033,6 +147628,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;
       }
@@ -147046,7 +147642,7 @@ function applyBinaryOperator(node, left, right, context) {
           throw new TypeError("Function has a non-object prototype in instanceof check.");
         }
         let depth = 0;
-        for (let current = getSandboxPrototype(left); current !== null; current = getSandboxPrototype(current)) {
+        for (let current = getSandboxPrototype(left, context.budget); current !== null; current = getSandboxPrototype(current, context.budget)) {
           context.budget.visitNode();
           assertSandboxDataDepth(depth++);
           if (current === prototype) return true;
@@ -147096,8 +147692,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 "<":
@@ -147180,6 +147776,7 @@ function toPrimitive(value) {
   return toString(value);
 }
 async function toNumericPrimitive(value, context) {
+  if (isSandboxDate(value)) return dateTime(value);
   if (isPrimitiveCoercionType(getCoercionType(value))) {
     return value;
   }
@@ -147209,6 +147806,7 @@ async function toNumericPrimitive(value, context) {
   return toString(value);
 }
 function toNumber(value) {
+  if (isSandboxDate(value)) return dateTime(value);
   if (typeof value === "number") {
     return value;
   }
@@ -147227,6 +147825,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(",");
   }
@@ -147257,7 +147856,7 @@ function getMemberValue(target, property, context) {
       return getPropertyValue(current, property, context);
     }
     if (Object.hasOwn(current, String(property))) return current[String(property)];
-    current = getSandboxPrototype(current);
+    current = getSandboxPrototype(current, context.budget);
     if (current !== null) {
       context.budget.visitNode();
       assertSandboxDataDepth(++depth);
@@ -147272,6 +147871,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;
@@ -147306,7 +147906,7 @@ function setSandboxProperty(target, property, value, budget) {
   } else {
     if (typeof prototypeOwner === "object" && prototypeOwner !== null) {
       let depth = 0;
-      for (let prototype = getSandboxPrototype(prototypeOwner); prototype !== null; prototype = getSandboxPrototype(prototype)) {
+      for (let prototype = getSandboxPrototype(prototypeOwner, budget); prototype !== null; prototype = getSandboxPrototype(prototype, budget)) {
         budget.visitNode();
         assertSandboxDataDepth(depth++);
         const properties = isSandboxClosure(prototype) ? prototype.properties : prototype;
@@ -147500,6 +148100,13 @@ async function evaluateObjectSpread(node, context) {
       value: []
     };
   }
+  if (isGuestHostObject(value.value)) {
+    const entries = [];
+    for (const key3 of getHostObjectKeys(value.value)) {
+      if (hasHostObjectMember(value.value, key3, true)) entries.push([key3, getHostObjectMember(value.value, key3)]);
+    }
+    return { ok: true, value: entries };
+  }
   if (isSandboxClosure(value.value) && !isGuestClosure(value.value) || isSandboxPromise(value.value)) {
     throw new TypeError(
       `Cannot spread ${describeObjectSpreadValue(value.value)} into object literal.`
@@ -147576,6 +148183,7 @@ var init_interpreter = __esm({
     "use strict";
     init_promise_replay();
     init_host_capabilities();
+    init_string_coercion();
     init_promise_tracker();
     init_jobs4();
     init_cancel2();
@@ -147603,6 +148211,8 @@ var init_interpreter = __esm({
     init_collections();
     init_float32array2();
     init_float32();
+    init_date();
+    init_date2();
     init_values();
     init_scope();
     init_var_hoist();
@@ -147770,6 +148380,7 @@ function createInterpretedClosure(node, context, evaluateNode3) {
 function createGeneratorClosure(node, context, evaluateNode3) {
   return createSandboxClosure({
     guest: true,
+    generator: true,
     sandbox: true,
     length: getFunctionLength(node.params),
     ...node.id === void 0 ? {} : { name: node.id.name },
@@ -148021,7 +148632,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(
@@ -148032,13 +148643,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 (error3) {
+              captured.rollback();
+              throw error3;
+            }
             if (options.realm.awaitResult(callable)) {
               return Promise.resolve(result).then((value2) => copyHostResultToSandbox(value2, stackFrames, options));
             }
@@ -148626,6 +149245,14 @@ function copyHostValueToSandbox(value, stackFrames, options, state, path193) {
       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;
@@ -148907,6 +149534,7 @@ var init_host_bridge = __esm({
   "packages/safe-js/src/interp/host-bridge.ts"() {
     "use strict";
     init_async();
+    init_date();
     init_host_capabilities();
     init_shape();
     init_budget2();
@@ -149046,7 +149674,9 @@ function toJsonParseText(input) {
 }
 async function stringifyProperty(key3, holder, state, indent = "") {
   let value = getOwnDataValue(holder, key3);
-  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, [key3], value, state);
@@ -149081,7 +149711,7 @@ async function stringifyValue3(value, state, indent) {
     return stringifyArray(value, state, indent);
   }
   if (isStringifyObject(value)) {
-    return stringifyObject(value, state, indent);
+    return stringifyObject2(value, state, indent);
   }
   return void 0;
 }
@@ -149107,7 +149737,7 @@ ${indent}]`;
     leaveStringifyObject(value, state);
   }
 }
-async function stringifyObject(value, state, indent) {
+async function stringifyObject2(value, state, indent) {
   enterStringifyObject(value, state);
   try {
     const nextIndent = indent + state.gap;
@@ -149232,6 +149862,7 @@ function defineDataProperty8(target, key3, value) {
 var init_console_json = __esm({
   "packages/safe-js/src/interp/globals/console-json.ts"() {
     "use strict";
+    init_date();
     init_compile_guard();
     init_host_bridge();
     init_values();
@@ -149457,89 +150088,143 @@ var init_misc = __esm({
   }
 });
 
-// packages/safe-js/src/interp/string-coercion.ts
-function sandboxString(value, budget, context, joining = /* @__PURE__ */ new Set()) {
-  if (value === null || typeof value !== "object") {
-    if (typeof value === "function") throw new TypeError("Expected a sandbox value.");
-    return budget.allocateString(String(value));
-  }
-  return stringifyObject2(value, budget, context, joining);
-}
-async function stringifyObject2(value, budget, context, joining) {
-  const leaveCall = budget.enterCall();
-  try {
-    budget.visitNode();
-    for (const name of ["toString", "valueOf"]) {
-      const descriptor = Object.getOwnPropertyDescriptor(value, name);
-      let result;
-      if (descriptor === void 0) {
-        if (name === "valueOf") continue;
-        result = await defaultToString(value, budget, context, joining);
-      } else {
-        const hook = ownDataValue(value, name);
-        if (!isSandboxClosure(hook)) continue;
-        if (context?.invokeClosure === void 0) {
-          throw new TypeError("String hooks require a sandbox call context.");
-        }
-        result = await context.invokeClosure(hook, [], value);
-      }
-      if (result === null || typeof result !== "object") {
-        return sandboxString(result, budget, context, joining);
-      }
+// packages/safe-js/src/interp/globals/object.ts
+function createObjectGlobal(methods, budget) {
+  const construct = ([value]) => {
+    if (value === null || value === void 0) {
+      budget.chargeDataUsage(1);
+      return /* @__PURE__ */ Object.create(null);
     }
-    throw new TypeError("Cannot convert object to primitive value");
-  } finally {
-    leaveCall();
-  }
-}
-async function defaultToString(value, budget, context, joining) {
-  if (Array.isArray(value) || isFloat32Array(value)) {
-    if (Object.hasOwn(value, "join")) {
-      const join21 = ownDataValue(value, "join");
-      if (!isSandboxClosure(join21))
-        return isFloat32Array(value) ? "[object Float32Array]" : "[object Array]";
-      if (context?.invokeClosure === void 0) {
-        throw new TypeError("String hooks require a sandbox call context.");
+    if (typeof value !== "object") throw new TypeError("Object primitive boxing is not supported.");
+    return value;
+  };
+  const constructor = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "Object",
+    length: 1,
+    call: construct,
+    construct
+  });
+  const properties = materializeFunctionProperties(constructor);
+  const prototype = properties.prototype;
+  Object.defineProperty(properties, "prototype", { writable: false });
+  for (const [name, method] of Object.entries(methods)) {
+    Object.defineProperty(properties, name, { value: method, writable: true, configurable: true });
+  }
+  const prototypeMethods = {
+    toString: createSandboxClosure({
+      sandbox: true,
+      name: "toString",
+      length: 0,
+      call: (_args, context) => budget.allocateString(`[object ${typeTag(context?.thisValue)}]`)
+    }),
+    valueOf: createSandboxClosure({
+      sandbox: true,
+      name: "valueOf",
+      length: 0,
+      call: (_args, context) => {
+        const value = requireReceiver(context?.thisValue);
+        if (typeof value !== "object")
+          throw new TypeError("Object primitive boxing is not supported.");
+        return value;
       }
-      return context.invokeClosure(join21, [], value);
-    }
-    if (joining.has(value)) return "";
-    joining.add(value);
-    try {
-      const length = isFloat32Array(value) ? float32Storage(value).length : value.length;
-      let text5 = "";
-      for (let index = 0; index < length; index++) {
-        budget.visitNode();
-        const element = ownDataValue(value, String(index));
-        const part = element === null || element === void 0 ? "" : await sandboxString(element, budget, context, joining);
-        text5 = budget.allocateString(text5 + (index === 0 ? "" : ",") + part);
+    }),
+    hasOwnProperty: createSandboxClosure({
+      sandbox: true,
+      name: "hasOwnProperty",
+      length: 1,
+      call: async ([key3], context) => hasOwnSandboxProperty(
+        requireReceiver(context?.thisValue),
+        await sandboxString(key3, budget, context),
+        false
+      )
+    }),
+    propertyIsEnumerable: createSandboxClosure({
+      sandbox: true,
+      name: "propertyIsEnumerable",
+      length: 1,
+      call: async ([key3], context) => hasOwnSandboxProperty(
+        requireReceiver(context?.thisValue),
+        await sandboxString(key3, budget, context),
+        true
+      )
+    }),
+    isPrototypeOf: createSandboxClosure({
+      sandbox: true,
+      name: "isPrototypeOf",
+      length: 1,
+      call: ([value], context) => {
+        if (typeof value !== "object" || value === null) return false;
+        const receiver = requireReceiver(context?.thisValue);
+        let depth = 0;
+        for (let current = getSandboxPrototype(value, budget); current !== null; current = getSandboxPrototype(current, budget)) {
+          budget.visitNode();
+          assertSandboxDataDepth(depth++);
+          if (current === receiver) return true;
+        }
+        return false;
       }
-      return text5;
-    } finally {
-      joining.delete(value);
-    }
-  }
-  if (sandboxErrorTypes.has(value)) {
-    const nameValue = ownDataValue(value, "name");
-    const name = nameValue === void 0 ? "Error" : await sandboxString(nameValue, budget, context, joining);
-    const messageValue2 = ownDataValue(value, "message");
-    const message2 = messageValue2 === void 0 ? "" : await sandboxString(messageValue2, budget, context, joining);
-    return name === "" ? message2 : message2 === "" ? name : `${name}: ${message2}`;
+    })
+  };
+  for (const [name, method] of Object.entries(prototypeMethods)) {
+    Object.defineProperty(prototype, name, { value: method, writable: true, configurable: true });
   }
-  return isSandboxPromise(value) ? "[object Promise]" : "[object Object]";
+  markDescriptorObject(prototype);
+  installObjectPrototype(budget, prototype, constructor);
+  return constructor;
 }
-function ownDataValue(value, name) {
-  const descriptor = Object.getOwnPropertyDescriptor(value, name);
-  if (descriptor !== void 0 && !Object.hasOwn(descriptor, "value")) {
-    throw new TypeError("String conversion requires sandbox data properties.");
-  }
-  return descriptor?.value;
+function requireReceiver(value) {
+  if (value === null || value === void 0)
+    throw new TypeError("Object method requires a non-null receiver.");
+  return value;
 }
-var init_string_coercion = __esm({
-  "packages/safe-js/src/interp/string-coercion.ts"() {
+function hasOwnSandboxProperty(value, key3, enumerable) {
+  requireReceiver(value);
+  if (isGuestHostObject(value)) return hasHostObjectMember(value, key3, enumerable);
+  let properties;
+  if (isGuestClosure(value)) properties = materializeFunctionProperties(value);
+  else if (isSandboxClosure(value)) {
+    if (key3 === "length" || key3 === "name") return !enumerable;
+    properties = value.properties ?? /* @__PURE__ */ Object.create(null);
+  } else if (isSandboxMap(value) || isSandboxSet(value) || isSandboxPromise(value) || isSandboxGenerator(value))
+    return false;
+  else if (isSandboxRegex(value)) return key3 === "lastIndex" && !enumerable;
+  else properties = Object(value);
+  const descriptor = Object.getOwnPropertyDescriptor(properties, key3);
+  return descriptor !== void 0 && (!enumerable || descriptor.enumerable === true);
+}
+function typeTag(value) {
+  if (value === void 0) return "Undefined";
+  if (value === null) return "Null";
+  if (typeof value === "string") return "String";
+  if (typeof value === "number") return "Number";
+  if (typeof value === "boolean") return "Boolean";
+  if (isSandboxClosure(value)) {
+    while (value.boundTarget !== void 0) value = value.boundTarget;
+    return value.generator ? "GeneratorFunction" : value.async ? "AsyncFunction" : "Function";
+  }
+  if (Array.isArray(value)) return "Array";
+  if (isSandboxDate(value)) return "Date";
+  if (isSandboxErrorConstructorInstance(value, "Error")) return "Error";
+  if (isSandboxRegex(value)) return "RegExp";
+  if (isSandboxMap(value)) return "Map";
+  if (isSandboxSet(value)) return "Set";
+  if (isSandboxPromise(value)) return "Promise";
+  if (isSandboxGenerator(value)) return "Generator";
+  if (isFloat32Array(value)) return "Float32Array";
+  return "Object";
+}
+var init_object2 = __esm({
+  "packages/safe-js/src/interp/globals/object.ts"() {
     "use strict";
-    init_shape();
+    init_graph_depth();
+    init_date();
+    init_exceptions();
     init_float32();
+    init_host_capabilities();
+    init_object_model();
+    init_string_coercion();
     init_values();
   }
 });
@@ -149547,7 +150232,7 @@ var init_string_coercion = __esm({
 // packages/safe-js/src/interp/globals/object-array.ts
 function createObjectArrayGlobals(options) {
   return {
-    Object: {
+    Object: createObjectGlobal({
       keys: createSandboxClosure({
         sandbox: true,
         call: ([value]) => budgetSandboxValue2(getOwnEnumerableKeys(value), options.budget),
@@ -149565,7 +150250,11 @@ function createObjectArrayGlobals(options) {
       }),
       hasOwn: createSandboxClosure({
         sandbox: true,
-        call: ([value, key3]) => Reflect.apply(Object.hasOwn, Object, [isSandboxClosure(value) ? objectProperties(value) : value, key3]),
+        call: ([value, key3], context) => {
+          if (value === null || value === void 0) throw new TypeError("Cannot convert undefined or null to object.");
+          const name = sandboxString(key3, options.budget, context);
+          return typeof name === "string" ? hasOwnSandboxProperty(value, name, false) : name.then((property) => hasOwnSandboxProperty(value, property, false));
+        },
         name: "hasOwn"
       }),
       getOwnPropertyDescriptor: createSandboxClosure({
@@ -149604,8 +150293,9 @@ function createObjectArrayGlobals(options) {
       getPrototypeOf: createSandboxClosure({
         sandbox: true,
         call: ([value]) => {
+          if (isSandboxDate(value)) return getDatePrototype(value, options.budget, options.compileOwner);
           objectProperties(value);
-          return getSandboxPrototype(value);
+          return getSandboxPrototype(value, options.budget);
         },
         name: "getPrototypeOf"
       }),
@@ -149663,6 +150353,7 @@ function createObjectArrayGlobals(options) {
       freeze: createSandboxClosure({
         sandbox: true,
         call: ([value]) => {
+          if (isGuestHostObject(value)) throw new TypeError("Live host objects cannot be frozen.");
           if (typeof value === "object" && value !== null) {
             Object.freeze(isGuestClosure(value) ? materializeFunctionProperties(value) : value);
           }
@@ -149680,7 +150371,7 @@ function createObjectArrayGlobals(options) {
         call: ([target, ...sources]) => assignSandboxValues(target, sources, options.budget),
         name: "assign"
       })
-    },
+    }, options.budget),
     Array: createSandboxClosure({
       sandbox: true,
       call: (args) => createArrayFromConstructorArgs(args, options.budget),
@@ -149728,7 +150419,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({
@@ -149828,6 +150519,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)) {
@@ -149873,6 +150568,21 @@ function isAssignableSandboxTarget(value) {
 async function arrayFromSandboxValues(args, budget) {
   const [items, mapFn, thisValue] = args;
   const iterator = getSandboxIterator(items);
+  if (isGuestHostObject(items) && iterator !== void 0) {
+    if (mapFn !== void 0 && !isSandboxClosure(mapFn))
+      throw new TypeError("Array.from mapping callback must be a function.");
+    const values2 = [];
+    while (true) {
+      const next = await iterator.next();
+      if (next.done) break;
+      budget.allocateArrayLength(values2.length + 1);
+      const value = mapFn === void 0 ? next.value : await mapFn.call([next.value, values2.length], { stack: [], thisValue });
+      if (isSandboxPromise(value) && value.synchronousPrefix !== void 0)
+        await value.synchronousPrefix;
+      values2.push(value);
+    }
+    return allocateProducedSandboxValue(values2, budget);
+  }
   const values = iterator === void 0 ? Reflect.apply(Array.from, Array, [items]) : await collectIteratorValues(iterator);
   if (mapFn === void 0 || !isSandboxClosure(mapFn)) {
     if (mapFn !== void 0) {
@@ -149945,6 +150655,9 @@ function getTemplateRawParts(template2) {
 var init_object_array = __esm({
   "packages/safe-js/src/interp/globals/object-array.ts"() {
     "use strict";
+    init_date();
+    init_date2();
+    init_object2();
     init_host_capabilities();
     init_float32();
     init_interpreter();
@@ -149961,6 +150674,7 @@ function createBuiltinBindings(options) {
     ...createConsoleJsonGlobals(options),
     ...createCollectionGlobals(options),
     Float32Array: createFloat32ArrayGlobal(options.budget),
+    Date: createDateGlobal(options),
     ...createErrorGlobals(options),
     ...createMathGlobals({ random: options.random }),
     ...createObjectArrayGlobals(options),
@@ -149981,6 +150695,7 @@ var init_globals = __esm({
     init_misc();
     init_object_array();
     init_promise();
+    init_date2();
   }
 });
 
@@ -150176,10 +150891,10 @@ var init_random = __esm({
 
 // packages/safe-js/src/realm.ts
 import { AsyncLocalStorage as AsyncLocalStorage9 } from "node:async_hooks";
-import { types as types3 } from "node:util";
+import { types as types5 } from "node:util";
 function readModules(input) {
   const entries = (value, label) => {
-    if (types3.isMap(value) && !types3.isProxy(value)) {
+    if (types5.isMap(value) && !types5.isProxy(value)) {
       const result = [...Map.prototype.entries.call(value)];
       if (result.length > 4096 || result.some(([key3]) => typeof key3 !== "string" || key3.length === 0))
         throw new TypeError(`${label} requires bounded string keys.`);
@@ -150242,6 +150957,7 @@ function readRealmOptions(value, oneShot = false) {
     "signal",
     "sink",
     "randomSeed",
+    "clock",
     "limits"
   ]);
   for (const [key3, entry] of Object.entries(options)) {
@@ -150257,6 +150973,7 @@ var init_realm = __esm({
     init_budget2();
     init_compile_guard();
     init_globals();
+    init_object_model();
     init_interpreter();
     init_jobs4();
     init_cancel2();
@@ -150281,6 +150998,7 @@ var init_realm = __esm({
           extensions: 32,
           hostObjects: 1024,
           callbacks: 1024,
+          guestReferences: 1024,
           cleanups: 1024,
           nestedEvaluations: 16
         };
@@ -150289,7 +151007,7 @@ var init_realm = __esm({
             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) || types5.isProxy(options.extensions)))
           throw new TypeError("Extensions must be a registration array.");
         const registrations = options.extensions ?? [];
         const extensions = [];
@@ -150317,6 +151035,7 @@ var init_realm = __esm({
           owner: this,
           assertActive: this.assertOpen,
           wrapCallback: this.wrapCallback,
+          captureArguments: this.captureArguments,
           invoke: this.invokeHost,
           awaitResult: (operation) => this.nestedOperations.has(operation)
         };
@@ -150325,6 +151044,7 @@ var init_realm = __esm({
             budget: this.budget,
             compileOwner: this.lease.owner,
             sink: options.sink,
+            clock: options.clock,
             random: createReplayableRandom({ seed: options.randomSeed }).next
           });
           const names = /* @__PURE__ */ new Set();
@@ -150356,9 +151076,10 @@ var init_realm = __esm({
           }
           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((error3) => this.poison(error3));
         } catch (error3) {
+          releaseObjectPrototype(this.budget);
           this.compilation.dispose();
           this.lease.release();
           throw error3;
@@ -150380,6 +151101,8 @@ var init_realm = __esm({
       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() };
@@ -150399,10 +151122,56 @@ var init_realm = __esm({
         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 (error3) {
+          rollback();
+          if (error3 instanceof SandboxError) this.poison(error3);
+          throw error3;
+        }
+      };
+      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.");
@@ -150458,7 +151227,7 @@ var init_realm = __esm({
         return this.phase.run(phase, () => {
           try {
             const result = call();
-            if (types3.isPromise(result) || phase.pending.size > 0 || phase.failure !== void 0) {
+            if (types5.isPromise(result) || phase.pending.size > 0 || phase.failure !== void 0) {
               return Promise.resolve(result).then(
                 async (value) => {
                   await Promise.allSettled(phase.pending);
@@ -150513,17 +151282,26 @@ var init_realm = __esm({
           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, validate2) => {
             const value = this.invokeHost(operation, operation);
-            if (types3.isPromise(value)) {
+            if (types5.isPromise(value)) {
               void Promise.resolve(value).catch(() => void 0);
               throw new TypeError("Live property getters must be synchronous.");
             }
-            return this.importValue(value);
+            return this.importValue(validate2 === void 0 ? value : validate2(value));
           },
           write: (operation, value) => {
             const result = this.invokeHost(operation, () => operation(this.exportValue(value)));
-            if (types3.isPromise(result)) {
+            if (types5.isPromise(result)) {
               void Promise.resolve(result).catch(() => void 0);
               throw new TypeError("Live property setters must be synchronous.");
             }
@@ -150570,7 +151348,7 @@ var init_realm = __esm({
         });
         try {
           this.budget.reconcileDataUsage(
-            measureSandboxData([...this.scope?.retainedValues() ?? [], ...this.retainedCallbacks()])
+            measureSandboxData([...this.scope?.retainedValues() ?? [], ...this.retainedRoots()])
           );
         } catch (error3) {
           this.poison(error3);
@@ -150585,7 +151363,7 @@ var init_realm = __esm({
         if (this.active === void 0)
           reconcileCompiledValues(
             this.budget,
-            [...this.scope?.retainedValues() ?? [], ...this.retainedCallbacks()],
+            [...this.scope?.retainedValues() ?? [], ...this.retainedRoots()],
             this.compilation
           );
       };
@@ -150644,7 +151422,7 @@ var init_realm = __esm({
           if (!this.closed && this.active === void 0)
             reconcileCompiledValues(
               this.budget,
-              [...this.scope?.retainedValues() ?? [], ...this.retainedCallbacks()],
+              [...this.scope?.retainedValues() ?? [], ...this.retainedRoots()],
               this.compilation
             );
         }
@@ -150661,6 +151439,23 @@ var init_realm = __esm({
             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"))
@@ -150699,7 +151494,7 @@ var init_realm = __esm({
             }
           });
           const output = getExtensionSetup(extension)(context);
-          if (types3.isPromise(output)) {
+          if (types5.isPromise(output)) {
             void Promise.resolve(output).catch(() => void 0);
             throw new TypeError("Extension setup must be synchronous.");
           }
@@ -150823,7 +151618,7 @@ var init_realm = __esm({
           if (!this.closed)
             reconcileCompiledValues(
               this.budget,
-              [...this.scope?.retainedValues() ?? [], ...this.retainedCallbacks()],
+              [...this.scope?.retainedValues() ?? [], ...this.retainedRoots()],
               this.compilation
             );
           return result;
@@ -150857,7 +151652,10 @@ var init_realm = __esm({
         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);
+        releaseObjectPrototype(this.budget);
         this.disposal = (async () => {
           const errors2 = [];
           for (const cleanup of this.cleanups.splice(0).reverse()) {
@@ -151319,6 +152117,7 @@ var init_serialize = __esm({
     init_arrays();
     init_float32();
     init_float32array();
+    init_date();
     init_values();
     UnsnapshotableValueError = class extends Error {
       path;
@@ -151526,7 +152325,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 ?? {})
           );
@@ -151787,6 +152586,7 @@ function run(source, options = {}) {
         }
       });
     } finally {
+      releaseObjectPrototype(budget);
       compilation.dispose();
       operation.release();
     }
@@ -151998,6 +152798,7 @@ var init_run7 = __esm({
     init_promise_tracker();
     init_host_call();
     init_globals();
+    init_object_model();
     init_host_bridge();
     init_interpreter();
     init_promise();
@@ -158877,7 +159678,7 @@ var init_package2 = __esm({
   "package.json"() {
     package_default2 = {
       name: "poe-code",
-      version: "14.0.6",
+      version: "14.0.8",
       description: "CLI tool to configure Poe API for developer workflows.",
       license: "MIT",
       type: "module",