import { type CanonicalHsonDifference } from "../core/canonical-hson-equal.js";
import type { HsonNode } from "../core/types.js";
export type CircuitEntry = "hson" | "json" | "html";
export type CircuitDirection = "cw" | "ccw";
export type CircuitLegPhase = "conversion" | "closure";
export type CircuitTransformBoundary = Readonly<{
    identity: string;
    parse(format: CircuitEntry, text: string): HsonNode;
    serialize(format: CircuitEntry, node: HsonNode): string;
}>;
export type CircuitOperationCounts = Readonly<{
    parses: number;
    serializations: number;
    strictComparisons: number;
    laps: number;
    directions: number;
}>;
export type CircuitFailureStage = "prepare" | "serialize" | "parse" | "compare" | "cancel";
export type CircuitFailure = Readonly<{
    stage: CircuitFailureStage;
    message: string;
    terminal: boolean;
    direction?: CircuitDirection;
    lap?: number;
    leg?: number;
    sourceFormat?: CircuitEntry;
    targetFormat?: CircuitEntry;
    difference?: CanonicalHsonDifference;
}>;
export type CircuitTiming = Readonly<{
    serializeMs: number;
    parseMs: number;
    compareMs: number;
    totalMs: number;
}>;
export type PreparedCircuitInput = Readonly<{
    boundaryIdentity: string;
    entry: CircuitEntry;
    text: string;
    node: HsonNode;
    timingMs: number;
}>;
export type CircuitRepresentation = Readonly<{
    format: CircuitEntry;
    text: string;
    node: HsonNode;
}>;
export type CircuitComparisonEvidence = Readonly<{
    equal: boolean;
    difference?: CanonicalHsonDifference;
}>;
export type CapturedCircuitMaterial = Readonly<{
    inputText: string;
    serializedOutput: string;
    sourceNode: HsonNode;
    parsedNode: HsonNode;
}>;
export type CircuitLegDiagnostic = Readonly<{
    direction: CircuitDirection;
    lap: number;
    leg: number;
    phase: CircuitLegPhase;
    sourceFormat: CircuitEntry;
    targetFormat: CircuitEntry;
    comparison?: CircuitComparisonEvidence;
    timing: CircuitTiming;
    failure?: CircuitFailure;
    material?: CapturedCircuitMaterial;
}>;
export type CircuitLeg = Readonly<{
    direction: CircuitDirection;
    lap: number;
    leg: number;
    phase: CircuitLegPhase;
    sourceFormat: CircuitEntry;
    targetFormat: CircuitEntry;
    inputText: string;
    sourceNode: HsonNode;
    serializedOutput?: string;
    parseResult?: HsonNode;
    comparison?: CircuitComparisonEvidence;
    timing: CircuitTiming;
    failure?: CircuitFailure;
    next?: CircuitRepresentation;
}>;
export type CompletedCircuitLap = Readonly<{
    direction: CircuitDirection;
    lap: number;
    completed: boolean;
    next: CircuitRepresentation;
    failures: readonly CircuitFailure[];
    legs?: readonly CircuitLegDiagnostic[];
}>;
export type CircuitCheckpointNode = Readonly<{
    lap: number;
    targetFormat: CircuitEntry;
    phase: CircuitLegPhase;
    node: HsonNode;
}>;
export type CompletedCircuitDirection = Readonly<{
    direction: CircuitDirection;
    requestedLaps: number;
    completedLaps: number;
    completed: boolean;
    ok: boolean;
    final: CircuitRepresentation;
    failures: readonly CircuitFailure[];
    laps?: readonly CompletedCircuitLap[];
    checkpoints?: readonly CircuitCheckpointNode[];
}>;
export type DualDirectionComparison = Readonly<{
    performed: boolean;
    comparison?: CircuitComparisonEvidence;
    failure?: CircuitFailure;
    paranoidComparisons: number;
}>;
export type CircuitCheckpoint = Readonly<{
    stage: "before-direction" | "before-opposite-direction" | "before-leg" | "between-laps" | "before-final-comparison";
    direction?: CircuitDirection;
    lap?: number;
    leg?: number;
}>;
export type CircuitExecutionOptions = Readonly<{
    capture?: boolean;
    verbose?: boolean;
    paranoid?: boolean;
    stopOnFirstFail?: boolean;
    shouldCancel?: (checkpoint: CircuitCheckpoint) => boolean;
    now?: () => number;
}>;
export type CircuitExecutionResult = Readonly<{
    ok: boolean;
    entry: CircuitEntry;
    boundaryIdentity: string;
    prepared?: PreparedCircuitInput;
    prepareFailure?: CircuitFailure;
    executionFailure?: CircuitFailure;
    directions: readonly CompletedCircuitDirection[];
    finalComparison?: DualDirectionComparison;
    operations: CircuitOperationCounts;
}>;
export declare function prepare_explicit_entry(boundary: CircuitTransformBoundary, entry: CircuitEntry, text: string, options?: CircuitExecutionOptions): Readonly<{
    prepared?: PreparedCircuitInput;
    failure?: CircuitFailure;
    operations: CircuitOperationCounts;
}>;
export declare function run_conversion_leg(boundary: CircuitTransformBoundary, current: CircuitRepresentation, targetFormat: CircuitEntry, details: Readonly<{
    direction: CircuitDirection;
    lap: number;
    leg: number;
    phase?: CircuitLegPhase;
}>, options?: CircuitExecutionOptions): Readonly<{
    leg: CircuitLeg;
    operations: CircuitOperationCounts;
}>;
export declare function run_direction(boundary: CircuitTransformBoundary, prepared: PreparedCircuitInput, direction: CircuitDirection, times: number, options?: CircuitExecutionOptions): Readonly<{
    direction: CompletedCircuitDirection;
    operations: CircuitOperationCounts;
}>;
/** Execute one directional lap without requiring a dual-circuit structure. */
export declare function run_directional_lap(boundary: CircuitTransformBoundary, prepared: PreparedCircuitInput, direction: CircuitDirection, options?: CircuitExecutionOptions): Readonly<{
    lap: CompletedCircuitLap;
    operations: CircuitOperationCounts;
}>;
export declare function compare_completed_directions(boundary: CircuitTransformBoundary, cw: CompletedCircuitDirection, ccw: CompletedCircuitDirection, options?: CircuitExecutionOptions): Readonly<{
    comparison: DualDirectionComparison;
    operations: CircuitOperationCounts;
}>;
export declare function execute_circuit(boundary: CircuitTransformBoundary, entry: CircuitEntry, text: string, request: Readonly<{
    times: number;
    dual: boolean;
    direction: CircuitDirection;
}>, options?: CircuitExecutionOptions): CircuitExecutionResult;
//# sourceMappingURL=circuit-engine.d.ts.map