poe-code 14.0.5 → 14.0.7

package/packages/safe-js/dist/interp/globals/date.js

@@ -0,0 +1,95 @@
+import { createSandboxDate, dateFromParts, dateMethods, dateNumber, dateString, dateTime, isSandboxDate, parseDate } from "../date.js";
+import { declareHostOperation, wrapCallerInjectedBindings } from "../host-bridge.js";
+import { createSandboxClosure } from "../values.js";
+const intrinsics = new WeakMap();
+const constructors = new WeakSet();
+export function createDateGlobal(options) {
+    const validateClockTime = (value) => {
+        if (typeof value !== "number" || !Number.isSafeInteger(value) || Math.abs(value) > 8.64e15)
+            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 === undefined ? Date.now() : options.clock.now();
+        return validateClockTime(value);
+    }, "re-issue", {
+        onReplay: (_args, outcome) => {
+            if (outcome.status === "fulfilled") {
+                const time = validateClockTime(outcome.value);
+                options.clock?.restore?.({ next: time + 1 });
+            }
+        }
+    });
+    const now = wrapCallerInjectedBindings({ now: readNow }, { ...options, moduleId: "<Date>" })
+        .now;
+    const prototype = createSandboxDate(NaN);
+    const constructor = createSandboxClosure({
+        sandbox: true,
+        name: "Date",
+        length: 7,
+        call: async (_args, context) => options.budget.allocateString(dateString(createSandboxDate(Number(await now.call([], context))))),
+        construct: async (args, context) => {
+            let time;
+            if (args.length === 0)
+                time = Number(await now.call([], context));
+            else if (args.length > 1)
+                time = dateFromParts(args, false);
+            else if (isSandboxDate(args[0]))
+                time = dateTime(args[0]);
+            else if (typeof args[0] === "string")
+                time = parseDate(args[0], options.budget);
+            else
+                time = dateNumber(args[0]);
+            options.budget.chargeDataUsage(9);
+            return createSandboxDate(time);
+        },
+        properties: {
+            now,
+            prototype,
+            parse: createSandboxClosure({
+                sandbox: true,
+                name: "parse",
+                length: 1,
+                call: ([value]) => parseDate(value, options.budget)
+            }),
+            UTC: createSandboxClosure({
+                sandbox: true,
+                name: "UTC",
+                length: 7,
+                call: (args) => dateFromParts(args, true)
+            })
+        }
+    });
+    const methods = 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;
+            }
+        }));
+    constructors.add(constructor);
+    intrinsics.set(options.compileOwner ?? options.budget, { constructor, prototype, methods });
+    return constructor;
+}
+export function isDateConstructor(value) {
+    return typeof value === "object" && value !== null && constructors.has(value);
+}
+export function getDateMember(property, budget, owner) {
+    const state = intrinsics.get(owner ?? budget);
+    return property === "constructor" ? state?.constructor : state?.methods.get(String(property));
+}
+export function getDatePrototype(value, budget, owner) {
+    const prototype = intrinsics.get(owner ?? budget)?.prototype;
+    return prototype === value ? null : (prototype ?? null);
+}

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

