import type { AvmContractsDBContext, AvmSimulator } from './avm_simulator.js';
export interface AvmSimulatorPoolOptions {
    /** Maximum number of concurrent AVM processes. If not set, defaults to AVM_MAX_CONCURRENT_SIMULATIONS env var or 4. */
    maxSize?: number;
    /** Path to the bb-avm-sim binary. If omitted, the generated package resolves it. */
    avmBinaryPath?: string;
    /** IPC path for the shared WSDB server. */
    wsdbIpcPath: string;
    /** Optional logger function for AVM process output. */
    logger?: (msg: string) => void;
    /**
     * Flat delay between environmental spawn failures (default 1s). No backoff: sequencers live on
     * ~6s slots, so sleeping longer than this after a failure costs whole blocks while the machine may
     * have recovered — and a spawn attempt is cheap. Spawning never gives up on its own; the caller's
     * deadline (abort signal) is the bound.
     */
    spawnRetryIntervalMs?: number;
    /** Process spawner override. Test hook; defaults to spawning a real bb-avm-sim via the generated AvmService. */
    spawnProcess?: (options: AvmProcessSpawnOptions) => Promise<AvmProcessHandle>;
}
/** Options handed to the process spawner for each new pool slot. */
export interface AvmProcessSpawnOptions {
    binaryPath?: string;
    wsdbIpcPath: string;
    cdbIpcPath: string;
    logger?: (msg: string) => void;
}
/**
 * A handle to a single bb-avm-sim service: it runs serialized simulations and connects back to the
 * shared CDB/WSDB servers for state, but is unaware of which fork's contract data it is reading — that is
 * routed by the fork id baked into the input buffer. The underlying service owns its process lifecycle
 * (including respawn-on-death), so a handle stays usable for the life of the pool.
 */
export interface AvmProcessHandle {
    simulate(inputBuffer: Uint8Array, signal?: AbortSignal): Promise<Uint8Array>;
    simulateWithHints(inputBuffer: Uint8Array): Promise<Uint8Array>;
    destroy(): Promise<void>;
}
/**
 * The public-execution AVM backend: a lazily-grown pool of bb-avm-sim services plus the CDB server that
 * answers those processes' contract-data callbacks. Callers hold this as an {@link AvmSimulator}; the pool,
 * the CDB server, its IPC path, and fork-id routing are all hidden behind that interface. Each `simulate`
 * registers the call's contracts DB on the CDB server for the duration of the simulation (keyed by fork id
 * so concurrent simulations on different forks don't collide) and unregisters it once the call returns.
 *
 * Process lifecycle is invisible to callers, exactly as when the simulator ran in-process: a simulation
 * either produces a result, fails on its own merits, or runs until the caller's deadline aborts it.
 * Environmental trouble is absorbed here — spawn failures retry indefinitely on a backoff ladder (bounded
 * only by the caller's abort signal), and a simulation whose process dies is re-issued on the respawned
 * process. The one deliberate exception: an input that kills the process twice is treated as a failing
 * transaction, so a simulator-crashing tx gets evicted instead of burning a process per block forever.
 */
export declare class AvmSimulatorPool implements AvmSimulator {
    private options;
    private slots;
    private available;
    private waiters;
    private createdCount;
    private destroyed;
    private log;
    private maxSize;
    private cdbServer;
    private readonly spawnRetryIntervalMs;
    private readonly spawnProcess;
    constructor(options: AvmSimulatorPoolOptions);
    static spawn(options: AvmSimulatorPoolOptions): Promise<AvmSimulatorPool>;
    [Symbol.asyncDispose](): Promise<void>;
    simulate(inputBuffer: Uint8Array, context: AvmContractsDBContext, signal?: AbortSignal): Promise<Uint8Array>;
    simulateWithHints(inputBuffer: Uint8Array): Promise<Uint8Array>;
    /** Destroy all AVM services in the pool and close the CDB server. */
    destroy(): Promise<void>;
    /**
     * Eagerly spawn up to `count` AVM processes (capped at maxSize) and leave them available, so the
     * first simulate() doesn't pay process spawn/connect cost. Idempotent.
     */
    prewarm(count?: number): Promise<void>;
    private runOnPool;
    private checkout;
    /** Return an AVM service to the pool after use. */
    private return;
    private createSlot;
    private spawnUntilUp;
}
//# sourceMappingURL=data:application/json;base64,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