/**
 * 💾 THE DURABLE PUBLIC LOG — turn the AI Transparency Log (R50) + Witness Network (R51) from a per-request demo
 * into a REAL, persistent public good that survives restarts and that anyone can submit to and monitor.
 *
 * A transparency log only matters if it actually PERSISTS: claims must accumulate over time, the signing key must
 * survive restarts (so a Signed Tree Head issued yesterday still verifies today), and the whole history must be
 * reconstructible from durable storage with the SAME Merkle root. This wraps the R50 log with durable storage: the
 * raw claims are appended to an append-only store, the log's Ed25519 key is persisted once and reloaded, and on
 * restart the entire log rebuilds to a byte-identical root — so inclusion proofs and append-only consistency proofs
 * issued before the restart still verify after it. Storage is injected (an in-memory store for tests, a file store
 * on the server), so the durability guarantee itself is measured, not assumed.
 *
 * WHO BENEFITS (a whole ecosystem, ≥4): ① SUBMITTERS get a permanent public record that does not vanish on a deploy;
 * ② AUDITORS can re-pull a months-old tree head and it still checks out; ③ MONITORS watch a live, growing log;
 * ④ the OPERATOR can restart / migrate the service without breaking a single past proof.
 *
 * (DIAKRISIS — MEASURED: a log rebuilt from durable storage after a simulated restart has the identical Merkle root
 * and the identical signing key; inclusion proofs survive the restart; an append-only consistency proof verifies
 * across the restart; editing the stored history changes the root, so a pre-restart Signed Tree Head no longer
 * matches → tamper detected; deterministic + total. HONEST: durability here means the log's OWN state is persistent
 * and reconstructible — it does not replicate the log across machines [that is the Witness Network's job, R51]; a
 * single-operator durable log + independent witnesses together give the full guarantee.)
 */
import { type SignedTreeHead, type TransparencyLog } from "./translog.js";
export interface LogStore {
    readLines: () => string[];
    appendLine: (s: string) => void;
    readKeyPem: () => string | null;
    writeKeyPem: (pem: string) => void;
}
export declare function memoryStore(seedLines?: string[], seedKeyPem?: string): LogStore;
export interface DurableLog {
    logId: string;
    publicKeyPem: string;
    submit: (entry: string) => {
        index: number;
        sth: SignedTreeHead;
    };
    size: () => number;
    sth: () => SignedTreeHead;
    inclusionProof: (index: number) => ReturnType<TransparencyLog["inclusionProof"]>;
    consistencyProof: (firstSize: number) => ReturnType<TransparencyLog["consistencyProof"]>;
    recent: (k?: number) => Array<{
        index: number;
        entry: string;
    }>;
}
export declare function openDurableLog(opts: {
    logId?: string;
    store: LogStore;
    now?: () => number;
}): DurableLog;
export declare function durableGauntlet(): {
    score: 0 | 100;
    checks: Array<{
        name: string;
        pass: boolean;
        detail: string;
    }>;
};
//# sourceMappingURL=durable.d.ts.map