@poe-platform/safe-js 0.1.720 → 0.1.722

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

@@ -1,6 +1,6 @@
 import {
   deepCopyToSandbox
-} from "./chunk-KP6I45ET.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-NEJ44T4Y.js.map
+//# sourceMappingURL=chunk-XHSOM5CG.js.map

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

@@ -12,13 +12,13 @@ import {
   parseFsConfig,
   resolveFsConfig,
   splitFrontmatter
-} from "./chunk-XMA6FOJU.js";
+} from "./chunk-WF7HYDJ4.js";
 import {
   parseMcpConfig
-} from "./chunk-HYD4K4HN.js";
+} from "./chunk-D3GC5QPZ.js";
 import {
   lint
-} from "./chunk-B2SQLK4O.js";
+} from "./chunk-3QQYJ4RQ.js";
 import {
   createBrokenPipeState,
   createSafeOutputStream,
@@ -34,7 +34,7 @@ import {
   parseModule,
   parseSourceModule,
   replaceErrorStack
-} from "./chunk-IDQ67DY2.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-IDIUFLKY.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-KGAEHYMV.js"),
-    import("./restore-P27AUZR2.js"),
-    import("./dump-TRGFSCJ7.js"),
-    import("./runtime-modules-KICK45EE.js"),
-    import("./fs-4T5MZW5J.js"),
-    import("./mcp-TNVEFJ6K.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-DLEQ2Z3O.js"),
-    import("./fs-4T5MZW5J.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-PO6DQDHP.js.map
+//# sourceMappingURL=cli-runtime-6QPGM3TX.js.map

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

@@ -4,9 +4,9 @@ import {
   dump,
   dumpCurrent,
   serializeRunSnapshot
-} from "./chunk-A7CADQAD.js";
-import "./chunk-KP6I45ET.js";
-import "./chunk-IDQ67DY2.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-TRGFSCJ7.js.map
+//# sourceMappingURL=dump-TU6SYRFD.js.map

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

@@ -1,13 +1,13 @@
 import {
   FS_OPTION_SURFACE,
   makeFsModule
-} from "./chunk-OP3H3ZDN.js";
+} from "./chunk-55RIIUGG.js";
 import "./chunk-SJZWSPWD.js";
-import "./chunk-KP6I45ET.js";
-import "./chunk-IDQ67DY2.js";
+import "./chunk-BNIEPGDU.js";
+import "./chunk-RYVHEOHM.js";
 import "./chunk-4YIDX44G.js";
 export {
   FS_OPTION_SURFACE,
   makeFsModule
 };
-//# sourceMappingURL=fs-4T5MZW5J.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-PO6DQDHP.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-PO6DQDHP.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-B2SQLK4O.js";
+} from "./chunks/chunk-3QQYJ4RQ.js";
 import {
   createRealm,
   createReplayableRandom,
   run
-} from "./chunks/chunk-KK5NCR5R.js";
+} from "./chunks/chunk-EH5A2EQI.js";
 import "./chunks/chunk-U7ZNMTSQ.js";
-import "./chunks/chunk-NJM2Q74Z.js";
-import "./chunks/chunk-A7CADQAD.js";
+import "./chunks/chunk-7SBQ7WTV.js";
+import "./chunks/chunk-S2GFVXSI.js";
 import "./chunks/chunk-SJZWSPWD.js";
