import type { GjcBundleIdentity, GjcRuntimeFinding, GjcRuntimeSnapshot, GjcRuntimeSnapshotState } from "./types";
/**
 * Deterministic numeric activation generation for an activation fingerprint.
 *
 * Equal activation inputs yield an equal generation, so a consumer holding a
 * snapshot can tell whether it still describes the state it is rendering.
 * Derived from the fingerprint's leading hex so it stays inside the safe
 * integer range.
 */
export declare function gjcActivationGenerationFor(activationFingerprint: string): number;
/**
 * Caller-owned accumulator for scope-qualified runtime evidence.
 *
 * Producers (loaders, adapters, validators) hand findings to an accumulator
 * they were given; they never publish. Exactly one coordinator publishes a
 * complete generation snapshot, and consumers merge it only when the identity
 * and generation match.
 */
export declare class GjcRuntimeFindingAccumulator {
    readonly generation: number;
    private readonly findings;
    constructor(generation: number);
    add(finding: GjcRuntimeFinding): void;
    addAll(findings: readonly GjcRuntimeFinding[]): void;
    /** Sorted, de-duplicated snapshot for the generation this accumulator owns. */
    snapshot(): GjcRuntimeSnapshot;
}
/** Read-only view of the most recently published complete generation. */
export interface GjcRuntimeSnapshotProvider {
    current(): GjcRuntimeSnapshotState;
}
/**
 * Single-writer publisher for runtime evidence.
 *
 * Passes can overlap: the session's prompt rebuild is re-entrant, so a second
 * pass may start while a first is still awaiting its producers. Publication is
 * therefore fenced by a monotonic epoch. A pass reserves an epoch when it
 * begins, which immediately retires whatever was published before, and its
 * later publish is accepted only if no newer pass has reserved since. A slow or
 * failed older pass can never overwrite a newer one, and an incomplete pass
 * simply never publishes, leaving consumers at `unavailable`.
 */
export declare class GjcRuntimeSnapshotStore implements GjcRuntimeSnapshotProvider {
    private state;
    private epoch;
    /**
     * Begin a pass. Retires the current snapshot and returns the epoch token the
     * caller must present to publish.
     */
    beginPass(): number;
    /** Publish only if `epoch` is still the newest reserved pass. */
    publish(snapshot: GjcRuntimeSnapshot, epoch?: number): void;
    invalidate(): void;
    current(): GjcRuntimeSnapshotState;
}
/**
 * Findings for one bundle, but only when the snapshot is current AND describes
 * the exact generation the consumer is rendering. Missing provider, mismatched
 * generation, or unavailable state resolve to `unavailable` — never to a
 * silently empty "clear" result.
 */
export declare function findingsForBundle(provider: GjcRuntimeSnapshotProvider | undefined, identity: GjcBundleIdentity, expectedGeneration: number): {
    status: "unavailable";
} | {
    status: "current";
    findings: GjcRuntimeFinding[];
};