Export types

export type ReviewTarget = {
    kind: "board";
} | {
    kind: "shot";
    animationId: string;
} | {
    kind: "editorial";
    sequenceId: string;
};

export type ReviewFrameSource = {
    kind: "board";
    panelId: string;
    incomingPanelId?: string;
    transitionProgress: number;
} | {
    kind: "shot";
    animationId: string;
    sourceFrame: number;
} | {
    kind: "editorial";
    sequenceId: string;
    outgoing: {
        clipId: string;
        animationId: string;
        sourceFrame: number;
    };
    incoming?: {
        clipId: string;
        animationId: string;
        sourceFrame: number;
    };
    transition: Transition["type"];
    transitionProgress: number;
};

export interface ReviewExportOptions {
    target?: ReviewTarget;
    frames: number[];
    expectedVersion: number;
    revision?: string;
    annotations?: boolean;
    signal?: AbortSignal;
}

export interface ReviewManifest {
    format: "codeboard-review/2";
    createdAt: string;
    source: {
        projectId: string;
        version: number;
        schemaVersion: number;
        documentHash: string;
        revision?: string;
    };
    renderer: {
        package: string;
        version: string;
        node: string;
        platform: string;
    };
    settings: {
        target: ReviewTarget;
        annotations: boolean;
        frameRate: RationalRate;
        space: "camera";
        imageFormat: "PNG";
    };
    frames: {
        frame: number;
        file: string;
        sha256: string;
        bytes: number;
        width: number;
        height: number;
        source: ReviewFrameSource;
    }[];
}

export interface ProjectPublishManifest {
    format: "codeboard-project-publish/1";
    source: {
        projectId: string;
        version: number;
        documentHash: string;
    };
    file: {
        name: "project.cboard";
        bytes: number;
        sha256: string;
    };
    engine: RenderIdentity;
    externalFonts: string[];
    fontFiles?: FontFileDependency[];
}

export interface MovieOptions extends MovieEncodingOptions {
    fontPolicy?: FontPolicy;
    assetRoot?: string;
}

export interface StudioMovieOptions extends MovieEncodingOptions {
    fontPolicy?: FontPolicy;
    range?: {
        startFrame: number;
        endFrame: number;
    };
    audio?: "omit" | {
        mode: "mix";
        decoder: StudioAudioDecoder;
        transitions: "sum" | "linear";
        maxSamples?: number;
        rounding?: AudioSampleRounding;
    };
}

export type AudioStemTarget = {
    kind: "shot";
    animation: ShotAnimation;
} | {
    kind: "editorial";
    sequence: EditorialSequence;
    animations: readonly ShotAnimation[];
};

export interface AudioStemExportOptions {
    stems: readonly {
        name: string;
        tracks: readonly AudioTrackRef[];
    }[];
    transitions: "sum" | "linear";
    sampleFormat?: "pcm16" | "float32";
    mix?: Omit<AudioMixOptions, "tracks">;
}

export interface AudioStemManifest {
    format: "codeboard-audio-stems/1";
    source: {
        kind: "shot" | "editorial";
        id: string;
        fingerprint: string;
    };
    sampleRate: number;
    sampleFormat: "pcm16" | "float32";
    transitions: "sum" | "linear";
    range: {
        startSample: number;
        endSample: number;
    };
    stems: {
        name: string;
        tracks: AudioTrackRef[];
        file: string;
        sha256: string;
        bytes: number;
        samples: number;
        peak: number;
        clippedSamples: number;
    }[];
}

export interface FrameJobOptions {
    expectedVersion: number;
    target: FrameJobManifest["target"];
    range?: {
        startFrame: number;
        endFrame: number;
    };
    maxBytes?: number;
    fontPolicy?: "allow-fallback" | "require-available";
    outputProfile?: FrameJobManifest["outputProfile"];
    fontFiles?: FrameJobManifest["fontFiles"];
}

export interface RunFrameJobOptions {
    sourcePath?: string;
    range?: {
        startFrame: number;
        endFrame: number;
    };
    signal?: AbortSignal;
    onProgress?: (completed: number, total: number) => void;
}

export interface FrameJobMovieOptions extends Omit<StudioMovieOptions, "range"> {
    sourcePath?: string;
}

export interface VerifyFrameJobOptions {
    signal?: AbortSignal;
    onProgress?: (visited: number, total: number) => void;
}

export type FrameOutputProfile = {
    width: number;
    height: number;
    fit: "contain" | "cover" | "fill";
} & ({
    alpha: "preserve";
} | {
    alpha: "flatten";
    background: {
        r: number;
        g: number;
        b: number;
    };
});

export type FrameJobFontFile = FontFileDependency;

export interface FrameJobManifest {
    format: "codeboard-frame-job/1";
    source: {
        path: string;
        projectId: string;
        version: number;
        documentHash: string;
    };
    target: {
        kind: "shot";
        animationId: string;
        render?: ShotRenderOptions;
    } | {
        kind: "editorial";
        sequenceId: string;
    };
    range: {
        startFrame: number;
        endFrame: number;
    };
    frameRate: {
        numerator: number;
        denominator: number;
    };
    renderer: RenderIdentity;
    maxBytes: number;
    fontPolicy?: "allow-fallback" | "require-available";
    outputProfile?: FrameOutputProfile;
    fontFiles?: FrameJobFontFile[];
}

export interface MovieEncodingOptions {
    ffmpegPath?: string;
    maxFrames?: number;
    signal?: AbortSignal;
    onProgress?: (completed: number, total: number) => void;
}

export interface ReviewDecisionInput {
    id: string;
    reviewer: {
        id: string;
        kind: "human" | "agent";
    };
    outcome: "approved" | "changes-requested" | "not-reviewed";
    criteria: string[];
    frames: number[];
    notes: string;
}

export interface ReviewDecision extends ReviewDecisionInput {
    format: "codeboard-review-decision/1";
    createdAt: string;
    evidence: {
        manifestSha256: string;
        projectId: string;
        version: number;
        documentHash: string;
        target: ReviewTarget;
    };
    sha256: string;
}

export interface ReviewDecisionVerifyOptions {
    decode?: boolean;
    signal?: AbortSignal;
    source?: {
        projectPath: string;
        revision?: string;
    };
}

export interface VerifyFrameSequenceOptions {
    decode?: boolean;
    signal?: AbortSignal;
    onProgress?: (verified: number, total: number) => void;
}

export interface FrameJobSequenceOptions {
    maxFrames?: number;
    signal?: AbortSignal;
    onProgress?: (completed: number, total: number) => void;
}

export interface PublishProjectOptions extends CopyProjectOptions {
    fontFiles?: FontFileDependency[];
}