@@ -1,4 +1,4 @@
-import type { Budget } from "../budget.js";
+import type { Budget, CompileOwner } from "../budget.js";
 import { type SandboxClosure, type SandboxObject } from "../values.js";
 export type ObjectArrayGlobals = {
     Object: SandboxObject;
@@ -9,4 +9,5 @@ export type ObjectArrayGlobals = {
 };
 export declare function createObjectArrayGlobals(options: {
     budget: Budget;
+    compileOwner?: CompileOwner;
 }): ObjectArrayGlobals;

package/packages/safe-js/dist/interp/globals/object-array.js

@@ -1,3 +1,6 @@
+import { dateTime, isSandboxDate } from "../date.js";
+import { getDatePrototype } from "./date.js";
+import { getHostObjectKeys, isGuestHostObject } from "../host-capabilities.js";
 import { isFloat32Array } from "../float32.js";
 import { setSandboxProperty } from "../interpreter.js";
 import { getSandboxIterator } from "../iteration.js";
@@ -64,6 +67,8 @@ export function createObjectArrayGlobals(options) {
             getPrototypeOf: createSandboxClosure({
                 sandbox: true,
                 call: ([value]) => {
+                    if (isSandboxDate(value))
+                        return getDatePrototype(value, options.budget, options.compileOwner);
                     objectProperties(value);
                     return getSandboxPrototype(value);
                 },
@@ -184,7 +189,7 @@ export function createObjectArrayGlobals(options) {
         }),
         Number: createSandboxClosure({
             sandbox: true,
-            call: ([value]) => Number(value),
+            call: ([value]) => isSandboxDate(value) ? dateTime(value) : Number(value),
             name: "Number",
             properties: {
                 isFinite: createSandboxClosure({
@@ -287,6 +292,13 @@ 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)) {
@@ -389,6 +401,8 @@ async function collectIteratorValues(iterator) {
     }
 }
 function getOwnEnumerableKeys(value) {
+    if (isGuestHostObject(value))
+        return getHostObjectKeys(value);
     return getOwnEnumerableEntries(value).map(([key]) => key);
 }
 function getOwnEnumerableValues(value) {

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

@@ -0,0 +1,34 @@
+import { createConsoleJsonGlobals } from "./globals/console-json.js";
+import type { RunClock } from "../run.js";
+export declare function createBuiltinBindings(options: Parameters<typeof createConsoleJsonGlobals>[0] & {
+    random?: () => number;
+    clock?: RunClock;
+}): {
+    RegExp: import("./values.js").SandboxClosure;
+    Promise: import("./values.js").SandboxClosure;
+    structuredClone: import("./values.js").SandboxClosure;
+    parseInt: import("./values.js").SandboxClosure;
+    parseFloat: import("./values.js").SandboxClosure;
+    isNaN: import("./values.js").SandboxClosure;
+    isFinite: import("./values.js").SandboxClosure;
+    Object: import("./values.js").SandboxObject;
+    Array: import("./values.js").SandboxClosure;
+    String: import("./values.js").SandboxClosure;
+    Number: import("./values.js").SandboxClosure;
+    Boolean: import("./values.js").SandboxClosure;
+    Infinity: number;
+    Math: import("./values.js").SandboxObject;
+    NaN: number;
+    Error: import("./values.js").SandboxClosure;
+    TypeError: import("./values.js").SandboxClosure;
+    RangeError: import("./values.js").SandboxClosure;
+    ReferenceError: import("./values.js").SandboxClosure;
+    SyntaxError: import("./values.js").SandboxClosure;
+    AggregateError: import("./values.js").SandboxClosure;
+    Float32Array: import("./values.js").SandboxClosure;
+    Date: import("./values.js").SandboxClosure;
+    Map: import("./values.js").SandboxClosure;
+    Set: import("./values.js").SandboxClosure;
+    JSON: import("./values.js").SandboxObject;
+    console: import("./values.js").SandboxObject;
+};

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

@@ -0,0 +1,24 @@
+import { createConsoleJsonGlobals } from "./globals/console-json.js";
+import { createCollectionGlobals } from "./globals/collections.js";
+import { createFloat32ArrayGlobal } from "./globals/float32array.js";
+import { createErrorGlobals } from "./globals/error.js";
+import { createMathGlobals } from "./globals/math.js";
+import { createRegexGlobals } from "./globals/regex.js";
+import { createMiscGlobals } from "./globals/misc.js";
+import { createObjectArrayGlobals } from "./globals/object-array.js";
+import { createPromiseGlobals } from "./promise.js";
+import { createDateGlobal } from "./globals/date.js";
+export function createBuiltinBindings(options) {
+    return {
+        ...createConsoleJsonGlobals(options),
+        ...createCollectionGlobals(options),
+        Float32Array: createFloat32ArrayGlobal(options.budget),
+        Date: createDateGlobal(options),
+        ...createErrorGlobals(options),
+        ...createMathGlobals({ random: options.random }),
+        ...createObjectArrayGlobals(options),
+        ...createMiscGlobals(options),
+        ...createPromiseGlobals(options),
+        ...createRegexGlobals(options.compileOwner)
+    };
+}

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

@@ -6,7 +6,19 @@ import type { RunLifecycle } from "../snapshot/dump.js";
 type CallerInjectedFunction = {
     bivarianceHack(...args: readonly unknown[]): unknown;
 }["bivarianceHack"];
-type HostBridgeOptions = {
+export type RealmBridge = {
+    readonly owner: object;
+    assertActive(): void;
+    wrapCallback(closure: SandboxClosure): (...args: readonly unknown[]) => Promise<unknown>;
+    invoke(operation: CallerInjectedFunction, call: () => unknown): unknown;
+    awaitResult(operation: CallerInjectedFunction): boolean;
+    captureArguments(operation: CallerInjectedFunction, args: readonly SandboxValue[], copy: (values: readonly SandboxValue[]) => unknown[]): {
+        args: unknown[];
+        rollback(): void;
+    };
+};
+export type HostBridgeOptions = {
+    realm?: RealmBridge;
     registerCapabilities?: boolean;
     capabilityPath?: readonly string[];
     budget: Budget;
@@ -26,4 +38,9 @@ export declare function declareHostOperation<TFunction extends CallerInjectedFun
 }): TFunction;
 export declare function readHostOperationPolicy(operation: CallerInjectedFunction): PendingHostCallPolicyMode | undefined;
 export declare function wrapCallerInjectedBindings(bindings: Record<string, CallerInjectedBinding>, options: HostBridgeOptions): Record<string, SandboxValue>;
+export declare function copyHostValueToSandbox(value: unknown, stackFrames: readonly string[], options: HostBridgeOptions & {
+    errorData?: boolean;
+}, state: {
+    seen: WeakMap<object, SandboxValue>;
+}, path: string): SandboxValue;
 export {};

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

@@ -1,4 +1,6 @@
 import { normalizeClosureResult } from "./async.js";
+import { copyNativeDate } from "./date.js";
+import { exportHostCapability, importHostCapability, isLiveCapability } from "./host-capabilities.js";
 import { attachErrorSpan, replaceErrorStack } from "../error/shape.js";
 import { SandboxError } from "./budget.js";
 import { CompileScope } from "./regex/compile-guard.js";
@@ -38,7 +40,7 @@ export function wrapCallerInjectedBindings(bindings, options) {
         const state = { seen: new WeakMap() };
         const copied = Object.fromEntries(Object.entries(bindings).map(([name, value]) => [
             name,
-            typeof value === "function"
+            typeof value === "function" && !isLiveCapability(value)
                 ? wrapCallerInjectedFunction(name, value, { ...options, capabilityPath: [name] }, state)
                 : copyHostValueToSandbox(value, [], { ...options, operation: name, capabilityPath: [name] }, state, "<root>")
         ]));
@@ -56,9 +58,10 @@ function wrapCallerInjectedFunction(name, value, options, state) {
     const bindingName = name === "default" && value.name.length > 0 ? value.name : name;
     const callable = value;
     return createSandboxClosure({
-        ...(isAsyncFunction(callable) ? { async: true } : {}),
+        ...(isAsyncFunction(callable) && !options.realm?.awaitResult(callable) ? { async: true } : {}),
         cancellationSignal: options.signal,
         call: (args, context) => {
+            options.realm?.assertActive();
             const operationLease = options.budget.acquireCompileOwner(false, options.compileOwner);
             const compilation = new CompileScope(operationLease.owner);
             try {
@@ -75,10 +78,13 @@ function wrapCallerInjectedFunction(name, value, options, state) {
                     seen: new WeakMap(),
                     restored: []
                 };
-                const hostArgs = deepCopyFromSandbox([...args], {
+                const copyArguments = (values) => deepCopyFromSandbox([...values], {
                     compilation,
-                    wrapClosure: (closure) => wrapSandboxClosureForHost(closure, stackFrames, options.budget, operationLease.owner, callbacks)
+                    unwrapHostObject: options.realm === undefined ? undefined : object => exportHostCapability(object, options.realm.owner),
+                    wrapClosure: (closure) => options.realm?.wrapCallback(closure) ?? wrapSandboxClosureForHost(closure, stackFrames, options.budget, operationLease.owner, callbacks)
                 });
+                const captured = options.realm?.captureArguments(callable, args, copyArguments);
+                const hostArgs = captured?.args ?? copyArguments(args);
                 const hostCalls = options.hostCalls;
                 const operation = options.operation ?? bindingName;
                 const moduleId = options.moduleId ?? "<bindings>";
@@ -86,6 +92,20 @@ function wrapCallerInjectedFunction(name, value, options, state) {
                     readRegisteredPendingHostCallPolicy(moduleId, operation) ??
                     "re-issue";
                 if (hostCalls === undefined) {
+                    if (options.realm !== undefined) {
+                        let result;
+                        try {
+                            result = options.realm.invoke(callable, () => Reflect.apply(callable, undefined, hostArgs));
+                        }
+                        catch (error) {
+                            captured.rollback();
+                            throw error;
+                        }
+                        if (options.realm.awaitResult(callable)) {
+                            return Promise.resolve(result).then(value => copyHostResultToSandbox(value, stackFrames, options));
+                        }
+                        return copyHostResultToSandbox(result, stackFrames, options);
+                    }
                     return copyHostResultToSandbox(invokeHostCallback(() => Reflect.apply(callable, undefined, hostArgs), options), stackFrames, options);
                 }
                 const issued = hostCalls.issue({
@@ -595,8 +615,13 @@ function wrapHostPromiseWithSignal(promise, signal) {
         });
     });
 }
-function copyHostValueToSandbox(value, stackFrames, options, state, path) {
+export function copyHostValueToSandbox(value, stackFrames, options, state, path) {
     const { budget } = options;
+    if (isLiveCapability(value)) {
+        if (options.realm === undefined || options.errorData || options.hostCalls !== undefined)
+            throw new TypeError("Live capabilities are not portable replay or error data.");
+        return importHostCapability(value, options.realm.owner);
+    }
     if (value === null ||
         value === undefined ||
         typeof value === "number" ||
@@ -643,6 +668,15 @@ function copyHostValueToSandbox(value, stackFrames, options, state, path) {
                 : path
         }, state);
     }
+    const date = copyNativeDate(value);
+    if (date !== undefined) {
+        const existing = state.seen.get(value);
+        if (existing !== undefined)
+            return existing;
+        budget.chargeDataUsage(9);
+        state.seen.set(value, date);
+        return date;
+    }
     if (isFloat32Array(value)) {
         const existing = state.seen.get(value);
         if (existing !== undefined)

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

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

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

@@ -0,0 +1,50 @@
+import { type HostOperation } from "../extensions.js";
+import type { SandboxClosure, SandboxObject, SandboxValue } from "./values.js";
+declare const hostObjectBrand: unique symbol;
+declare const guestReferenceBrand: unique symbol;
+declare const sandboxHostObjectBrand: unique symbol;
+type SandboxHostObject = SandboxObject & {
+    readonly [sandboxHostObjectBrand]: true;
+};
+export type HostObject = Readonly<Record<string, never>> & {
+    readonly [hostObjectBrand]: true;
+};
+export type GuestReference = Readonly<Record<string, never>> & {
+    readonly [guestReferenceBrand]: true;
+};
+export type HostObjectDefinition = {
+    properties?: Record<string, {
+        get?: () => unknown;
+        set?: (value: unknown) => void;
+    }>;
+    methods?: Record<string, HostOperation>;
+};
+export type HostObjectController = {
+    owner: object;
+    assertActive(): void;
+    chargeWork(units?: number): void;
+    read(operation: () => unknown): SandboxValue;
+    write(operation: (value: unknown) => void, value: SandboxValue): void;
+    method(operation: HostOperation): SandboxClosure;
+};
+type GuestCallbackState = {
+    owner: object;
+    closure?: SandboxClosure;
+    assertActive(): void;
+};
+export declare function createGuestReference(root: [SandboxValue], owner: object, assertActive: () => void): GuestReference;
+export declare function readGuestReference(reference: unknown, owner: object): SandboxValue;
+export declare function revokeGuestReference(reference: GuestReference, owner: object): void;
+export declare function createLiveHostObject(definition: HostObjectDefinition, controller: HostObjectController): HostObject;
+export declare function isGuestHostObject(value: unknown): value is SandboxHostObject;
+export declare function isLiveCapability(value: unknown): boolean;
+export declare function importHostCapability(value: object, owner: object): SandboxValue;
+export declare function exportHostCapability(value: object, owner: object): HostObject;
+export declare function registerGuestCallback(callback: HostOperation, state: GuestCallbackState): void;
+export declare function readGuestCallback(callback: unknown, owner: object): SandboxClosure;
+export declare function revokeGuestCallback(callback: object, owner: object): void;
+export declare function revokeHostObject(value: HostObject, owner: object): void;
+export declare function getHostObjectMember(value: SandboxObject, key: string): SandboxValue;
+export declare function setHostObjectMember(value: SandboxObject, key: string, entry: SandboxValue): void;
+export declare function getHostObjectKeys(value: SandboxObject): string[];
+export {};

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

@@ -0,0 +1,151 @@
+import { readDataRecord } from "../extensions.js";
+const hostObjects = new WeakMap();
+const guestObjects = new WeakMap();
+const guestCallbacks = new WeakMap();
+const guestReferences = new WeakMap();
+export function createGuestReference(root, owner, assertActive) {
+    const reference = Object.freeze(Object.create(null));
+    guestReferences.set(reference, { root, owner, assertActive });
+    return reference;
+}
+export function readGuestReference(reference, owner) {
+    const state = typeof reference === "object" && reference !== null
+        ? guestReferences.get(reference)
+        : undefined;
+    if (state === undefined || state.owner !== owner)
+        throw new TypeError("Foreign or invalid guest reference.");
+    state.assertActive();
+    if (state.root === undefined)
+        throw new TypeError("Guest reference is revoked.");
+    return state.root[0];
+}
+export function revokeGuestReference(reference, owner) {
+    const state = guestReferences.get(reference);
+    if (state === undefined || state.owner !== owner)
+        throw new TypeError("Foreign guest reference.");
+    state.root = undefined;
+}
+export function createLiveHostObject(definition, controller) {
+    const input = readDataRecord(definition, "Host object definition");
+    if (Object.keys(input).some((key) => key !== "properties" && key !== "methods"))
+        throw new TypeError("Unknown host object definition field.");
+    const properties = new Map();
+    for (const [name, inputProperty] of Object.entries(readDataRecord(input.properties ?? {}, "Host properties"))) {
+        const property = readDataRecord(inputProperty, `Host property '${name}'`);
+        if (Object.keys(property).some((key) => key !== "get" && key !== "set"))
+            throw new TypeError("Unknown host property field.");
+        if ((property.get !== undefined && typeof property.get !== "function") ||
+            (property.set !== undefined && typeof property.set !== "function"))
+            throw new TypeError("Host property operations must be functions.");
+        properties.set(name, property);
+    }
+    const operations = readDataRecord(input.methods ?? {}, "Host methods");
+    for (const [name, operation] of Object.entries(operations)) {
+        if (typeof operation !== "function")
+            throw new TypeError("Host methods must be functions.");
+        if (properties.has(name))
+            throw new TypeError(`Conflicting host member '${name}'.`);
+    }
+    for (const name of [...properties.keys(), ...Object.keys(operations)]) {
+        if (["constructor", "prototype", "__proto__"].includes(name))
+            throw new TypeError(`Reserved host member '${name}'.`);
+    }
+    controller.assertActive();
+    controller.chargeWork(properties.size + Object.keys(operations).length + 1);
+    const host = Object.freeze(Object.create(null));
+    const guest = Object.freeze(Object.create(null));
+    const methods = new Map(Object.entries(operations).map(([name, operation]) => [
+        name,
+        controller.method(operation)
+    ]));
+    const state = { host, guest, controller, properties, methods };
+    hostObjects.set(host, state);
+    guestObjects.set(guest, state);
+    return host;
+}
+export function isGuestHostObject(value) {
+    return typeof value === "object" && value !== null && guestObjects.has(value);
+}
+export function isLiveCapability(value) {
+    return (((typeof value === "object" && value !== null) || typeof value === "function") &&
+        (hostObjects.has(value) ||
+            guestObjects.has(value) ||
+            guestCallbacks.has(value) ||
+            guestReferences.has(value)));
+}
+export function importHostCapability(value, owner) {
+    if (guestReferences.has(value))
+        return readGuestReference(value, owner);
+    const object = hostObjects.get(value);
+    if (object !== undefined) {
+        if (object.controller.owner !== owner)
+            throw new TypeError("Foreign realm host capability.");
+        object.controller.assertActive();
+        return object.guest;
+    }
+    const callback = guestCallbacks.get(value);
+    if (callback !== undefined) {
+        if (callback.owner !== owner)
+            throw new TypeError("Foreign realm guest callback.");
+        callback.assertActive();
+        if (callback.closure === undefined)
+            throw new TypeError("Guest callback is revoked.");
+        return callback.closure;
+    }
+    throw new TypeError("Unsupported live capability conversion.");
+}
+export function exportHostCapability(value, owner) {
+    const state = guestObjects.get(value);
+    if (state === undefined || state.controller.owner !== owner)
+        throw new TypeError("Foreign realm host capability.");
+    state.controller.assertActive();
+    return state.host;
+}
+export function registerGuestCallback(callback, state) {
+    guestCallbacks.set(callback, state);
+}
+export function readGuestCallback(callback, owner) {
+    const state = typeof callback === "function" ? guestCallbacks.get(callback) : undefined;
+    if (state === undefined || state.owner !== owner)
+        throw new TypeError("Foreign or invalid guest callback.");
+    state.assertActive();
+    if (state.closure === undefined)
+        throw new TypeError("Guest callback is revoked.");
+    return state.closure;
+}
+export function revokeGuestCallback(callback, owner) {
+    const state = guestCallbacks.get(callback);
+    if (state === undefined || state.owner !== owner)
+        throw new TypeError("Foreign guest callback.");
+    state.closure = undefined;
+}
+export function revokeHostObject(value, owner) {
+    const state = hostObjects.get(value);
+    if (state === undefined || state.controller.owner !== owner)
+        throw new TypeError("Foreign host object.");
+    state.properties.clear();
+    state.methods.clear();
+}
+export function getHostObjectMember(value, key) {
+    const state = guestObjects.get(value);
+    state.controller.assertActive();
+    state.controller.chargeWork();
+    const property = state.properties.get(key);
+    if (property !== undefined)
+        return property.get === undefined ? undefined : state.controller.read(property.get);
+    return state.methods.get(key);
+}
+export function setHostObjectMember(value, key, entry) {
+    const state = guestObjects.get(value);
+    state.controller.assertActive();
+    state.controller.chargeWork();
+    const property = state.properties.get(key);
+    if (property?.set === undefined)
+        throw new TypeError(`Host property '${key}' is not writable.`);
+    state.controller.write(property.set, entry);
+}
+export function getHostObjectKeys(value) {
+    const state = guestObjects.get(value);
+    state.controller.assertActive();
+    return [...state.properties.keys(), ...state.methods.keys()];
+}

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

@@ -1,3 +1,4 @@
+import { SandboxJobQueue } from "./jobs.js";
 import type { ParseResult, SourceSpan } from "../parse.js";
 import { type AsyncEvaluationContext, type AsyncEvaluationResult, type InterpreterYieldPoint } from "./async.js";
 import type { GeneratorCompletion } from "./generator.js";
@@ -43,6 +44,9 @@ export type InterpreterResult = {
     stats: InterpreterStats;
 };
 export type InterpretOptions = {
+    assertActive?: () => void;
+    jobs?: SandboxJobQueue;
+    nested?: boolean;
     compilation?: CompileScope;
     compileOwner?: CompileOwner;
     captureReplayState?: () => unknown;