@poe-platform/safe-js 0.1.721 → 0.1.722

package/dist/safe-js/chunks/{chunk-IS7YUCOF.js → chunk-XHSOM5CG.js}

@@ -1,6 +1,6 @@
 import {
   deepCopyToSandbox
-} from "./chunk-DNA7BMBY.js";
+} from "./chunk-BNIEPGDU.js";
 
 // packages/safe-js/src/modules/harness.ts
 function makeHarnessModule(frontmatter, meta) {
@@ -52,4 +52,4 @@ ${prompt}`;
 export {
   makeHarnessModule
 };
-//# sourceMappingURL=chunk-IS7YUCOF.js.map
+//# sourceMappingURL=chunk-XHSOM5CG.js.map

package/dist/safe-js/chunks/{cli-runtime-YK2WE33M.js → cli-runtime-6QPGM3TX.js}

@@ -12,13 +12,13 @@ import {
   parseFsConfig,
   resolveFsConfig,
   splitFrontmatter
-} from "./chunk-Y4LNCDCP.js";
+} from "./chunk-WF7HYDJ4.js";
 import {
   parseMcpConfig
-} from "./chunk-HYD4K4HN.js";
+} from "./chunk-D3GC5QPZ.js";
 import {
   lint
-} from "./chunk-B4M6QVUV.js";
+} from "./chunk-3QQYJ4RQ.js";
 import {
   createBrokenPipeState,
   createSafeOutputStream,
@@ -34,7 +34,7 @@ import {
   parseModule,
   parseSourceModule,
   replaceErrorStack
-} from "./chunk-ILYJBA2D.js";
+} from "./chunk-RYVHEOHM.js";
 import "./chunk-4YIDX44G.js";
 
 // packages/safe-js/src/cli-runtime.ts
@@ -55,7 +55,7 @@ async function runCli(argv, options, usage) {
     async () => {
       try {
         if (argv[0] === "migrate") {
-          const { migrateSnapshotFile } = await import("./migration-file-IXO5MLP4.js");
+          const { migrateSnapshotFile } = await import("./migration-file-K7UH5ZG6.js");
           const result = await migrateSnapshotFile({
             ...parseMigrationArgs(argv.slice(1)),
             cwd: options.cwd ?? readCurrentWorkingDirectory()
@@ -272,12 +272,12 @@ async function assertHarnessFile(input) {
 }
 async function runScriptFile(filepath, parsed, options) {
   const [{ run }, { restore }, { dump, dumpCurrent }, { createLintModulesFromRuntimeRegistry }, { makeFsModule }, { makeMcpModule }] = await Promise.all([
-    import("./run-SHI2PYR6.js"),
-    import("./restore-SI7HOC6C.js"),
-    import("./dump-ATWBOZWV.js"),
-    import("./runtime-modules-OO72HTVF.js"),
-    import("./fs-D72Y52I5.js"),
-    import("./mcp-IWKZB2R2.js")
+    import("./run-6SETM7SV.js"),
+    import("./restore-7LRP4BM3.js"),
+    import("./dump-TU6SYRFD.js"),
+    import("./runtime-modules-MCQS2SHQ.js"),
+    import("./fs-HTZT32MQ.js"),
+    import("./mcp-DO2IRFGQ.js")
   ]);
   const loaded = loadExecutableSource(filepath, await options.readFile(filepath, "utf8"));
   const meta = {
@@ -513,8 +513,8 @@ async function createRuntime(frontmatter, meta, options) {
     };
   }
   const [{ makeHarnessModule }, { makeFsModule }] = await Promise.all([
-    import("./harness-LUYCGWHZ.js"),
-    import("./fs-D72Y52I5.js")
+    import("./harness-RYAMI444.js"),
+    import("./fs-HTZT32MQ.js")
   ]);
   const state = {
     metricCalls: /* @__PURE__ */ new Map(),
@@ -704,4 +704,4 @@ export {
   exitCodeForError,
   runCli
 };
-//# sourceMappingURL=cli-runtime-YK2WE33M.js.map
+//# sourceMappingURL=cli-runtime-6QPGM3TX.js.map

package/dist/safe-js/chunks/{dump-ATWBOZWV.js → dump-TU6SYRFD.js}

@@ -4,9 +4,9 @@ import {
   dump,
   dumpCurrent,
   serializeRunSnapshot
-} from "./chunk-BEXRQET4.js";
-import "./chunk-DNA7BMBY.js";
-import "./chunk-ILYJBA2D.js";
+} from "./chunk-S2GFVXSI.js";
+import "./chunk-BNIEPGDU.js";
+import "./chunk-RYVHEOHM.js";
 import "./chunk-4YIDX44G.js";
 export {
   attachDumpController,
@@ -15,4 +15,4 @@ export {
   dumpCurrent,
   serializeRunSnapshot
 };
-//# sourceMappingURL=dump-ATWBOZWV.js.map
+//# sourceMappingURL=dump-TU6SYRFD.js.map

package/dist/safe-js/chunks/{fs-D72Y52I5.js → fs-HTZT32MQ.js}

@@ -1,13 +1,13 @@
 import {
   FS_OPTION_SURFACE,
   makeFsModule
-} from "./chunk-BHYBD6SY.js";
+} from "./chunk-55RIIUGG.js";
 import "./chunk-SJZWSPWD.js";
-import "./chunk-DNA7BMBY.js";
-import "./chunk-ILYJBA2D.js";
+import "./chunk-BNIEPGDU.js";
+import "./chunk-RYVHEOHM.js";
 import "./chunk-4YIDX44G.js";
 export {
   FS_OPTION_SURFACE,
   makeFsModule
 };
-//# sourceMappingURL=fs-D72Y52I5.js.map
+//# sourceMappingURL=fs-HTZT32MQ.js.map

package/dist/safe-js/chunks/harness-RYAMI444.js

@@ -0,0 +1,10 @@
+import {
+  makeHarnessModule
+} from "./chunk-XHSOM5CG.js";
+import "./chunk-BNIEPGDU.js";
+import "./chunk-RYVHEOHM.js";
+import "./chunk-4YIDX44G.js";
+export {
+  makeHarnessModule
+};
+//# sourceMappingURL=harness-RYAMI444.js.map

package/dist/safe-js/chunks/mcp-DO2IRFGQ.js

@@ -0,0 +1,11 @@
+import {
+  makeMcpModule
+} from "./chunk-GCOLKRMY.js";
+import "./chunk-D3GC5QPZ.js";
+import "./chunk-BNIEPGDU.js";
+import "./chunk-RYVHEOHM.js";
+import "./chunk-4YIDX44G.js";
+export {
+  makeMcpModule
+};
+//# sourceMappingURL=mcp-DO2IRFGQ.js.map

package/dist/safe-js/chunks/migration-file-K7UH5ZG6.js

@@ -0,0 +1,12 @@
+import {
+  migrateSnapshotFile
+} from "./chunk-QL2ALAE6.js";
+import "./chunk-SJZWSPWD.js";
+import "./chunk-K3ZRBAG5.js";
+import "./chunk-BNIEPGDU.js";
+import "./chunk-RYVHEOHM.js";
+import "./chunk-4YIDX44G.js";
+export {
+  migrateSnapshotFile
+};
+//# sourceMappingURL=migration-file-K7UH5ZG6.js.map

package/dist/safe-js/chunks/restore-7LRP4BM3.js

@@ -0,0 +1,13 @@
+import {
+  SnapshotMismatchError,
+  restore
+} from "./chunk-7SBQ7WTV.js";
+import "./chunk-K3ZRBAG5.js";
+import "./chunk-BNIEPGDU.js";
+import "./chunk-RYVHEOHM.js";
+import "./chunk-4YIDX44G.js";
+export {
+  SnapshotMismatchError,
+  restore
+};
+//# sourceMappingURL=restore-7LRP4BM3.js.map

package/dist/safe-js/chunks/run-6SETM7SV.js

@@ -0,0 +1,17 @@
+import {
+  UnhandledRejectionError,
+  run
+} from "./chunk-EH5A2EQI.js";
+import "./chunk-U7ZNMTSQ.js";
+import "./chunk-7SBQ7WTV.js";
+import "./chunk-S2GFVXSI.js";
+import "./chunk-SJZWSPWD.js";
+import "./chunk-K3ZRBAG5.js";
+import "./chunk-BNIEPGDU.js";
+import "./chunk-RYVHEOHM.js";
+import "./chunk-4YIDX44G.js";
+export {
+  UnhandledRejectionError,
+  run
+};
+//# sourceMappingURL=run-6SETM7SV.js.map

package/dist/safe-js/chunks/runtime-modules-MCQS2SHQ.js

@@ -0,0 +1,10 @@
+import {
+  createLintModulesFromRuntimeRegistry
+} from "./chunk-FA5CQO6V.js";
+import "./chunk-BNIEPGDU.js";
+import "./chunk-RYVHEOHM.js";
+import "./chunk-4YIDX44G.js";
+export {
+  createLintModulesFromRuntimeRegistry
+};
+//# sourceMappingURL=runtime-modules-MCQS2SHQ.js.map

package/dist/safe-js/cli.js

@@ -13,7 +13,7 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 async function runCli(argv, options = {}) {
   if (!argv.includes("--help") && !argv.includes("-h")) {
-    const runtime = await import("./chunks/cli-runtime-YK2WE33M.js");
+    const runtime = await import("./chunks/cli-runtime-6QPGM3TX.js");
     return runtime.runCli(argv, options, createUsage());
   }
   const brokenPipe = createBrokenPipeState();
@@ -32,7 +32,7 @@ async function runCli(argv, options = {}) {
         stderr.write(`${error instanceof Error ? error.message : String(error)}
 `);
         if (brokenPipe.closed) return 0;
-        const { exitCodeForError } = await import("./chunks/cli-runtime-YK2WE33M.js");
+        const { exitCodeForError } = await import("./chunks/cli-runtime-6QPGM3TX.js");
         return exitCodeForError(error);
       }
     }

package/dist/safe-js/core.js

@@ -1,23 +1,23 @@
 import {
   lint
-} from "./chunks/chunk-B4M6QVUV.js";
+} from "./chunks/chunk-3QQYJ4RQ.js";
 import {
   createRealm,
   createReplayableRandom,
   run
-} from "./chunks/chunk-Q7B6JIMI.js";
+} from "./chunks/chunk-EH5A2EQI.js";
 import "./chunks/chunk-U7ZNMTSQ.js";
-import "./chunks/chunk-A4L72WXV.js";
-import "./chunks/chunk-BEXRQET4.js";
+import "./chunks/chunk-7SBQ7WTV.js";
+import "./chunks/chunk-S2GFVXSI.js";
 import "./chunks/chunk-SJZWSPWD.js";
-import "./chunks/chunk-GMPZBMPA.js";
+import "./chunks/chunk-K3ZRBAG5.js";
 import {
   admitNativePromiseProperties,
   defineExtension
-} from "./chunks/chunk-DNA7BMBY.js";
+} from "./chunks/chunk-BNIEPGDU.js";
 import {
   Budget
-} from "./chunks/chunk-ILYJBA2D.js";
+} from "./chunks/chunk-RYVHEOHM.js";
 import "./chunks/chunk-4YIDX44G.js";
 export {
   Budget,

package/dist/safe-js/index.js

@@ -1,15 +1,15 @@
 import {
   createLintModulesFromRuntimeRegistry
-} from "./chunks/chunk-4CX3HYRY.js";
+} from "./chunks/chunk-FA5CQO6V.js";
 import {
   makeFsModule
-} from "./chunks/chunk-BHYBD6SY.js";
+} from "./chunks/chunk-55RIIUGG.js";
 import {
   makeHarnessModule
-} from "./chunks/chunk-IS7YUCOF.js";
+} from "./chunks/chunk-XHSOM5CG.js";
 import {
   makeMcpModule
-} from "./chunks/chunk-LPBTSTDG.js";
+} from "./chunks/chunk-GCOLKRMY.js";
 import {
   AgentSpawnError,
   EnvAccessError,
@@ -30,13 +30,13 @@ import {
   runWithSpawnUsageAccumulator,
   splitFrontmatter,
   supportsSpawnMode
-} from "./chunks/chunk-Y4LNCDCP.js";
+} from "./chunks/chunk-WF7HYDJ4.js";
 import {
   parseMcpConfig
-} from "./chunks/chunk-HYD4K4HN.js";
+} from "./chunks/chunk-D3GC5QPZ.js";
 import {
   lint
-} from "./chunks/chunk-B4M6QVUV.js";
+} from "./chunks/chunk-3QQYJ4RQ.js";
 import "./chunks/chunk-OZLTLIHX.js";
 import {
   createRootedSourceResolver
@@ -46,23 +46,23 @@ import {
   createRealm,
   createReplayableRandom,
   run
-} from "./chunks/chunk-Q7B6JIMI.js";
+} from "./chunks/chunk-EH5A2EQI.js";
 import "./chunks/chunk-U7ZNMTSQ.js";
 import {
   restore
-} from "./chunks/chunk-A4L72WXV.js";
+} from "./chunks/chunk-7SBQ7WTV.js";
 import {
   dump
-} from "./chunks/chunk-BEXRQET4.js";
+} from "./chunks/chunk-S2GFVXSI.js";
 import {
   inspectSnapshotMigration,
   migrateSnapshot,
   migrateSnapshotFile
-} from "./chunks/chunk-JNLY7IMV.js";
+} from "./chunks/chunk-QL2ALAE6.js";
 import {
   hasOwnErrorCode
 } from "./chunks/chunk-SJZWSPWD.js";
-import "./chunks/chunk-GMPZBMPA.js";
+import "./chunks/chunk-K3ZRBAG5.js";
 import {
   HostCallResumabilityError,
   HostOperationResumePolicyError,
@@ -74,7 +74,7 @@ import {
   deepCopyToSandbox,
   defineExtension,
   registerPendingHostCallPolicy
-} from "./chunks/chunk-DNA7BMBY.js";
+} from "./chunks/chunk-BNIEPGDU.js";
 import {
   Budget,
   SandboxError,
@@ -82,7 +82,7 @@ import {
   parse,
   parseModule,
   parseSourceModule
-} from "./chunks/chunk-ILYJBA2D.js";
+} from "./chunks/chunk-RYVHEOHM.js";
 import "./chunks/chunk-4YIDX44G.js";
 
 // packages/safe-js/src/parse.ts

package/dist/safe-js/interp/async.d.ts

@@ -5,7 +5,7 @@ import { type Budget } from "./budget.js";
 import { type EvaluationResult } from "./exceptions.js";
 import type { InterpreterError, InterpreterSnapshot, LoopIterationSnapshot } from "./interpreter.js";
 import { CompileScope } from "./regex/compile-guard.js";
-import type { Scope } from "./scope.js";
+import { type Scope } from "./scope.js";
 import { type SandboxCallContext, type SandboxClosure, type SandboxGenerator, type SandboxObject, type SandboxPromise, type SandboxValue } from "./values.js";
 export type InterpreterYieldPoint = {
     kind: "await" | "generator-yield" | "loop-iteration";
@@ -19,6 +19,9 @@ type ResumeBreakpoint = Omit<InterpreterYieldPoint, "snapshot">;
 export type AsyncInterpreterError = InterpreterError;
 export type AsyncEvaluationResult = EvaluationResult<AsyncInterpreterError>;
 export type AsyncEvaluationContext = {
+    sourceReference?: Readonly<{
+        referrer: string;
+    }>;
     scriptScope?: Scope;
     evalCompletion?: boolean;
     callee?: SandboxClosure;

package/dist/safe-js/interp/budget.d.ts

@@ -4,15 +4,16 @@ export type BudgetOptions = {
     deadline?: number | Date;
     maxCallDepth?: number;
     stringLength?: number;
+    regexSourceLength?: number;
+    regexCompileAllocations?: number;
     arrayLength?: number;
     dataSize?: number;
 };
-export declare const REGEX_STEP_LIMIT = 2000;
 export declare const REGEX_COMPILE_LIMITS: Readonly<{
-    sourceLength: 4096;
-    flagsLength: 8;
-    depth: 64;
-    allocations: 16384;
+    sourceLength: number;
+    flagsLength: number;
+    depth: number;
+    allocations: number;
 }>;
 export declare class SandboxError extends Error {
     readonly code: "aborted" | "budgetExceeded" | "reentry";
@@ -31,6 +32,8 @@ type BudgetLimits = {
     maxSteps?: number;
     maxCallDepth?: number;
     stringLength?: number;
+    regexSourceLength?: number;
+    regexCompileAllocations?: number;
     arrayLength?: number;
     dataSize?: number;
 };
@@ -59,15 +62,19 @@ export declare class Budget {
     set peakDataSize(value: number);
     get currentCallDepth(): number;
     set currentCallDepth(value: number);
+    acquireDeadline(deadline: number, onExceeded?: (reason: SandboxError) => void): () => void;
     forkRealm(): Budget;
     acquireRealmOwner(): ReturnType<Budget["acquireCompileOwner"]>;
     visitNode(units?: number): void;
     allocateString(value: string): string;
+    allocateStringLength(length: number): void;
     allocateArrayLength(length: number): void;
     allocateCollectionEntries(count: number): void;
     reconcileDataUsage(usage: number): void;
     setRetainedDataUsage(owner: object, usage: number): void;
     setRetainedValues(owner: object, values: (() => Iterable<unknown> | undefined) | undefined): void;
+    get reconciliationDeferred(): boolean;
+    deferReconciliation(): () => void;
     retainedValues(): Iterable<unknown>;
     acquireCompileOwner(reset?: boolean, owner?: CompileOwner): {
         owner: CompileOwner;
@@ -90,5 +97,4 @@ export declare class Budget {
     private checkSampledDeadline;
     private enterDepth;
 }
-export declare function allocateRegexSteps(steps: number): void;
 export {};

package/dist/safe-js/interp/collection-iterator.d.ts

@@ -1,6 +1,6 @@
 import type { Budget } from "./budget.js";
 import type { SandboxMap, SandboxSet, SandboxValue, SandboxObject } from "./values.js";
-export declare const collectionIteratorPrototypes: WeakMap<Budget, Partial<Record<"set" | "map", SandboxObject>>>;
+export declare const collectionIteratorPrototypes: WeakMap<Budget, Partial<Record<"map" | "set", SandboxObject>>>;
 declare const collectionIteratorBrand: unique symbol;
 export type SandboxCollectionIterator = {
     readonly [collectionIteratorBrand]: true;

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

@@ -37,6 +37,7 @@ export type CallerInjectedBinding = SandboxValue | CallerInjectedFunction | read
 };
 export declare function declareHostOperation<TFunction extends CallerInjectedFunction>(operation: TFunction, policy: PendingHostCallPolicyMode, options?: {
     onReplay?: (args: readonly unknown[], outcome: HostCallOutcome) => void;
+    awaitResult?: boolean;
 }): TFunction;
 export declare function readHostOperationPolicy(operation: CallerInjectedFunction): PendingHostCallPolicyMode | undefined;
 export declare function wrapCallerInjectedBindings(bindings: Record<string, CallerInjectedBinding>, options: HostBridgeOptions): Record<string, SandboxValue>;

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

@@ -19,6 +19,11 @@ export type HostObjectIndexedDefinition = {
     maxLength: number;
 };
 export type HostObjectDefinition = {
+    expandos?: {
+        maxKeys: number;
+        maxKeyCodeUnits: number;
+        assertActive?: () => void;
+    };
     indexed?: HostObjectIndexedDefinition;
     named?: HostObjectNamedDefinition;
     properties?: Record<string, {
@@ -40,6 +45,7 @@ export type HostObjectController = {
     owner: object;
     assertActive(): void;
     chargeWork(units?: number): void;
+    chargeGuestData(units: number): void;
     checkLength(length: number): void;
     checkString(value: string): void;
     checkTemporaryDataSize(size: number): void;
@@ -64,11 +70,14 @@ export declare function registerGuestCallback(callback: HostOperation, state: Gu
 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 deleteHostObjectMember(value: SandboxObject, key: string): boolean;
+export declare function getHostObjectMember(value: SandboxObject, key: string | symbol): SandboxValue;
+export declare function setHostObjectMember(value: SandboxObject, key: string | symbol, entry: SandboxValue): void;
+export declare function deleteHostObjectMember(value: SandboxObject, key: string | symbol): boolean;
 export declare function getHostObjectKeys(value: SandboxObject): string[];
-export declare function hasHostObjectMember(value: SandboxObject, key: string, enumerableOnly?: boolean): boolean;
+export declare function hasHostObjectMember(value: SandboxObject, key: string | symbol, enumerableOnly?: boolean): boolean;
 export declare function measureHostObjectData(value: SandboxObject): number;
 export declare function getHostObjectIterator(value: SandboxObject): SandboxIterator | undefined;
+export declare function getHostObjectSymbolKeys(value: SandboxObject): symbol[];
+export declare function hostObjectGuestRoot(value: HostObject | SandboxObject): SandboxObject | undefined;
+export declare function hostObjectGuestRoots(value: HostObject | SandboxObject): SandboxValue[];
 export {};

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

@@ -22,7 +22,7 @@ export type LoopIterationSnapshot = number | {
     index: number;
     values: InterpreterValue[];
 };
-export type InterpreterErrorCode = "LABEL_NOT_FOUND" | "UNBOUND_IDENTIFIER" | "UNSUPPORTED_NODE";
+export type InterpreterErrorCode = "LABEL_NOT_FOUND" | "UNBOUND_IDENTIFIER" | "UNSUPPORTED_NODE" | "UNCAUGHT_EXCEPTION";
 export type InterpreterError = {
     code: InterpreterErrorCode;
     message: string;
@@ -44,7 +44,10 @@ export type InterpreterResult = {
     stats: InterpreterStats;
 };
 export type InterpretOptions = {
+    sourceReference?: AsyncEvaluationContext["sourceReference"];
     modulePhase?: "link" | "evaluate";
+    /** Skip unused public bindings; retained data is still reconciled. */
+    captureSnapshot?: boolean;
     script?: {
         strict: boolean;
     };
@@ -61,6 +64,7 @@ export type InterpretOptions = {
     scope?: Scope;
     signal?: AbortSignal;
     surfaceUnhandledThrows?: boolean;
+    reportUnhandledThrows?: boolean;
     useScopeDirectly?: boolean;
     generatorYield?: (value?: SandboxValue, yieldNodeId?: number, yieldedResult?: SandboxValue) => Promise<GeneratorCompletion>;
     asyncGenerator?: boolean;

package/dist/safe-js/interp/intl-numberformat.d.ts

@@ -1,4 +1,4 @@
-import type { Budget } from "./budget.js";
+import { type Budget } from "./budget.js";
 import { createNumberFormatter } from "./numberformat-backend.js";
 import type { SandboxCallContext, SandboxClosure, SandboxObject, SandboxValue } from "./values.js";
 export type NumberFormatOptions = Record<string, string | number | boolean>;
@@ -10,4 +10,4 @@ export declare function numberFormatState(value: unknown): {
     format?: SandboxClosure;
 };
 export declare function numberFormatValue(value: SandboxValue, budget: Budget, context?: SandboxCallContext): Promise<number | bigint | string>;
-export declare function formatNumberValue(receiver: unknown, method: "format" | "formatToParts" | "formatRange" | "formatRangeToParts", values: Array<number | bigint | string>): SandboxValue;
+export declare function formatNumberValue(receiver: unknown, method: "format" | "formatToParts" | "formatRange" | "formatRangeToParts", values: Array<number | bigint | string>, budget: Budget): SandboxValue;

package/dist/safe-js/interp/jobs.d.ts

@@ -7,17 +7,23 @@ export type ExecutionControl = {
 type ExecutionJob = {
     queue: SandboxJobQueue;
     ownsExecution: boolean;
+    attribution?: ReadonlyMap<object, object | undefined>;
     prefixParent?: ExecutionJob;
     keptTargets?: Map<Budget, Set<object | symbol>>;
 };
+export declare function getJobAttribution(key: object): object | undefined;
+export declare function withJobAttribution<Result>(key: object, value: object | undefined, task: () => Result): Result;
+export declare function captureJobAttribution(): <Result>(task: () => Result) => Result;
 export declare class SandboxJobQueue {
     private running;
     private pending;
     private ready;
     private readonly idle;
+    private readonly unsettled;
     private generation;
     private controlled;
     private nodesUntilHostTurn;
+    private lastHostTurn;
     private pauseRequest?;
     private finished;
     private interruption?;
@@ -33,6 +39,8 @@ export declare class SandboxJobQueue {
     acquire(job: ExecutionJob): Promise<void>;
     release(job: ExecutionJob): void;
     run<T>(task: () => T | Promise<T>): Promise<T>;
+    track<T>(pending: Promise<T>): Promise<T>;
+    settle(): Promise<void>;
     drain(): Promise<void>;
     private advance;
 }

package/dist/safe-js/interp/scope.d.ts

@@ -2,7 +2,7 @@ import type { VariableDeclarationKind } from "../parse.js";
 import type { PrivateName } from "./private-state.js";
 import type { InterpreterSnapshot, InterpreterValue } from "./interpreter.js";
 import type { ResourceScopeState } from "./resource-management.js";
-import type { SandboxObject } from "./values.js";
+import type { SandboxClosure, SandboxObject, SandboxValue } from "./values.js";
 import type { ModuleEnvironment } from "../modules/registry.js";
 type ScopeLookupResult = {
     found: true;
@@ -99,11 +99,14 @@ export declare class Scope {
     lookupModuleId(): string;
     lookupModuleEnvironment(): ModuleEnvironment | undefined;
     retainedValues(): InterpreterValue[];
-    retainedDataRoots(): InterpreterValue[];
+    retainedDataRoots(append?: (values: InterpreterValue[]) => void): InterpreterValue[];
+    static captureDataRoots(scope: Scope, append: (values: InterpreterValue[]) => void): InterpreterValue[];
+    static visitDataRoots(scope: Scope, append: (value: InterpreterValue) => void): void;
     declare(name: string, kind: VariableDeclarationKind, value: InterpreterValue, options?: {
         silentImmutable: true;
     }): void;
     declareImport(name: string, target: Scope, targetName: string): void;
+    declareDeferredFunction(name: string, kind: VariableDeclarationKind, create: () => SandboxClosure, collect: (append: (value: SandboxValue) => void) => void): void;
     declareAlias(name: string, target: string): void;
     declareVar(name: string, options?: {
         functionValue?: InterpreterValue;
@@ -124,8 +127,12 @@ export declare class Scope {
     hydrateFrame(frame: ScopeFrame): void;
     copyInitializedBindingsFrom(source: Scope, names: readonly string[]): void;
     private writeBindingValue;
+    private readBindingValue;
     private resolveScope;
     private trackReplacement;
     private requireInitializedBinding;
 }
+export declare const captureScopeDataRoots: typeof Scope.captureDataRoots;
+export declare const visitScopeDataRoots: typeof Scope.visitDataRoots;
+export declare function appendScopeDataRoots(values: InterpreterValue[], captured: Iterable<InterpreterValue>, index?: number): number;
 export {};

package/dist/safe-js/interp/typed-array.d.ts

@@ -7,7 +7,7 @@ export declare const typedArrayViewLayouts: WeakMap<NumericTypedArray, {
 }>;
 export declare function createOwnedTypedArray(Native: NumericTypedArrayConstructor, args: unknown[]): NumericTypedArray;
 export declare function nativeTypedArrayView<T extends object>(value: T): T;
-export declare function restoreTypedArrayView(buffer: ArrayBufferLike, byteOffset: number, length?: number, budget?: Budget, Native?: NumericTypedArrayConstructor): NumericTypedArray;
+export declare function restoreTypedArrayView(buffer: ArrayBufferLike, byteOffset: number, length?: number, budget?: Budget, Native?: NumericTypedArrayConstructor, owned?: boolean): NumericTypedArray;
 export declare function isNumericTypedArray(value: unknown): value is NumericTypedArray;
 export declare function typedArrayStorage(value: NumericTypedArray, requireInBounds?: boolean): {
     buffer: ArrayBufferLike;
@@ -26,5 +26,5 @@ export declare function checkTypedArrayAllocation(length: number, budget: Budget
 export declare function copyTypedArrayStorage<TValue>(value: NumericTypedArray, state: {
     seen: WeakMap<object, TValue>;
     float32Buffers?: WeakMap<ArrayBufferLike, ArrayBufferLike>;
-}): NumericTypedArray;
+}, owned?: boolean): NumericTypedArray;
 export declare function requireUint8Array(value: unknown): Uint8Array<ArrayBuffer>;

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

@@ -136,6 +136,7 @@ export declare function createSandboxClosure(input: {
     properties?: SandboxObject | ((closure: SandboxClosure) => SandboxObject);
     retainedValues?: () => Iterable<SandboxValue>;
 }): SandboxClosure;
+export declare function registerDeferredClosureChargeIdentity(closure: SandboxClosure, identity: object): void;
 export declare function ownEnumerableSandboxEntries(value: SandboxValue, excludedKeys?: ReadonlySet<string>): Array<[string, SandboxValue]>;
 export declare function ownSandboxSymbolKeys(value: SandboxValue): symbol[];
 export declare function ownEnumerableSandboxKeys(value: SandboxValue): string[];

package/dist/safe-js/modules/registry.d.ts

@@ -20,6 +20,7 @@ export type ModuleEnvironmentOptions = {
     prepareNamespace?: (namespace: Record<string, SandboxValue>, moduleName: string) => Record<string, SandboxValue>;
 };
 export declare function createModuleEnvironment(modules: ModuleRegistry | undefined, options: ModuleEnvironmentOptions, restored?: ModuleEnvironment): ModuleEnvironment;
+export declare function createImmutableEmptyModuleEnvironment(options: ModuleEnvironmentOptions): ModuleEnvironment;
 export declare function resolveModuleNamespace(environment: ModuleEnvironment, moduleName: string, prepare?: boolean): Record<string, SandboxValue>;
 export declare function resolveModuleFunction(environment: ModuleEnvironment, origin: ModuleFunctionOrigin): SandboxClosure;
 export declare function createUnknownModuleMessage(moduleName: string, moduleNames: readonly string[]): string;
@@ -28,5 +29,7 @@ export declare function resolveModuleImports(module: Module, modules: ModuleRegi
     environment?: ModuleEnvironment;
     allowMissing?: boolean;
 }): Record<string, SandboxValue>;
-export declare function attachSourceLoader(environment: ModuleEnvironment, loader: (specifier: string, referrer: string) => Promise<Record<string, SandboxValue>>): void;
+export declare function attachSourceLoader(environment: ModuleEnvironment, loader: (specifier: string, referrer: string) => Promise<Record<string, SandboxValue>>, options?: {
+    preserveImmutableNamespaces?: true;
+}): void;
 export declare function importModuleNamespace(environment: ModuleEnvironment, specifier: string, referrer: string): Record<string, SandboxValue> | Promise<Record<string, SandboxValue>>;