poe-code 14.0.6 → 14.0.8

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

@@ -1,5 +1,6 @@
 import { promiseReplayContext } from "./promise-replay.js";
-import { getHostObjectKeys, getHostObjectMember, isGuestHostObject, setHostObjectMember } from "./host-capabilities.js";
+import { getHostObjectKeys, getHostObjectMember, hasHostObjectMember, isGuestHostObject, setHostObjectMember } from "./host-capabilities.js";
+import { sandboxString } from "./string-coercion.js";
 import { assertPromiseExecutionAllowed } from "./promise-tracker.js";
 import { SandboxJobQueue, runAsyncPrefix, suspendJob } from "./jobs.js";
 import { withCancellationSignal } from "./cancel.js";
@@ -11,7 +12,7 @@ import { CompileScope, RegexCompileGuard } from "./regex/compile-guard.js";
 import { coerceThrownValue, createCapturedException, evaluateThrowStatement as evaluateThrowStatementResult, evaluateTryStatement as evaluateTryStatementResult, isCapturedException, surfaceThrownValue } from "./exceptions.js";
 import { callArrayMethod, getArrayMember, isArrayMethodName } from "./methods/array.js";
 import { getFunctionMember } from "./methods/function.js";
-import { getGuestFunctionProperty, getSandboxPrototype, isGuestClosure, materializeFunctionProperties } from "./object-model.js";
+import { getGuestFunctionProperty, getSandboxPrototype, isGuestClosure, materializeFunctionProperties, setSandboxPrototype } from "./object-model.js";
 import { assertSandboxDataDepth } from "../graph-depth.js";
 import { callMapMethod, getMapMember, isMapMethodName } from "./methods/map.js";
 import { callNumberMethod, getNumberMember, isNumberMethodName } from "./methods/number.js";
@@ -27,6 +28,8 @@ import { isSandboxErrorConstructorInstance } from "./globals/error.js";
 import { isSandboxMapConstructor, isSandboxSetConstructor } from "./globals/collections.js";
 import { getFloat32Member, isFloat32ArrayConstructor, setFloat32Member } from "./globals/float32array.js";
 import { isFloat32Array } from "./float32.js";
+import { dateString, dateTime, isSandboxDate } from "./date.js";
+import { getDateMember, getDatePrototype, isDateConstructor } from "./globals/date.js";
 import { createSandboxRegex, allocateProducedSandboxValue, isSandboxClosure, isSandboxGenerator, isSandboxMap, isSandboxPromise, isSandboxRegex, isSandboxSet, reconcileCompiledValues } from "./values.js";
 import { Scope } from "./scope.js";
 import { hoistVarDeclarations } from "./var-hoist.js";
@@ -323,6 +326,9 @@ async function evaluateObjectExpression(node, context) {
             return value;
         }
         if (isObjectPrototypeSetterProperty(property, key.value)) {
+            if (value.value === null || typeof value.value === "object") {
+                setSandboxPrototype(object, value.value, context.budget);
+            }
             continue;
         }
         defineSandboxProperty(object, String(key.value), value.value);
