/**
 * The exploration engine — a stateful session over a behavior space.
 *
 * Each `step()`: allocate budget across INPUT cells (floor first, then variance
 * steering toward the least-certain cells), propose candidates (the proposer
 * reads current elites + findings, so the search deepens generationally),
 * evaluate with bounded concurrency, archive the most interesting scenario per
 * input×measured bin, and admit notable candidates that pass the validity gates.
 * `run()` loops to budget. `coverage()`/`findings()`/`capsule()` read live state —
 * the surface `makeExploreTools` exposes so an agent can drive the session.
 *
 * One evaluation log (`EvalRecord[]`) is the source of truth; allocation
 * observations and coverage are projections of it.
 */
import type { CapsuleData, CoverageCell, ExploreOptions, Finding } from './types';
export declare class BehaviorExplorer<S> {
    private readonly opts;
    private readonly cells;
    private readonly cellById;
    private readonly objective;
    private readonly threshold;
    private readonly floorPerCell;
    private readonly perRoundBudget;
    /** The single evaluation log — coverage + allocation are projections of it. */
    private readonly log;
    /** binId (input × measured coords) → the most interesting entry seen. */
    private readonly archiveByBin;
    private readonly _findings;
    private runsUsed;
    private candidateFindings;
    private evalErrors;
    private consecutiveEvalErrors;
    private stoppedEarly;
    private rngState;
    /** Accumulated KNOWN dollars — unknown-cost runs never inflate it. */
    private spentKnownUsd;
    private costUnknownRuns;
    constructor(opts: ExploreOptions<S>);
    private rng;
    private binId;
    private allocate;
    private objectiveContext;
    /** Mirrors control-runtime: stop once accumulated KNOWN cost ≥ the ceiling. */
    private costExhausted;
    /** Fold one run's cost in: null counts as unknown (never $0); a known cost
     *  accrues toward the budget, lands in the ledger, and fires `onCost`. */
    /** Returns the run's known cost, `null` when tracked-but-unknown, `undefined`
     *  when cost tracking is not wired — the log row mirrors this exactly. */
    private recordRunCost;
    /** Elites whose INPUT cell matches — what the proposer mutates/deepens from. */
    private elitesFor;
    /** One allocate → propose → evaluate → gate → archive round. */
    step(): Promise<{
        runs: number;
        findings: Finding<S>[];
    }>;
    /** Loop `step()` until the run or dollar budget is spent, the signal aborts,
     *  or no progress is made. */
    run(): Promise<CapsuleData<S>>;
    coverage(): CoverageCell[];
    findings(): Finding<S>[];
    capsule(): CapsuleData<S>;
}
//# sourceMappingURL=explorer.d.ts.map