import type { AccessMemory } from "./types/accessMemory.js";
/**
 * A single normalized "touch" of a file by one step. Both orchestrators map their
 * own result shape to a stream of these, so the deterministic core below is
 * single-sourced and can't drift between audit and remediate:
 *   - audit: each `AuditResult.file_coverage[]` entry → a covered event.
 *   - remediate: each file a merged block actually edited → an edited event.
 */
export interface AccessTouchEvent {
    /** Repo-relative path, as the orchestrator sees it (normalization is the reader's job). */
    path: string;
    /** true = an edit (remediate); false = a read/coverage (audit). */
    edited: boolean;
    /** Step-ordinal: the step's position in its ledger/wave order (never wall-clock). */
    ordinal: number;
    /** Optional lens/category tag for the touch. */
    lens?: string;
}
/**
 * Deterministic core of the access-memory harvest, shared by both orchestrators.
 *
 * Pure: the same event stream always yields a byte-identical record. Frequency is
 * split into `covered_count` (reads) and `edited_count` (edits); recency is the
 * MAXIMUM ordinal that touched the path (step-ordinal space, never wall-clock).
 * Output arrays are content-sorted (paths by path, lenses lexically) so the
 * serialized bytes are stable regardless of event iteration order — the
 * "stable, content-derived array order" invariant that keeps the artifact's
 * content hash from churning the staleness DAG.
 */
export declare function deriveAccessMemoryFromEvents(events: Iterable<AccessTouchEvent>, options: {
    totalOrdinals: number;
    runId?: string;
}): AccessMemory;
//# sourceMappingURL=accessMemory.d.ts.map