@@ -431,7 +437,13 @@ 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: undefined,
+            invokeClosure: (closure, args, thisValue) => invokeSandboxClosure(closure, args, context, context.callStack, undefined, thisValue)
+        }))
+        : applyBinaryOperator(node, left.value, right.value, context);
     return {
         kind: "normal",
         hasValue: true,
@@ -1128,7 +1140,7 @@ function forInKeys(object, budget) {
     const keys = [];
     const seen = 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++);
@@ -1147,9 +1159,9 @@ function forInKeys(object, budget) {
 }
 function hasForInProperty(object, key, budget) {
     if (isGuestHostObject(object))
-        return getHostObjectKeys(object).includes(key);
+        return hasHostObjectMember(object, key, 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++);
@@ -1648,6 +1660,8 @@ function getPropertyValue(target, property, context) {
         return undefined;
     if (isFloat32Array(target))
         return getFloat32Member(target, property, context.budget);
+    if (isSandboxDate(target))
+        return getDateMember(property, context.budget, context.compilation?.owner);
     if (isSandboxMap(target))
         return getMapMember(target, property, createMapMethodOptions(context));
     if (isSandboxSet(target))
@@ -1864,6 +1878,9 @@ async function evaluateMemberCallExpression(node, context) {
     if (isSandboxMap(member.object)) {
         return evaluatePrimitiveMemberCall(node, "Map", member.property, getMapMember(member.object, member.property, createMapMethodOptions(context)), context);
     }
+    if (isSandboxDate(member.object)) {
+        return evaluateResolvedCallExpression(node, getDateMember(member.property, context.budget, context.compilation?.owner), context, member.object);
+    }
     if (isFloat32Array(member.object)) {
         return evaluateResolvedCallExpression(node, getFloat32Member(member.object, member.property, context.budget), context, member.object);
     }
@@ -2076,6 +2093,8 @@ function applyBinaryOperator(node, left, right, context) {
             }
             if (isFloat32ArrayConstructor(right))
                 return isFloat32Array(left);
+            if (isDateConstructor(right))
+                return isSandboxDate(left) && getDatePrototype(left, context.budget, context.compilation?.owner) !== null;
             if (isSandboxSetConstructor(right) && isSandboxSet(left)) {
                 return true;
             }
@@ -2090,7 +2109,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)
@@ -2141,8 +2160,8 @@ function applyAdditionOperator(left, right, context) {
     return toNumber(leftPrimitive) + toNumber(rightPrimitive);
 }
 function compareRelational(left, right, operator) {
-    const leftPrimitive = toPrimitive(left);
-    const rightPrimitive = toPrimitive(right);
+    const leftPrimitive = isSandboxDate(left) ? dateTime(left) : toPrimitive(left);
+    const rightPrimitive = isSandboxDate(right) ? dateTime(right) : toPrimitive(right);
     if (typeof leftPrimitive === "string" && typeof rightPrimitive === "string") {
         switch (operator) {
             case "<":
@@ -2225,6 +2244,8 @@ function toPrimitive(value) {
     return toString(value);
 }
 async function toNumericPrimitive(value, context) {
+    if (isSandboxDate(value))
+        return dateTime(value);
     if (isPrimitiveCoercionType(getCoercionType(value))) {
         return value;
     }
@@ -2247,6 +2268,8 @@ async function toNumericPrimitive(value, context) {
     return toString(value);
 }
 function toNumber(value) {
+    if (isSandboxDate(value))
+        return dateTime(value);
     if (typeof value === "number") {
         return value;
     }
@@ -2265,6 +2288,8 @@ function toNumber(value) {
     return toNumber(toPrimitive(value));
 }
 function toString(value) {
+    if (isSandboxDate(value))
+        return dateString(value);
     if (Array.isArray(value)) {
         return value
             .map((entry) => (entry === null || entry === undefined ? "" : toString(entry)))
@@ -2308,7 +2333,7 @@ function getMemberValue(target, 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);
@@ -2323,6 +2348,8 @@ function getArrayMemberValue(target, property, context) {
     return getArrayMember(target, property, createArrayMethodOptions(context));
 }
 export function setSandboxProperty(target, property, value, budget) {
+    if (isSandboxDate(target))
+        throw new TypeError("Date own properties are not supported.");
     if (isGuestHostObject(target)) {
         setHostObjectMember(target, String(property), value);
         return;
@@ -2359,7 +2386,7 @@ export 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;
@@ -2553,6 +2580,14 @@ async function evaluateObjectSpread(node, context) {
             value: []
         };
     }
+    if (isGuestHostObject(value.value)) {
+        const entries = [];
+        for (const key of getHostObjectKeys(value.value)) {
+            if (hasHostObjectMember(value.value, key, true))
+                entries.push([key, getHostObjectMember(value.value, key)]);
+        }
+        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.`);
     }

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

@@ -1,7 +1,10 @@
 import { isSandboxGenerator, isSandboxMap, isSandboxSet } from "./values.js";
 import { enterRunningState } from "./running-state.js";
 import { isFloat32Array } from "./float32.js";
+import { getHostObjectIterator, isGuestHostObject } from "./host-capabilities.js";
 export function getSandboxIterator(value) {
+    if (isGuestHostObject(value))
+        return getHostObjectIterator(value);
     if (isFloat32Array(value)) {
         return syncIterator(Float32Array.prototype.values.call(value));
     }

package/packages/safe-js/dist/interp/object-model.d.ts

@@ -5,7 +5,9 @@ export declare function isGuestClosure(value: unknown): value is SandboxClosure;
 export declare function getGuestFunctionProperties(closure: SandboxClosure): SandboxObject | undefined;
 export declare function materializeFunctionProperties(closure: SandboxClosure): SandboxObject;
 export declare function getGuestFunctionProperty(closure: SandboxClosure, key: string): SandboxValue;
-export declare function getSandboxPrototype(value: object): object | null;
+export declare function installObjectPrototype(budget: Budget, prototype: SandboxObject, constructor: SandboxClosure): void;
+export declare function releaseObjectPrototype(budget: Budget): void;
+export declare function getSandboxPrototype(value: object, budget?: Budget): object | null;
 export declare function getSandboxDataProperty(value: SandboxValue, key: string | number, budget?: Budget): SandboxValue;
 export declare function setSandboxPrototype(value: object, prototype: object | null, budget?: Budget): void;
 export declare function markDescriptorObject(value: object): void;

package/packages/safe-js/dist/interp/object-model.js

@@ -4,6 +4,8 @@ import { isSandboxClosure, isSandboxGenerator, isSandboxMap, isSandboxPromise, i
 const guestClosures = new WeakSet();
 const functionProperties = new WeakMap();
 const prototypes = new WeakMap();
+const intrinsicPrototypes = new WeakMap();
+const intrinsicConstructors = new WeakMap();
 const descriptorObjects = new WeakSet();
 export function registerGuestClosure(closure) {
     guestClosures.add(closure);
@@ -56,8 +58,33 @@ export function getGuestFunctionProperty(closure, key) {
         ? undefined
         : Object.getOwnPropertyDescriptor(properties, key)?.value;
 }
-export function getSandboxPrototype(value) {
-    return prototypes.get(value) ?? null;
+export 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 !== undefined && after !== undefined && 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(key => unchanged(descriptors.get(key), current[key]));
+    }));
+    budget.setRetainedValues(prototype, () => records.flatMap(({ value, descriptors }) => Object.entries(Object.getOwnPropertyDescriptors(value)).flatMap(([key, descriptor]) => unchanged(descriptors.get(key), descriptor) ? [] : [key, descriptor.value])));
+}
+export function releaseObjectPrototype(budget) {
+    const prototype = intrinsicPrototypes.get(budget);
+    if (prototype !== undefined)
+        budget.setRetainedValues(prototype, undefined);
+    intrinsicPrototypes.delete(budget);
+}
+export function getSandboxPrototype(value, budget) {
+    if (prototypes.has(value))
+        return prototypes.get(value) ?? null;
+    return budget !== undefined && isPrototypeRecord(value)
+        ? intrinsicPrototypes.get(budget) ?? null
+        : null;
 }
 export function getSandboxDataProperty(value, key, budget) {
     let current = value;
@@ -81,7 +108,7 @@ export function getSandboxDataProperty(value, key, budget) {
             return undefined;
         if (Object.hasOwn(current, String(key)))
             return current[String(key)];
-        current = getSandboxPrototype(current);
+        current = getSandboxPrototype(current, budget);
         if (current !== null) {
             budget?.visitNode();
             assertSandboxDataDepth(++depth);
@@ -90,25 +117,25 @@ export function getSandboxDataProperty(value, key, budget) {
     return undefined;
 }
 export function setSandboxPrototype(value, prototype, budget) {
+    if (budget !== undefined && 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)
+    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))
@@ -130,6 +157,9 @@ export function hasManagedDescriptors(value) {
     return descriptorObjects.has(value);
 }
 export function hasGuestObjectState(value) {
+    const intrinsicUnchanged = intrinsicConstructors.get(value);
+    if (intrinsicUnchanged !== undefined)
+        return !intrinsicUnchanged();
     if (isLiveCapability(value))
         return true;
     if (functionProperties.has(value) || prototypes.has(value))

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

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

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

@@ -12,7 +12,7 @@ declare const sandboxRegexPattern: unique symbol;
 declare const sandboxSetBrand: unique symbol;
 declare const sandboxRetainedValues: unique symbol;
 export type SandboxPrimitive = string | number | boolean | null | undefined;
-export type SandboxValue = SandboxPrimitive | Float32Array | SandboxObject | SandboxArray | SandboxClosure | SandboxGenerator | SandboxMap | SandboxSet | SandboxPromise | SandboxRegex;
+export type SandboxValue = SandboxPrimitive | Date | Float32Array | SandboxObject | SandboxArray | SandboxClosure | SandboxGenerator | SandboxMap | SandboxSet | SandboxPromise | SandboxRegex;
 export type SandboxObject = {
     [key: string]: SandboxValue;
 };
@@ -55,6 +55,7 @@ export type SandboxCallContext = {
 };
 export type SandboxClosure = {
     readonly async?: true;
+    readonly generator?: true;
     readonly sandbox?: true;
     readonly boundTarget?: SandboxClosure;
     readonly cancellationSignal?: AbortSignal;
@@ -92,6 +93,7 @@ type CopyFromSandboxOptions = {
 export declare function createSandboxClosure(input: {
     guest?: boolean;
     async?: boolean;
+    generator?: boolean;
     sandbox?: boolean;
     boundTarget?: SandboxClosure;
     cancellationSignal?: AbortSignal;

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

@@ -1,5 +1,6 @@
 import { bindOtelSpan, getBoundOtelSpan } from "../observability/otel.js";
-import { getHostObjectKeys, getHostObjectMember, isGuestHostObject, isLiveCapability } from "./host-capabilities.js";
+import { copyNativeDate, exportDate, isSandboxDate } from "./date.js";
+import { getHostObjectKeys, getHostObjectMember, hasHostObjectMember, measureHostObjectData, isGuestHostObject, isLiveCapability } from "./host-capabilities.js";
 import { types as nodeTypes } from "node:util";
 import { CompileScope, RegexCompileGuard, regexCompiledData } from "./regex/compile-guard.js";
 import { copyFloat32Storage, float32DataProperties, float32Storage, isFloat32Array } from "./float32.js";
@@ -40,6 +41,8 @@ export 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 !== undefined) {
         Object.defineProperty(closure, "length", { value: input.length });
     }
@@ -71,8 +74,14 @@ export function createSandboxClosure(input) {
     return Object.freeze(closure);
 }
 export function ownEnumerableSandboxEntries(value) {
-    if (isGuestHostObject(value))
-        return getHostObjectKeys(value).map(key => [key, getHostObjectMember(value, key)]);
+    if (isGuestHostObject(value)) {
+        const entries = [];
+        for (const key of getHostObjectKeys(value)) {
+            if (hasHostObjectMember(value, key, true))
+                entries.push([key, getHostObjectMember(value, key)]);
+        }
+        return entries;
+    }
     if (value === null || value === undefined)
         throw new TypeError("Cannot convert undefined or null to object.");
     if (isGuestClosure(value))
@@ -225,9 +234,12 @@ export function measureSandboxData(values, options = {}) {
         assertSandboxDataDepth(depth);
         seen.add(value);
         usage += 1;
+        if (isSandboxDate(value)) {
+            usage += 8;
+            return;
+        }
         if (isGuestHostObject(value)) {
-            for (const key of getHostObjectKeys(value))
-                usage += key.length + 1;
+            usage += measureHostObjectData(value);
             return;
         }
         const prototype = getSandboxPrototype(value);
@@ -341,7 +353,7 @@ export function reconcileCompiledValues(budget, values, compilation, parent, esc
     while (parent?.closed)
         parent = parent.parent;
     const included = new Set();
-    const usage = measureSandboxData(values, { compileTickets: included });
+    const usage = measureSandboxData([...values, ...budget.retainedValues()], { compileTickets: included });
     const kept = new Set();
     if (parent !== undefined)
         measureSandboxData(escaping, { compileTickets: kept });
@@ -435,6 +447,14 @@ function copyToSandbox(value, state, path = "<root>", cloneSandboxCollections =
         }
         return sandboxPromise;
     }
+    if (nodeTypes.isDate(value)) {
+        const existing = state.seen.get(value);
+        if (existing !== undefined)
+            return existing;
+        const copy = copyNativeDate(value);
+        state.seen.set(value, copy);
+        return copy;
+    }
     if (isFloat32Array(value)) {
         const existing = state.seen.get(value);
         if (existing !== undefined)
@@ -567,6 +587,14 @@ function copyFromSandbox(value, state, path = "<root>", options, depth = 0) {
             Object.preventExtensions(copy);
         return copy;
     }
+    if (isSandboxDate(value)) {
+        const existing = state.seen.get(value);
+        if (existing !== undefined)
+            return existing;
+        const copy = exportDate(value);
+        state.seen.set(value, copy);
+        return copy;
+    }
     if (isSandboxClosure(value)) {
         if (options.wrapClosure === undefined) {
             throw new TypeError("Sandbox closures cannot cross into host values without an explicit wrapper.");

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

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

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

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

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

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

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

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