/**
 * RenderManifold — the RENDER leg of the Conjecture Engine.
 *
 * A render manifold is the deterministic, receipt-carrying visible geometry
 * surface derived from a conjecture run's proof-carrying receipts. The runner
 * emits discover/prove/RENDER as the full triple under one deterministic
 * receipt (the paper's core novelty thesis: vs LeanConjecturer / AlphaEvolve /
 * FunSearch covering one leg each).
 *
 * The render-manifold artifact carries:
 *   - The vertex and element data from each surviving candidate
 *   - A deterministic SHA-256 invariant-probe hash over the manifold geometry
 *   - Replay guarantee: same input -> identical hash (F.069)
 *
 * @module RenderManifold
 */
import { type HashMode } from './hashes';
import type { ConjectureReceipt, GeometryConjectureCandidate, ConjectureStatus } from './ConjectureEngine';
export declare const RENDER_MANIFOLD_V1: "conjecture.render-manifold.v1";
export type RenderManifoldSolverType = typeof RENDER_MANIFOLD_V1;
/** A single rendered surface derived from one receipt's geometry. */
export interface RenderedSurface {
    candidateId: string;
    family: string;
    status: ConjectureStatus;
    /** Deterministic geometry hash (via hashGeometry). */
    geometryHash: string;
    vertexCount: number;
    elementCount: number;
    elementArity: 3 | 4 | null;
    /** SHA-256 of the canonical (vertices, elements) pair — replay-deterministic. */
    surfaceDigest: string;
}
/** The RENDER leg output: a receipt-carrying render manifold. */
export interface RenderManifoldArtifact {
    solverType: RenderManifoldSolverType;
    specVersion: 1;
    /** Which runner receipt key this manifold was derived from. */
    sourceReceiptKey: string;
    /** The rendered surfaces, one per surviving/falsified candidate. */
    surfaces: ReadonlyArray<RenderedSurface>;
    /** Deterministic SHA-256 invariant-probe hash over the entire manifold. */
    invariantProbeHash: string;
    /** The hash mode used (mirrors the runner's hashMode). */
    hashMode: HashMode;
    /** Deterministic receipt key for the manifold artifact itself. */
    receiptKey: string;
}
/**
 * Derive a render-manifold artifact from a set of conjecture receipts.
 *
 * Each receipt's candidate geometry is rendered into a surface with a
 * deterministic SHA-256 surface digest. The overall manifold gets an
 * invariant-probe hash that is replay-deterministic: same inputs always
 * produce the same hash (F.069).
 */
export declare function renderManifoldFromReceipts(receipts: ReadonlyArray<ConjectureReceipt>, candidates: ReadonlyArray<ReadonlyArray<GeometryConjectureCandidate>>, hashMode?: HashMode): RenderManifoldArtifact;
/**
 * Replay-determinism check: run the manifold twice with the same inputs and
 * verify the invariant-probe hash is identical.
 *
 * Returns true if the manifold is replay-deterministic (F.069 guarantee).
 */
export declare function verifyRenderManifoldReplay(receipts: ReadonlyArray<ConjectureReceipt>, candidates: ReadonlyArray<ReadonlyArray<GeometryConjectureCandidate>>, hashMode?: HashMode): {
    passed: boolean;
    firstHash: string;
    secondHash: string;
};
//# sourceMappingURL=RenderManifold.d.ts.map