poe-code 13.0.3 → 13.0.5

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

@@ -1,5 +1,11 @@
 import { replaceErrorStack } from "../error/shape.js";
 export const REGEX_STEP_LIMIT = 2_000;
+export const REGEX_COMPILE_LIMITS = Object.freeze({
+    sourceLength: 4_096,
+    flagsLength: 8,
+    depth: 64,
+    allocations: 16_384
+});
 const DEADLINE_CHECK_INTERVAL = 1_024;
 export class SandboxError extends Error {
     code;
@@ -42,6 +48,12 @@ export class Budget {
     retainedDataSize = 0;
     retainedData = new Map();
     retainedValueSources = new Map();
+    compileGeneration = 0;
+    activeCompileOwner;
+    compileUses = 0;
+    provisionalScopes = 0;
+    compileTickets = new Map();
+    completedCompileTickets = new Set();
     constructor(options = {}) {
         this.deadline = normalizeDeadline(options.deadline);
         this.limits = Object.freeze({
@@ -122,6 +134,126 @@ export class Budget {
         for (const values of this.retainedValueSources.values())
             yield* values();
     }
+    acquireCompileOwner(reset = false, owner) {
+        if ((owner !== undefined &&
+            (owner.budget !== this || owner.generation !== this.compileGeneration)) ||
+            (this.activeCompileOwner !== undefined && this.activeCompileOwner !== owner) ||
+            (reset && (this.compileUses !== 0 || owner !== undefined))) {
+            throw new SandboxError("reentry");
+        }
+        if (reset)
+            this.reset();
+        const selected = owner ?? Object.freeze({ budget: this, generation: this.compileGeneration });
+        this.activeCompileOwner = selected;
+        this.compileUses += 1;
+        let released = false;
+        return {
+            owner: selected,
+            release: () => {
+                if (released)
+                    return;
+                released = true;
+                this.compileUses -= 1;
+                if (this.compileUses === 0)
+                    this.activeCompileOwner = undefined;
+            }
+        };
+    }
+    createCompileTicket(owner) {
+        if (owner.budget !== this ||
+            owner.generation !== this.compileGeneration ||
+            this.activeCompileOwner !== owner) {
+            throw new SandboxError("reentry");
+        }
+        const ticket = Object.freeze({ owner });
+        this.compileTickets.set(ticket, 0);
+        return ticket;
+    }
+    compileTicketUsage(ticket) {
+        return ticket.owner.generation === this.compileGeneration
+            ? (this.compileTickets.get(ticket) ?? 0)
+            : 0;
+    }
+    resizeCompileTicket(ticket, usage) {
+        if (ticket.owner.generation !== this.compileGeneration || !this.compileTickets.has(ticket)) {
+            throw new SandboxError("reentry");
+        }
+        this.setRetainedDataUsage(ticket, usage);
+        this.compileTickets.set(ticket, usage);
+    }
+    discardCompileTicket(ticket) {
+        if (ticket.owner.generation !== this.compileGeneration)
+            return;
+        const usage = this.compileTickets.get(ticket);
+        if (usage === undefined)
+            return;
+        this.compileTickets.delete(ticket);
+        this.completedCompileTickets.delete(ticket);
+        this.retainedData.delete(ticket);
+        this.retainedDataSize -= usage;
+        this.currentDataSize -= usage;
+    }
+    reconcileCompileData(usage, included, transferred = included, retainedOwner, complete = false) {
+        let includedUsage = 0;
+        let transferredUsage = 0;
+        let discardedUsage = 0;
+        const releasing = [];
+        const retained = new Set();
+        for (const ticket of included) {
+            const charge = this.compileTicketUsage(ticket);
+            includedUsage += charge;
+            if (charge > 0 &&
+                transferred.has(ticket) &&
+                (this.provisionalScopes === 0 || retainedOwner !== undefined)) {
+                releasing.push(ticket);
+                transferredUsage += charge;
+            }
+            else if (charge > 0 && complete && transferred.has(ticket)) {
+                retained.add(ticket);
+            }
+        }
+        if (retainedOwner === undefined) {
+            for (const ticket of this.completedCompileTickets) {
+                if (included.has(ticket))
+                    continue;
+                releasing.push(ticket);
+                discardedUsage += this.compileTicketUsage(ticket);
+            }
+        }
+        const oldOwnerUsage = retainedOwner === undefined ? 0 : (this.retainedData.get(retainedOwner) ?? 0);
+        const nextRetained = this.retainedDataSize -
+            transferredUsage -
+            discardedUsage +
+            (retainedOwner === undefined ? 0 : usage - oldOwnerUsage);
+        const measured = retainedOwner === undefined
+            ? usage - includedUsage + transferredUsage
+            : this.currentDataSize - this.retainedDataSize;
+        const total = measured + nextRetained;
+        this.checkDataUsage(total);
+        for (const ticket of releasing) {
+            this.compileTickets.delete(ticket);
+            this.completedCompileTickets.delete(ticket);
+            this.retainedData.delete(ticket);
+        }
+        if (retainedOwner !== undefined) {
+            if (usage === 0)
+                this.retainedData.delete(retainedOwner);
+            else
+                this.retainedData.set(retainedOwner, usage);
+        }
+        this.retainedDataSize = nextRetained;
+        this.currentDataSize = total;
+        this.peakDataSize = Math.max(this.peakDataSize, total);
+        for (const ticket of retained)
+            this.completedCompileTickets.add(ticket);
+        return retained;
+    }
+    chargeDataUsage(usage) {
+        const total = this.currentDataSize + usage;
+        this.checkDataUsage(total);
+        this.currentDataSize = total;
+        this.peakDataSize = Math.max(this.peakDataSize, total);
+    }
     provisionDataUsage(usage) {
         const previous = this.currentDataSize;
         const previousRetained = this.retainedDataSize;
@@ -129,11 +261,16 @@ export class Budget {
         this.checkDataUsage(next);
         this.currentDataSize = next;
         this.peakDataSize = Math.max(this.peakDataSize, next);
+        const generation = this.compileGeneration;
+        this.provisionalScopes += 1;
         let released = false;
         return () => {
             if (released)
                 return;
             released = true;
+            if (generation !== this.compileGeneration)
+                return;
+            this.provisionalScopes -= 1;
             this.currentDataSize = previous + this.retainedDataSize - previousRetained;
         };
     }
@@ -144,6 +281,12 @@ export class Budget {
         return this.enterDepth();
     }
     reset() {
+        if (this.compileUses !== 0)
+            throw new SandboxError("reentry");
+        this.compileGeneration += 1;
+        this.provisionalScopes = 0;
+        this.compileTickets.clear();
+        this.completedCompileTickets.clear();
         this.stepsUsed = 0;
         this.peakCallDepth = 0;
         this.currentCallDepth = 0;

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

@@ -1,4 +1,4 @@
-import type { Budget } from "../budget.js";
+import type { Budget, CompileOwner } from "../budget.js";
 import type { HostCallJournal } from "../host-call.js";
 import { type SandboxObject } from "../values.js";
 export type ConsoleSink = {
@@ -7,6 +7,7 @@ export type ConsoleSink = {
 };
 export type ConsoleJsonGlobalsOptions = {
     budget: Budget;
+    compileOwner?: CompileOwner;
     sink?: ConsoleSink;
     hostCalls?: HostCallJournal;
 };

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

@@ -1,3 +1,4 @@
+import { CompileScope } from "../regex/compile-guard.js";
 import { wrapCallerInjectedBindings } from "../host-bridge.js";
 import { allocateProducedSandboxValue, createSandboxClosure, deepCopyFromSandbox, isSandboxClosure, isSandboxPromise } from "../values.js";
 export function createConsoleJsonGlobals(options) {
@@ -19,17 +20,33 @@ export function createConsoleJsonGlobals(options) {
             ? {
                 error: createSandboxClosure({
                     sandbox: true,
-                    call: async (args) => {
-                        sink.error(...args.map((value) => deepCopyFromSandbox(value)));
-                        return undefined;
+                    call: async (args, context) => {
+                        const operation = options.budget.acquireCompileOwner(false, options.compileOwner ?? context?.compilation?.owner);
+                        const compilation = new CompileScope(operation.owner);
+                        try {
+                            sink.error(...args.map((value) => deepCopyFromSandbox(value, { compilation })));
+                            return undefined;
+                        }
+                        finally {
+                            compilation.dispose();
+                            operation.release();
+                        }
                     },
                     name: "error"
                 }),
                 log: createSandboxClosure({
                     sandbox: true,
-                    call: async (args) => {
-                        sink.log(...args.map((value) => deepCopyFromSandbox(value)));
-                        return undefined;
+                    call: async (args, context) => {
+                        const operation = options.budget.acquireCompileOwner(false, options.compileOwner ?? context?.compilation?.owner);
+                        const compilation = new CompileScope(operation.owner);
+                        try {
+                            sink.log(...args.map((value) => deepCopyFromSandbox(value, { compilation })));
+                            return undefined;
+                        }
+                        finally {
+                            compilation.dispose();
+                            operation.release();
+                        }
                     },
                     name: "log"
                 })
@@ -45,6 +62,7 @@ export function createConsoleJsonGlobals(options) {
                 }
             }, {
                 budget: options.budget,
+                compileOwner: options.compileOwner,
                 hostCalls: options.hostCalls,
                 moduleId: "<console>"
             })

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

@@ -1,4 +1,5 @@
 import { type SandboxClosure } from "../values.js";
-export declare function createRegexGlobals(): {
+import { type CompileOwner } from "../budget.js";
+export declare function createRegexGlobals(owner?: CompileOwner): {
     RegExp: SandboxClosure;
 };

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

@@ -1,6 +1,27 @@
-import { createSandboxClosure, createSandboxRegex } from "../values.js";
-export function createRegexGlobals() {
-    const construct = (args) => createSandboxRegex(String(args[0] ?? ""), String(args[1] ?? ""));
+import { createSandboxClosure, createSandboxRegex, reconcileCompiledValues } from "../values.js";
+import { CompileScope } from "../regex/compile-guard.js";
+import { SandboxError } from "../budget.js";
+export function createRegexGlobals(owner) {
+    const construct = (args, context) => {
+        const selected = owner ?? context?.compilation?.owner;
+        if (context?.compilation?.owner !== undefined && selected !== context.compilation.owner) {
+            throw new SandboxError("reentry");
+        }
+        const operation = selected?.budget.acquireCompileOwner(false, selected);
+        const compilation = context?.compilation ?? new CompileScope(selected);
+        try {
+            const regex = createSandboxRegex(String(args[0] ?? ""), String(args[1] ?? ""), 0, compilation);
+            if (context?.compilation === undefined && selected !== undefined) {
+                reconcileCompiledValues(selected.budget, [regex], compilation);
+            }
+            return regex;
+        }
+        finally {
+            if (context?.compilation === undefined)
+                compilation.dispose();
+            operation?.release();
+        }
+    };
     return {
         RegExp: createSandboxClosure({ sandbox: true, name: "RegExp", call: construct, construct })
     };

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

@@ -1,4 +1,4 @@
-import { type Budget } from "./budget.js";
+import { type Budget, type CompileOwner } from "./budget.js";
 import { type PendingHostCallPolicyMode } from "../snapshot/policy.js";
 import { type HostCallJournal, type HostCallOutcome } from "./host-call.js";
 import { type SandboxClosure, type SandboxValue } from "./values.js";
@@ -10,6 +10,7 @@ type HostBridgeOptions = {
     registerCapabilities?: boolean;
     capabilityPath?: readonly string[];
     budget: Budget;
+    compileOwner?: CompileOwner;
     hostCalls?: HostCallJournal;
     moduleId?: string;
     operation?: string;

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

@@ -1,6 +1,7 @@
 import { normalizeClosureResult } from "./async.js";
 import { attachErrorSpan, replaceErrorStack } from "../error/shape.js";
 import { SandboxError } from "./budget.js";
+import { CompileScope } from "./regex/compile-guard.js";
 import { checkFloat32Allocation, copyFloat32Storage, float32DataProperties, float32Storage, isFloat32Array } from "./float32.js";
 import { createSubsetErrorValue } from "./exceptions.js";
 import { bindOtelSpan, getBoundOtelSpan } from "../observability/otel.js";
@@ -31,16 +32,22 @@ export function readHostOperationPolicy(operation) {
     return hostOperationPolicies.get(operation);
 }
 export function wrapCallerInjectedBindings(bindings, options) {
-    options = { ...options, registerCapabilities: true };
-    const state = { seen: new WeakMap() };
-    const copied = Object.fromEntries(Object.entries(bindings).map(([name, value]) => [
-        name,
-        typeof value === "function"
-            ? wrapCallerInjectedFunction(name, value, { ...options, capabilityPath: [name] }, state)
-            : copyHostValueToSandbox(value, [], { ...options, operation: name, capabilityPath: [name] }, state, "<root>")
-    ]));
-    options.budget.provisionDataUsage(measureSandboxData(Object.values(copied)));
-    return copied;
+    const operation = options.budget.acquireCompileOwner(false, options.compileOwner);
+    options = { ...options, registerCapabilities: true, compileOwner: operation.owner };
+    try {
+        const state = { seen: new WeakMap() };
+        const copied = Object.fromEntries(Object.entries(bindings).map(([name, value]) => [
+            name,
+            typeof value === "function"
+                ? wrapCallerInjectedFunction(name, value, { ...options, capabilityPath: [name] }, state)
+                : copyHostValueToSandbox(value, [], { ...options, operation: name, capabilityPath: [name] }, state, "<root>")
+        ]));
+        options.budget.chargeDataUsage(measureSandboxData(Object.values(copied)));
+        return copied;
+    }
+    finally {
+        operation.release();
+    }
 }
 function wrapCallerInjectedFunction(name, value, options, state) {
     const existing = state.seen.get(value) ?? options.hostCalls?.nativeClosures.get(value);
@@ -52,6 +59,8 @@ function wrapCallerInjectedFunction(name, value, options, state) {
         ...(isAsyncFunction(callable) ? { async: true } : {}),
         cancellationSignal: options.signal,
         call: (args, context) => {
+            const operationLease = options.budget.acquireCompileOwner(false, options.compileOwner);
+            const compilation = new CompileScope(operationLease.owner);
             try {
                 if (options.signal?.aborted)
                     throw readAbortReason(options.signal);
@@ -67,7 +76,8 @@ function wrapCallerInjectedFunction(name, value, options, state) {
                     restored: []
                 };
                 const hostArgs = deepCopyFromSandbox([...args], {
-                    wrapClosure: (closure) => wrapSandboxClosureForHost(closure, stackFrames, options.budget, callbacks)
+                    compilation,
+                    wrapClosure: (closure) => wrapSandboxClosureForHost(closure, stackFrames, options.budget, operationLease.owner, callbacks)
                 });
                 const hostCalls = options.hostCalls;
                 const operation = options.operation ?? bindingName;
@@ -112,13 +122,27 @@ function wrapCallerInjectedFunction(name, value, options, state) {
                         return {
                             token,
                             start: () => {
-                                const callback = callbacks.entries.get(invocation.id);
-                                if (callback === undefined)
-                                    throw new TypeError("Missing restored host callback.");
-                                const args = decodeReplayData(invocation.arguments, {
-                                    resolveCapability: hostCalls.resolveCapability
-                                });
-                                void callback(args, token).then(resolve, reject);
+                                const callbackLease = options.budget.acquireCompileOwner(false, options.compileOwner);
+                                const callbackCompilation = new CompileScope(callbackLease.owner);
+                                try {
+                                    const callback = callbacks.entries.get(invocation.id);
+                                    if (callback === undefined)
+                                        throw new TypeError("Missing restored host callback.");
+                                    const args = decodeReplayData(invocation.arguments, {
+                                        resolveCapability: hostCalls.resolveCapability
+                                    }, callbackCompilation);
+                                    void callback(args, token)
+                                        .then(resolve, reject)
+                                        .finally(() => {
+                                        callbackCompilation.dispose();
+                                        callbackLease.release();
+                                    });
+                                }
+                                catch (error) {
+                                    callbackCompilation.dispose();
+                                    callbackLease.release();
+                                    throw error;
+                                }
                             }
                         };
                     }));
@@ -128,12 +152,17 @@ function wrapCallerInjectedFunction(name, value, options, state) {
                 return executeHostCall(issued.record, issued.restored, () => invokeHostCallback(() => Reflect.apply(callable, undefined, hostArgs), options), stackFrames, options, context?.span, callbacks, hostOperationReplayHandlers.get(value)?.bind(undefined, hostArgs));
             }
             catch (error) {
+                compilation.dispose();
                 if (isFatalBridgeError(error) ||
                     (typeof error === "object" && error !== null && sandboxErrorTypes.has(error))) {
                     throw error;
                 }
                 throw createHostErrorValue(error, context?.stack ?? [], options.budget, context?.span);
             }
+            finally {
+                compilation.dispose();
+                operationLease.release();
+            }
         },
         name: bindingName,
         properties: (closure) => {
@@ -345,7 +374,7 @@ function copyHostResultToSandbox(result, stackFrames, options) {
     const value = copyHostValueToSandbox(result, stackFrames, { ...options, registerCapabilities: false }, {
         seen: new WeakMap()
     }, "<root>");
-    options.budget.provisionDataUsage(measureSandboxData([value]));
+    options.budget.chargeDataUsage(measureSandboxData([value]));
     return value;
 }
 function createHostErrorValue(reason, stackFrames, budget, span, state = { seen: new WeakMap() }, chargeBudget = false) {
@@ -375,7 +404,7 @@ function createHostErrorValue(reason, stackFrames, budget, span, state = { seen:
         if (data !== undefined) {
             const copied = copyHostValueToSandbox(data, stackFrames, { budget, errorData: true }, state, "<error>");
             Object.defineProperties(error, Object.getOwnPropertyDescriptors(copied));
-            budget.provisionDataUsage(measureSandboxData([error]));
+            budget.chargeDataUsage(measureSandboxData([error]));
         }
     }
     attachErrorSpan(error, span);
@@ -400,21 +429,24 @@ function copyHostErrorMetadata(error, reason, budget, chargeBudget) {
         resumeChecks?.();
     }
 }
-function wrapSandboxClosureForHost(closure, stackFrames, budget, callbacks) {
+function wrapSandboxClosureForHost(closure, stackFrames, budget, compileOwner, callbacks) {
     const existing = callbacks?.seen.get(closure);
     if (existing !== undefined)
         return existing;
     const id = (callbacks?.entries.size ?? 0) + 1;
     const invoke = async (sandboxArgs, token) => {
+        const operation = budget.acquireCompileOwner(false, compileOwner);
+        const compilation = new CompileScope(operation.owner);
         let leaveRunning;
         let leaveCall;
-        const wrapClosure = (nestedClosure) => wrapSandboxClosureForHost(nestedClosure, stackFrames, budget, callbacks);
+        const wrapClosure = (nestedClosure) => wrapSandboxClosureForHost(nestedClosure, stackFrames, budget, compileOwner, callbacks);
         try {
             leaveRunning = enterRunningState(closure);
             leaveCall = budget.enterCall();
             let result;
             try {
                 result = closure.call(sandboxArgs, {
+                    compilation,
                     stack: stackFrames,
                     thisValue: undefined
                 });
@@ -422,12 +454,14 @@ function wrapSandboxClosureForHost(closure, stackFrames, budget, callbacks) {
             catch (error) {
                 if (isSandboxLikeValue(error)) {
                     throw deepCopyFromSandbox(error, {
+                        compilation,
                         wrapClosure
                     });
                 }
                 throw error;
             }
             return await deepCopyFromSandbox(normalizeClosureResult(result, budget), {
+                compilation,
                 wrapClosure
             });
         }
@@ -437,6 +471,8 @@ function wrapSandboxClosureForHost(closure, stackFrames, budget, callbacks) {
             throw error;
         }
         finally {
+            compilation.dispose();
+            operation.release();
             leaveCall?.();
             leaveRunning?.();
             if (token !== undefined)
@@ -444,41 +480,48 @@ function wrapSandboxClosureForHost(closure, stackFrames, budget, callbacks) {
         }
     };
     const wrapped = async (...args) => {
-        const sandboxArgs = copyHostValueToSandbox([...args], stackFrames, {
-            budget,
-            hostCalls: callbacks?.journal
-        }, { seen: new WeakMap() }, "<callback>");
-        const restored = callbacks?.nextReissuedInvocation === undefined
-            ? undefined
-            : callbacks.restored[callbacks.nextReissuedInvocation++];
-        if (restored !== undefined) {
-            if (restored.id !== id ||
-                JSON.stringify(encodeReplayData(sandboxArgs, {
-                    identifyCapability: callbacks?.journal?.identifyCapability
-                })) !== JSON.stringify(restored.arguments)) {
-                const error = new HostCallResumabilityError(callbacks.record, "external-reconciliation", "Host callback arguments changed while re-issuing the operation; external reconciliation is required.");
-                promiseReplayContext.getStore()?.fail(error);
-                throw error;
+        const operation = budget.acquireCompileOwner(false, compileOwner);
+        try {
+            const sandboxArgs = copyHostValueToSandbox([...args], stackFrames, {
+                budget,
+                compileOwner,
+                hostCalls: callbacks?.journal
+            }, { seen: new WeakMap() }, "<callback>");
+            const restored = callbacks?.nextReissuedInvocation === undefined
+                ? undefined
+                : callbacks.restored[callbacks.nextReissuedInvocation++];
+            if (restored !== undefined) {
+                if (restored.id !== id ||
+                    JSON.stringify(encodeReplayData(sandboxArgs, {
+                        identifyCapability: callbacks?.journal?.identifyCapability
+                    })) !== JSON.stringify(restored.arguments)) {
+                    const error = new HostCallResumabilityError(callbacks.record, "external-reconciliation", "Host callback arguments changed while re-issuing the operation; external reconciliation is required.");
+                    promiseReplayContext.getStore()?.fail(error);
+                    throw error;
+                }
+                return await restored.result;
             }
-            return await restored.result;
+            const replay = promiseReplayContext.getStore();
+            const catchUp = replay?.waitForLiveExecution();
+            if (catchUp !== undefined)
+                await catchUp;
+            const token = callbacks?.record === undefined
+                ? undefined
+                : callbacks.journal?.recordCallback(callbacks.record, id, sandboxArgs, replay?.currentStep ?? 0);
+            if (token !== undefined)
+                replay?.beginCallback(token);
+            const pending = invoke(sandboxArgs, token);
+            callbacks?.active.add(pending);
+            void pending.then(() => {
+                callbacks?.active.delete(pending);
+            }, () => {
+                callbacks?.active.delete(pending);
+            });
+            return await pending;
+        }
+        finally {
+            operation.release();
         }
-        const replay = promiseReplayContext.getStore();
-        const catchUp = replay?.waitForLiveExecution();
-        if (catchUp !== undefined)
-            await catchUp;
-        const token = callbacks?.record === undefined
-            ? undefined
-            : callbacks.journal?.recordCallback(callbacks.record, id, sandboxArgs, replay?.currentStep ?? 0);
-        if (token !== undefined)
-            replay?.beginCallback(token);
-        const pending = invoke(sandboxArgs, token);
-        callbacks?.active.add(pending);
-        void pending.then(() => {
-            callbacks?.active.delete(pending);
-        }, () => {
-            callbacks?.active.delete(pending);
-        });
-        return pending;
     };
     if (closure.length !== undefined)
         Object.defineProperty(wrapped, "length", { value: closure.length });

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

@@ -1,5 +1,5 @@
 import { type SandboxClosure, type SandboxValue } from "./values.js";
-import type { Budget } from "./budget.js";
+import type { Budget, CompileOwner } from "./budget.js";
 import { type ReplayData } from "../snapshot/replay-data.js";
 import { type PendingHostCallPolicyMode } from "../snapshot/policy.js";
 export type HostCallLifecycle = "created" | "running" | "settled" | "consumed" | "cancelled";
@@ -77,6 +77,7 @@ export declare class HostCallJournal {
     private readonly sourceHash;
     private readonly resumeProvider?;
     private budget?;
+    private compileOwner?;
     readonly runId: string;
     private nextCall;
     private readonly records;
@@ -96,7 +97,7 @@ export declare class HostCallJournal {
     private readonly capabilityWaiters;
     readonly identifyCapability: (key: SandboxClosure) => string | undefined;
     readonly resolveCapability: (id: string) => SandboxClosure;
-    constructor(sourceHash: string, records?: readonly HostCallRecord[], resumeProvider?: HostCallResumeProvider | undefined, replay?: unknown, budget?: Budget | undefined);
+    constructor(sourceHash: string, records?: readonly HostCallRecord[], resumeProvider?: HostCallResumeProvider | undefined, replay?: unknown, budget?: Budget | undefined, compileOwner?: CompileOwner | undefined);
     issue(input: {
         moduleId: string;
         operation: string;