-import "./chunks/chunk-U6KZ2DQ2.js";
+import "./chunks/chunk-K3ZRBAG5.js";
 import {
   admitNativePromiseProperties,
   defineExtension
-} from "./chunks/chunk-KP6I45ET.js";
+} from "./chunks/chunk-BNIEPGDU.js";
 import {
   Budget
-} from "./chunks/chunk-IDQ67DY2.js";
+} from "./chunks/chunk-RYVHEOHM.js";
 import "./chunks/chunk-4YIDX44G.js";
 export {
   Budget,

package/dist/safe-js/extensions.d.ts

@@ -1,4 +1,4 @@
-import type { HostObjectDefinition, HostObject } from "./interp/host-capabilities.js";
+import type { HostObjectDefinition, HostObject, GuestReference } from "./interp/host-capabilities.js";
 import type { ModuleRegistry } from "./modules/registry.js";
 import type { CallerInjectedBinding } from "./interp/host-bridge.js";
 export type CallbackOptions = {
@@ -28,6 +28,8 @@ export type ExtensionContext = {
     onCleanup(cleanup: () => void | Promise<void>): void;
     chargeWork(units?: number): void;
     createHostObject(definition: HostObjectDefinition): HostObject;
+    /** Explicit realm-owned live fixed buffer; default host ingress still copies. */
+    createArrayBufferReference(buffer: ArrayBuffer): GuestReference;
     startCallback(callback: unknown, options?: CallbackOptions): CallbackInvocation;
     invokeCallback(callback: unknown, options?: CallbackOptions): Promise<unknown>;
     releaseCallback(callback: unknown): void;

package/dist/safe-js/index.js

@@ -1,15 +1,15 @@
 import {
   createLintModulesFromRuntimeRegistry
-} from "./chunks/chunk-APKV5Y6T.js";
+} from "./chunks/chunk-FA5CQO6V.js";
 import {
   makeFsModule
-} from "./chunks/chunk-OP3H3ZDN.js";
+} from "./chunks/chunk-55RIIUGG.js";
 import {
   makeHarnessModule
-} from "./chunks/chunk-NEJ44T4Y.js";
+} from "./chunks/chunk-XHSOM5CG.js";
 import {
   makeMcpModule
-} from "./chunks/chunk-RML35GIF.js";
+} from "./chunks/chunk-GCOLKRMY.js";
 import {
   AgentSpawnError,
   EnvAccessError,
@@ -30,13 +30,13 @@ import {
   runWithSpawnUsageAccumulator,
   splitFrontmatter,
   supportsSpawnMode
-} from "./chunks/chunk-XMA6FOJU.js";
+} from "./chunks/chunk-WF7HYDJ4.js";
 import {
   parseMcpConfig
-} from "./chunks/chunk-HYD4K4HN.js";
+} from "./chunks/chunk-D3GC5QPZ.js";
 import {
   lint
-} from "./chunks/chunk-B2SQLK4O.js";
+} from "./chunks/chunk-3QQYJ4RQ.js";
 import "./chunks/chunk-OZLTLIHX.js";
 import {
   createRootedSourceResolver
@@ -46,23 +46,23 @@ import {
   createRealm,
   createReplayableRandom,
   run
-} from "./chunks/chunk-KK5NCR5R.js";
+} from "./chunks/chunk-EH5A2EQI.js";
 import "./chunks/chunk-U7ZNMTSQ.js";
 import {
   restore
-} from "./chunks/chunk-NJM2Q74Z.js";
+} from "./chunks/chunk-7SBQ7WTV.js";
 import {
   dump
-} from "./chunks/chunk-A7CADQAD.js";
+} from "./chunks/chunk-S2GFVXSI.js";
 import {
   inspectSnapshotMigration,
   migrateSnapshot,
   migrateSnapshotFile
-} from "./chunks/chunk-BGJXQN4A.js";
+} from "./chunks/chunk-QL2ALAE6.js";
 import {
   hasOwnErrorCode
 } from "./chunks/chunk-SJZWSPWD.js";
-import "./chunks/chunk-U6KZ2DQ2.js";
+import "./chunks/chunk-K3ZRBAG5.js";
 import {
   HostCallResumabilityError,
   HostOperationResumePolicyError,
@@ -74,7 +74,7 @@ import {
   deepCopyToSandbox,
   defineExtension,
   registerPendingHostCallPolicy
-} from "./chunks/chunk-KP6I45ET.js";
+} from "./chunks/chunk-BNIEPGDU.js";
 import {
   Budget,
   SandboxError,
@@ -82,7 +82,7 @@ import {
   parse,
   parseModule,
   parseSourceModule
-} from "./chunks/chunk-IDQ67DY2.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;
 };
@@ -44,6 +47,8 @@ export type CompileTicket = {
 };
 export declare class Budget {
     private accounting;
+    private realmView;
+    private realmLease;
     constructor(options?: BudgetOptions);
     get deadline(): number | undefined;
     get limits(): Readonly<BudgetLimits>;
@@ -57,14 +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;
@@ -87,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;
@@ -25,6 +25,7 @@ export type BindingReference = {
     name: string;
     object: SandboxObject;
     withEnvironment: boolean;
+    globalEnvironment?: Scope;
 };
 export type BindingOperations = {
     has(object: SandboxObject, name: string): boolean | Promise<boolean>;
@@ -39,6 +40,7 @@ type ScopeOptions = {
 export type ScopeFrame = {
     simpleCatchParameter?: string;
     globalEnvironment?: boolean;
+    globalVarNames?: string[];
     moduleEnvironment?: ModuleEnvironment;
     objectEnvironment?: SandboxObject;
     withObject?: SandboxObject;
@@ -75,7 +77,7 @@ export declare class Scope {
     constructor(bindings?: Record<string, InterpreterValue>, parent?: Scope | undefined, importMeta?: InterpreterValue, options?: ScopeOptions, restoredBindings?: Record<string, InterpreterValue>);
     child(bindings?: Record<string, InterpreterValue>, options?: ScopeOptions): Scope;
     withObject(object: SandboxObject): Scope;
-    resolveBinding(name: string, operations: BindingOperations): BindingReference | Promise<BindingReference>;
+    resolveBinding(name: string, operations: BindingOperations, globalEnvironment?: Scope): BindingReference | Promise<BindingReference>;
     private resolveObjectBinding;
     declarePrivateName(description: string): PrivateName;
     resolvePrivateName(description: string): PrivateName;
@@ -88,6 +90,7 @@ export declare class Scope {
     };
     hasOwnBinding(name: string): boolean;
     deleteBinding(name: string): boolean;
+    deleteGlobalBinding(name: string): boolean;
     getOwnBindingKind(name: string): VariableDeclarationKind | undefined;
     isFunctionBoundary(): boolean;
     iterationChild(names: readonly string[]): Scope;
@@ -96,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;
@@ -121,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 {};