export declare const HEADLESS_EXPERIMENT_PLAN_SCHEMA: "holoscript.headless-experiment-plan.v1";
export declare const HEADLESS_EXPERIMENT_RECEIPT_SCHEMA: "holoscript.headless-experiment-run.v1";
export declare const HEADLESS_EXPERIMENT_HASH_ALGORITHM: "sha256-strict-canonical-json-v1";
export type HeadlessJsonPrimitive = null | boolean | number | string;
export type HeadlessJsonValue = HeadlessJsonPrimitive | HeadlessJsonValue[] | {
    [key: string]: HeadlessJsonValue;
};
export type HeadlessJsonObject = {
    [key: string]: HeadlessJsonValue;
};
export interface HeadlessExperimentClockDeclaration {
    startTick: number;
    endTick: number;
    step: number;
}
interface HeadlessObservationSubjectBinding {
    argumentKey: string;
    observationKey: string;
    targetCardinality: 1;
}
export interface HeadlessExperimentManifest {
    kind: 'manifest';
    schema: typeof HEADLESS_EXPERIMENT_PLAN_SCHEMA;
    runId: string;
    seed: string;
    clock: HeadlessExperimentClockDeclaration;
    publicStateKeys: string[];
    expected: {
        scheduleCount: number;
        observationCount: number;
        actionCount: number;
        finalPublicState: HeadlessJsonObject;
    };
    authorization?: {
        required: boolean;
        startSequence: number;
    };
    observationPolicy?: {
        allowedRootKeys?: string[];
        forbiddenKeys?: string[];
        forbiddenValues?: HeadlessJsonValue[];
        subjectBinding?: HeadlessObservationSubjectBinding;
    };
}
export interface HeadlessActionAuthorization {
    nonce: string;
    sequence: number;
    turnOpportunityId: string;
    safetyReceiptId: string;
    decisionReceiptId: string;
}
export interface HeadlessExperimentScheduleEntry {
    kind: 'observation' | 'action';
    scheduleEntryId: string;
    order: number;
    tick: number;
    phase: string;
    entrypoint: string;
    args?: HeadlessJsonObject;
    targetIds?: string[];
    barrierId?: string | null;
    authorization?: HeadlessActionAuthorization;
    expect?: {
        allowed?: boolean;
        outcome?: string;
        stateChanged?: boolean;
    };
}
export interface ParsedHeadlessExperimentPlan {
    manifest: HeadlessExperimentManifest;
    schedule: HeadlessExperimentScheduleEntry[];
}
export interface HeadlessExperimentInvocationResult {
    value: HeadlessJsonValue;
    state: Record<string, unknown>;
    emittedEvents?: HeadlessJsonValue[];
}
export type HeadlessExperimentInvoker = (entry: HeadlessExperimentScheduleEntry) => Promise<HeadlessExperimentInvocationResult> | HeadlessExperimentInvocationResult;
export interface HeadlessChainedEntry<TPayload extends HeadlessJsonValue = HeadlessJsonValue> {
    sequence: number;
    logicalTick: number;
    previousHash: string;
    payload: TPayload;
    entryHash: string;
}
export interface HeadlessExecutedSchedulePayload extends HeadlessJsonObject {
    scheduleEntryId: string;
    order: number;
    tick: number;
    phase: string;
    kind: 'observation' | 'action';
    entrypoint: string;
    source: HeadlessJsonObject;
    outcomeHashes: string[];
}
export interface HeadlessObservationPayload extends HeadlessJsonObject {
    scheduleEntryId: string;
    tick: number;
    entrypoint: string;
    targetIds: string[];
    publicStateHash: string;
    observation: HeadlessJsonValue;
}
export interface HeadlessRollbackReference extends HeadlessJsonObject {
    preStateSnapshotId: string;
    preStateHash: string;
    priorActionRoot: string;
}
export interface HeadlessActionPayload extends HeadlessJsonObject {
    scheduleEntryId: string;
    tick: number;
    entrypoint: string;
    args: HeadlessJsonObject;
    targetIds: string[];
    authorization: HeadlessJsonObject | null;
    allowed: boolean;
    outcome: string;
    result: HeadlessJsonObject;
    emittedEvents: HeadlessJsonValue[];
    preStateSnapshotId: string;
    postStateSnapshotId: string;
    prePublicStateHash: string;
    postPublicStateHash: string;
    stateChanged: boolean;
    rollbackReference: HeadlessRollbackReference;
}
export interface HeadlessPublicStatePayload extends HeadlessJsonObject {
    snapshotId: string;
    scheduleEntryId: string | null;
    publicState: HeadlessJsonObject;
    publicStateHash: string;
}
export interface HeadlessExperimentReceipt {
    schema: typeof HEADLESS_EXPERIMENT_RECEIPT_SCHEMA;
    hashAlgorithm: typeof HEADLESS_EXPERIMENT_HASH_ALGORITHM;
    runId: string;
    seed: string;
    sourceBundleHash: string;
    manifest: HeadlessExperimentManifest;
    logicalClock: {
        start_tick: number;
        end_tick: number;
        step: number;
        executed_ticks: number[];
    };
    scene: HeadlessJsonValue;
    posePhysics: HeadlessJsonValue;
    publicStateSnapshots: HeadlessChainedEntry<HeadlessPublicStatePayload>[];
    scheduleLedger: HeadlessChainedEntry<HeadlessExecutedSchedulePayload>[];
    observationLedger: HeadlessChainedEntry<HeadlessObservationPayload>[];
    actionLedger: HeadlessChainedEntry<HeadlessActionPayload>[];
    canonicalFields: {
        canonicalSceneHash: string;
        canonicalPoseHash: string;
        logicalClockHash: string;
        publicStateHash: string;
        executedScheduleHash: string;
        residentObservationHash: string;
        actionReceiptRoot: string;
    };
    terminal: {
        finalTick: number;
        finalPublicStateHash: string;
        expectedCounts: {
            schedule: number;
            observations: number;
            actions: number;
            publicStateSnapshots: number;
        };
        actualCounts: {
            schedule: number;
            observations: number;
            actions: number;
            publicStateSnapshots: number;
        };
        publicStateHistoryRoot: string;
        scheduleRoot: string;
        observationRoot: string;
        actionRoot: string;
        terminalCommitment: string;
    };
}
export interface HeadlessExperimentVerificationOptions {
    expectedSourceBundleHash?: string;
    expectedSchedule?: HeadlessExperimentScheduleEntry[];
    expectedTerminalCommitment?: string;
    /** Optional live-admission registry. Deterministic offline replays omit it. */
    replayRegistry?: HeadlessExperimentReplayRegistry;
}
export interface HeadlessExperimentReplayRegistry {
    terminalCommitments: Set<string>;
    authorizationIds: Set<string>;
}
export interface HeadlessExperimentVerificationResult {
    valid: boolean;
    errors: string[];
}
/**
 * Strict canonical JSON. Object keys are sorted, array order is preserved, and
 * values that JSON would silently coerce/drop are rejected.
 */
export declare function canonicalizeHeadlessValue(value: unknown): string;
export declare function cloneHeadlessValue<T extends HeadlessJsonValue>(value: T): T;
export declare function hashHeadlessValue(value: unknown): string;
export declare function parseHeadlessExperimentPlan(records: unknown): ParsedHeadlessExperimentPlan;
export declare function buildHeadlessExperimentReceipt(options: {
    sourceBundleHash: string;
    scene: unknown;
    posePhysics: unknown;
    plan: ParsedHeadlessExperimentPlan;
    initialState: Record<string, unknown>;
    invoke: HeadlessExperimentInvoker;
}): Promise<HeadlessExperimentReceipt>;
export declare function verifyHeadlessExperimentReceipt(receipt: HeadlessExperimentReceipt, options?: HeadlessExperimentVerificationOptions): HeadlessExperimentVerificationResult;
export {};
//# sourceMappingURL=HeadlessExecutionLedger.d.ts.map