acorde_core/model/

playback.rs

use super::duration::Duration;
use super::notation::{Articulation, ChordSymbol, GuitarTechnique, TabPosition};
use super::repeat::measure_sequence;
use super::score::{GuitarBendPoint, Note, NoteAddr, Score};
use serde::{Deserialize, Serialize};
use std::collections::{BTreeMap, BTreeSet};

fn default_fermata_multiplier() -> f64 {
    1.5
}
fn default_fermata_hold_beats() -> f64 {
    0.0
}
fn default_swing_unit() -> Duration {
    Duration::Eighth
}
fn default_tempo_multiplier() -> f64 {
    1.0
}
fn default_metronome_channel() -> u8 {
    9
}
fn default_accent_pitch() -> u8 {
    76
}
fn default_beat_pitch() -> u8 {
    77
}
fn default_accent_velocity() -> u8 {
    100
}
fn default_beat_velocity() -> u8 {
    70
}

/// Explicit opt-in event realization policy.
///
/// [`Authored`](Self::Authored) is the default: ornaments and arpeggiation remain notation
/// semantics on one event. Measured single-note tremolos are an exception: their written
/// strokes determine repeated attacks in every profile. Other ornament realization remains opt-in.
#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "kebab-case")]
pub enum PlaybackRealizationProfile {
    /// Preserve authored event semantics without generating auxiliary attacks.
    #[default]
    Authored,
    /// Deterministic chromatic ornament attacks and chord arpeggiation for preview providers.
    ///
    /// Trills and shakes alternate the written pitch with one chromatic semitone above; mordents
    /// and turns use a fixed four-attack figure. Chord tones marked `arpeggiate` are staggered
    /// low-to-high (or high-to-low) by at most 0.18 beats. This is a reproducible preview policy,
    /// not a claim about historical performance practice.
    OrnamentArpeggioV1,
}

/// Click-track injected into [`to_playback_events`] output.
///
/// Metronome events are tagged with `PlaybackEvent.is_metronome = true` and can be
/// routed separately by checking `channel` (default 9 = GM drums).
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct MetronomeConfig {
    /// MIDI channel for the click track. Default 9 (GM drum channel).
    #[serde(default = "default_metronome_channel")]
    pub channel: u8,
    /// MIDI note for the accented first beat. Default 76 (High Wood Block).
    #[serde(default = "default_accent_pitch")]
    pub accent_pitch: u8,
    /// MIDI note for regular beats. Default 77 (Low Wood Block).
    #[serde(default = "default_beat_pitch")]
    pub beat_pitch: u8,
    /// Velocity for the accented first beat. Default 100.
    #[serde(default = "default_accent_velocity")]
    pub accent_velocity: u8,
    /// Velocity for regular beats. Default 70.
    #[serde(default = "default_beat_velocity")]
    pub beat_velocity: u8,
}

impl Default for MetronomeConfig {
    fn default() -> Self {
        Self {
            channel: 9,
            accent_pitch: 76,
            beat_pitch: 77,
            accent_velocity: 100,
            beat_velocity: 70,
        }
    }
}

/// Options for [`to_playback_events`].
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(default)]
pub struct PlaybackOptions {
    /// Replaces every written tempo when `Some` and suppresses written tempo ramps.
    ///
    /// Use [`tempo_multiplier`](Self::tempo_multiplier) when a host needs to speed up or slow
    /// down a score while retaining the written tempo map.
    pub bpm_override: Option<u16>,
    /// Multiplies every effective tempo, including written tempo changes and ramps.
    ///
    /// The default `1.0` preserves the score. Non-finite or non-positive values are normalized
    /// to `1.0` so an untrusted host option cannot produce an invalid schedule.
    #[serde(default = "default_tempo_multiplier")]
    pub tempo_multiplier: f64,
    /// Part indices to silence. Events from these parts are omitted entirely.
    pub muted_parts: Vec<usize>,
    /// Written dynamic marks to apply to every staff of their own part. Entries are
    /// physical note addresses; all other dynamics retain staff-local scope.
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub shared_dynamics: Vec<NoteAddr>,
    /// Hairpin start addresses to apply to every staff of their own part. Select
    /// a dynamic separately when both marks occur on the same note.
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub shared_hairpins: Vec<NoteAddr>,
    /// Restrict playback to measures in the inclusive range `[start, end]`.
    /// Physical measure indices (0-based). `None` plays the full sequence.
    /// Events within the region start at `time_beats = 0`.
    #[serde(default)]
    pub loop_region: Option<(usize, usize)>,
    /// Fermata duration multiplier. Values above 1 insert a shared score-wide hold
    /// at the end of the marked note or rest; other sounding notes are sustained and
    /// later events wait. The default is 1.5.
    #[serde(default = "default_fermata_multiplier")]
    pub fermata_multiplier: f64,
    /// Additional beat-domain hold requested after a fermata note. Default 0 keeps legacy
    /// multiplier-only behavior; hosts decide how to realize the resulting silence.
    #[serde(default = "default_fermata_hold_beats")]
    pub fermata_hold_beats: f64,
    /// Swing ratio for aligned pairs of plain notes or rests of [`swing_unit`] duration.
    /// `None` = straight.
    /// `0.67` ≈ triplet swing (2:1). Valid range: (0.5, 1.0).
    /// Applied only when both adjacent rhythmic units match `swing_unit`, with no tuplet or dot.
    #[serde(default)]
    pub swing: Option<f64>,
    /// Note duration that swing is applied to. Defaults to `Duration::Eighth`.
    /// Set to `Duration::Sixteenth` for Latin/funk 16th-note swing.
    #[serde(default = "default_swing_unit")]
    pub swing_unit: Duration,
    /// When `Some`, injects metronome click events into the event list.
    /// Clicks are tagged with `PlaybackEvent.is_metronome = true`.
    #[serde(default)]
    pub metronome: Option<MetronomeConfig>,
    /// Optional realization policy. The default retains authored ornament and arpeggio marks
    /// without synthesizing extra events.
    #[serde(default)]
    pub realization_profile: PlaybackRealizationProfile,
}

impl Default for PlaybackOptions {
    fn default() -> Self {
        Self {
            bpm_override: None,
            tempo_multiplier: 1.0,
            muted_parts: Vec::new(),
            shared_dynamics: Vec::new(),
            shared_hairpins: Vec::new(),
            loop_region: None,
            fermata_multiplier: 1.5,
            fermata_hold_beats: 0.0,
            swing: None,
            swing_unit: Duration::Eighth,
            metronome: None,
            realization_profile: PlaybackRealizationProfile::Authored,
        }
    }
}

fn normalized_tempo_multiplier(options: &PlaybackOptions) -> f64 {
    let multiplier = options.tempo_multiplier;
    if multiplier.is_finite() && multiplier > 0.0 {
        multiplier
    } else {
        1.0
    }
}

fn swingable_rhythm_slot(note: &Note, unit: &Duration) -> bool {
    !note.is_grace
        && !note.is_cue
        && note.tuplet.is_none()
        && note.dot_count == 0
        && note.duration == *unit
}

fn starts_swing_pair(
    notes: &[Note],
    note_index: usize,
    written_beats: f64,
    grid_offset_beats: f64,
    measure_beats: f64,
    unit: &Duration,
) -> bool {
    let Some(first) = notes.get(note_index) else {
        return false;
    };
    let Some(second) = notes.get(note_index + 1) else {
        return false;
    };
    if !swingable_rhythm_slot(first, unit) || !swingable_rhythm_slot(second, unit) {
        return false;
    }
    let pair_beats = first.beats() * 2.0;
    if written_beats + pair_beats > measure_beats + 1e-9 {
        return false;
    }
    let slot = (written_beats + grid_offset_beats) / pair_beats;
    (slot - slot.round()).abs() < 1e-9
}

fn initial_tempo_bpm(score: &Score, options: &PlaybackOptions) -> f64 {
    f64::from(
        options
            .bpm_override
            .unwrap_or(score.settings.tempo_bpm)
            .max(1),
    ) * normalized_tempo_multiplier(options)
}

fn written_tempo_bpm(options: &PlaybackOptions, tempo: u16) -> Option<f64> {
    options
        .bpm_override
        .is_none()
        .then(|| f64::from(tempo.max(1)) * normalized_tempo_multiplier(options))
}

fn written_tempo_ramp_bpm(options: &PlaybackOptions, tempo: Option<u16>) -> Option<f64> {
    options.bpm_override.is_none().then_some(())?;
    tempo.map(|tempo| f64::from(tempo.max(1)) * normalized_tempo_multiplier(options))
}

#[derive(Clone, Copy, Default)]
struct ScoreTempoMark {
    bpm: Option<u16>,
    ramp_to_bpm: Option<u16>,
}

/// Tempo directions are score-wide even when an interchange format places them on one part.
/// Resolve each field from the first staff that writes it, in score order.
fn score_tempo_marks(score: &Score) -> Vec<ScoreTempoMark> {
    let count = score
        .parts
        .iter()
        .flat_map(|part| &part.staves)
        .map(|staff| staff.measures.len())
        .max()
        .unwrap_or(0);
    let mut marks = vec![ScoreTempoMark::default(); count];
    for (index, mark) in marks.iter_mut().enumerate() {
        for part in &score.parts {
            for staff in &part.staves {
                if let Some(measure) = staff.measures.get(index) {
                    mark.bpm = mark.bpm.or(measure.tempo);
                    mark.ramp_to_bpm = mark.ramp_to_bpm.or(measure.tempo_ramp_to);
                }
            }
        }
    }
    marks
}

fn semantic_tempo_bpm(bpm: f64) -> u16 {
    bpm.round().clamp(1.0, f64::from(u16::MAX)) as u16
}

/// A single sounding event suitable for audio playback engines (e.g. Web Audio, Tone.js).
///
/// Grace notes and rests are excluded. Chords are expanded to one event per pitch.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct PlaybackEvent {
    /// Stable source note address (`part:staff:measure:voice:note`), or `None` for metronome events.
    /// Chord pitches share the address of their source note.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub address: Option<String>,
    /// Typed source address for notation hosts; `None` for metronome events.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source: Option<NoteAddr>,
    /// Original MusicXML voice number when the source used a non-default identifier.
    /// `source` remains the stable four-slot canonical address used by editing APIs.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source_voice_number: Option<u32>,
    /// Absolute beat position from the start of the score.
    pub time_beats: f64,
    /// Absolute time in seconds from the start of the score.
    pub time_secs: f64,
    /// MIDI pitch number (0–127).
    pub pitch_midi: u8,
    /// Exact sounding pitch in hundredths of a MIDI semitone.
    ///
    /// `pitch_midi` is retained as a compatibility convenience for integer-MIDI hosts;
    /// microtonal-capable hosts should use this field.
    #[serde(default)]
    pub pitch_midi_cents: i32,
    /// Authored normalized pitch-bend curve for a bend-capable host. Each point is relative to
    /// `pitch_midi_cents` and positioned within this event's sounding duration. Empty means the
    /// event has no authored continuous bend.
    #[serde(default)]
    pub pitch_bend_curve: Vec<GuitarBendPoint>,
    /// Authored pause requested after this note by a breath mark or caesura. The host decides
    /// how to realize the silence while preserving this deterministic beat-domain contract.
    #[serde(default)]
    pub post_note_pause_beats: f64,
    /// Authored articulation and ornament marks for a provider to interpret. The core schedule
    /// deliberately does not invent auxiliary pitches for trill, mordent, or turn.
    #[serde(default)]
    pub articulations: Vec<Articulation>,
    /// Authored chord symbol at this note position. It is a semantic cue for accompaniment or
    /// harmonic playback providers; acorde does not invent accompaniment notes.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub chord_symbol: Option<ChordSymbol>,
    /// Authored guitar playing technique, when present. Providers may map this stable semantic
    /// value to keyswitches or synthesis behavior without score re-parsing.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub guitar_technique: Option<GuitarTechnique>,
    /// MIDI velocity (1–127). Derived from the staff's [`Dynamic`](crate::Dynamic) in force
    /// (see [`DynamicTimeline`]); 64 before the first marking.
    /// Boosted by +20 for Accent / Marcato articulations (clamped to 127).
    pub velocity: u8,
    /// Sounding duration in beats. Halved for Staccato / Staccatissimo.
    pub duration_beats: f64,
    /// Sounding duration in seconds.
    pub duration_secs: f64,
    /// True when the note has `pedal_start` set (sustain pedal down).
    pub pedal: bool,
    /// Index of the part this event originates from (useful for per-channel MIDI routing).
    pub part_index: usize,
    /// MIDI channel of the originating part (`part.midi_channel`). For Tone.js channel routing.
    pub channel: u8,
    /// Effective General MIDI program after applying any measure-local instrument change.
    #[serde(default)]
    pub program: u8,
    /// Stable effective instrument ID when the part or measure declares one.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub instrument_id: Option<String>,
    /// `true` for metronome click events injected via [`MetronomeConfig`].
    #[serde(default)]
    pub is_metronome: bool,
}

/// Version of the host-neutral playback timing comparison contract.
pub const PLAYBACK_COMPARISON_CONTRACT_VERSION: u16 = 2;
/// Maximum number of events accepted by one comparison operation.
pub const MAX_PLAYBACK_COMPARISON_EVENTS: usize = 1_000_000;
const MAX_PLAYBACK_MISMATCHES: usize = 256;
/// Maximum number of projected tablature events retained in one report.
pub const MAX_TAB_PERFORMANCE_EVENTS: usize = 1_000_000;
const MAX_TAB_PERFORMANCE_DIAGNOSTICS: usize = 1_024;

/// Version of the host-neutral offline rendering manifest contract.
pub const OFFLINE_RENDER_CONTRACT_VERSION: u16 = 3;

/// Score material selected for an offline render.  Addresses remain those of the
/// source score even when a view or a range is selected.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "kebab-case")]
pub enum OfflineRenderScope {
    #[default]
    FullScore,
    MeasureRange {
        start: usize,
        end: usize,
    },
    Selection {
        addresses: Vec<NoteAddr>,
    },
}

/// Navigation realization selected by an offline-render request.
#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "kebab-case")]
pub enum OfflineRenderNavigationPolicy {
    /// Follow the score's authored repeats, jumps and endings.
    #[default]
    Authored,
}

/// One event with integer sample-frame boundaries for an offline renderer.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct OfflineRenderFrameEvent {
    pub event: PlaybackEvent,
    pub start_frame: u64,
    pub duration_frames: u64,
    pub end_frame: u64,
}

/// A non-note semantic action expressed on the same sample-frame clock as
/// [`OfflineRenderFrameEvent`].  Audio providers can consume these without
/// reverse-engineering notation from a note schedule.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "kebab-case")]
pub enum OfflineRenderSemanticEventKind {
    /// A measure-local instrument routing change. Providers apply this before
    /// attacks at the same frame rather than inferring it from note events.
    InstrumentChange {
        instrument_id: String,
        channel: u8,
        program: u8,
        transpose_semitones: i8,
    },
    Controller {
        channel: u8,
        controller: u8,
        value: u8,
    },
    /// Signed MIDI 14-bit pitch bend retained from the interchange timeline.
    PitchBend {
        channel: u8,
        value: i16,
    },
    /// MIDI program selection at a canonical score tick.
    ProgramChange {
        channel: u8,
        program: u8,
    },
    /// Channel pressure or key pressure at a canonical score tick.
    Aftertouch {
        channel: u8,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        key: Option<u8>,
        value: u8,
    },
    Tempo {
        bpm: u16,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        ramp_to_bpm: Option<u16>,
    },
    Navigation {
        marker: String,
    },
    Pedal {
        down: bool,
    },
    Articulation {
        articulation: Articulation,
    },
    GuitarBend {
        points: Vec<GuitarBendPoint>,
    },
    /// A semantic release boundary.  It intentionally has no synthesis
    /// parameters: providers decide how a release tail is rendered.
    ReleaseTail,
}

/// A source-addressable non-note action in an offline render manifest.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct OfflineRenderSemanticFrameEvent {
    pub kind: OfflineRenderSemanticEventKind,
    pub frame: u64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source: Option<NoteAddr>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub measure: Option<OfflineRenderMeasureAddress>,
}

/// Stable source location for a measure-scoped offline action.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct OfflineRenderMeasureAddress {
    pub part: usize,
    pub staff: usize,
    pub measure: usize,
}

/// Machine-readable condition observed while deriving an offline schedule.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "kebab-case")]
pub enum OfflineRenderDiagnosticKind {
    /// A selected canonical note address did not yield a sounding event.
    UnresolvedSelectionAddress,
    /// A valid selection contained no sounding events after scheduling.
    EmptySelection,
}

/// Source-located diagnostic for a provider-neutral offline manifest.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct OfflineRenderDiagnostic {
    pub kind: OfflineRenderDiagnosticKind,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source: Option<NoteAddr>,
}

/// Encoded audio format requested from a host-side offline renderer.
///
/// The core does not encode audio; this keeps the requested output explicit in the deterministic
/// schedule handed to the native SF2 renderer, Composer, or another host.
#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize, PartialEq, Eq)]
pub enum OfflineRenderFormat {
    #[default]
    Wav,
    Flac,
    Mp3,
}

/// Host-neutral parameters for an offline render operation.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct OfflineRenderRequest {
    /// Requested encoded format. The host reports unsupported formats explicitly.
    #[serde(default)]
    pub format: OfflineRenderFormat,
    /// PCM sample rate used to convert event seconds to exact sample frames.
    #[serde(default = "default_offline_render_sample_rate")]
    pub sample_rate_hz: u32,
    /// Requested interleaved output channel count.
    #[serde(default = "default_offline_render_channels")]
    pub channels: u8,
    /// Stable name/version of the selected host provider, when already chosen.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub provider_identity: Option<String>,
    /// Stable provider asset identifier (for example a host preset or sample set).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub asset_identity: Option<String>,
    /// Optional linked view to resolve before event scheduling.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub view_id: Option<String>,
    #[serde(default)]
    pub scope: OfflineRenderScope,
    #[serde(default)]
    pub navigation_policy: OfflineRenderNavigationPolicy,
    /// Extra release tail after the final sounding event, in milliseconds.
    #[serde(default)]
    pub release_tail_millis: u32,
    /// Full reproducible playback policy. When omitted, the legacy function
    /// argument is used and copied into the manifest for migration clarity.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub playback_options: Option<PlaybackOptions>,
}

fn default_offline_render_sample_rate() -> u32 {
    48_000
}

fn default_offline_render_channels() -> u8 {
    2
}

impl Default for OfflineRenderRequest {
    fn default() -> Self {
        Self {
            format: OfflineRenderFormat::Wav,
            sample_rate_hz: default_offline_render_sample_rate(),
            channels: default_offline_render_channels(),
            provider_identity: None,
            asset_identity: None,
            view_id: None,
            scope: OfflineRenderScope::FullScore,
            navigation_policy: OfflineRenderNavigationPolicy::Authored,
            release_tail_millis: 0,
            playback_options: None,
        }
    }
}

/// Sample-accurate event schedule for a host-side offline render.
///
/// `duration_frames` is derived from the final event's end time and deliberately excludes codec
/// padding. A host owns synthesis, tail policy, file creation, and encoded bytes.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct OfflineRenderManifest {
    pub contract_version: u16,
    pub playback_contract_version: u16,
    pub format: OfflineRenderFormat,
    pub sample_rate_hz: u32,
    pub channels: u8,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub provider_identity: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub asset_identity: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub view_id: Option<String>,
    #[serde(default)]
    pub scope: OfflineRenderScope,
    #[serde(default)]
    pub navigation_policy: OfflineRenderNavigationPolicy,
    #[serde(default)]
    pub release_tail_frames: u64,
    /// The exact timing policy that produced this manifest.
    #[serde(default)]
    pub playback_options: PlaybackOptions,
    pub duration_frames: u64,
    pub events: Vec<PlaybackEvent>,
    /// Frame-quantized equivalents of `events`; retained alongside the legacy
    /// seconds schedule so v1 clients can migrate without losing semantics.
    #[serde(default)]
    pub frame_events: Vec<OfflineRenderFrameEvent>,
    /// Pedal, articulation, bend and release semantics on the exact output
    /// sample clock.  Note attacks remain in [`Self::frame_events`].
    #[serde(default)]
    pub semantic_events: Vec<OfflineRenderSemanticFrameEvent>,
    #[serde(default)]
    pub diagnostics: Vec<OfflineRenderDiagnostic>,
}

impl OfflineRenderManifest {
    /// Validate a persisted provider-neutral schedule before a host hands it to
    /// a synthesizer. Legacy v1/v2 manifests remain readable; current manifests
    /// additionally require a one-to-one frame schedule for every note event.
    pub fn validate(&self) -> Result<(), crate::Error> {
        if !(1..=OFFLINE_RENDER_CONTRACT_VERSION).contains(&self.contract_version)
            || !(8_000..=384_000).contains(&self.sample_rate_hz)
            || !(1..=8).contains(&self.channels)
            || self.release_tail_frames > self.duration_frames
        {
            return Err(crate::Error::InvalidOfflineRenderRequest);
        }

        if self.contract_version >= 2 && self.frame_events.len() != self.events.len() {
            return Err(crate::Error::InvalidOfflineRenderRequest);
        }
        let mut latest_event_end = 0_u64;
        for (index, frame_event) in self.frame_events.iter().enumerate() {
            let Some(expected_event) = self.events.get(index) else {
                return Err(crate::Error::InvalidOfflineRenderRequest);
            };
            if frame_event.event != *expected_event
                || frame_event
                    .start_frame
                    .checked_add(frame_event.duration_frames)
                    != Some(frame_event.end_frame)
                || frame_event.end_frame > self.duration_frames
            {
                return Err(crate::Error::InvalidOfflineRenderRequest);
            }
            latest_event_end = latest_event_end.max(frame_event.end_frame);
        }
        let latest_semantic_frame = self
            .semantic_events
            .iter()
            .map(|event| event.frame)
            .max()
            .unwrap_or(0);
        if latest_semantic_frame > self.duration_frames {
            return Err(crate::Error::InvalidOfflineRenderRequest);
        }
        if self.contract_version >= 2
            && latest_event_end
                .max(latest_semantic_frame)
                .checked_add(self.release_tail_frames)
                != Some(self.duration_frames)
        {
            return Err(crate::Error::InvalidOfflineRenderRequest);
        }
        Ok(())
    }
}

/// Host-reported result metadata for an [`OfflineRenderManifest`].
///
/// This is a result contract, not proof of audio quality or device-independent equivalence.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct OfflineRenderResult {
    pub contract_version: u16,
    pub format: OfflineRenderFormat,
    pub sample_rate_hz: u32,
    pub channels: u8,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub provider_identity: Option<String>,
    pub duration_frames: u64,
    pub output_bytes: u64,
}

/// A host-side auxiliary send between two logical playback buses.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct PlaybackAuxSend {
    pub source_bus: String,
    pub destination_bus: String,
    /// Gain applied before the destination effect chain, in dB.
    pub gain_db: f64,
}

/// Identifies a host effect attached to a logical bus without carrying provider-specific settings.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct PlaybackEffectRoute {
    pub bus_id: String,
    pub effect_id: String,
    #[serde(default = "default_effect_enabled")]
    pub enabled: bool,
}

fn default_effect_enabled() -> bool {
    true
}

/// Host-neutral routing choices resolved after score playback events are generated.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct PlaybackRoutingConfig {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub provider_identity: Option<String>,
    #[serde(default = "default_master_bus")]
    pub master_bus: String,
    #[serde(default = "default_metronome_bus")]
    pub metronome_bus: String,
    /// Part-index routes, overridden by a matching stable instrument ID.
    #[serde(default)]
    pub part_buses: BTreeMap<usize, String>,
    #[serde(default)]
    pub instrument_buses: BTreeMap<String, String>,
    #[serde(default)]
    pub aux_sends: Vec<PlaybackAuxSend>,
    #[serde(default)]
    pub effect_routes: Vec<PlaybackEffectRoute>,
}

fn default_master_bus() -> String {
    "master".into()
}

fn default_metronome_bus() -> String {
    "metronome".into()
}

impl Default for PlaybackRoutingConfig {
    fn default() -> Self {
        Self {
            provider_identity: None,
            master_bus: default_master_bus(),
            metronome_bus: default_metronome_bus(),
            part_buses: BTreeMap::new(),
            instrument_buses: BTreeMap::new(),
            aux_sends: Vec::new(),
            effect_routes: Vec::new(),
        }
    }
}

/// One unique event source route in a [`PlaybackRoutingManifest`].
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
pub struct PlaybackBusRoute {
    pub part_index: usize,
    pub channel: u8,
    pub program: u8,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub instrument_id: Option<String>,
    pub is_metronome: bool,
    pub bus_id: String,
}

/// Deterministic logical routing graph for score playback events.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct PlaybackRoutingManifest {
    pub contract_version: u16,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub provider_identity: Option<String>,
    pub master_bus: String,
    pub metronome_bus: String,
    pub routes: Vec<PlaybackBusRoute>,
    pub aux_sends: Vec<PlaybackAuxSend>,
    pub effect_routes: Vec<PlaybackEffectRoute>,
}

/// Version of the host-neutral routing manifest contract.
pub const PLAYBACK_ROUTING_CONTRACT_VERSION: u16 = 1;

fn valid_routing_id(value: &str) -> bool {
    !value.is_empty()
        && value.len() <= 64
        && value
            .bytes()
            .all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'.' | b'_' | b'-'))
}

fn validate_playback_routing(config: &PlaybackRoutingConfig) -> Result<(), crate::Error> {
    if !valid_routing_id(&config.master_bus)
        || !valid_routing_id(&config.metronome_bus)
        || config.part_buses.values().any(|bus| !valid_routing_id(bus))
        || config
            .instrument_buses
            .values()
            .any(|bus| !valid_routing_id(bus))
        || config.aux_sends.len() > 64
        || config.effect_routes.len() > 128
    {
        return Err(crate::Error::InvalidPlaybackRouting);
    }
    for send in &config.aux_sends {
        if !valid_routing_id(&send.source_bus)
            || !valid_routing_id(&send.destination_bus)
            || !send.gain_db.is_finite()
            || !(-120.0..=24.0).contains(&send.gain_db)
        {
            return Err(crate::Error::InvalidPlaybackRouting);
        }
    }
    if config
        .effect_routes
        .iter()
        .any(|effect| !valid_routing_id(&effect.bus_id) || !valid_routing_id(&effect.effect_id))
    {
        return Err(crate::Error::InvalidPlaybackRouting);
    }
    Ok(())
}

/// Resolve a bounded, deterministic logical routing graph for a score schedule.
pub fn build_playback_routing_manifest(
    score: &Score,
    playback_options: &PlaybackOptions,
    config: &PlaybackRoutingConfig,
) -> Result<PlaybackRoutingManifest, crate::Error> {
    validate_playback_routing(config)?;
    let events = to_playback_events_bounded(score, playback_options)?;
    let mut routes = BTreeMap::new();
    for event in events {
        let bus_id = if event.is_metronome {
            config.metronome_bus.clone()
        } else if let Some(bus) = event
            .instrument_id
            .as_ref()
            .and_then(|instrument_id| config.instrument_buses.get(instrument_id))
        {
            bus.clone()
        } else if let Some(bus) = config.part_buses.get(&event.part_index) {
            bus.clone()
        } else {
            config.master_bus.clone()
        };
        let route = PlaybackBusRoute {
            part_index: event.part_index,
            channel: event.channel,
            program: event.program,
            instrument_id: event.instrument_id,
            is_metronome: event.is_metronome,
            bus_id,
        };
        routes.insert(route.clone(), route);
    }
    Ok(PlaybackRoutingManifest {
        contract_version: PLAYBACK_ROUTING_CONTRACT_VERSION,
        provider_identity: config.provider_identity.clone(),
        master_bus: config.master_bus.clone(),
        metronome_bus: config.metronome_bus.clone(),
        routes: routes.into_values().collect(),
        aux_sends: config.aux_sends.clone(),
        effect_routes: config.effect_routes.clone(),
    })
}

/// Build a bounded sample-accurate schedule for a host-side offline render.
pub fn build_offline_render_manifest(
    score: &Score,
    playback_options: &PlaybackOptions,
    request: &OfflineRenderRequest,
) -> Result<OfflineRenderManifest, crate::Error> {
    if !(8_000..=384_000).contains(&request.sample_rate_hz) || !(1..=8).contains(&request.channels)
    {
        return Err(crate::Error::InvalidOfflineRenderRequest);
    }
    let resolved_score = match request.view_id.as_deref() {
        Some(view_id) => score.resolve_view(view_id)?,
        None => score.clone(),
    };
    let mut effective_options = request
        .playback_options
        .clone()
        .unwrap_or_else(|| playback_options.clone());
    if let OfflineRenderScope::MeasureRange { start, end } = request.scope {
        if start > end {
            return Err(crate::Error::InvalidOfflineRenderRequest);
        }
        effective_options.loop_region = Some((start, end));
    }
    let mut events = to_playback_events_bounded(&resolved_score, &effective_options)?;
    let mut diagnostics = Vec::new();
    let mut selection_origin_secs = 0.0;
    if let OfflineRenderScope::Selection { ref addresses } = request.scope {
        if addresses.is_empty() {
            return Err(crate::Error::InvalidOfflineRenderRequest);
        }
        for address in addresses {
            if !events
                .iter()
                .any(|event| event.source.as_ref() == Some(address))
            {
                diagnostics.push(OfflineRenderDiagnostic {
                    kind: OfflineRenderDiagnosticKind::UnresolvedSelectionAddress,
                    source: Some(address.clone()),
                });
            }
        }
        events.retain(|event| {
            event
                .source
                .as_ref()
                .is_some_and(|source| addresses.contains(source))
        });
        let origin_secs = events
            .iter()
            .map(|event| event.time_secs)
            .fold(f64::INFINITY, f64::min);
        if origin_secs.is_finite() {
            selection_origin_secs = origin_secs;
            for event in &mut events {
                event.time_secs -= origin_secs;
            }
        }
        if events.is_empty() {
            diagnostics.push(OfflineRenderDiagnostic {
                kind: OfflineRenderDiagnosticKind::EmptySelection,
                source: None,
            });
        }
    }
    let duration_secs = events
        .iter()
        .map(|event| event.time_secs + event.duration_secs)
        .fold(0.0_f64, f64::max);
    if !duration_secs.is_finite() || duration_secs < 0.0 {
        return Err(crate::Error::InvalidOfflineRenderRequest);
    }
    let release_tail_frames =
        (f64::from(request.release_tail_millis) * f64::from(request.sample_rate_hz) / 1_000.0)
            .ceil();
    let duration_frames = (duration_secs * f64::from(request.sample_rate_hz)).ceil();
    if !duration_frames.is_finite() || duration_frames > u64::MAX as f64 {
        return Err(crate::Error::InvalidOfflineRenderRequest);
    }
    if !release_tail_frames.is_finite()
        || release_tail_frames > u64::MAX as f64
        || duration_frames > (u64::MAX as f64 - release_tail_frames)
    {
        return Err(crate::Error::InvalidOfflineRenderRequest);
    }
    let frame_events = events
        .iter()
        .cloned()
        .map(|event| {
            let start_frame = (event.time_secs * f64::from(request.sample_rate_hz)).round() as u64;
            let end_frame = ((event.time_secs + event.duration_secs)
                * f64::from(request.sample_rate_hz))
            .ceil() as u64;
            OfflineRenderFrameEvent {
                duration_frames: end_frame.saturating_sub(start_frame),
                event,
                start_frame,
                end_frame,
            }
        })
        .collect::<Vec<_>>();
    let mut semantic_events = Vec::new();
    for event in &frame_events {
        let source = event.event.source.clone();
        let timed_pedal_at_note = source
            .as_ref()
            .and_then(|address| {
                let measure = resolved_score
                    .parts
                    .get(address.part)?
                    .staves
                    .get(address.staff)?
                    .measures
                    .get(address.measure)?;
                let voice = measure.voices.get(address.voice)?;
                let onset: f64 = voice.iter().take(address.note).map(Note::beats).sum();
                Some(
                    measure
                        .timed_pedals
                        .iter()
                        .any(|pedal| pedal.down && (pedal.position_beats - onset).abs() < 1e-9),
                )
            })
            .unwrap_or(false);
        if event.event.pedal && !timed_pedal_at_note {
            semantic_events.push(OfflineRenderSemanticFrameEvent {
                kind: OfflineRenderSemanticEventKind::Pedal { down: true },
                frame: event.start_frame,
                source: source.clone(),
                measure: None,
            });
        }
        if source.as_ref().is_some_and(|address| {
            resolved_score
                .parts
                .get(address.part)
                .and_then(|part| part.staves.get(address.staff))
                .and_then(|staff| staff.measures.get(address.measure))
                .and_then(|measure| {
                    measure
                        .voices
                        .get(address.voice)
                        .map(|voice| (measure, voice))
                })
                .is_some_and(|(measure, voice)| {
                    let onset: f64 = voice.iter().take(address.note).map(Note::beats).sum();
                    voice.get(address.note).is_some_and(|note| note.pedal_end)
                        && !measure
                            .timed_pedals
                            .iter()
                            .any(|pedal| !pedal.down && (pedal.position_beats - onset).abs() < 1e-9)
                })
        }) {
            semantic_events.push(OfflineRenderSemanticFrameEvent {
                kind: OfflineRenderSemanticEventKind::Pedal { down: false },
                frame: event.start_frame,
                source: source.clone(),
                measure: None,
            });
        }
        for articulation in &event.event.articulations {
            semantic_events.push(OfflineRenderSemanticFrameEvent {
                kind: OfflineRenderSemanticEventKind::Articulation {
                    articulation: articulation.clone(),
                },
                frame: event.start_frame,
                source: source.clone(),
                measure: None,
            });
        }
        if !event.event.pitch_bend_curve.is_empty() {
            semantic_events.push(OfflineRenderSemanticFrameEvent {
                kind: OfflineRenderSemanticEventKind::GuitarBend {
                    points: event.event.pitch_bend_curve.clone(),
                },
                frame: event.start_frame,
                source,
                measure: None,
            });
        }
    }
    append_rest_pedal_events(
        &resolved_score,
        &effective_options,
        request.sample_rate_hz,
        &request.scope,
        selection_origin_secs,
        &mut semantic_events,
    );
    append_measure_semantic_events(
        &resolved_score,
        &effective_options,
        request.sample_rate_hz,
        &request.scope,
        selection_origin_secs,
        &mut semantic_events,
    );
    // Automation can outlive the final sounding note (for example an imported
    // program change on an otherwise silent measure). The manifest duration
    // must retain those actions before adding any host release tail.
    let semantic_end_frame = semantic_events
        .iter()
        .map(|event| event.frame)
        .max()
        .unwrap_or(0);
    let content_duration_frames = (duration_frames as u64).max(semantic_end_frame);
    if release_tail_frames > 0.0 {
        semantic_events.push(OfflineRenderSemanticFrameEvent {
            kind: OfflineRenderSemanticEventKind::ReleaseTail,
            frame: content_duration_frames,
            source: None,
            measure: None,
        });
    }
    let manifest = OfflineRenderManifest {
        contract_version: OFFLINE_RENDER_CONTRACT_VERSION,
        playback_contract_version: PLAYBACK_COMPARISON_CONTRACT_VERSION,
        format: request.format,
        sample_rate_hz: request.sample_rate_hz,
        channels: request.channels,
        provider_identity: request.provider_identity.clone(),
        asset_identity: request.asset_identity.clone(),
        view_id: request.view_id.clone(),
        scope: request.scope.clone(),
        navigation_policy: request.navigation_policy,
        release_tail_frames: release_tail_frames as u64,
        playback_options: effective_options,
        duration_frames: content_duration_frames + release_tail_frames as u64,
        events,
        frame_events,
        semantic_events,
        diagnostics,
    };
    manifest.validate()?;
    Ok(manifest)
}

#[derive(Clone, Copy)]
struct OfflineMeasureTime {
    measure: usize,
    start_secs: f64,
    bpm: f64,
    ramp_to_bpm: Option<f64>,
    beats: f64,
}

/// Notes become frame events, but rests do not. Preserve pedal controls written
/// on rests as independent semantic events on the same repeat/tempo timeline.
fn append_rest_pedal_events(
    score: &Score,
    options: &PlaybackOptions,
    sample_rate_hz: u32,
    scope: &OfflineRenderScope,
    origin_secs: f64,
    events: &mut Vec<OfflineRenderSemanticFrameEvent>,
) {
    let marks = score_tempo_marks(score);
    let holds = score_fermata_holds(score, options);
    let swing = options
        .swing
        .filter(|ratio| ratio.is_finite() && *ratio > 0.5 && *ratio < 1.0);
    for (part_index, part) in score.parts.iter().enumerate() {
        if options.muted_parts.contains(&part_index) {
            continue;
        }
        for (staff_index, staff) in part.staves.iter().enumerate() {
            let timeline = offline_measure_times(score, options, part_index, staff_index, &marks);
            for time in timeline {
                let measure = &staff.measures[time.measure];
                let meter = staff
                    .meter_at(time.measure, &score.settings.time_signature)
                    .total_beats();
                let grid_offset = if time.measure == 0 && time.beats < meter {
                    (meter - time.beats).max(0.0)
                } else {
                    0.0
                };
                for (voice_index, voice) in measure.voices.iter().enumerate() {
                    let mut local = 0.0;
                    let mut written = 0.0;
                    let mut swing_second = false;
                    for (note_index, note) in voice.iter().enumerate() {
                        if note.is_grace || note.is_cue {
                            continue;
                        }
                        let address = NoteAddr {
                            part: part_index,
                            staff: staff_index,
                            measure: time.measure,
                            voice: voice_index,
                            note: note_index,
                        };
                        let selected = match scope {
                            OfflineRenderScope::Selection { addresses } => {
                                addresses.contains(&address)
                            }
                            _ => true,
                        };
                        if note.is_rest && selected && (note.pedal_start || note.pedal_end) {
                            let secs = time.start_secs
                                + tempo_ramp_seconds(time.bpm, time.ramp_to_bpm, time.beats, local);
                            let frame = ((fermata_warp_secs(secs, &holds) - origin_secs).max(0.0)
                                * f64::from(sample_rate_hz))
                            .round() as u64;
                            // At a pedal retake, release before pressing again.
                            for (present, down) in
                                [(note.pedal_end, false), (note.pedal_start, true)]
                            {
                                if present
                                    && !measure.timed_pedals.iter().any(|pedal| {
                                        pedal.down == down
                                            && (pedal.position_beats - written).abs() < 1e-9
                                    })
                                {
                                    events.push(OfflineRenderSemanticFrameEvent {
                                        kind: OfflineRenderSemanticEventKind::Pedal { down },
                                        frame,
                                        source: Some(address.clone()),
                                        measure: None,
                                    });
                                }
                            }
                        }
                        let dur = if let Some(ratio) = swing {
                            if swing_second {
                                swing_second = false;
                                (1.0 - ratio) * note.beats() * 2.0
                            } else if starts_swing_pair(
                                voice,
                                note_index,
                                written,
                                grid_offset,
                                time.beats,
                                &options.swing_unit,
                            ) {
                                swing_second = true;
                                ratio * note.beats() * 2.0
                            } else {
                                note.beats()
                            }
                        } else {
                            note.beats()
                        };
                        written += note.beats();
                        local += dur;
                    }
                }
            }
        }
    }
}

fn offline_measure_times(
    score: &Score,
    options: &PlaybackOptions,
    part: usize,
    staff: usize,
    tempo_marks: &[ScoreTempoMark],
) -> Vec<OfflineMeasureTime> {
    let Some(staff_ref) = score
        .parts
        .get(part)
        .and_then(|part| part.staves.get(staff))
    else {
        return Vec::new();
    };
    let sequence = measure_sequence(score).into_iter().filter(|measure| {
        options
            .loop_region
            .is_none_or(|(start, end)| *measure >= start && *measure <= end)
    });
    let mut bpm = initial_tempo_bpm(score, options);
    let mut secs = 0.0;
    let mut result = Vec::new();
    for measure_index in sequence {
        if staff_ref.measures.get(measure_index).is_none() {
            continue;
        }
        let mark = tempo_marks.get(measure_index).copied().unwrap_or_default();
        if let Some(tempo) = mark.bpm.and_then(|tempo| written_tempo_bpm(options, tempo)) {
            bpm = tempo;
        }
        let beats = score.playback_measure_beats(measure_index);
        let ramp_to_bpm = written_tempo_ramp_bpm(options, mark.ramp_to_bpm);
        result.push(OfflineMeasureTime {
            measure: measure_index,
            start_secs: secs,
            bpm,
            ramp_to_bpm,
            beats,
        });
        secs += tempo_ramp_seconds(bpm, ramp_to_bpm, beats, beats);
        if let Some(end_bpm) = ramp_to_bpm {
            bpm = end_bpm;
        }
    }
    result
}

fn append_measure_semantic_events(
    score: &Score,
    options: &PlaybackOptions,
    sample_rate_hz: u32,
    scope: &OfflineRenderScope,
    origin_secs: f64,
    events: &mut Vec<OfflineRenderSemanticFrameEvent>,
) {
    let tempo_marks = score_tempo_marks(score);
    let holds = score_fermata_holds(score, options);
    for (part_index, part) in score.parts.iter().enumerate() {
        let timeline = offline_measure_times(score, options, part_index, 0, &tempo_marks);
        let Some(staff) = part.staves.first() else {
            continue;
        };
        let mut tick_starts = Vec::with_capacity(staff.measures.len());
        let mut tick = 0u64;
        for measure_index in 0..staff.measures.len() {
            tick_starts.push(tick);
            let beats = score.playback_measure_beats(measure_index);
            tick = tick.saturating_add((beats * 480.0).round() as u64);
        }
        for time in timeline {
            if let OfflineRenderScope::Selection { addresses } = scope
                && !addresses
                    .iter()
                    .any(|address| address.part == part_index && address.measure == time.measure)
            {
                continue;
            }
            let address = OfflineRenderMeasureAddress {
                part: part_index,
                staff: 0,
                measure: time.measure,
            };
            let frame = ((fermata_warp_secs(time.start_secs, &holds) - origin_secs).max(0.0)
                * f64::from(sample_rate_hz))
            .round() as u64;
            let measure = &staff.measures[time.measure];
            let mark = tempo_marks.get(time.measure).copied().unwrap_or_default();
            if part_index == 0
                && options.bpm_override.is_none()
                && (mark.bpm.is_some() || mark.ramp_to_bpm.is_some())
            {
                events.push(OfflineRenderSemanticFrameEvent {
                    kind: OfflineRenderSemanticEventKind::Tempo {
                        bpm: semantic_tempo_bpm(time.bpm),
                        ramp_to_bpm: time.ramp_to_bpm.map(semantic_tempo_bpm),
                    },
                    frame,
                    source: None,
                    measure: Some(address.clone()),
                });
            }
            if part_index == 0
                && let Some(marker) = &measure.navigation
            {
                events.push(OfflineRenderSemanticFrameEvent {
                    kind: OfflineRenderSemanticEventKind::Navigation {
                        marker: marker.clone(),
                    },
                    frame,
                    source: None,
                    measure: Some(address.clone()),
                });
            }
            if let Some(instrument) = &measure.instrument_change {
                events.push(OfflineRenderSemanticFrameEvent {
                    kind: OfflineRenderSemanticEventKind::InstrumentChange {
                        instrument_id: instrument.id.clone(),
                        channel: instrument.midi_channel,
                        program: instrument.midi_program,
                        transpose_semitones: instrument.transpose_semitones,
                    },
                    frame,
                    source: None,
                    measure: Some(address.clone()),
                });
            }
            for (staff_index, event) in part
                .staves
                .iter()
                .enumerate()
                .filter_map(|(staff_index, staff)| {
                    staff
                        .measures
                        .get(time.measure)
                        .map(|measure| (staff_index, measure))
                })
                .flat_map(|(staff_index, measure)| {
                    measure
                        .timed_pedals
                        .iter()
                        .map(move |event| (staff_index, event))
                })
            {
                if !event.position_beats.is_finite()
                    || event.position_beats < 0.0
                    || event.position_beats > time.beats
                {
                    continue;
                }
                let secs = time.start_secs
                    + tempo_ramp_seconds(
                        time.bpm,
                        time.ramp_to_bpm,
                        time.beats,
                        event.position_beats,
                    );
                events.push(OfflineRenderSemanticFrameEvent {
                    kind: OfflineRenderSemanticEventKind::Pedal { down: event.down },
                    frame: ((fermata_warp_secs(secs, &holds) - origin_secs).max(0.0)
                        * f64::from(sample_rate_hz))
                    .round() as u64,
                    source: None,
                    measure: Some(OfflineRenderMeasureAddress {
                        part: part_index,
                        staff: staff_index,
                        measure: time.measure,
                    }),
                });
            }
            let start_tick = tick_starts[time.measure];
            let end_tick = start_tick.saturating_add((time.beats * 480.0).round() as u64);
            for control in &part.midi_control_changes {
                if control.tick < start_tick || control.tick >= end_tick {
                    continue;
                }
                let local_beats = (control.tick - start_tick) as f64 / 480.0;
                let secs = time.start_secs
                    + tempo_ramp_seconds(time.bpm, time.ramp_to_bpm, time.beats, local_beats);
                events.push(OfflineRenderSemanticFrameEvent {
                    kind: OfflineRenderSemanticEventKind::Controller {
                        channel: control.channel,
                        controller: control.controller,
                        value: control.value,
                    },
                    frame: ((fermata_warp_secs(secs, &holds) - origin_secs).max(0.0)
                        * f64::from(sample_rate_hz))
                    .round() as u64,
                    source: None,
                    measure: Some(address.clone()),
                });
            }
            for bend in &part.midi_pitch_bends {
                if bend.tick < start_tick || bend.tick >= end_tick {
                    continue;
                }
                let local_beats = (bend.tick - start_tick) as f64 / 480.0;
                let secs = time.start_secs
                    + tempo_ramp_seconds(time.bpm, time.ramp_to_bpm, time.beats, local_beats);
                events.push(OfflineRenderSemanticFrameEvent {
                    kind: OfflineRenderSemanticEventKind::PitchBend {
                        channel: bend.channel,
                        value: bend.value,
                    },
                    frame: ((fermata_warp_secs(secs, &holds) - origin_secs).max(0.0)
                        * f64::from(sample_rate_hz))
                    .round() as u64,
                    source: None,
                    measure: Some(address.clone()),
                });
            }
            for program in &part.midi_program_changes {
                if program.tick < start_tick || program.tick >= end_tick {
                    continue;
                }
                let local_beats = (program.tick - start_tick) as f64 / 480.0;
                let secs = time.start_secs
                    + tempo_ramp_seconds(time.bpm, time.ramp_to_bpm, time.beats, local_beats);
                events.push(OfflineRenderSemanticFrameEvent {
                    kind: OfflineRenderSemanticEventKind::ProgramChange {
                        channel: program.channel,
                        program: program.program,
                    },
                    frame: ((fermata_warp_secs(secs, &holds) - origin_secs).max(0.0)
                        * f64::from(sample_rate_hz))
                    .round() as u64,
                    source: None,
                    measure: Some(address.clone()),
                });
            }
            for aftertouch in &part.midi_aftertouch {
                if aftertouch.tick < start_tick || aftertouch.tick >= end_tick {
                    continue;
                }
                let local_beats = (aftertouch.tick - start_tick) as f64 / 480.0;
                let secs = time.start_secs
                    + tempo_ramp_seconds(time.bpm, time.ramp_to_bpm, time.beats, local_beats);
                events.push(OfflineRenderSemanticFrameEvent {
                    kind: OfflineRenderSemanticEventKind::Aftertouch {
                        channel: aftertouch.channel,
                        key: aftertouch.key,
                        value: aftertouch.value,
                    },
                    frame: ((fermata_warp_secs(secs, &holds) - origin_secs).max(0.0)
                        * f64::from(sample_rate_hz))
                    .round() as u64,
                    source: None,
                    measure: Some(address.clone()),
                });
            }
        }
    }
    events.sort_by_key(|event| event.frame);
}

/// Timing tolerances for comparing a host/backend event trace with acorde's schedule.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct PlaybackTimingTolerance {
    pub start_secs: f64,
    pub duration_secs: f64,
}

impl Default for PlaybackTimingTolerance {
    fn default() -> Self {
        Self {
            start_secs: 0.005,
            duration_secs: 0.005,
        }
    }
}

/// A typed difference in a host playback trace. Audio rendering is deliberately not compared.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum PlaybackTimingMismatch {
    EventCount { expected: usize, actual: usize },
    EventIdentity { index: usize },
    StartTime { index: usize, error_secs: f64 },
    Duration { index: usize, error_secs: f64 },
}

/// Deterministic report for a bounded playback timing comparison.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct PlaybackTimingReport {
    pub contract_version: u16,
    pub expected_events: usize,
    pub actual_events: usize,
    pub matched_events: usize,
    pub max_start_error_secs: f64,
    pub max_duration_error_secs: f64,
    pub within_tolerance: bool,
    pub mismatches: Vec<PlaybackTimingMismatch>,
}

/// Compare a host-provided event trace with the deterministic score schedule.
///
/// This contract covers event identity and timing only. Web Audio scheduling,
/// SoundFont decoding, device latency, and rendered PCM remain host/provider concerns.
pub fn compare_playback_timing(
    expected: &[PlaybackEvent],
    actual: &[PlaybackEvent],
    tolerance: &PlaybackTimingTolerance,
) -> Result<PlaybackTimingReport, crate::Error> {
    if !tolerance.start_secs.is_finite()
        || tolerance.start_secs < 0.0
        || !tolerance.duration_secs.is_finite()
        || tolerance.duration_secs < 0.0
    {
        return Err(crate::Error::InvalidPlaybackComparison);
    }
    if expected.len() > MAX_PLAYBACK_COMPARISON_EVENTS {
        return Err(crate::Error::PlaybackComparisonTooLarge(expected.len()));
    }
    if actual.len() > MAX_PLAYBACK_COMPARISON_EVENTS {
        return Err(crate::Error::PlaybackComparisonTooLarge(actual.len()));
    }
    let mut mismatches = Vec::new();
    if expected.len() != actual.len() {
        mismatches.push(PlaybackTimingMismatch::EventCount {
            expected: expected.len(),
            actual: actual.len(),
        });
    }
    let mut matched_events = 0;
    let mut max_start_error_secs: f64 = 0.0;
    let mut max_duration_error_secs: f64 = 0.0;
    for (index, (expected_event, actual_event)) in expected.iter().zip(actual).enumerate() {
        let source_identity_matches = match (&expected_event.source, &actual_event.source) {
            (Some(expected), Some(actual)) => expected == actual,
            _ => expected_event.address == actual_event.address,
        };
        let identity_matches = source_identity_matches
            && expected_event.pitch_midi_cents == actual_event.pitch_midi_cents
            && expected_event.velocity == actual_event.velocity
            && expected_event.part_index == actual_event.part_index
            && expected_event.channel == actual_event.channel
            && expected_event.program == actual_event.program
            && expected_event.instrument_id == actual_event.instrument_id
            && expected_event.pitch_bend_curve == actual_event.pitch_bend_curve
            && expected_event.post_note_pause_beats == actual_event.post_note_pause_beats
            && expected_event.articulations == actual_event.articulations
            && expected_event.chord_symbol == actual_event.chord_symbol
            && expected_event.guitar_technique == actual_event.guitar_technique
            && expected_event.is_metronome == actual_event.is_metronome;
        let start_error_secs = (expected_event.time_secs - actual_event.time_secs).abs();
        let duration_error_secs = (expected_event.duration_secs - actual_event.duration_secs).abs();
        if start_error_secs.is_finite() {
            max_start_error_secs = max_start_error_secs.max(start_error_secs);
        }
        if duration_error_secs.is_finite() {
            max_duration_error_secs = max_duration_error_secs.max(duration_error_secs);
        }
        let start_matches =
            start_error_secs.is_finite() && start_error_secs <= tolerance.start_secs;
        let duration_matches =
            duration_error_secs.is_finite() && duration_error_secs <= tolerance.duration_secs;
        if identity_matches && start_matches && duration_matches {
            matched_events += 1;
            continue;
        }
        if mismatches.len() < MAX_PLAYBACK_MISMATCHES {
            if !identity_matches {
                mismatches.push(PlaybackTimingMismatch::EventIdentity { index });
            }
            if !start_matches && mismatches.len() < MAX_PLAYBACK_MISMATCHES {
                mismatches.push(PlaybackTimingMismatch::StartTime {
                    index,
                    error_secs: start_error_secs,
                });
            }
            if !duration_matches && mismatches.len() < MAX_PLAYBACK_MISMATCHES {
                mismatches.push(PlaybackTimingMismatch::Duration {
                    index,
                    error_secs: duration_error_secs,
                });
            }
        }
    }
    Ok(PlaybackTimingReport {
        contract_version: PLAYBACK_COMPARISON_CONTRACT_VERSION,
        expected_events: expected.len(),
        actual_events: actual.len(),
        matched_events,
        max_start_error_secs,
        max_duration_error_secs,
        within_tolerance: mismatches.is_empty(),
        mismatches,
    })
}

/// Version of the score-schedule timing corpus contract.
pub const PLAYBACK_TIMING_CORPUS_CONTRACT_VERSION: u16 = 1;
const MAX_PLAYBACK_TIMING_CORPUS_CASES: usize = 256;

/// One score-backed timing case, independent from an audio synthesis backend.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PlaybackTimingCase {
    pub id: String,
    pub score: Score,
    #[serde(default)]
    pub options: PlaybackOptions,
    pub expected_events: Vec<PlaybackEvent>,
    #[serde(default)]
    pub tolerance: PlaybackTimingTolerance,
}

/// Result for one [`PlaybackTimingCase`].
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct PlaybackTimingCaseReport {
    pub id: String,
    pub report: PlaybackTimingReport,
}

/// Deterministic aggregate result for a score-schedule timing corpus.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct PlaybackTimingCorpusReport {
    pub contract_version: u16,
    pub total_cases: usize,
    pub passed_cases: usize,
    pub cases: Vec<PlaybackTimingCaseReport>,
}

/// Compare score-generated schedules against a bounded corpus of expected event traces.
///
/// The corpus verifies notation-to-event semantics only. It makes no assertion about synthesized
/// PCM, codec output, browser scheduling, or real-time device latency.
pub fn evaluate_playback_timing_corpus(
    cases: &[PlaybackTimingCase],
) -> Result<PlaybackTimingCorpusReport, crate::Error> {
    if cases.is_empty() || cases.len() > MAX_PLAYBACK_TIMING_CORPUS_CASES {
        return Err(crate::Error::InvalidPlaybackTimingCorpus);
    }
    let mut ids = BTreeSet::new();
    let mut reports = Vec::with_capacity(cases.len());
    let mut passed_cases = 0;
    for case in cases {
        if !valid_routing_id(&case.id) || !ids.insert(case.id.clone()) {
            return Err(crate::Error::InvalidPlaybackTimingCorpus);
        }
        let actual = to_playback_events_bounded(&case.score, &case.options)?;
        let report = compare_playback_timing(&case.expected_events, &actual, &case.tolerance)?;
        if report.within_tolerance {
            passed_cases += 1;
        }
        reports.push(PlaybackTimingCaseReport {
            id: case.id.clone(),
            report,
        });
    }
    Ok(PlaybackTimingCorpusReport {
        contract_version: PLAYBACK_TIMING_CORPUS_CONTRACT_VERSION,
        total_cases: cases.len(),
        passed_cases,
        cases: reports,
    })
}

/// Version of the host-neutral tablature performance projection contract.
pub const TAB_PERFORMANCE_CONTRACT_VERSION: u16 = 4;

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct TablaturePerformanceEvent {
    pub playback: PlaybackEvent,
    pub string: u8,
    pub fret: u8,
    /// Authored guitar technique for the host playback adapter, when present.
    #[serde(default)]
    pub technique: Option<GuitarTechnique>,
    /// Authored bend alteration in cents, when the technique is `Bend`.
    #[serde(default)]
    pub bend_alter_cents: Option<i16>,
    /// Normalized bend/hold/release curve for a bend-capable host. Positions are per-mille of
    /// this event's sounding duration and values are cents relative to the written pitch.
    #[serde(default)]
    pub bend_curve: Vec<GuitarBendPoint>,
    pub expected_pitch_midi_cents: i32,
    pub pitch_error_cents: i32,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum TablaturePerformanceDiagnostic {
    NoTablatureStaff {
        address: String,
    },
    MissingPosition {
        address: String,
        pitch_index: usize,
    },
    StringOutOfRange {
        address: String,
        string: u8,
        lines: u8,
    },
    TuningUnavailable {
        address: String,
        string: u8,
    },
    PitchMismatch {
        address: String,
        pitch_index: usize,
        error_cents: i32,
    },
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct TablaturePerformanceReport {
    pub contract_version: u16,
    pub events: Vec<TablaturePerformanceEvent>,
    pub diagnostics: Vec<TablaturePerformanceDiagnostic>,
}

/// Version of the score-model tablature round-trip diagnostic contract.
pub const TAB_ROUND_TRIP_CONTRACT_VERSION: u16 = 1;

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct TablatureRoundTripReport {
    pub contract_version: u16,
    pub checked_notes: usize,
    pub positioned_notes: usize,
    pub equivalent: bool,
    pub diagnostics: Vec<TablatureRoundTripDiagnostic>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum TablatureRoundTripDiagnostic {
    StructureMismatch {
        address: String,
    },
    TablatureConfigMismatch {
        address: String,
    },
    PositionMismatch {
        address: String,
        pitch_index: usize,
        expected: Option<TabPosition>,
        actual: Option<TabPosition>,
    },
}

/// Verify that authored tablature survives the canonical score JSON round-trip.
///
/// This checks score-model persistence only. It does not claim MusicXML/MSCX or external
/// application equivalence; those format and host comparisons remain separate gates.
pub fn tablature_round_trip_report(
    score: &Score,
) -> Result<TablatureRoundTripReport, crate::Error> {
    let encoded = serde_json::to_string(score)
        .map_err(|error| crate::Error::TabRoundTripSerialization(error.to_string()))?;
    let restored: Score = serde_json::from_str(&encoded)
        .map_err(|error| crate::Error::TabRoundTripSerialization(error.to_string()))?;
    let mut checked_notes = 0;
    let mut positioned_notes = 0;
    let mut diagnostics = Vec::new();
    for (part_index, part) in score.parts.iter().enumerate() {
        let Some(restored_part) = restored.parts.get(part_index) else {
            diagnostics.push(TablatureRoundTripDiagnostic::StructureMismatch {
                address: format!("{part_index}"),
            });
            continue;
        };
        for (staff_index, staff) in part.staves.iter().enumerate() {
            let address = format!("{part_index}:{staff_index}");
            let Some(restored_staff) = restored_part.staves.get(staff_index) else {
                diagnostics.push(TablatureRoundTripDiagnostic::StructureMismatch { address });
                continue;
            };
            if staff.tablature != restored_staff.tablature {
                diagnostics.push(TablatureRoundTripDiagnostic::TablatureConfigMismatch {
                    address: address.clone(),
                });
            }
            for (measure_index, measure) in staff.measures.iter().enumerate() {
                let Some(restored_measure) = restored_staff.measures.get(measure_index) else {
                    diagnostics.push(TablatureRoundTripDiagnostic::StructureMismatch {
                        address: format!("{address}:{measure_index}"),
                    });
                    continue;
                };
                for (voice_index, voice) in measure.voices.iter().enumerate() {
                    let Some(restored_voice) = restored_measure.voices.get(voice_index) else {
                        diagnostics.push(TablatureRoundTripDiagnostic::StructureMismatch {
                            address: format!("{address}:{measure_index}:{voice_index}"),
                        });
                        continue;
                    };
                    for (note_index, note) in voice.iter().enumerate() {
                        checked_notes += 1;
                        if !note.tab_positions.is_empty() || note.tab_position.is_some() {
                            positioned_notes += 1;
                        }
                        let note_address =
                            format!("{address}:{measure_index}:{voice_index}:{note_index}");
                        let Some(restored_note) = restored_voice.get(note_index) else {
                            diagnostics.push(TablatureRoundTripDiagnostic::StructureMismatch {
                                address: note_address,
                            });
                            continue;
                        };
                        let pitch_count = note.pitches.len().max(note.tab_positions.len()).max(1);
                        for pitch_index in 0..pitch_count {
                            let expected = note
                                .tab_positions
                                .get(pitch_index)
                                .cloned()
                                .or_else(|| note.tab_position.clone());
                            let actual = restored_note
                                .tab_positions
                                .get(pitch_index)
                                .cloned()
                                .or_else(|| restored_note.tab_position.clone());
                            if expected != actual {
                                diagnostics.push(TablatureRoundTripDiagnostic::PositionMismatch {
                                    address: note_address.clone(),
                                    pitch_index,
                                    expected,
                                    actual,
                                });
                            }
                        }
                    }
                }
            }
        }
    }
    Ok(TablatureRoundTripReport {
        contract_version: TAB_ROUND_TRIP_CONTRACT_VERSION,
        checked_notes,
        positioned_notes,
        equivalent: diagnostics.is_empty(),
        diagnostics,
    })
}

/// Project score playback events onto authored tablature positions.
///
/// This operation never invents a string or fret. Callers may run
/// [`assign_tablature_positions`](crate::assign_tablature_positions) before this
/// projection when automatic positions are desired.
pub fn project_tablature_performance(
    score: &Score,
    options: &PlaybackOptions,
) -> Result<TablaturePerformanceReport, crate::Error> {
    let playback = to_playback_events(score, options);
    if playback.len() > MAX_TAB_PERFORMANCE_EVENTS {
        return Err(crate::Error::TabPerformanceTooLarge(playback.len()));
    }
    let mut events = Vec::new();
    let mut diagnostics = Vec::new();
    for event in playback {
        let Some(address) = event.address.as_deref() else {
            continue;
        };
        let Some((part_index, staff_index, measure_index, voice_index, note_index)) =
            parse_playback_address(address)
        else {
            continue;
        };
        let Some(staff) = score
            .parts
            .get(part_index)
            .and_then(|part| part.staves.get(staff_index))
        else {
            continue;
        };
        let Some(note) = staff
            .measures
            .get(measure_index)
            .and_then(|measure| measure.voices.get(voice_index))
            .and_then(|voice| voice.get(note_index))
        else {
            continue;
        };
        let Some(tab) = staff.tablature_at(measure_index) else {
            push_tab_diagnostic(
                &mut diagnostics,
                TablaturePerformanceDiagnostic::NoTablatureStaff {
                    address: address.into(),
                },
            );
            continue;
        };
        let transpose_cents = if event.channel == 9 {
            0
        } else {
            i32::from(staff.transpose_semitones) * 100
        };
        let written_pitch_cents = event.pitch_midi_cents - transpose_cents;
        let pitch_index = note
            .pitches
            .iter()
            .position(|pitch| pitch.to_midi_cents() == written_pitch_cents)
            .unwrap_or(0);
        let position = note
            .tab_positions
            .get(pitch_index)
            .or(note.tab_position.as_ref());
        let Some(position) = position else {
            push_tab_diagnostic(
                &mut diagnostics,
                TablaturePerformanceDiagnostic::MissingPosition {
                    address: address.into(),
                    pitch_index,
                },
            );
            continue;
        };
        if position.string == 0 || position.string > tab.lines {
            push_tab_diagnostic(
                &mut diagnostics,
                TablaturePerformanceDiagnostic::StringOutOfRange {
                    address: address.into(),
                    string: position.string,
                    lines: tab.lines,
                },
            );
            continue;
        }
        let Some(tuning) = tab.tuning_midi.get(usize::from(position.string - 1)) else {
            push_tab_diagnostic(
                &mut diagnostics,
                TablaturePerformanceDiagnostic::TuningUnavailable {
                    address: address.into(),
                    string: position.string,
                },
            );
            continue;
        };
        let expected_pitch_midi_cents =
            tuning.saturating_add(i16::from(position.fret) + i16::from(tab.capo)) as i32 * 100;
        let pitch_error_cents = event.pitch_midi_cents - expected_pitch_midi_cents;
        if pitch_error_cents != 0 {
            push_tab_diagnostic(
                &mut diagnostics,
                TablaturePerformanceDiagnostic::PitchMismatch {
                    address: address.into(),
                    pitch_index,
                    error_cents: pitch_error_cents,
                },
            );
        }
        events.push(TablaturePerformanceEvent {
            playback: event,
            string: position.string,
            fret: position.fret,
            technique: note.guitar_technique.clone(),
            bend_alter_cents: note.guitar_bend_alter_cents,
            bend_curve: note.guitar_bend_curve.clone(),
            expected_pitch_midi_cents,
            pitch_error_cents,
        });
    }
    Ok(TablaturePerformanceReport {
        contract_version: TAB_PERFORMANCE_CONTRACT_VERSION,
        events,
        diagnostics,
    })
}

fn parse_playback_address(address: &str) -> Option<(usize, usize, usize, usize, usize)> {
    let mut fields = address.split(':').map(|field| field.parse::<usize>().ok());
    Some((
        fields.next()??,
        fields.next()??,
        fields.next()??,
        fields.next()??,
        fields.next()??,
    ))
}

fn push_tab_diagnostic(
    diagnostics: &mut Vec<TablaturePerformanceDiagnostic>,
    diagnostic: TablaturePerformanceDiagnostic,
) {
    if diagnostics.len() < MAX_TAB_PERFORMANCE_DIAGNOSTICS {
        diagnostics.push(diagnostic);
    }
}

type ExpressionKey = (usize, usize, usize, usize, usize);

fn expression_key(address: &NoteAddr) -> ExpressionKey {
    (
        address.part,
        address.staff,
        address.measure,
        address.voice,
        address.note,
    )
}

/// Dynamic levels of one staff along a played measure order, so a marking carries on until
/// the next one as in engraved music: a level (p, f, …) holds, an accent (sf, sfz, fz, rfz,
/// sffz) lifts only its own moment, and a compound (fp, sfp, pf, …) attacks at the first
/// level and continues at the second. A hairpin ramps the level across its notes towards the
/// marking that follows it (or two dynamic steps up or down when none follows at once) and
/// leaves the level there. Before the first marking notes play at velocity 64.
#[derive(Debug, Clone, Default)]
pub struct DynamicTimeline {
    /// Start of each position of the order, in beats from the start.
    position_beats: Vec<f64>,
    /// (time, attack, level after), in time order.
    changes: Vec<(f64, u8, u8)>,
    /// Hairpins as (start, end, from velocity, to velocity).
    ramps: Vec<(f64, f64, u8, u8)>,
}

/// One dynamic event on a staff timeline: a written marking or the level a hairpin reaches.
#[derive(Clone, Copy)]
enum DynamicMark {
    Marking(crate::Dynamic, bool),
    Level(u8, bool),
}

fn mark_priority(mark: DynamicMark) -> u8 {
    match mark {
        DynamicMark::Level(_, false) => 0,
        DynamicMark::Level(_, true) => 1,
        DynamicMark::Marking(_, false) => 2,
        DynamicMark::Marking(_, true) => 3,
    }
}

// Group near-equal times using the timeline tolerance and keep explicit/local
// events after shared/synthetic events within each simultaneous group.
fn order_dynamic_marks(marks: &mut [(f64, DynamicMark)]) {
    marks.sort_by(|a, b| a.0.total_cmp(&b.0));
    let mut group_start = 0;
    while group_start < marks.len() {
        let time = marks[group_start].0;
        let mut group_end = group_start + 1;
        while group_end < marks.len() && marks[group_end].0 <= time + 1e-9 {
            group_end += 1;
        }
        for mark in &mut marks[group_start..group_end] {
            mark.0 = time;
        }
        marks[group_start..group_end].sort_by_key(|(_, mark)| mark_priority(*mark));
        group_start = group_end;
    }
}

impl DynamicTimeline {
    /// Velocity of a note before any dynamic marking.
    pub const DEFAULT_VELOCITY: u8 = 64;
    /// How far a hairpin moves the level when no marking follows it (two dynamic steps).
    const HAIRPIN_STEP: i16 = 24;

    /// Collect the markings and hairpins of every voice of `staff` along `order` (measure
    /// indices as played, repeats expanded). Grace and cue notes take no time.
    pub fn for_staff(staff: &crate::Staff, order: &[usize]) -> Self {
        Self::for_staves(std::slice::from_ref(staff), order, None, None)
    }

    fn for_staves(
        staves: &[crate::Staff],
        order: &[usize],
        measure_lengths: Option<&[f64]>,
        shared: Option<(
            usize,
            usize,
            &BTreeSet<ExpressionKey>,
            &BTreeSet<ExpressionKey>,
        )>,
    ) -> Self {
        let mut position_beats = Vec::with_capacity(order.len());
        let mut marks: Vec<(f64, DynamicMark)> = Vec::new();
        let mut hairpins: Vec<(f64, f64, bool, bool)> = Vec::new();
        // Identical voice numbers in different staves are independent span owners.
        let mut open_hairpins = vec![[None; 4]; staves.len()];
        let mut elapsed = 0.0;
        for &measure_index in order {
            position_beats.push(elapsed);
            let mut length: f64 = 0.0;
            for (staff_index, staff) in staves.iter().enumerate() {
                let Some(measure) = staff.measures.get(measure_index) else {
                    continue;
                };
                for (voice_index, voice) in measure.voices.iter().enumerate() {
                    let mut beats = 0.0;
                    for (note_index, note) in voice.iter().enumerate() {
                        let onset = elapsed + beats;
                        let local = shared.is_none_or(|(_, target, _, _)| staff_index == target);
                        let key = shared.map(|(part, _, _, _)| {
                            (part, staff_index, measure_index, voice_index, note_index)
                        });
                        let shared_dynamic = shared.is_some_and(|(_, _, dynamics, _)| {
                            key.is_some_and(|key| dynamics.contains(&key))
                        });
                        let shared_hairpin = shared.is_some_and(|(_, _, _, hairpins)| {
                            key.is_some_and(|key| hairpins.contains(&key))
                        });
                        if (local || shared_dynamic)
                            && let Some(dynamic) = note.dynamic
                            && !note.is_rest
                        {
                            marks.push((onset, DynamicMark::Marking(dynamic, local)));
                        }
                        let end = onset + note.beats();
                        let slot = &mut open_hairpins[staff_index][voice_index];
                        let ends_earlier = note.hairpin_end && slot.is_some();
                        if ends_earlier && let Some((start, up, source_local)) = slot.take() {
                            hairpins.push((start, end, up, source_local));
                        }
                        if (local || shared_hairpin)
                            && let Some(kind) = note.hairpin_start
                        {
                            *slot = Some((onset, kind == crate::HairpinKind::Crescendo, local));
                        }
                        if note.hairpin_end
                            && !ends_earlier
                            && let Some((start, up, source_local)) = slot.take()
                        {
                            hairpins.push((start, end, up, source_local));
                        }
                        beats += note.beats();
                    }
                    length = length.max(beats);
                }
            }
            elapsed += measure_lengths
                .and_then(|values| values.get(measure_index))
                .copied()
                .unwrap_or(length);
        }
        order_dynamic_marks(&mut marks);
        let written = Self::resolve(&marks);
        let mut ramps = Vec::new();
        // A staff-local hairpin wins over an overlapping shared hairpin.
        hairpins.sort_by_key(|(_, _, _, local)| *local);
        for (start, end, up, local) in hairpins {
            if end <= start {
                continue;
            }
            let from = Self::level_at(&written, start);
            // The marking the hairpin leads to, if one comes within a beat of its end.
            let first = written.partition_point(|&(time, _, _)| time < end - 1e-9);
            let next = written
                .get(first)
                .and_then(|&(time, _, _)| {
                    if time > end + 1.0 {
                        return None;
                    }
                    let last = written
                        .partition_point(|&(other, _, _)| other <= time + 1e-9)
                        .saturating_sub(1);
                    written.get(last).map(|&(_, attack, _)| attack)
                })
                .filter(|&attack| if up { attack > from } else { attack < from });
            let to = next.unwrap_or_else(|| {
                let step = if up {
                    Self::HAIRPIN_STEP
                } else {
                    -Self::HAIRPIN_STEP
                };
                (i16::from(from) + step).clamp(1, 127) as u8
            });
            if next.is_none() {
                marks.push((end, DynamicMark::Level(to, local)));
            }
            ramps.push((start, end, from, to));
        }
        // Written marks override synthetic endpoints at the same score time.
        order_dynamic_marks(&mut marks);
        Self {
            position_beats,
            changes: Self::resolve(&marks),
            ramps,
        }
    }

    fn resolve(marks: &[(f64, DynamicMark)]) -> Vec<(f64, u8, u8)> {
        let mut level = Self::DEFAULT_VELOCITY;
        marks
            .iter()
            .map(|&(time, mark)| match mark {
                DynamicMark::Marking(dynamic, _) => {
                    if let Some(next) = dynamic.sustained_level() {
                        level = next.to_velocity();
                    }
                    (time, dynamic.to_velocity(), level)
                }
                DynamicMark::Level(velocity, _) => {
                    level = velocity;
                    (time, velocity, level)
                }
            })
            .collect()
    }

    fn level_at(changes: &[(f64, u8, u8)], time: f64) -> u8 {
        let before = changes.partition_point(|&(t, _, _)| t <= time + 1e-9);
        before
            .checked_sub(1)
            .map_or(Self::DEFAULT_VELOCITY, |index| changes[index].2)
    }

    /// Velocity of a note at `beats` into the measure at `position` of the order: its own
    /// marking's attack, the attack of a marking at the same moment in another voice, the
    /// point a hairpin has reached, or the level in force.
    pub fn velocity(&self, position: usize, beats: f64, own: Option<crate::Dynamic>) -> u8 {
        if let Some(dynamic) = own {
            return dynamic.to_velocity();
        }
        let time = self.position_beats.get(position).copied().unwrap_or(0.0) + beats;
        let before = self.changes.partition_point(|&(t, _, _)| t <= time + 1e-9);
        let current = before.checked_sub(1).map(|index| self.changes[index]);
        if let Some((t, attack, _)) = current
            && (t - time).abs() <= 1e-9
        {
            return attack;
        }
        if let Some(&(start, end, from, to)) = self
            .ramps
            .iter()
            .rev()
            .find(|&&(start, end, _, _)| start <= time + 1e-9 && time < end - 1e-9)
        {
            let fraction = ((time - start) / (end - start)).clamp(0.0, 1.0);
            let value = f64::from(from) + (f64::from(to) - f64::from(from)) * fraction;
            return value.round().clamp(1.0, 127.0) as u8;
        }
        current.map_or(Self::DEFAULT_VELOCITY, |(_, _, level)| level)
    }
}

/// Convert a [`Score`] into a flat, time-ordered list of [`PlaybackEvent`]s.
///
/// All parts, staves, and voices are included unless excluded via [`PlaybackOptions`].
/// Repeat sections and volta brackets are expanded using [`measure_sequence`].
/// Events are sorted by `time_beats`.
pub fn to_playback_events(score: &Score, options: &PlaybackOptions) -> Vec<PlaybackEvent> {
    // A pedal held only as a typed spanner still presses the pedal on its first note.
    let materialized = score.with_legacy_spanner_flags();
    let score: &Score = &materialized;
    let bpm = initial_tempo_bpm(score, options);
    let tempo_marks = score_tempo_marks(score);
    let measure_lengths: Vec<f64> = (0..tempo_marks.len())
        .map(|index| score.playback_measure_beats(index))
        .collect();
    let mut measure_tick_starts = Vec::with_capacity(measure_lengths.len());
    let mut next_tick = 0_u64;
    for beats in &measure_lengths {
        measure_tick_starts.push(next_tick);
        next_tick = next_tick.saturating_add((beats * 480.0).round() as u64);
    }
    let swing_ratio = options
        .swing
        .filter(|ratio| ratio.is_finite() && *ratio > 0.5 && *ratio < 1.0);
    let full_seq = measure_sequence(score);
    let seq: Vec<usize> = if let Some((lo, hi)) = options.loop_region {
        full_seq
            .iter()
            .copied()
            .filter(|&idx| idx >= lo && idx <= hi)
            .collect()
    } else {
        full_seq.clone()
    };
    let mut events: Vec<PlaybackEvent> = Vec::new();

    for (part_index, part) in score.parts.iter().enumerate() {
        if options.muted_parts.contains(&part_index) {
            continue;
        }
        let selected_note = |address: &NoteAddr| {
            (address.part == part_index).then_some(())?;
            part.staves
                .get(address.staff)?
                .measures
                .get(address.measure)?
                .voices
                .get(address.voice)?
                .get(address.note)
        };
        let shared_dynamic_keys: BTreeSet<ExpressionKey> = options
            .shared_dynamics
            .iter()
            .filter(|address| {
                selected_note(address).is_some_and(|note| !note.is_rest && note.dynamic.is_some())
            })
            .map(expression_key)
            .collect();
        let shared_hairpin_keys: BTreeSet<ExpressionKey> = options
            .shared_hairpins
            .iter()
            .filter(|address| {
                selected_note(address).is_some_and(|note| note.hairpin_start.is_some())
            })
            .map(expression_key)
            .collect();
        for (staff_index, staff) in part.staves.iter().enumerate() {
            let has_shared_foreign = shared_dynamic_keys
                .iter()
                .chain(&shared_hairpin_keys)
                .any(|key| key.1 != staff_index);
            let dynamics = if !has_shared_foreign {
                DynamicTimeline::for_staff(staff, &seq)
            } else {
                DynamicTimeline::for_staves(
                    &part.staves,
                    &seq,
                    Some(&measure_lengths),
                    Some((
                        part_index,
                        staff_index,
                        &shared_dynamic_keys,
                        &shared_hairpin_keys,
                    )),
                )
            };
            for voice_idx in 0..4usize {
                let mut time_beats = 0.0f64;
                let mut time_secs_cursor = 0.0f64;
                let mut current_bpm = bpm;
                let mut prior_note_events = 0..0;
                // Reconstruct channel state along the played prefix when playback starts
                // inside a selection, including repeats and skipped endings.
                let mut active_named_channel = None;
                if let Some(&first) = seq.first() {
                    for &idx in full_seq.iter().take_while(|&&idx| idx != first) {
                        if let Some(measure) = staff.measures.get(idx) {
                            let mut switches: Vec<_> = measure
                                .channel_switches
                                .iter()
                                .filter(|switch| {
                                    switch.voice == voice_idx && switch.position_beats.is_finite()
                                })
                                .collect();
                            switches.sort_by(|a, b| a.position_beats.total_cmp(&b.position_beats));
                            for switch in switches {
                                if let Some(channel) = part
                                    .named_channels
                                    .iter()
                                    .find(|channel| channel.name == switch.channel_name)
                                {
                                    active_named_channel = Some(channel);
                                }
                            }
                        }
                    }
                }
                for (seq_position, &idx) in seq.iter().enumerate() {
                    let measure = match staff.measures.get(idx) {
                        Some(m) => m,
                        None => continue,
                    };
                    let instrument = measure
                        .instrument_change
                        .as_ref()
                        .or(part.instrument.as_ref());
                    let base_channel =
                        instrument.map_or(part.midi_channel, |value| value.midi_channel);
                    let default_program =
                        instrument.map_or(part.midi_program, |value| value.midi_program);
                    let instrument_id = instrument.map(|value| value.id.clone());
                    let mark = tempo_marks.get(idx).copied().unwrap_or_default();
                    if let Some(b) = mark.bpm.and_then(|tempo| written_tempo_bpm(options, tempo)) {
                        current_bpm = b;
                    }
                    let measure_beats = measure_lengths[idx];
                    let grid_offset_beats = if idx == 0
                        && measure_beats
                            < staff
                                .meter_at(idx, &score.settings.time_signature)
                                .total_beats()
                    {
                        (staff
                            .meter_at(idx, &score.settings.time_signature)
                            .total_beats()
                            - measure_beats)
                            .max(0.0)
                    } else {
                        0.0
                    };
                    let ramp_end_bpm = written_tempo_ramp_bpm(options, mark.ramp_to_bpm);
                    let measure_start_beats = time_beats;
                    let measure_start_secs = time_secs_cursor;
                    let mut local_beats = 0.0f64;
                    // Unswung position, which dynamic markings are keyed by.
                    let mut written_beats = 0.0f64;
                    let mut swing_second = false;
                    let mut switches: Vec<_> = measure
                        .channel_switches
                        .iter()
                        .filter(|switch| {
                            switch.voice == voice_idx && switch.position_beats.is_finite()
                        })
                        .collect();
                    switches.sort_by(|a, b| a.position_beats.total_cmp(&b.position_beats));
                    let mut next_switch = 0;
                    for (note_index, note) in measure.voices[voice_idx].iter().enumerate() {
                        if note.is_grace || note.is_cue {
                            continue;
                        }
                        let onset_written_beats = written_beats;
                        while let Some(switch) = switches
                            .get(next_switch)
                            .filter(|switch| switch.position_beats <= onset_written_beats + 1e-9)
                        {
                            if let Some(channel) = part
                                .named_channels
                                .iter()
                                .find(|channel| channel.name == switch.channel_name)
                            {
                                active_named_channel = Some(channel);
                            }
                            next_switch += 1;
                        }
                        let channel =
                            active_named_channel.map_or(base_channel, |value| value.midi_channel);
                        written_beats += note.beats();
                        let dur = if let Some(ratio) = swing_ratio {
                            if swing_second {
                                swing_second = false;
                                (1.0 - ratio) * note.beats() * 2.0
                            } else if starts_swing_pair(
                                &measure.voices[voice_idx],
                                note_index,
                                onset_written_beats,
                                grid_offset_beats,
                                measure_beats,
                                &options.swing_unit,
                            ) {
                                swing_second = true;
                                ratio * note.beats() * 2.0
                            } else {
                                note.beats()
                            }
                        } else {
                            note.beats()
                        };
                        if !note.is_rest {
                            // MIDI program changes are keyed to the source's physical tick
                            // timeline. Use the written onset, so opt-in swing does not move a
                            // change across the note it belongs to.
                            let source_tick = measure_tick_starts[idx]
                                .saturating_add((onset_written_beats * 480.0).round() as u64);
                            let mut program = default_program;
                            let mut latest_change_tick = 0_u64;
                            for change in &part.midi_program_changes {
                                if change.channel == channel
                                    && change.tick <= source_tick
                                    && change.tick >= latest_change_tick
                                {
                                    program = change.program;
                                    latest_change_tick = change.tick;
                                }
                            }
                            if let Some(named) = active_named_channel {
                                program = named.program;
                            }
                            let mut velocity =
                                dynamics.velocity(seq_position, onset_written_beats, note.dynamic);
                            let mut sounding_dur = dur;
                            for art in &note.articulations {
                                match art {
                                    Articulation::Staccato | Articulation::Staccatissimo => {
                                        sounding_dur *= 0.5;
                                    }
                                    Articulation::Accent | Articulation::Marcato => {
                                        velocity = velocity.saturating_add(20).min(127);
                                    }
                                    // Extensions are applied score-wide after tie resolution.
                                    // Values below one retain their existing shortening behavior.
                                    Articulation::Fermata
                                        if options.fermata_multiplier.is_finite()
                                            && options.fermata_multiplier < 1.0 =>
                                    {
                                        sounding_dur *= options.fermata_multiplier.max(0.0);
                                    }
                                    _ => {}
                                }
                            }
                            // Keep the legacy note-on hint when an independent pedal-down
                            // happens exactly at this note's written onset.
                            let pedal = note.pedal_start
                                || measure.timed_pedals.iter().any(|pedal| {
                                    pedal.down
                                        && (pedal.position_beats - onset_written_beats).abs() < 1e-9
                                });
                            let fermata_hold_beats = if options.fermata_hold_beats.is_finite() {
                                options.fermata_hold_beats.max(0.0)
                            } else {
                                0.0
                            };
                            let post_note_pause_beats =
                                note.articulations
                                    .iter()
                                    .fold(0.0f64, |pause, articulation| {
                                        pause.max(match articulation {
                                            Articulation::BreathMark => 0.25,
                                            Articulation::Caesura => 0.5,
                                            Articulation::Fermata => fermata_hold_beats,
                                            _ => 0.0,
                                        })
                                    });
                            let transpose = if channel == 9 {
                                0i8
                            } else {
                                staff.transpose_semitones.saturating_add(
                                    instrument.map_or(0, |value| value.transpose_semitones),
                                )
                            };
                            let main_event_start = events.len();
                            for (pitch_index, pitch) in note.pitches.iter().enumerate() {
                                // An unpitched note sounds its instrument's percussion key.
                                let percussion = part.percussion_key(note, pitch_index);
                                let transpose = if percussion.is_some() { 0 } else { transpose };
                                let midi = percussion.map_or_else(
                                    || (pitch.to_midi() + transpose as i16).clamp(0, 127) as u8,
                                    |key| key.min(127),
                                );
                                events.push(PlaybackEvent {
                                    address: Some(format!(
                                        "{part_index}:{staff_index}:{idx}:{voice_idx}:{note_index}"
                                    )),
                                    source: Some(NoteAddr {
                                        part: part_index,
                                        staff: staff_index,
                                        measure: idx,
                                        voice: voice_idx,
                                        note: note_index,
                                    }),
                                    source_voice_number: measure.source_voice_numbers[voice_idx],
                                    time_beats: measure_start_beats + local_beats,
                                    time_secs: measure_start_secs
                                        + tempo_ramp_seconds(
                                            current_bpm,
                                            ramp_end_bpm,
                                            measure_beats,
                                            local_beats,
                                        ),
                                    pitch_midi: midi,
                                    pitch_midi_cents: if percussion.is_some() {
                                        i32::from(midi) * 100
                                    } else {
                                        pitch.to_midi_cents() + transpose as i32 * 100
                                    },
                                    pitch_bend_curve: note.guitar_bend_curve.clone(),
                                    post_note_pause_beats,
                                    articulations: note.articulations.clone(),
                                    chord_symbol: note.chord_symbol.clone(),
                                    guitar_technique: note.guitar_technique.clone(),
                                    velocity,
                                    duration_beats: sounding_dur,
                                    duration_secs: tempo_ramp_seconds(
                                        current_bpm,
                                        ramp_end_bpm,
                                        measure_beats,
                                        local_beats + sounding_dur,
                                    ) - tempo_ramp_seconds(
                                        current_bpm,
                                        ramp_end_bpm,
                                        measure_beats,
                                        local_beats,
                                    ),
                                    pedal,
                                    part_index,
                                    channel,
                                    program,
                                    instrument_id: instrument_id.clone(),
                                    is_metronome: false,
                                });
                            }
                            let main_event_end = events.len();
                            let voice = &measure.voices[voice_idx];
                            let mut grace_start = note_index;
                            while grace_start > 0 && voice[grace_start - 1].is_grace {
                                grace_start -= 1;
                            }
                            if grace_start < note_index && main_event_start < main_event_end {
                                let graces = &voice[grace_start..note_index];
                                // A short written grace group occupies part of the preceding
                                // rhythmic slot. At the start of playback it takes time from
                                // the following main note instead; the bar length is unchanged.
                                let written: Vec<f64> = graces
                                    .iter()
                                    .map(|grace| {
                                        (grace.duration.beats(grace.dot_count) * 0.25).min(0.25)
                                    })
                                    .collect();
                                let requested: f64 = written.iter().sum();
                                let prior_onset = prior_note_events
                                    .clone()
                                    .next()
                                    .map(|index| events[index].time_beats - measure_start_beats)
                                    .unwrap_or(0.0);
                                let before = requested
                                    .min(local_beats * 0.5)
                                    .min((local_beats - prior_onset).max(0.0) * 0.5);
                                let take_from_previous = before > 0.0;
                                let grace_total = if take_from_previous {
                                    before
                                } else {
                                    requested.min(sounding_dur * 0.5)
                                };
                                if grace_total > 0.0 {
                                    let grace_start_beat = if take_from_previous {
                                        local_beats - grace_total
                                    } else {
                                        local_beats
                                    };
                                    let grace_start_secs = measure_start_secs
                                        + tempo_ramp_seconds(
                                            current_bpm,
                                            ramp_end_bpm,
                                            measure_beats,
                                            grace_start_beat,
                                        );
                                    if take_from_previous {
                                        for event in &mut events[prior_note_events.clone()] {
                                            if event.time_beats + event.duration_beats
                                                > measure_start_beats + grace_start_beat
                                            {
                                                event.duration_beats = measure_start_beats
                                                    + grace_start_beat
                                                    - event.time_beats;
                                                event.duration_secs =
                                                    grace_start_secs - event.time_secs;
                                            }
                                        }
                                    } else {
                                        let shifted_beat = local_beats + grace_total;
                                        let shifted_secs = measure_start_secs
                                            + tempo_ramp_seconds(
                                                current_bpm,
                                                ramp_end_bpm,
                                                measure_beats,
                                                shifted_beat,
                                            );
                                        for event in &mut events[main_event_start..main_event_end] {
                                            event.time_beats = measure_start_beats + shifted_beat;
                                            event.time_secs = shifted_secs;
                                            event.duration_beats -= grace_total;
                                            event.duration_secs = tempo_ramp_seconds(
                                                current_bpm,
                                                ramp_end_bpm,
                                                measure_beats,
                                                local_beats + sounding_dur,
                                            ) - tempo_ramp_seconds(
                                                current_bpm,
                                                ramp_end_bpm,
                                                measure_beats,
                                                shifted_beat,
                                            );
                                        }
                                    }
                                    let mut cursor = grace_start_beat;
                                    for (offset, grace) in graces.iter().enumerate() {
                                        let grace_beats = grace_total * written[offset] / requested;
                                        let grace_end = cursor + grace_beats;
                                        for (pitch_index, pitch) in grace.pitches.iter().enumerate()
                                        {
                                            let percussion =
                                                part.percussion_key(grace, pitch_index);
                                            let pitch_transpose =
                                                if percussion.is_some() { 0 } else { transpose };
                                            let mut event = events[main_event_start].clone();
                                            event.address = Some(format!(
                                                "{part_index}:{staff_index}:{idx}:{voice_idx}:{}",
                                                grace_start + offset
                                            ));
                                            event.source = Some(NoteAddr {
                                                part: part_index,
                                                staff: staff_index,
                                                measure: idx,
                                                voice: voice_idx,
                                                note: grace_start + offset,
                                            });
                                            event.pitch_midi = percussion.map_or_else(
                                                || {
                                                    (pitch.to_midi() + pitch_transpose as i16)
                                                        .clamp(0, 127)
                                                        as u8
                                                },
                                                |key| key.min(127),
                                            );
                                            event.pitch_midi_cents = if percussion.is_some() {
                                                i32::from(event.pitch_midi) * 100
                                            } else {
                                                pitch.to_midi_cents()
                                                    + i32::from(pitch_transpose) * 100
                                            };
                                            event.time_beats = measure_start_beats + cursor;
                                            event.time_secs = measure_start_secs
                                                + tempo_ramp_seconds(
                                                    current_bpm,
                                                    ramp_end_bpm,
                                                    measure_beats,
                                                    cursor,
                                                );
                                            event.duration_beats = grace_beats;
                                            event.duration_secs = tempo_ramp_seconds(
                                                current_bpm,
                                                ramp_end_bpm,
                                                measure_beats,
                                                grace_end,
                                            ) - tempo_ramp_seconds(
                                                current_bpm,
                                                ramp_end_bpm,
                                                measure_beats,
                                                cursor,
                                            );
                                            event.articulations = grace.articulations.clone();
                                            event.pitch_bend_curve =
                                                grace.guitar_bend_curve.clone();
                                            event.guitar_technique = grace.guitar_technique.clone();
                                            event.chord_symbol = grace.chord_symbol.clone();
                                            event.post_note_pause_beats = 0.0;
                                            event.velocity = dynamics.velocity(
                                                seq_position,
                                                onset_written_beats,
                                                grace.dynamic,
                                            );
                                            event.pedal = grace.pedal_start;
                                            events.push(event);
                                        }
                                        cursor = grace_end;
                                    }
                                }
                            }
                            prior_note_events = main_event_start..main_event_end;
                        }
                        local_beats += dur;
                    }
                    // A direction can occur after the final note or in an otherwise silent
                    // measure and must still affect this voice in the following measure.
                    for switch in switches
                        .iter()
                        .skip(next_switch)
                        .filter(|switch| switch.position_beats <= measure_beats + 1e-9)
                    {
                        if let Some(channel) = part
                            .named_channels
                            .iter()
                            .find(|channel| channel.name == switch.channel_name)
                        {
                            active_named_channel = Some(channel);
                        }
                    }
                    // A voice may omit rests, but the next measure still starts
                    // at the notated bar boundary. This also keeps sparse voices
                    // aligned with compute_playback_position and other voices.
                    time_beats = measure_start_beats + measure_beats;
                    time_secs_cursor = measure_start_secs
                        + tempo_ramp_seconds(
                            current_bpm,
                            ramp_end_bpm,
                            measure_beats,
                            measure_beats,
                        );
                    if let Some(end_bpm) = ramp_end_bpm {
                        current_bpm = end_bpm;
                    }
                }
            }
        }
    }

    if let Some(ref metro) = options.metronome {
        let mut cursor_secs = 0.0f64;
        let mut cursor_beats = 0.0f64;
        let mut metro_bpm = bpm;
        for &idx in &seq {
            let first_staff = score.parts.first().and_then(|p| p.staves.first());
            let mark = tempo_marks.get(idx).copied().unwrap_or_default();
            if let Some(t) = mark.bpm.and_then(|tempo| written_tempo_bpm(options, tempo)) {
                metro_bpm = t;
            }
            let ts = first_staff.map_or(&score.settings.time_signature, |s| {
                s.meter_at(idx, &score.settings.time_signature)
            });
            let measure_beats = measure_lengths[idx];
            let ramp_end_bpm = written_tempo_ramp_bpm(options, mark.ramp_to_bpm);
            let beat_unit = ts.beat_unit_beats();
            let num_beats = (measure_beats / beat_unit).round() as u32;
            for b in 0..num_beats {
                let is_accent = b == 0;
                let beat_offset_beats = b as f64 * beat_unit;
                let beat_offset_secs =
                    tempo_ramp_seconds(metro_bpm, ramp_end_bpm, measure_beats, beat_offset_beats);
                events.push(PlaybackEvent {
                    address: None,
                    source: None,
                    source_voice_number: None,
                    time_beats: cursor_beats + b as f64 * beat_unit,
                    time_secs: cursor_secs + beat_offset_secs,
                    pitch_midi: if is_accent {
                        metro.accent_pitch
                    } else {
                        metro.beat_pitch
                    },
                    pitch_midi_cents: i32::from(if is_accent {
                        metro.accent_pitch
                    } else {
                        metro.beat_pitch
                    }) * 100,
                    pitch_bend_curve: Vec::new(),
                    post_note_pause_beats: 0.0,
                    articulations: Vec::new(),
                    chord_symbol: None,
                    guitar_technique: None,
                    velocity: if is_accent {
                        metro.accent_velocity
                    } else {
                        metro.beat_velocity
                    },
                    duration_beats: beat_unit * 0.1,
                    duration_secs: tempo_ramp_seconds(
                        metro_bpm,
                        ramp_end_bpm,
                        measure_beats,
                        beat_offset_beats + beat_unit * 0.1,
                    ) - beat_offset_secs,
                    pedal: false,
                    part_index: usize::MAX,
                    channel: metro.channel,
                    program: 0,
                    instrument_id: None,
                    is_metronome: true,
                });
            }
            cursor_secs +=
                tempo_ramp_seconds(metro_bpm, ramp_end_bpm, measure_beats, measure_beats);
            cursor_beats += measure_beats;
            if let Some(end_bpm) = ramp_end_bpm {
                metro_bpm = end_bpm;
            }
        }
    }

    // Parts, staves and voices are projected separately. Sort before resolving ties so a
    // continuation moved to another staff or voice follows its start on the shared clock.
    events.sort_by(|a, b| {
        a.time_beats
            .partial_cmp(&b.time_beats)
            .unwrap_or(std::cmp::Ordering::Equal)
    });
    events = merge_tied_events(score, options, events);
    events = realize_single_tremolos(score, options, events);
    apply_fermata_holds(&mut events, &score_fermata_holds(score, options));
    events = apply_realization_profile(score, events, options.realization_profile);
    events.sort_by(|a, b| {
        a.time_beats
            .partial_cmp(&b.time_beats)
            .unwrap_or(std::cmp::Ordering::Equal)
    });
    events
}

// Expand measured tremolo before score-wide fermata holds, using the same tempo clock as
// the rest of playback. A tremolo mark adds strokes to any flags already on the note.
fn realize_single_tremolos(
    score: &Score,
    options: &PlaybackOptions,
    events: Vec<PlaybackEvent>,
) -> Vec<PlaybackEvent> {
    let mut realized = Vec::with_capacity(events.len());
    let mut clock = None;
    for event in events {
        let strokes = event.articulations.iter().find_map(|mark| match mark {
            Articulation::Tremolo(n @ 1..=8) => Some(*n),
            _ => None,
        });
        let note = event.source.as_ref().and_then(|source| {
            score
                .parts
                .get(source.part)
                .and_then(|part| part.staves.get(source.staff))
                .and_then(|staff| staff.measures.get(source.measure))
                .and_then(|measure| measure.voices.get(source.voice))
                .and_then(|voice| voice.get(source.note))
        });
        let (Some(strokes), Some(note)) = (strokes, note) else {
            realized.push(event);
            continue;
        };
        if note.tremolo_pair.is_some() {
            realized.push(event);
            continue;
        }
        let tuplet_scale = note.tuplet.as_ref().map_or(1.0, |tuplet| {
            f64::from(tuplet.normal_notes) / f64::from(tuplet.actual_notes.max(1))
        });
        let attack_beats =
            note.duration.beats(0).min(1.0) * tuplet_scale / f64::from(1_u32 << strokes);
        if !attack_beats.is_finite() || attack_beats <= 0.0 {
            realized.push(event);
            continue;
        }
        if !event.duration_beats.is_finite() || event.duration_beats <= 0.0 {
            realized.push(event);
            continue;
        }
        let count = (event.duration_beats / attack_beats - 1e-9).ceil() as usize;
        // Bound expansion of malformed or exceptionally long tied values.
        if count <= 1 || count > 65_536 {
            realized.push(event);
            continue;
        }
        let timeline = clock.get_or_insert_with(|| playback_measure_clock(score, options));
        for ordinal in 0..count {
            let start = event.time_beats + ordinal as f64 * attack_beats;
            let end = (start + attack_beats).min(event.time_beats + event.duration_beats);
            let mut attack = event.clone();
            attack.time_beats = start;
            attack.duration_beats = end - start;
            let start_secs = playback_secs_at_beat(timeline, start);
            let end_secs = playback_secs_at_beat(timeline, end);
            if let (Some(start_secs), Some(end_secs)) = (start_secs, end_secs) {
                attack.time_secs = start_secs;
                attack.duration_secs = end_secs - start_secs;
            } else {
                attack.time_secs +=
                    event.duration_secs * (start - event.time_beats) / event.duration_beats;
                attack.duration_secs =
                    event.duration_secs * attack.duration_beats / event.duration_beats;
            }
            attack
                .articulations
                .retain(|mark| !matches!(mark, Articulation::Tremolo(_)));
            if ordinal > 0 {
                attack.pedal = false;
                attack.chord_symbol = None;
            }
            if ordinal + 1 < count {
                attack.post_note_pause_beats = 0.0;
            }
            realized.push(attack);
        }
    }
    realized
}

const ORNAMENT_ATTACK_COUNT: usize = 4;
const ARPEGGIO_MAX_SPREAD_BEATS: f64 = 0.18;

fn apply_realization_profile(
    score: &Score,
    mut events: Vec<PlaybackEvent>,
    profile: PlaybackRealizationProfile,
) -> Vec<PlaybackEvent> {
    if profile == PlaybackRealizationProfile::Authored {
        return events;
    }

    let mut chord_groups: BTreeMap<(String, u64), Vec<usize>> = BTreeMap::new();
    for (index, event) in events.iter().enumerate() {
        if !event.is_metronome
            && let Some(address) = &event.address
        {
            chord_groups
                .entry((address.clone(), event.time_beats.to_bits()))
                .or_default()
                .push(index);
        }
    }
    for indices in chord_groups.into_values() {
        let Some(source) = events[indices[0]].source.as_ref() else {
            continue;
        };
        let Some(direction) = score
            .parts
            .get(source.part)
            .and_then(|part| part.staves.get(source.staff))
            .and_then(|staff| staff.measures.get(source.measure))
            .and_then(|measure| measure.voices.get(source.voice))
            .and_then(|voice| voice.get(source.note))
            .and_then(|note| note.arpeggiate)
        else {
            continue;
        };
        if indices.len() < 2 {
            continue;
        }
        let mut ordered = indices;
        ordered.sort_by_key(|&index| events[index].pitch_midi_cents);
        if !direction {
            ordered.reverse();
        }
        let max_spread = events[ordered[0]]
            .duration_beats
            .max(0.0)
            .mul_add(0.5, 0.0)
            .min(ARPEGGIO_MAX_SPREAD_BEATS);
        let step = max_spread / (ordered.len() - 1) as f64;
        for (ordinal, index) in ordered.into_iter().enumerate() {
            shift_event_time(&mut events[index], step * ordinal as f64);
        }
    }

    let mut realized = Vec::with_capacity(events.len());
    for event in events {
        let offsets = ornament_offsets(&event.articulations);
        if offsets.is_empty()
            || event.is_metronome
            || event.duration_beats <= 0.0
            || event
                .articulations
                .iter()
                .filter(|mark| is_playback_ornament(mark))
                .count()
                != 1
        {
            realized.push(event);
            continue;
        }
        let attack_beats = event.duration_beats / ORNAMENT_ATTACK_COUNT as f64;
        let attack_secs = event.duration_secs / ORNAMENT_ATTACK_COUNT as f64;
        for (ordinal, semitones) in offsets.into_iter().enumerate() {
            let mut attack = event.clone();
            let displacement = i32::from(semitones) * 100;
            attack.pitch_midi_cents = (attack.pitch_midi_cents + displacement).clamp(0, 12_700);
            attack.pitch_midi =
                ((i32::from(attack.pitch_midi) + i32::from(semitones)).clamp(0, 127)) as u8;
            attack.time_beats += attack_beats * ordinal as f64;
            attack.time_secs += attack_secs * ordinal as f64;
            attack.duration_beats = attack_beats;
            attack.duration_secs = attack_secs;
            // The selected ornament is already represented by these attacks.
            // Keep unrelated articulations, so a renderer can still apply them.
            attack
                .articulations
                .retain(|mark| !is_playback_ornament(mark));
            if ordinal > 0 {
                attack.chord_symbol = None;
            }
            realized.push(attack);
        }
    }
    realized
}

fn shift_event_time(event: &mut PlaybackEvent, offset_beats: f64) {
    if offset_beats <= 0.0 || event.duration_beats <= 0.0 {
        return;
    }
    event.time_beats += offset_beats;
    event.time_secs += event.duration_secs * (offset_beats / event.duration_beats);
}

fn is_playback_ornament(mark: &Articulation) -> bool {
    matches!(
        mark,
        Articulation::Trill
            | Articulation::Shake
            | Articulation::Mordent
            | Articulation::InvertedMordent
            | Articulation::Turn
            | Articulation::InvertedTurn
    )
}

fn ornament_offsets(articulations: &[Articulation]) -> Vec<i8> {
    if articulations
        .iter()
        .any(|articulation| matches!(articulation, Articulation::Trill | Articulation::Shake))
    {
        return vec![0, 1, 0, 1];
    }
    if articulations
        .iter()
        .any(|articulation| matches!(articulation, Articulation::Mordent))
    {
        return vec![0, 1, 0, 0];
    }
    if articulations
        .iter()
        .any(|articulation| matches!(articulation, Articulation::InvertedMordent))
    {
        return vec![0, -1, 0, 0];
    }
    if articulations
        .iter()
        .any(|articulation| matches!(articulation, Articulation::Turn))
    {
        return vec![1, 0, -1, 0];
    }
    if articulations
        .iter()
        .any(|articulation| matches!(articulation, Articulation::InvertedTurn))
    {
        return vec![-1, 0, 1, 0];
    }
    Vec::new()
}

/// Integrate seconds over `beats` while BPM changes linearly across a measure.
fn tempo_ramp_seconds(start_bpm: f64, end_bpm: Option<f64>, measure_beats: f64, beats: f64) -> f64 {
    let beats = beats.max(0.0);
    let Some(end_bpm) = end_bpm else {
        return beats / start_bpm * 60.0;
    };
    if measure_beats <= 0.0 || (end_bpm - start_bpm).abs() < f64::EPSILON {
        return beats / start_bpm * 60.0;
    }
    let delta = end_bpm - start_bpm;
    let bpm_at_beats = start_bpm + delta * beats / measure_beats;
    if bpm_at_beats <= 0.0 {
        return beats / start_bpm * 60.0;
    }
    60.0 * measure_beats / delta * (bpm_at_beats / start_bpm).ln()
}

/// Inverse of [`tempo_ramp_seconds`] within one measure.
///
/// This keeps visual/browser cursors on the same clock as emitted playback events when a written
/// tempo ramp is active. Invalid or degenerate ramps fall back to constant-tempo conversion.
fn tempo_ramp_beats_at_seconds(
    start_bpm: f64,
    end_bpm: Option<f64>,
    measure_beats: f64,
    seconds: f64,
) -> f64 {
    let seconds = seconds.max(0.0);
    let Some(end_bpm) = end_bpm else {
        return seconds * start_bpm / 60.0;
    };
    if measure_beats <= 0.0 || (end_bpm - start_bpm).abs() < f64::EPSILON {
        return seconds * start_bpm / 60.0;
    }
    let delta = end_bpm - start_bpm;
    let exponent = seconds * delta / (60.0 * measure_beats);
    let ratio = exponent.exp();
    if !ratio.is_finite() {
        return measure_beats;
    }
    let beats = measure_beats * start_bpm * (ratio - 1.0) / delta;
    if beats.is_finite() {
        beats
    } else {
        measure_beats
    }
}

/// Coalesce adjacent playback events that are connected by authored ties.
///
/// Ties are a notational continuation, not repeated attacks. The event keeps the first
/// source address. The notated duration determines continuity; articulations on any segment
/// affect the combined note once. Malformed or non-contiguous tie endings remain independent.
fn merge_tied_events(
    score: &Score,
    options: &PlaybackOptions,
    events: Vec<PlaybackEvent>,
) -> Vec<PlaybackEvent> {
    use std::collections::HashMap;

    struct PendingTie {
        index: usize,
        staff: usize,
        voice: usize,
        notated_end_beats: f64,
        staccato: bool,
    }

    let mut merged = Vec::with_capacity(events.len());
    let mut pending: HashMap<(usize, i32), Vec<PendingTie>> = HashMap::new();
    let mut clock = None;
    for event in events {
        let Some(source) = event.source.as_ref() else {
            merged.push(event);
            continue;
        };
        let tied_staff = score
            .parts
            .get(source.part)
            .and_then(|part| part.staves.get(source.staff));
        let tied_note = tied_staff
            .and_then(|staff| staff.measures.get(source.measure))
            .and_then(|measure| measure.voices.get(source.voice))
            .and_then(|voice| voice.get(source.note));
        let (Some(staff), Some(note)) = (tied_staff, tied_note) else {
            merged.push(event);
            continue;
        };
        // A chord may tie only some of its pitches: use the flags of the pitch that sounds here.
        let transpose_cents = i32::from(staff.transpose_semitones) * 100;
        let pitch_index = note
            .pitches
            .iter()
            .position(|pitch| pitch.to_midi_cents() + transpose_cents == event.pitch_midi_cents);
        let (tie_start, tie_end) = match pitch_index {
            Some(index) => (note.pitch_tie_start(index), note.pitch_tie_end(index)),
            None => (note.tie_start, note.tie_end),
        };
        let mut articulation_scale = 1.0;
        let mut staccato = false;
        for articulation in &note.articulations {
            match articulation {
                Articulation::Staccato | Articulation::Staccatissimo => {
                    articulation_scale *= 0.5;
                    staccato = true;
                }
                Articulation::Fermata
                    if options.fermata_multiplier.is_finite()
                        && options.fermata_multiplier < 1.0 =>
                {
                    articulation_scale *= options.fermata_multiplier.max(0.0)
                }
                _ => {}
            }
        }
        let notated_duration = if articulation_scale.is_finite()
            && articulation_scale > 0.0
            && event.duration_beats.is_finite()
        {
            event.duration_beats / articulation_scale
        } else {
            note.beats()
        };
        let source_staff = source.staff;
        let source_voice = source.voice;
        let key = (source.part, event.pitch_midi_cents);
        if let Some(candidates) = pending.get_mut(&key) {
            candidates.retain(|candidate| candidate.notated_end_beats >= event.time_beats - 1e-9);
            if tie_end {
                let matching = candidates
                    .iter()
                    .enumerate()
                    .filter(|(_, candidate)| {
                        (candidate.notated_end_beats - event.time_beats).abs() < 1e-9
                    })
                    .max_by_key(|(_, candidate)| {
                        (
                            candidate.staff == source.staff,
                            candidate.voice == source.voice,
                        )
                    })
                    .map(|(position, _)| position);
                if let Some(position) = matching {
                    let mut candidate = candidates.remove(position);
                    let previous = &mut merged[candidate.index];
                    for articulation in event.articulations.iter().filter(|articulation| {
                        matches!(
                            articulation,
                            Articulation::Staccato | Articulation::Staccatissimo
                        )
                    }) {
                        if !previous.articulations.contains(articulation) {
                            previous.articulations.push(articulation.clone());
                        }
                    }
                    candidate.notated_end_beats = event.time_beats + notated_duration;
                    candidate.staccato |= staccato;
                    previous.duration_beats += event.duration_beats;
                    previous.duration_secs += event.duration_secs;
                    if candidate.staccato {
                        previous.duration_beats =
                            (candidate.notated_end_beats - previous.time_beats) * 0.5;
                        let timeline =
                            clock.get_or_insert_with(|| playback_measure_clock(score, options));
                        if let Some(end_secs) = playback_secs_at_beat(
                            timeline,
                            previous.time_beats + previous.duration_beats,
                        ) {
                            previous.duration_secs = end_secs - previous.time_secs;
                        }
                    }
                    if tie_start {
                        candidate.staff = source.staff;
                        candidate.voice = source.voice;
                        candidates.push(candidate);
                    }
                    continue;
                }
            }
        }

        let index = merged.len();
        merged.push(event);
        if tie_start {
            pending.entry(key).or_default().push(PendingTie {
                index,
                staff: source_staff,
                voice: source_voice,
                notated_end_beats: merged[index].time_beats + notated_duration,
                staccato,
            });
        }
    }
    merged
}

#[derive(Clone, Copy)]
struct PlaybackClockMeasure {
    start_beats: f64,
    start_secs: f64,
    bpm: f64,
    ramp_to_bpm: Option<f64>,
    beats: f64,
}

fn playback_measure_clock(score: &Score, options: &PlaybackOptions) -> Vec<PlaybackClockMeasure> {
    let marks = score_tempo_marks(score);
    let mut bpm = initial_tempo_bpm(score, options);
    let mut start_beats = 0.0;
    let mut start_secs = 0.0;
    let mut clock = Vec::new();
    for index in measure_sequence(score).into_iter().filter(|index| {
        options
            .loop_region
            .is_none_or(|(start, end)| *index >= start && *index <= end)
    }) {
        let mark = marks.get(index).copied().unwrap_or_default();
        if let Some(next) = mark.bpm.and_then(|tempo| written_tempo_bpm(options, tempo)) {
            bpm = next;
        }
        let beats = score.playback_measure_beats(index);
        let ramp_to_bpm = written_tempo_ramp_bpm(options, mark.ramp_to_bpm);
        clock.push(PlaybackClockMeasure {
            start_beats,
            start_secs,
            bpm,
            ramp_to_bpm,
            beats,
        });
        start_beats += beats;
        start_secs += tempo_ramp_seconds(bpm, ramp_to_bpm, beats, beats);
        if let Some(next) = ramp_to_bpm {
            bpm = next;
        }
    }
    clock
}

/// A pause inserted into the shared score clock at a written note/rest end.
#[derive(Clone, Copy, Debug)]
struct FermataHold {
    at_beat: f64,
    at_secs: f64,
    extra_beats: f64,
    extra_secs: f64,
    cumulative_beats: f64,
    cumulative_secs: f64,
}

fn score_fermata_holds(score: &Score, options: &PlaybackOptions) -> Vec<FermataHold> {
    let multiplier = options.fermata_multiplier;
    if !multiplier.is_finite()
        || multiplier <= 1.0
        || !score
            .parts
            .iter()
            .flat_map(|part| &part.staves)
            .flat_map(|staff| &staff.measures)
            .flat_map(|measure| &measure.voices)
            .flatten()
            .any(|note| note.articulations.contains(&Articulation::Fermata))
    {
        return Vec::new();
    }
    let sequence = measure_sequence(score).into_iter().filter(|index| {
        options
            .loop_region
            .is_none_or(|(start, end)| *index >= start && *index <= end)
    });
    let clock = playback_measure_clock(score, options);
    let swing = options
        .swing
        .filter(|ratio| ratio.is_finite() && *ratio > 0.5 && *ratio < 1.0);
    let mut holds = Vec::new();
    for (index, measure_clock) in sequence.zip(clock.iter()) {
        for staff in score.parts.iter().flat_map(|part| &part.staves) {
            let Some(measure) = staff.measures.get(index) else {
                continue;
            };
            let grid_offset = if index == 0 {
                let meter = staff
                    .meter_at(index, &score.settings.time_signature)
                    .total_beats();
                (meter - measure_clock.beats).max(0.0)
            } else {
                0.0
            };
            for voice in &measure.voices {
                let (mut local, mut written) = (0.0, 0.0);
                let mut swing_second = false;
                for (note_index, note) in voice.iter().enumerate() {
                    if note.is_grace || note.is_cue {
                        continue;
                    }
                    let duration = if let Some(ratio) = swing {
                        if swing_second {
                            swing_second = false;
                            (1.0 - ratio) * note.beats() * 2.0
                        } else if starts_swing_pair(
                            voice,
                            note_index,
                            written,
                            grid_offset,
                            measure_clock.beats,
                            &options.swing_unit,
                        ) {
                            swing_second = true;
                            ratio * note.beats() * 2.0
                        } else {
                            note.beats()
                        }
                    } else {
                        note.beats()
                    };
                    written += note.beats();
                    local += duration;
                    if note.articulations.contains(&Articulation::Fermata) && duration > 0.0 {
                        let at_beat = measure_clock.start_beats + local;
                        let Some(at_secs) = playback_secs_at_beat(&clock, at_beat) else {
                            continue;
                        };
                        let bpm = measure_clock.ramp_to_bpm.map_or(measure_clock.bpm, |end| {
                            measure_clock.bpm
                                + (end - measure_clock.bpm)
                                    * (local / measure_clock.beats.max(f64::EPSILON))
                                        .clamp(0.0, 1.0)
                        });
                        let extra_beats = duration * (multiplier - 1.0);
                        holds.push(FermataHold {
                            at_beat,
                            at_secs,
                            extra_beats,
                            extra_secs: extra_beats * 60.0 / bpm,
                            cumulative_beats: 0.0,
                            cumulative_secs: 0.0,
                        });
                    }
                }
            }
        }
    }
    holds.sort_by(|a, b| a.at_beat.total_cmp(&b.at_beat));
    let mut unique: Vec<FermataHold> = Vec::new();
    for hold in holds {
        if let Some(last) = unique.last_mut()
            && (last.at_beat - hold.at_beat).abs() < 1e-9
        {
            if hold.extra_beats > last.extra_beats {
                *last = hold;
            }
        } else {
            unique.push(hold);
        }
    }
    let (mut beats, mut seconds) = (0.0, 0.0);
    for hold in &mut unique {
        beats += hold.extra_beats;
        seconds += hold.extra_secs;
        hold.cumulative_beats = beats;
        hold.cumulative_secs = seconds;
    }
    unique
}

pub(super) fn fermata_total_secs(score: &Score, region: Option<(usize, usize)>) -> f64 {
    let options = PlaybackOptions {
        loop_region: region,
        ..Default::default()
    };
    score_fermata_holds(score, &options)
        .last()
        .map_or(0.0, |hold| hold.cumulative_secs)
}

/// Score-clock pauses as (written beat, added beats), including repeats and loop filtering.
/// Use these when projecting the same score to a separate beat-based transport such as MIDI.
pub fn playback_fermata_pauses(score: &Score, options: &PlaybackOptions) -> Vec<(f64, f64)> {
    score_fermata_holds(score, options)
        .into_iter()
        .map(|hold| (hold.at_beat, hold.extra_beats))
        .collect()
}

fn apply_fermata_holds(events: &mut [PlaybackEvent], holds: &[FermataHold]) {
    let before = |index: usize| index.checked_sub(1).and_then(|i| holds.get(i));
    for event in events {
        let start = event.time_beats;
        let end = start + event.duration_beats;
        let first = holds.partition_point(|hold| hold.at_beat <= start + 1e-9);
        let last = holds.partition_point(|hold| hold.at_beat <= end + 1e-9);
        let start_beats = before(first).map_or(0.0, |hold| hold.cumulative_beats);
        let start_secs = before(first).map_or(0.0, |hold| hold.cumulative_secs);
        let end_beats = before(last).map_or(0.0, |hold| hold.cumulative_beats);
        let end_secs = before(last).map_or(0.0, |hold| hold.cumulative_secs);
        event.time_beats += start_beats;
        event.time_secs += start_secs;
        event.duration_beats += end_beats - start_beats;
        event.duration_secs += end_secs - start_secs;
    }
}

fn fermata_warp_secs(seconds: f64, holds: &[FermataHold]) -> f64 {
    let count = holds.partition_point(|hold| hold.at_secs <= seconds + 1e-9);
    seconds
        + count
            .checked_sub(1)
            .map_or(0.0, |index| holds[index].cumulative_secs)
}

fn fermata_unwarp_secs(seconds: f64, holds: &[FermataHold]) -> f64 {
    let count = holds
        .partition_point(|hold| hold.at_secs + hold.cumulative_secs - hold.extra_secs <= seconds);
    if count == 0 {
        return seconds;
    }
    let hold = holds[count - 1];
    let start = hold.at_secs + hold.cumulative_secs - hold.extra_secs;
    if seconds < start + hold.extra_secs {
        hold.at_secs
    } else {
        seconds - hold.cumulative_secs
    }
}

fn playback_secs_at_beat(clock: &[PlaybackClockMeasure], beat: f64) -> Option<f64> {
    let index = clock.partition_point(|measure| measure.start_beats <= beat);
    let measure = clock.get(index.saturating_sub(1))?;
    let offset = beat - measure.start_beats;
    if offset > measure.beats + 1e-9 {
        return None;
    }
    Some(
        measure.start_secs
            + tempo_ramp_seconds(
                measure.bpm,
                measure.ramp_to_bpm,
                measure.beats,
                offset.clamp(0.0, measure.beats),
            ),
    )
}

/// Convert a score into playback events while enforcing the host-comparison event bound.
pub fn to_playback_events_bounded(
    score: &Score,
    options: &PlaybackOptions,
) -> Result<Vec<PlaybackEvent>, crate::Error> {
    let events = to_playback_events(score, options);
    if events.len() > MAX_PLAYBACK_COMPARISON_EVENTS {
        return Err(crate::Error::PlaybackComparisonTooLarge(events.len()));
    }
    Ok(events)
}

/// One opt-in shared-unison attack and all notated notes represented by it.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct SharedUnisonPlaybackEvent {
    pub event: PlaybackEvent,
    pub sources: Vec<NoteAddr>,
}

/// Coalesce otherwise identical simultaneous events from different voices or staves of the
/// same part. This is an explicit host policy: the ordinary playback schedule stays unchanged.
/// Events with different expression, routing, duration or pedal data remain separate.
/// At most 256 candidate groups are compared per simultaneous pitch; additional distinct
/// groups remain separate to bound work on untrusted scores. Each group also retains
/// at most 256 sources; excess events remain separate.
pub fn coalesce_shared_unisons(events: Vec<PlaybackEvent>) -> Vec<SharedUnisonPlaybackEvent> {
    use std::collections::HashMap;
    let mut groups: Vec<SharedUnisonPlaybackEvent> = Vec::with_capacity(events.len());
    let mut buckets: HashMap<(usize, u64, i32, u8, u8), Vec<usize>> = HashMap::new();
    for event in events {
        let Some(source) = event.source.clone().filter(|_| !event.is_metronome) else {
            groups.push(SharedUnisonPlaybackEvent {
                event,
                sources: Vec::new(),
            });
            continue;
        };
        let key = (
            event.part_index,
            event.time_beats.to_bits(),
            event.pitch_midi_cents,
            event.channel,
            event.program,
        );
        let mut normalized = event.clone();
        normalized.address = None;
        normalized.source = None;
        normalized.source_voice_number = None;
        let candidates = buckets.entry(key).or_default();
        // Bound work for hostile scores with many simultaneous events at one pitch.
        let matching = candidates.iter().take(256).copied().find(|&index| {
            let group = &groups[index];
            if group.sources.len() >= 256
                || group
                    .sources
                    .iter()
                    .any(|other| other.staff == source.staff && other.voice == source.voice)
            {
                return false;
            }
            let mut other = group.event.clone();
            other.address = None;
            other.source = None;
            other.source_voice_number = None;
            normalized == other
        });
        if let Some(index) = matching {
            groups[index].sources.push(source);
        } else {
            if candidates.len() < 256 {
                candidates.push(groups.len());
            }
            groups.push(SharedUnisonPlaybackEvent {
                event,
                sources: vec![source],
            });
        }
    }
    groups
}

// ── PlaybackPosition + compute_playback_position ──────────────────────────────

/// Score position at a specific elapsed time.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PlaybackPosition {
    /// Physical measure index (0-based), same coordinate space as [`PlaybackEvent`] fields.
    pub measure_index: usize,
    /// Beat offset within the measure (`0.0 … time_sig.total_beats()`).
    pub beat: f64,
}

struct MeasureSegment {
    measure_idx: usize,
    start_secs: f64,
    duration_secs: f64,
    beats: f64,
    bpm: f64,
    ramp_to_bpm: Option<f64>,
}

fn build_measure_segments(score: &Score, options: &PlaybackOptions) -> Vec<MeasureSegment> {
    let init_bpm = initial_tempo_bpm(score, options);
    let tempo_marks = score_tempo_marks(score);
    let full_seq = measure_sequence(score);
    let seq: Vec<usize> = if let Some((lo, hi)) = options.loop_region {
        full_seq
            .into_iter()
            .filter(|&i| i >= lo && i <= hi)
            .collect()
    } else {
        full_seq
    };

    let mut segments = Vec::with_capacity(seq.len());
    let mut cursor_secs = 0.0f64;
    let mut current_bpm = init_bpm;

    for idx in seq {
        let mark = tempo_marks.get(idx).copied().unwrap_or_default();
        if let Some(t) = mark.bpm.and_then(|tempo| written_tempo_bpm(options, tempo)) {
            current_bpm = t;
        }
        let beats = score.playback_measure_beats(idx);
        let ramp_to_bpm = written_tempo_ramp_bpm(options, mark.ramp_to_bpm);
        let duration_secs = tempo_ramp_seconds(current_bpm, ramp_to_bpm, beats, beats);

        segments.push(MeasureSegment {
            measure_idx: idx,
            start_secs: cursor_secs,
            duration_secs,
            beats,
            bpm: current_bpm,
            ramp_to_bpm,
        });
        cursor_secs += duration_secs;
        if let Some(end_bpm) = ramp_to_bpm {
            current_bpm = end_bpm;
        }
    }
    segments
}

/// Map `elapsed_secs` to a position within the score.
///
/// Returns `None` if `elapsed_secs` is negative or past the end of the last measure.
/// Pass the same [`PlaybackOptions`] used for [`to_playback_events`] so that `loop_region`
/// and tempo overrides are applied consistently.
pub fn compute_playback_position(
    score: &Score,
    options: &PlaybackOptions,
    elapsed_secs: f64,
) -> Option<PlaybackPosition> {
    if elapsed_secs < 0.0 {
        return None;
    }
    let holds = score_fermata_holds(score, options);
    let elapsed_secs = fermata_unwarp_secs(elapsed_secs, &holds);
    let segments = build_measure_segments(score, options);
    for seg in &segments {
        if elapsed_secs < seg.start_secs + seg.duration_secs + 1e-9 {
            let beat = tempo_ramp_beats_at_seconds(
                seg.bpm,
                seg.ramp_to_bpm,
                seg.beats,
                elapsed_secs - seg.start_secs,
            )
            .clamp(0.0, seg.beats);
            return Some(PlaybackPosition {
                measure_index: seg.measure_idx,
                beat,
            });
        }
    }
    None
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::model::{
        duration::Duration,
        pitch::{Pitch, Step},
        score::{MidiAftertouch, MidiControlChange, MidiPitchBend, MidiProgramChange, Note, Score},
    };

    fn opts(bpm: Option<u16>) -> PlaybackOptions {
        PlaybackOptions {
            bpm_override: bpm,
            ..Default::default()
        }
    }

    #[test]
    fn shared_unison_policy_never_merges_different_routing_or_same_voice() {
        let mut score = Score::new("unison", 120, 4, 4, 0, 1);
        let note = Note::new(Pitch::new(Step::A, 3), Duration::Whole);
        score.parts[0].staves[0].measures[0].voices[0] = vec![note.clone()];
        score.parts[0].staves[0].measures[0].voices[1] = vec![note];
        let events = to_playback_events(&score, &PlaybackOptions::default());
        assert_eq!(coalesce_shared_unisons(events.clone()).len(), 1);
        let mut different_program = events.clone();
        different_program[1].program += 1;
        assert_eq!(coalesce_shared_unisons(different_program).len(), 2);
        let mut different_expression = events.clone();
        different_expression[1].velocity += 1;
        assert_eq!(coalesce_shared_unisons(different_expression).len(), 2);
        let mut same_voice = events;
        let voice = same_voice[0].source.as_ref().unwrap().voice;
        same_voice[1].source.as_mut().unwrap().voice = voice;
        assert_eq!(coalesce_shared_unisons(same_voice).len(), 2);
    }

    #[test]
    fn rest_pedal_controls_follow_swing_and_muted_parts() {
        let mut score = Score::new("rest pedal", 120, 2, 4, 0, 1);
        let first = Note::rest(Duration::Eighth);
        let mut second = Note::rest(Duration::Eighth);
        second.pedal_start = true;
        let mut note = Note::new(Pitch::new(Step::C, 4), Duration::Quarter);
        note.pedal_end = true;
        score.parts[0].staves[0].measures[0].voices[0] = vec![first, second, note];
        let mut options = PlaybackOptions {
            swing: Some(0.67),
            ..Default::default()
        };
        let manifest =
            build_offline_render_manifest(&score, &options, &OfflineRenderRequest::default())
                .unwrap();
        let controls: Vec<_> = manifest
            .semantic_events
            .iter()
            .filter_map(|event| match event.kind {
                OfflineRenderSemanticEventKind::Pedal { down } => Some((event.frame, down)),
                _ => None,
            })
            .collect();
        assert_eq!(controls, vec![(16080, true), (24000, false)]);
        options.muted_parts.push(0);
        let muted =
            build_offline_render_manifest(&score, &options, &OfflineRenderRequest::default())
                .unwrap();
        assert!(
            !muted
                .semantic_events
                .iter()
                .any(|event| matches!(event.kind, OfflineRenderSemanticEventKind::Pedal { .. }))
        );
    }

    #[test]
    fn playback_options_accepts_an_empty_json_object_as_defaults() {
        let parsed: PlaybackOptions = serde_json::from_str("{}").expect("default playback options");
        assert_eq!(parsed, PlaybackOptions::default());
    }

    #[test]
    fn bounded_playback_events_match_unbounded_schedule_within_limit() {
        let score = Score::new("bounded", 120, 4, 4, 0, 1);
        let options = opts(Some(120));
        let unbounded = to_playback_events(&score, &options);
        let bounded = to_playback_events_bounded(&score, &options).expect("bounded schedule");
        assert_eq!(bounded, unbounded);
    }

    #[test]
    fn bars_after_a_meter_change_keep_the_new_meter() {
        use crate::model::duration::Duration;
        use crate::{Note, Pitch, Step, TimeSignature};
        let mut score = Score::new("meter", 120, 4, 4, 0, 3);
        let staff = &mut score.parts[0].staves[0];
        staff.measures[1].time_sig = Some(TimeSignature {
            numerator: 3,
            denominator: 4,
        });
        for measure in &mut staff.measures {
            measure.voices[0] = vec![Note::new(Pitch::new(Step::C, 4), Duration::Quarter)];
        }
        let onsets: Vec<f64> = to_playback_events(&score, &opts(Some(120)))
            .iter()
            .filter(|event| event.address.is_some())
            .map(|event| event.time_beats)
            .collect();
        // 4/4, then two bars of 3/4: the third bar starts at 4 + 3, not 4 + 4.
        assert_eq!(onsets, vec![0.0, 4.0, 7.0]);
    }

    #[test]
    fn tempo_written_on_either_part_governs_the_whole_score() {
        let mut score = Score::new("shared tempo", 120, 4, 4, 0, 2);
        let mut second = score.parts[0].clone();
        second.id = "second".into();
        score.parts.push(second);
        for part in &mut score.parts {
            for measure in &mut part.staves[0].measures {
                measure.voices[0] = vec![Note::new(Pitch::new(Step::C, 4), Duration::Quarter)];
            }
        }
        score.parts[0].staves[0].measures[0].tempo = Some(92);
        score.parts[1].staves[0].measures[1].tempo = Some(60);
        let options = PlaybackOptions {
            metronome: Some(MetronomeConfig::default()),
            ..Default::default()
        };
        let events = to_playback_events(&score, &options);
        for part_index in 0..2 {
            let first = events
                .iter()
                .find(|event| {
                    event.part_index == part_index
                        && event
                            .source
                            .as_ref()
                            .is_some_and(|source| source.measure == 0)
                })
                .unwrap();
            let second = events
                .iter()
                .find(|event| {
                    event.part_index == part_index
                        && event
                            .source
                            .as_ref()
                            .is_some_and(|source| source.measure == 1)
                })
                .unwrap();
            assert!((first.duration_secs - 60.0 / 92.0).abs() < 1e-9);
            assert!((second.time_secs - 4.0 * 60.0 / 92.0).abs() < 1e-9);
            assert!((second.duration_secs - 1.0).abs() < 1e-9);
        }
        let clicks: Vec<_> = events.iter().filter(|event| event.is_metronome).collect();
        assert!((clicks[1].time_secs - 60.0 / 92.0).abs() < 1e-9);
        assert!((clicks[4].time_secs - 4.0 * 60.0 / 92.0).abs() < 1e-9);
        let position = compute_playback_position(&score, &options, 1.5 * 60.0 / 92.0).unwrap();
        assert_eq!(position.measure_index, 0);
        assert!((position.beat - 1.5).abs() < 1e-9);
        let timeline_1 = offline_measure_times(&score, &options, 1, 0, &score_tempo_marks(&score));
        assert!((timeline_1[0].bpm - 92.0).abs() < 1e-9);
        assert!((timeline_1[1].bpm - 60.0).abs() < 1e-9);
    }

    #[test]
    fn empty_score_no_events() {
        let score = Score::new("T", 120, 4, 4, 0, 1);
        assert!(to_playback_events(&score, &opts(None)).is_empty());
    }

    #[test]
    fn single_note_at_beat_zero() {
        let mut score = Score::new("T", 120, 4, 4, 0, 1);
        score.parts[0].staves[0].measures[0].voices[0] =
            vec![Note::new(Pitch::new(Step::C, 4), Duration::Quarter)];
        let events = to_playback_events(&score, &opts(None));
        assert_eq!(events.len(), 1);
        assert_eq!(events[0].address.as_deref(), Some("0:0:0:0:0"));
        assert_eq!(
            events[0].source,
            Some(NoteAddr {
                part: 0,
                staff: 0,
                measure: 0,
                voice: 0,
                note: 0,
            })
        );
        assert!((events[0].time_beats).abs() < 1e-9);
        assert_eq!(events[0].pitch_midi, 60);
        assert_eq!(events[0].velocity, 64);
        assert!((events[0].duration_beats - 1.0).abs() < 1e-9);
        assert_eq!(events[0].part_index, 0);
    }

    #[test]
    fn tied_notes_are_one_continuous_playback_event() {
        let mut score = Score::new("T", 120, 4, 4, 0, 1);
        let mut first = Note::new(Pitch::new(Step::C, 4), Duration::Quarter);
        first.tie_start = true;
        let mut second = Note::new(Pitch::new(Step::C, 4), Duration::Quarter);
        second.tie_end = true;
        score.parts[0].staves[0].measures[0].voices[0] = vec![first, second];

        let events = to_playback_events(&score, &opts(None));
        assert_eq!(events.len(), 1);
        assert_eq!(
            events[0].source.as_ref().map(|address| address.note),
            Some(0)
        );
        assert!((events[0].time_beats).abs() < 1e-9);
        assert!((events[0].duration_beats - 2.0).abs() < 1e-9);
        assert!((events[0].duration_secs - 1.0).abs() < 1e-9);
    }

    #[test]
    fn staccato_tied_across_barline_has_one_half_length_attack() {
        for marks in [[true, false], [false, true], [true, true]] {
            let mut score = Score::new("tied staccato", 120, 4, 4, 0, 2);
            let mut first = Note::new(Pitch::new(Step::D, 5), Duration::Eighth);
            first.tie_start = true;
            let mut second = Note::new(Pitch::new(Step::D, 5), Duration::Eighth);
            second.tie_end = true;
            if marks[0] {
                first.articulations.push(Articulation::Staccato);
            }
            if marks[1] {
                second.articulations.push(Articulation::Staccato);
            }
            score.parts[0].staves[0].measures[0].voices[0] = vec![
                Note::rest(Duration::Half),
                Note::rest(Duration::Quarter),
                Note::rest(Duration::Eighth),
                first,
            ];
            score.parts[0].staves[0].measures[1].voices[0] = vec![second];
            let events = to_playback_events(&score, &opts(None));
            assert_eq!(events.len(), 1, "articulations: {marks:?}");
            assert_eq!(events[0].pitch_midi, 74);
            assert_eq!(events[0].time_beats, 3.5);
            assert!(events[0].articulations.contains(&Articulation::Staccato));
            assert!((events[0].duration_beats - 0.5).abs() < 1e-9);
            assert!((events[0].duration_secs - 0.25).abs() < 1e-9);
        }
    }

    #[test]
    fn tied_staccato_uses_tempo_at_sounding_end() {
        let mut score = Score::new("tied tempo", 120, 4, 4, 0, 2);
        let mut first = Note::new(Pitch::new(Step::D, 5), Duration::Eighth);
        first.tie_start = true;
        first.articulations.push(Articulation::Staccato);
        let mut second = Note::new(Pitch::new(Step::D, 5), Duration::Quarter);
        second.dot_count = 1;
        second.tie_end = true;
        score.parts[0].staves[0].measures[0].voices[0] = vec![
            Note::rest(Duration::Half),
            Note::rest(Duration::Quarter),
            Note::rest(Duration::Eighth),
            first,
        ];
        score.parts[0].staves[0].measures[1].tempo = Some(60);
        score.parts[0].staves[0].measures[1].voices[0] = vec![second];
        let events = to_playback_events(&score, &opts(None));
        assert_eq!(events.len(), 1);
        assert!((events[0].duration_beats - 1.0).abs() < 1e-9);
        assert!((events[0].duration_secs - 0.75).abs() < 1e-9);
    }

    #[test]
    fn a_tie_on_one_chord_pitch_holds_only_that_pitch() {
        let mut score = Score::new("T", 120, 4, 4, 0, 1);
        // C–G chord tied on C only into another C–G chord: G re-strikes, C sustains.
        let chord = || {
            let mut note = Note::new(Pitch::new(Step::C, 4), Duration::Quarter);
            note.pitches.push(Pitch::new(Step::G, 4));
            note
        };
        let mut first = chord();
        first.set_pitch_ties(&[true, false], &[false, false]);
        let mut second = chord();
        second.set_pitch_ties(&[false, false], &[true, false]);
        assert!(first.tie_start && second.tie_end);
        score.parts[0].staves[0].measures[0].voices[0] = vec![first, second];

        let events = to_playback_events(&score, &opts(None));
        let durations = |midi: u8| {
            events
                .iter()
                .filter(|event| event.pitch_midi == midi)
                .map(|event| event.duration_beats)
                .collect::<Vec<_>>()
        };
        assert_eq!(durations(60), vec![2.0]);
        assert_eq!(durations(67), vec![1.0, 1.0]);
    }

    #[test]
    fn ties_cross_measure_boundaries_and_tempo_changes_without_retriggering() {
        let mut score = Score::new("T", 120, 4, 4, 0, 2);
        let first_measure = &mut score.parts[0].staves[0].measures[0];
        let mut first = Note::new(Pitch::new(Step::C, 4), Duration::Whole);
        first.tie_start = true;
        first_measure.voices[0] = vec![first];

        let second_measure = &mut score.parts[0].staves[0].measures[1];
        second_measure.tempo = Some(60);
        let mut second = Note::new(Pitch::new(Step::C, 4), Duration::Whole);
        second.tie_end = true;
        second_measure.voices[0] = vec![second];

        let events = to_playback_events(&score, &opts(None));
        assert_eq!(events.len(), 1);
        assert_eq!(
            events[0].source.as_ref().map(|address| address.measure),
            Some(0)
        );
        assert!((events[0].time_beats).abs() < 1e-9);
        assert!((events[0].duration_beats - 8.0).abs() < 1e-9);
        assert!((events[0].duration_secs - 6.0).abs() < 1e-9);
    }

    #[test]
    fn ties_continue_across_voice_and_staff_changes() {
        let whole_c = || Note::new(Pitch::new(Step::C, 4), Duration::Whole);

        let mut voice_score = Score::new("voice change", 120, 4, 4, 0, 2);
        let mut start = whole_c();
        start.tie_start = true;
        let mut end = whole_c();
        end.tie_end = true;
        voice_score.parts[0].staves[0].measures[0].voices[0] = vec![start.clone()];
        voice_score.parts[0].staves[0].measures[1].voices[1] = vec![end.clone()];
        let events = to_playback_events(&voice_score, &opts(None));
        assert_eq!(events.len(), 1);
        assert_eq!(events[0].time_beats, 0.0);
        assert_eq!(events[0].duration_beats, 8.0);

        let mut staff_score = Score::new("staff change", 120, 4, 4, 0, 2);
        let second_staff = staff_score.parts[0].staves[0].clone();
        staff_score.parts[0].staves.push(second_staff);
        staff_score.parts[0].staves[0].measures[0].voices[0] = vec![start];
        staff_score.parts[0].staves[1].measures[1].voices[0] = vec![end];
        let events = to_playback_events(&staff_score, &opts(None));
        assert_eq!(events.len(), 1);
        assert_eq!(events[0].time_beats, 0.0);
        assert_eq!(events[0].duration_beats, 8.0);
    }

    #[test]
    fn cross_voice_tie_keeps_independent_unison_attacks() {
        let mut score = Score::new("unison", 120, 4, 4, 0, 2);
        let mut start = Note::new(Pitch::new(Step::C, 4), Duration::Whole);
        start.tie_start = true;
        let mut end = Note::new(Pitch::new(Step::C, 4), Duration::Whole);
        end.tie_end = true;
        score.parts[0].staves[0].measures[0].voices[0] = vec![start];
        score.parts[0].staves[0].measures[0].voices[1] =
            vec![Note::new(Pitch::new(Step::C, 4), Duration::Whole)];
        score.parts[0].staves[0].measures[1].voices[1] = vec![end];
        score.parts[0].staves[0].measures[1].voices[2] =
            vec![Note::new(Pitch::new(Step::C, 4), Duration::Whole)];

        let mut durations: Vec<_> = to_playback_events(&score, &opts(None))
            .into_iter()
            .map(|event| event.duration_beats)
            .collect();
        durations.sort_by(f64::total_cmp);
        assert_eq!(durations, vec![4.0, 4.0, 8.0]);
    }

    #[test]
    fn malformed_tie_end_does_not_drop_playback_event() {
        let mut score = Score::new("T", 120, 4, 4, 0, 1);
        let mut note = Note::new(Pitch::new(Step::C, 4), Duration::Quarter);
        note.tie_end = true;
        score.parts[0].staves[0].measures[0].voices[0] = vec![note];
        let events = to_playback_events(&score, &opts(None));
        assert_eq!(events.len(), 1);
        assert!((events[0].duration_beats - 1.0).abs() < 1e-9);
    }

    #[test]
    fn microtonal_playback_event_keeps_exact_midi_cents() {
        let mut score = Score::new("T", 120, 4, 4, 0, 1);
        score.parts[0].staves[0].measures[0].voices[0] = vec![Note::new(
            Pitch::with_microtone(Step::C, 4, 0, 50),
            Duration::Quarter,
        )];
        let events = to_playback_events(&score, &opts(None));
        assert_eq!(events[0].pitch_midi, 61);
        assert_eq!(events[0].pitch_midi_cents, 6050);
    }

    #[test]
    fn chord_expands_to_multiple_events() {
        let mut score = Score::new("T", 120, 4, 4, 0, 1);
        let mut note = Note::new(Pitch::new(Step::C, 4), Duration::Quarter);
        note.pitches.push(Pitch::new(Step::E, 4));
        note.pitches.push(Pitch::new(Step::G, 4));
        score.parts[0].staves[0].measures[0].voices[0] = vec![note];
        let events = to_playback_events(&score, &opts(None));
        assert_eq!(events.len(), 3);
        assert!(
            events
                .iter()
                .all(|event| event.address.as_deref() == Some("0:0:0:0:0"))
        );
        assert!(events.iter().all(|e| e.time_beats.abs() < 1e-9));
    }

    #[test]
    fn playback_events_preserve_authored_chord_symbol_without_inventing_notes() {
        let mut score = Score::new("Harmony", 120, 4, 4, 0, 1);
        let mut note = Note::new(Pitch::new(Step::C, 4), Duration::Quarter);
        note.chord_symbol = Some(ChordSymbol {
            root: "C".into(),
            kind: "major-seventh".into(),
            bass: Some("E".into()),
            placement: None,
            extender: false,
            harmonic_degree: None,
            harmony_function: None,
            harmony_type: None,
            chord_ref: None,
            range_end: None,
            degrees: Vec::new(),
        });
        score.parts[0].staves[0].measures[0].voices[0] = vec![note];

        let events = to_playback_events(&score, &PlaybackOptions::default());
        assert_eq!(events.len(), 1);
        assert_eq!(events[0].pitch_midi, 60);
        assert_eq!(
            events[0]
                .chord_symbol
                .as_ref()
                .map(ChordSymbol::display_text),
            Some("Cmaj7/E".into())
        );
    }

    #[test]
    fn authored_realization_default_keeps_ornament_as_one_semantic_event() {
        let mut score = Score::new("authored ornament", 120, 4, 4, 0, 1);
        let mut note = Note::new(Pitch::new(Step::C, 4), Duration::Quarter);
        note.articulations.push(Articulation::Trill);
        score.parts[0].staves[0].measures[0].voices[0] = vec![note];

        let events = to_playback_events(&score, &PlaybackOptions::default());
        assert_eq!(events.len(), 1);
        assert_eq!(events[0].pitch_midi, 60);
        assert_eq!(events[0].articulations, vec![Articulation::Trill]);
    }

    #[test]
    fn ornament_arpeggio_profile_realizes_trill_with_pinned_timing() {
        let mut score = Score::new("realized ornament", 120, 4, 4, 0, 1);
        let mut note = Note::new(Pitch::new(Step::C, 4), Duration::Quarter);
        note.articulations.push(Articulation::Trill);
        score.parts[0].staves[0].measures[0].voices[0] = vec![note];

        let events = to_playback_events(
            &score,
            &PlaybackOptions {
                realization_profile: PlaybackRealizationProfile::OrnamentArpeggioV1,
                ..Default::default()
            },
        );
        assert_eq!(events.len(), 4);
        assert_eq!(
            events
                .iter()
                .map(|event| event.pitch_midi)
                .collect::<Vec<_>>(),
            vec![60, 61, 60, 61]
        );
        for (index, event) in events.iter().enumerate() {
            assert!((event.time_beats - index as f64 * 0.25).abs() < 1e-9);
            assert!((event.duration_beats - 0.25).abs() < 1e-9);
            assert!((event.time_secs - index as f64 * 0.125).abs() < 1e-9);
            assert!((event.duration_secs - 0.125).abs() < 1e-9);
            assert!(!event.articulations.contains(&Articulation::Trill));
        }
    }

    #[test]
    fn ornament_arpeggio_profile_staggers_chord_in_authored_direction() {
        let mut score = Score::new("realized arpeggio", 120, 4, 4, 0, 1);
        let mut chord = Note::new(Pitch::new(Step::C, 4), Duration::Quarter);
        chord.pitches.push(Pitch::new(Step::E, 4));
        chord.pitches.push(Pitch::new(Step::G, 4));
        chord.arpeggiate = Some(false);
        score.parts[0].staves[0].measures[0].voices[0] = vec![chord];

        let events = to_playback_events(
            &score,
            &PlaybackOptions {
                realization_profile: PlaybackRealizationProfile::OrnamentArpeggioV1,
                ..Default::default()
            },
        );
        assert_eq!(events.len(), 3);
        let by_pitch: BTreeMap<_, _> = events
            .iter()
            .map(|event| (event.pitch_midi, event.time_beats))
            .collect();
        assert!((by_pitch[&67] - 0.0).abs() < 1e-9);
        assert!((by_pitch[&64] - 0.09).abs() < 1e-9);
        assert!((by_pitch[&60] - 0.18).abs() < 1e-9);
    }

    #[test]
    fn written_grace_steals_time_from_preceding_note() {
        let mut score = Score::new("T", 120, 4, 4, 0, 1);
        let previous = Note::new(Pitch::new(Step::F, 4), Duration::Half);
        let mut grace = Note::new(Pitch::new(Step::B, 4), Duration::Eighth);
        grace.is_grace = true;
        let regular = Note::new(Pitch::new(Step::A, 4), Duration::Quarter);
        score.parts[0].staves[0].measures[0].voices[0] = vec![previous, grace, regular];
        let events = to_playback_events(&score, &opts(None));
        assert_eq!(events.len(), 3);
        assert_eq!(
            events
                .iter()
                .map(|event| event.pitch_midi)
                .collect::<Vec<_>>(),
            vec![65, 71, 69]
        );
        assert!((events[0].duration_beats - 1.875).abs() < 1e-9);
        assert!((events[1].time_beats - 1.875).abs() < 1e-9);
        assert!((events[1].duration_beats - 0.125).abs() < 1e-9);
        assert!((events[2].time_beats - 2.0).abs() < 1e-9);
        assert!((events[1].time_secs - 0.9375).abs() < 1e-9);
    }

    #[test]
    fn opening_grace_borrows_from_main_note_without_moving_later_notes() {
        let mut score = Score::new("opening grace", 120, 4, 4, 0, 1);
        let mut grace = Note::new(Pitch::new(Step::D, 4), Duration::Eighth);
        grace.is_grace = true;
        let main = Note::new(Pitch::new(Step::C, 4), Duration::Quarter);
        let next = Note::new(Pitch::new(Step::E, 4), Duration::Quarter);
        score.parts[0].staves[0].measures[0].voices[0] = vec![grace, main, next];
        let events = to_playback_events(&score, &opts(None));
        assert_eq!(events.len(), 3);
        assert_eq!(
            events
                .iter()
                .map(|event| event.pitch_midi)
                .collect::<Vec<_>>(),
            vec![62, 60, 64]
        );
        assert!((events[0].time_beats).abs() < 1e-9);
        assert!((events[0].duration_beats - 0.125).abs() < 1e-9);
        assert!((events[1].time_beats - 0.125).abs() < 1e-9);
        assert!((events[1].duration_beats - 0.875).abs() < 1e-9);
        assert!((events[2].time_beats - 1.0).abs() < 1e-9);
    }

    #[test]
    fn consecutive_graces_are_ordered_and_cue_notes_remain_silent() {
        let mut score = Score::new("two graces", 120, 4, 4, 0, 1);
        let mut first_grace = Note::new(Pitch::new(Step::D, 4), Duration::Sixteenth);
        first_grace.is_grace = true;
        let mut second_grace = Note::new(Pitch::new(Step::E, 4), Duration::Sixteenth);
        second_grace.is_grace = true;
        let mut cue = Note::new(Pitch::new(Step::B, 4), Duration::Eighth);
        cue.is_cue = true;
        score.parts[0].staves[0].measures[0].voices[0] = vec![
            Note::new(Pitch::new(Step::C, 4), Duration::Quarter),
            first_grace,
            second_grace,
            Note::new(Pitch::new(Step::F, 4), Duration::Quarter),
            cue,
        ];
        let events = to_playback_events(&score, &opts(None));
        assert_eq!(
            events
                .iter()
                .map(|event| event.pitch_midi)
                .collect::<Vec<_>>(),
            vec![60, 62, 64, 65]
        );
        assert_eq!(
            events
                .iter()
                .map(|event| event.time_beats)
                .collect::<Vec<_>>(),
            vec![0.0, 0.875, 0.9375, 1.0]
        );
        assert!((events[0].duration_beats - 0.875).abs() < 1e-9);
    }

    #[test]
    fn metronome_events_have_no_source_address() {
        let score = Score::new("T", 120, 4, 4, 0, 1);
        let options = PlaybackOptions {
            metronome: Some(MetronomeConfig::default()),
            ..Default::default()
        };
        let events = to_playback_events(&score, &options);
        assert!(!events.is_empty());
        assert!(events.iter().all(|event| event.address.is_none()));
    }

    #[test]
    fn second_note_has_correct_time() {
        let mut score = Score::new("T", 120, 4, 4, 0, 1);
        score.parts[0].staves[0].measures[0].voices[0] = vec![
            Note::new(Pitch::new(Step::C, 4), Duration::Quarter),
            Note::new(Pitch::new(Step::D, 4), Duration::Quarter),
        ];
        let events = to_playback_events(&score, &opts(None));
        assert_eq!(events.len(), 2);
        assert!((events[0].time_beats).abs() < 1e-9);
        assert!((events[1].time_beats - 1.0).abs() < 1e-9);
    }

    #[test]
    fn sparse_voice_keeps_measure_boundaries() {
        let mut score = Score::new("T", 120, 4, 4, 0, 2);
        let note = || Note::new(Pitch::new(Step::C, 4), Duration::Quarter);
        score.parts[0].staves[0].measures[0].voices[1] = vec![note()];
        score.parts[0].staves[0].measures[1].voices[1] = vec![note()];

        let events = to_playback_events(&score, &opts(None));
        assert_eq!(events.len(), 2);
        assert!((events[0].time_beats).abs() < 1e-9);
        assert!((events[1].time_beats - 4.0).abs() < 1e-9);
        assert!((events[1].time_secs - 2.0).abs() < 1e-9);
    }

    #[test]
    fn time_secs_120_bpm_quarter_note_is_half_second() {
        let mut score = Score::new("T", 120, 4, 4, 0, 1);
        score.parts[0].staves[0].measures[0].voices[0] =
            vec![Note::new(Pitch::new(Step::C, 4), Duration::Quarter)];
        let events = to_playback_events(&score, &opts(None));
        assert!((events[0].time_secs).abs() < 1e-9);
        assert!((events[0].duration_secs - 0.5).abs() < 1e-9);
    }

    #[test]
    fn bpm_override_changes_time_secs() {
        let mut score = Score::new("T", 120, 4, 4, 0, 1);
        score.parts[0].staves[0].measures[0].voices[0] = vec![
            Note::new(Pitch::new(Step::C, 4), Duration::Quarter),
            Note::new(Pitch::new(Step::D, 4), Duration::Quarter),
        ];
        let events = to_playback_events(&score, &opts(Some(60)));
        assert!((events[0].time_secs).abs() < 1e-9);
        assert!((events[1].time_secs - 1.0).abs() < 1e-9);
    }

    #[test]
    fn tempo_multiplier_preserves_written_tempo_changes_and_ramps() {
        let mut score = Score::new("T", 120, 4, 4, 0, 2);
        score.parts[0].staves[0].measures[0].tempo_ramp_to = Some(60);
        score.parts[0].staves[0].measures[1].tempo = Some(90);
        score.parts[0].staves[0].measures[0].voices[0] =
            vec![Note::new(Pitch::new(Step::C, 4), Duration::Quarter)];
        score.parts[0].staves[0].measures[1].voices[0] =
            vec![Note::new(Pitch::new(Step::D, 4), Duration::Quarter)];
        let options = PlaybackOptions {
            tempo_multiplier: 0.5,
            ..Default::default()
        };

        let events = to_playback_events(&score, &options);
        let second_measure_start = tempo_ramp_seconds(60.0, Some(30.0), 4.0, 4.0);
        assert!((events[1].time_secs - second_measure_start).abs() < 1e-9);

        let one_beat_into_ramp = tempo_ramp_seconds(60.0, Some(30.0), 4.0, 1.0);
        let position = compute_playback_position(&score, &options, one_beat_into_ramp).unwrap();
        assert_eq!(position.measure_index, 0);
        assert!((position.beat - 1.0).abs() < 1e-9);

        let second_measure_position =
            compute_playback_position(&score, &options, second_measure_start + 60.0 / 45.0)
                .unwrap();
        assert_eq!(second_measure_position.measure_index, 1);
        assert!((second_measure_position.beat - 1.0).abs() < 1e-9);
    }

    #[test]
    fn bpm_override_suppresses_written_tempo_changes_and_ramps() {
        let mut score = Score::new("T", 120, 4, 4, 0, 2);
        score.parts[0].staves[0].measures[0].tempo_ramp_to = Some(60);
        score.parts[0].staves[0].measures[1].tempo = Some(90);
        score.parts[0].staves[0].measures[0].voices[0] =
            vec![Note::new(Pitch::new(Step::C, 4), Duration::Quarter)];
        score.parts[0].staves[0].measures[1].voices[0] =
            vec![Note::new(Pitch::new(Step::D, 4), Duration::Quarter)];
        let options = PlaybackOptions {
            bpm_override: Some(120),
            ..Default::default()
        };

        let events = to_playback_events(&score, &options);
        assert!((events[1].time_secs - 2.0).abs() < 1e-9);
        let position = compute_playback_position(&score, &options, 2.5).unwrap();
        assert_eq!(position.measure_index, 1);
        assert!((position.beat - 1.0).abs() < 1e-9);
    }

    #[test]
    fn playback_position_tracks_repeats_rests_and_meter_changes_with_a_tempo_multiplier() {
        use crate::model::notation::{Barline, TimeSignature};

        let mut score = Score::new("transport", 120, 4, 4, 0, 3);
        let staff = &mut score.parts[0].staves[0];
        staff.measures[0].barline_left = Barline::RepeatStart;
        staff.measures[1].time_sig = Some(TimeSignature {
            numerator: 3,
            denominator: 4,
        });
        staff.measures[2].barline_right = Barline::RepeatEnd;
        staff.measures[0].voices[0] = vec![Note::new(Pitch::new(Step::C, 4), Duration::Quarter)];
        staff.measures[1].voices[0] = vec![Note::rest(Duration::Quarter)];
        staff.measures[2].voices[0] = vec![Note::new(Pitch::new(Step::D, 4), Duration::Quarter)];
        let options = PlaybackOptions {
            tempo_multiplier: 0.5,
            ..Default::default()
        };

        let events = to_playback_events(&score, &options);
        let note_starts: Vec<f64> = events
            .iter()
            .filter(|event| event.address.is_some())
            .map(|event| event.time_secs)
            .collect();
        // 4/4 (4s), then 3/4 rest (3s) and note (3s). The repeat restarts at 10s.
        assert_eq!(note_starts, vec![0.0, 7.0, 10.0, 17.0]);

        let middle = compute_playback_position(&score, &options, 5.0).unwrap();
        assert_eq!(middle.measure_index, 1);
        assert!((middle.beat - 1.0).abs() < 1e-9);

        let repeated = compute_playback_position(&score, &options, 10.5).unwrap();
        assert_eq!(repeated.measure_index, 0);
        assert!((repeated.beat - 0.5).abs() < 1e-9);
    }

    #[test]
    fn transpose_semitones_shifts_midi_output() {
        let mut score = Score::new("T", 120, 4, 4, 0, 1);
        score.parts[0].staves[0].transpose_semitones = -2;
        score.parts[0].staves[0].measures[0].voices[0] =
            vec![Note::new(Pitch::new(Step::C, 4), Duration::Quarter)];
        let events = to_playback_events(&score, &opts(None));
        assert_eq!(events.len(), 1);
        assert_eq!(events[0].pitch_midi, 58);
    }

    #[test]
    fn percussion_channel_9_ignores_transpose_semitones() {
        let mut score = Score::new("T", 120, 4, 4, 0, 1);
        score.parts[0].midi_channel = 9;
        score.parts[0].staves[0].transpose_semitones = -2;
        score.parts[0].staves[0].measures[0].voices[0] =
            vec![Note::new(Pitch::new(Step::C, 4), Duration::Quarter)];
        let events = to_playback_events(&score, &opts(None));
        assert_eq!(events.len(), 1);
        assert_eq!(events[0].pitch_midi, 60);
    }

    #[test]
    fn staccato_halves_duration_beats() {
        let mut score = Score::new("T", 120, 4, 4, 0, 1);
        let mut note = Note::new(Pitch::new(Step::C, 4), Duration::Quarter);
        note.articulations
            .push(crate::model::notation::Articulation::Staccato);
        score.parts[0].staves[0].measures[0].voices[0] = vec![note];
        let events = to_playback_events(&score, &opts(None));
        assert_eq!(events.len(), 1);
        assert!((events[0].duration_beats - 0.5).abs() < 1e-9);
    }

    #[test]
    fn staccatissimo_also_halves_duration() {
        let mut score = Score::new("T", 120, 4, 4, 0, 1);
        let mut note = Note::new(Pitch::new(Step::C, 4), Duration::Quarter);
        note.articulations
            .push(crate::model::notation::Articulation::Staccatissimo);
        score.parts[0].staves[0].measures[0].voices[0] = vec![note];
        let events = to_playback_events(&score, &opts(None));
        assert!((events[0].duration_beats - 0.5).abs() < 1e-9);
    }

    #[test]
    fn staccato_does_not_shift_next_note_time() {
        let mut score = Score::new("T", 120, 4, 4, 0, 1);
        let mut n1 = Note::new(Pitch::new(Step::C, 4), Duration::Quarter);
        n1.articulations
            .push(crate::model::notation::Articulation::Staccato);
        let n2 = Note::new(Pitch::new(Step::D, 4), Duration::Quarter);
        score.parts[0].staves[0].measures[0].voices[0] = vec![n1, n2];
        let events = to_playback_events(&score, &opts(None));
        assert_eq!(events.len(), 2);
        assert!((events[1].time_beats - 1.0).abs() < 1e-9);
    }

    #[test]
    fn dynamics_hold_until_the_next_marking_across_voices_and_bars() {
        use crate::model::notation::Dynamic;
        let mut score = Score::new("T", 120, 4, 4, 0, 2);
        let quarters = |dynamics: [Option<Dynamic>; 4]| -> Vec<Note> {
            dynamics
                .into_iter()
                .map(|dynamic| {
                    let mut note = Note::new(Pitch::new(Step::C, 4), Duration::Quarter);
                    note.dynamic = dynamic;
                    note
                })
                .collect()
        };
        // Bar 1: p, (p), sf, (p) ; bar 2: fp, (p), pf, (f). Voice 2 in bar 1 holds a half
        // note at beat 2, when voice 1's sf sounds, and one at beat 0.
        score.parts[0].staves[0].measures[0].voices[0] =
            quarters([Some(Dynamic::P), None, Some(Dynamic::Sf), None]);
        score.parts[0].staves[0].measures[0].voices[1] = vec![
            Note::new(Pitch::new(Step::C, 3), Duration::Half),
            Note::new(Pitch::new(Step::C, 3), Duration::Half),
        ];
        score.parts[0].staves[0].measures[1].voices[0] =
            quarters([Some(Dynamic::Fp), None, Some(Dynamic::Pf), None]);
        let events = to_playback_events(&score, &opts(None));
        let velocities = |pitch: u8| -> Vec<u8> {
            events
                .iter()
                .filter(|event| event.pitch_midi == pitch)
                .map(|event| event.velocity)
                .collect()
        };
        let (p, f, sf) = (
            Dynamic::P.to_velocity(),
            Dynamic::F.to_velocity(),
            Dynamic::Sf.to_velocity(),
        );
        assert_eq!(velocities(60), vec![p, p, sf, p, f, p, p, f]);
        assert_eq!(velocities(48), vec![p, sf]);
        // Before any marking, notes keep the historical default.
        assert_eq!(
            DynamicTimeline::default().velocity(0, 0.0, None),
            DynamicTimeline::DEFAULT_VELOCITY
        );
    }

    #[test]
    fn hairpins_ramp_towards_the_following_marking_or_two_steps() {
        use crate::model::notation::{Dynamic, HairpinKind};
        let mut score = Score::new("T", 120, 4, 4, 0, 2);
        let mut bar = |index: usize, dynamics: [Option<Dynamic>; 4], end: Option<Dynamic>| {
            let mut notes: Vec<Note> = dynamics
                .into_iter()
                .map(|dynamic| {
                    let mut note = Note::new(Pitch::new(Step::C, 4), Duration::Quarter);
                    note.dynamic = dynamic;
                    note
                })
                .collect();
            notes[0].hairpin_start = Some(HairpinKind::Crescendo);
            notes[2].hairpin_end = true;
            notes[3].dynamic = end;
            score.parts[0].staves[0].measures[index].voices[0] = notes;
        };
        // Bar 1: p < (three beats) f. Bar 2: < with nothing after: two steps above f.
        bar(0, [Some(Dynamic::P), None, None, None], Some(Dynamic::F));
        bar(1, [None, None, None, None], None);
        let events = to_playback_events(&score, &opts(None));
        let velocities: Vec<u8> = events.iter().map(|event| event.velocity).collect();
        assert_eq!(&velocities[..4], &[48, 60, 72, 84]);
        assert_eq!(&velocities[4..], &[84, 92, 100, 108]);
    }

    #[test]
    fn explicit_dynamic_at_hairpin_end_overrides_terminal_level_in_all_voices() {
        use crate::{Dynamic, HairpinKind};
        for (hairpin, dynamic, attack, sustain) in [
            (HairpinKind::Crescendo, Dynamic::P, 48, 48),
            (HairpinKind::Decrescendo, Dynamic::F, 84, 84),
            (
                HairpinKind::Decrescendo,
                Dynamic::Sfz,
                Dynamic::Sfz.to_velocity(),
                40,
            ),
            (
                HairpinKind::Crescendo,
                Dynamic::Pf,
                Dynamic::Pf.to_velocity(),
                84,
            ),
        ] {
            let mut score = Score::new("endpoint", 120, 4, 4, 0, 2);
            let mut first = Note::new(Pitch::new(Step::C, 4), Duration::Whole);
            first.hairpin_start = Some(hairpin);
            first.hairpin_end = true;
            score.parts[0].staves[0].measures[0].voices[0] = vec![first];
            let mut upper = Note::new(Pitch::new(Step::C, 5), Duration::Half);
            upper.dynamic = Some(dynamic);
            score.parts[0].staves[0].measures[1].voices[0] =
                vec![upper, Note::new(Pitch::new(Step::D, 5), Duration::Half)];
            score.parts[0].staves[0].measures[1].voices[1] = vec![
                Note::new(Pitch::new(Step::E, 4), Duration::Half),
                Note::new(Pitch::new(Step::F, 4), Duration::Half),
            ];
            let events = to_playback_events(&score, &opts(None));
            let at_start: Vec<_> = events
                .iter()
                .filter(|e| (e.time_beats - 4.0).abs() < 1e-9)
                .map(|e| e.velocity)
                .collect();
            let later: Vec<_> = events
                .iter()
                .filter(|e| (e.time_beats - 6.0).abs() < 1e-9)
                .map(|e| e.velocity)
                .collect();
            assert_eq!(at_start, vec![attack, attack]);
            assert_eq!(later, vec![sustain, sustain]);
        }
    }

    #[test]
    fn dynamic_names_round_trip_and_compounds_continue_at_their_second_level() {
        use crate::model::notation::Dynamic;
        for dynamic in Dynamic::ALL {
            assert_eq!(
                Dynamic::from_musicxml_str(dynamic.to_musicxml_str()),
                Some(dynamic)
            );
        }
        assert_eq!(Dynamic::from_musicxml_str("fffff"), Some(Dynamic::Ffff));
        assert_eq!(Dynamic::Sfpp.sustained_level(), Some(Dynamic::Pp));
        assert_eq!(Dynamic::Sfz.sustained_level(), None);
        assert_eq!(Dynamic::from_musicxml_str("other"), None);
    }

    #[test]
    fn accent_boosts_velocity_clamped() {
        let mut score = Score::new("T", 120, 4, 4, 0, 1);
        let mut note = Note::new(Pitch::new(Step::C, 4), Duration::Quarter);
        note.articulations
            .push(crate::model::notation::Articulation::Accent);
        score.parts[0].staves[0].measures[0].voices[0] = vec![note];
        let events = to_playback_events(&score, &opts(None));
        assert_eq!(events[0].velocity, 84);
    }

    #[test]
    fn accent_clamped_at_127() {
        let mut score = Score::new("T", 120, 4, 4, 0, 1);
        let mut note = Note::new(Pitch::new(Step::C, 4), Duration::Quarter);
        note.dynamic = Some(crate::model::notation::Dynamic::Ffff);
        note.articulations
            .push(crate::model::notation::Articulation::Accent);
        score.parts[0].staves[0].measures[0].voices[0] = vec![note];
        let events = to_playback_events(&score, &opts(None));
        assert_eq!(events[0].velocity, 127);
    }

    #[test]
    fn tenuto_keeps_full_duration() {
        let mut score = Score::new("T", 120, 4, 4, 0, 1);
        let mut note = Note::new(Pitch::new(Step::C, 4), Duration::Quarter);
        note.articulations
            .push(crate::model::notation::Articulation::Tenuto);
        score.parts[0].staves[0].measures[0].voices[0] = vec![note];
        let events = to_playback_events(&score, &opts(None));
        assert!((events[0].duration_beats - 1.0).abs() < 1e-9);
    }

    #[test]
    fn pedal_start_sets_pedal_field() {
        let mut score = Score::new("T", 120, 4, 4, 0, 1);
        let mut note = Note::new(Pitch::new(Step::C, 4), Duration::Quarter);
        note.pedal_start = true;
        score.parts[0].staves[0].measures[0].voices[0] = vec![note];
        let events = to_playback_events(&score, &opts(None));
        assert!(events[0].pedal);
    }

    #[test]
    fn no_pedal_start_pedal_is_false() {
        let mut score = Score::new("T", 120, 4, 4, 0, 1);
        score.parts[0].staves[0].measures[0].voices[0] =
            vec![Note::new(Pitch::new(Step::C, 4), Duration::Quarter)];
        let events = to_playback_events(&score, &opts(None));
        assert!(!events[0].pedal);
    }

    #[test]
    fn set_tempo_at_measure_changes_time_secs() {
        let mut score = Score::new("T", 120, 4, 4, 0, 2);
        score.parts[0].staves[0].measures[0].voices[0] =
            vec![Note::new(Pitch::new(Step::C, 4), Duration::Whole)];
        score.parts[0].staves[0].measures[1].tempo = Some(60);
        score.parts[0].staves[0].measures[1].voices[0] =
            vec![Note::new(Pitch::new(Step::D, 4), Duration::Whole)];
        let events = to_playback_events(&score, &opts(None));
        assert_eq!(events.len(), 2);
        assert!((events[0].time_secs).abs() < 1e-9);
        assert!((events[0].duration_secs - 2.0).abs() < 1e-9);
        assert!((events[1].time_secs - 2.0).abs() < 1e-9);
        assert!((events[1].duration_secs - 4.0).abs() < 1e-9);
    }

    #[test]
    fn muted_part_produces_no_events() {
        let mut score = Score::new("T", 120, 4, 4, 0, 1);
        score.parts[0].staves[0].measures[0].voices[0] =
            vec![Note::new(Pitch::new(Step::C, 4), Duration::Quarter)];
        let options = PlaybackOptions {
            muted_parts: vec![0],
            ..Default::default()
        };
        assert!(to_playback_events(&score, &options).is_empty());
    }

    #[test]
    fn part_index_field_set_correctly() {
        let mut score = Score::new("T", 120, 4, 4, 0, 1);
        score.parts[0].staves[0].measures[0].voices[0] =
            vec![Note::new(Pitch::new(Step::C, 4), Duration::Quarter)];
        let events = to_playback_events(&score, &opts(None));
        assert_eq!(events[0].part_index, 0);
    }

    // ── loop_region ───────────────────────────────────────────────────────────

    #[test]
    fn loop_region_filters_measures() {
        // 3 measures; notes in measures 0, 1, 2. Loop on [1,2] → only events from 1,2.
        let mut score = Score::new("T", 120, 4, 4, 0, 3);
        for mi in 0..3 {
            score.parts[0].staves[0].measures[mi].voices[0] =
                vec![Note::new(Pitch::new(Step::C, 4), Duration::Whole)];
        }
        let options = PlaybackOptions {
            loop_region: Some((1, 2)),
            ..Default::default()
        };
        let events = to_playback_events(&score, &options);
        assert_eq!(events.len(), 2);
        // First event in the region should start at beat 0 (region-relative)
        assert!((events[0].time_beats).abs() < 1e-9);
    }

    #[test]
    fn loop_region_none_plays_all_measures() {
        let mut score = Score::new("T", 120, 4, 4, 0, 3);
        for mi in 0..3 {
            score.parts[0].staves[0].measures[mi].voices[0] =
                vec![Note::new(Pitch::new(Step::C, 4), Duration::Whole)];
        }
        let events = to_playback_events(&score, &opts(None));
        assert_eq!(events.len(), 3);
    }

    // ── Fermata ───────────────────────────────────────────────────────────────

    #[test]
    fn fermata_holds_a_shared_clock_across_voices_and_repeat_traversal() {
        use crate::model::notation::Barline;
        let mut score = Score::new("Shared fermata", 120, 3, 4, 0, 1);
        let measure = &mut score.parts[0].staves[0].measures[0];
        measure.barline_left = Barline::RepeatStart;
        measure.barline_right = Barline::RepeatEnd;
        let mut held = Note::new(Pitch::new(Step::C, 4), Duration::Quarter);
        held.articulations.push(Articulation::Fermata);
        measure.voices[0] = vec![
            held,
            Note::new(Pitch::new(Step::D, 4), Duration::Quarter),
            Note::new(Pitch::new(Step::E, 4), Duration::Quarter),
        ];
        measure.voices[1] = vec![
            Note::new(Pitch::new(Step::C, 3), Duration::Half),
            Note::new(Pitch::new(Step::G, 3), Duration::Quarter),
        ];
        let events = to_playback_events(&score, &PlaybackOptions::default());
        let onsets = |pitch| {
            events
                .iter()
                .filter(|event| event.pitch_midi == pitch)
                .map(|event| event.time_beats)
                .collect::<Vec<_>>()
        };
        assert_eq!(onsets(60), vec![0.0, 3.5]);
        assert_eq!(onsets(62), vec![1.5, 5.0]);
        assert_eq!(onsets(64), vec![2.5, 6.0]);
        assert_eq!(onsets(55), vec![2.5, 6.0]);
        let bass = events.iter().find(|event| event.pitch_midi == 48).unwrap();
        assert_eq!(bass.duration_beats, 2.5);
        assert_eq!(bass.duration_secs, 1.25);
        assert!((super::super::score::score_duration_secs(&score) - 3.5).abs() < 1e-9);
        assert!(
            (super::super::score::score_duration_secs_region(&score, (0, 0)) - 3.5).abs() < 1e-9
        );
    }

    #[test]
    fn simultaneous_fermatas_hold_once_and_delay_rest_pedal_and_position() {
        let mut score = Score::new("Two staves", 120, 3, 4, 0, 1);
        let mut held = Note::new(Pitch::new(Step::C, 4), Duration::Quarter);
        held.articulations.push(Articulation::Fermata);
        score.parts[0].staves[0].measures[0].voices[0] = vec![
            held.clone(),
            Note::new(Pitch::new(Step::D, 4), Duration::Half),
        ];
        let mut lower = score.parts[0].staves[0].clone();
        held.pitches[0] = Pitch::new(Step::C, 3);
        let mut rest = Note::rest(Duration::Quarter);
        rest.pedal_start = true;
        lower.measures[0].voices[0] = vec![
            held,
            rest,
            Note::new(Pitch::new(Step::E, 3), Duration::Quarter),
        ];
        lower.measures[0].voices[1] = vec![
            Note::new(Pitch::new(Step::C, 2), Duration::Half),
            Note::rest(Duration::Quarter),
        ];
        score.parts[0].staves.push(lower);
        let opts = PlaybackOptions::default();
        let events = to_playback_events(&score, &opts);
        assert_eq!(
            events
                .iter()
                .find(|event| event.pitch_midi == 62)
                .unwrap()
                .time_beats,
            1.5
        );
        assert_eq!(
            events
                .iter()
                .find(|event| event.pitch_midi == 36)
                .unwrap()
                .duration_beats,
            2.5
        );
        let manifest = build_offline_render_manifest(
            &score,
            &opts,
            &OfflineRenderRequest {
                sample_rate_hz: 48_000,
                ..Default::default()
            },
        )
        .unwrap();
        assert!(manifest.semantic_events.iter().any(|event| matches!(
            event.kind,
            OfflineRenderSemanticEventKind::Pedal { down: true }
        ) && event.frame == 36_000));
        let position = compute_playback_position(&score, &opts, 0.625).unwrap();
        assert!((position.beat - 1.0).abs() < 1e-9);
        let position = compute_playback_position(&score, &opts, 1.0).unwrap();
        assert!((position.beat - 1.5).abs() < 1e-9);
    }

    #[test]
    fn fermata_multiplier_extends_duration() {
        let mut score = Score::new("T", 120, 4, 4, 0, 1);
        let mut note = Note::new(Pitch::new(Step::C, 4), Duration::Quarter);
        note.articulations
            .push(crate::model::notation::Articulation::Fermata);
        score.parts[0].staves[0].measures[0].voices[0] = vec![note];
        let options = PlaybackOptions {
            fermata_multiplier: 2.0,
            ..Default::default()
        };
        let events = to_playback_events(&score, &options);
        assert_eq!(events.len(), 1);
        assert!((events[0].duration_beats - 2.0).abs() < 1e-9);
    }

    #[test]
    fn fermata_default_multiplier_is_1_5() {
        let mut score = Score::new("T", 120, 4, 4, 0, 1);
        let mut note = Note::new(Pitch::new(Step::C, 4), Duration::Quarter);
        note.articulations
            .push(crate::model::notation::Articulation::Fermata);
        score.parts[0].staves[0].measures[0].voices[0] = vec![note];
        let events = to_playback_events(&score, &PlaybackOptions::default());
        assert_eq!(events.len(), 1);
        assert!((events[0].duration_beats - 1.5).abs() < 1e-9);
    }

    #[test]
    fn fermata_hold_is_an_explicit_post_note_request_separate_from_extension() {
        let mut score = Score::new("T", 120, 4, 4, 0, 1);
        let mut note = Note::new(Pitch::new(Step::C, 4), Duration::Quarter);
        note.articulations
            .push(crate::model::notation::Articulation::Fermata);
        score.parts[0].staves[0].measures[0].voices[0] = vec![note];
        let options = PlaybackOptions {
            fermata_multiplier: 2.0,
            fermata_hold_beats: 0.75,
            ..Default::default()
        };
        let events = to_playback_events(&score, &options);
        assert!((events[0].duration_beats - 2.0).abs() < 1e-9);
        assert!((events[0].post_note_pause_beats - 0.75).abs() < 1e-9);
    }

    #[test]
    fn invalid_fermata_hold_is_safely_ignored() {
        let mut score = Score::new("T", 120, 4, 4, 0, 1);
        let mut note = Note::new(Pitch::new(Step::C, 4), Duration::Quarter);
        note.articulations
            .push(crate::model::notation::Articulation::Fermata);
        score.parts[0].staves[0].measures[0].voices[0] = vec![note];
        let options = PlaybackOptions {
            fermata_hold_beats: f64::NAN,
            ..Default::default()
        };
        assert_eq!(
            to_playback_events(&score, &options)[0].post_note_pause_beats,
            0.0
        );
    }

    #[test]
    fn non_fermata_note_unaffected_by_fermata_multiplier() {
        let mut score = Score::new("T", 120, 4, 4, 0, 1);
        score.parts[0].staves[0].measures[0].voices[0] =
            vec![Note::new(Pitch::new(Step::C, 4), Duration::Quarter)];
        let options = PlaybackOptions {
            fermata_multiplier: 3.0,
            ..Default::default()
        };
        let events = to_playback_events(&score, &options);
        assert!((events[0].duration_beats - 1.0).abs() < 1e-9);
    }

    // ── swing ─────────────────────────────────────────────────────────────────

    #[test]
    fn swing_triplet_first_eighth_is_long() {
        // Two eighth notes in one measure; swing=0.67 → first=0.67, second=0.33
        let mut score = Score::new("T", 120, 4, 4, 0, 1);
        score.parts[0].staves[0].measures[0].voices[0] = vec![
            Note::new(Pitch::new(Step::C, 4), Duration::Eighth),
            Note::new(Pitch::new(Step::D, 4), Duration::Eighth),
        ];
        let options = PlaybackOptions {
            swing: Some(0.67),
            ..Default::default()
        };
        let events = to_playback_events(&score, &options);
        // events are sorted by time_beats; C comes first (time_beats=0), D second
        let e_c = events.iter().find(|e| e.pitch_midi == 60).unwrap();
        let e_d = events.iter().find(|e| e.pitch_midi == 62).unwrap();
        assert!(
            (e_c.duration_beats - 0.67).abs() < 1e-9,
            "first eighth should be 0.67"
        );
        assert!(
            (e_d.duration_beats - 0.33).abs() < 1e-9,
            "second eighth should be 0.33"
        );
        // D starts at 0.67, not 0.5
        assert!(
            (e_d.time_beats - 0.67).abs() < 1e-9,
            "second note start should be at 0.67"
        );
    }

    #[test]
    fn swing_does_not_stretch_an_unpaired_eighth() {
        let mut score = Score::new("unpaired", 120, 4, 4, 0, 1);
        score.parts[0].staves[0].measures[0].voices[0] = vec![
            Note::new(Pitch::new(Step::C, 4), Duration::Eighth),
            Note::new(Pitch::new(Step::D, 4), Duration::Quarter),
        ];
        let events = to_playback_events(
            &score,
            &PlaybackOptions {
                swing: Some(2.0 / 3.0),
                ..Default::default()
            },
        );
        assert!((events[0].duration_beats - 0.5).abs() < 1e-9);
        assert!((events[1].time_beats - 0.5).abs() < 1e-9);
    }

    #[test]
    fn cue_note_does_not_sound_or_pair_with_a_written_eighth() {
        let mut score = Score::new("cue", 120, 4, 4, 0, 1);
        let mut cue = Note::new(Pitch::new(Step::D, 4), Duration::Eighth);
        cue.is_cue = true;
        score.parts[0].staves[0].measures[0].voices[0] = vec![
            Note::new(Pitch::new(Step::C, 4), Duration::Eighth),
            cue,
            Note::new(Pitch::new(Step::E, 4), Duration::Eighth),
        ];
        let events = to_playback_events(
            &score,
            &PlaybackOptions {
                swing: Some(2.0 / 3.0),
                ..Default::default()
            },
        );
        assert_eq!(events.len(), 2);
        assert_eq!(events[0].pitch_midi, 60);
        assert_eq!(events[0].duration_beats, 0.5);
        assert_eq!(events[1].pitch_midi, 64);
        assert_eq!(events[1].time_beats, 0.5);
    }

    #[test]
    fn swing_requires_metric_alignment_and_a_matching_next_note() {
        let mut score = Score::new("metric boundary", 120, 4, 4, 0, 1);
        score.parts[0].staves[0].measures[0].voices[0] = vec![
            Note::new(Pitch::new(Step::C, 4), Duration::Eighth),
            Note::new(Pitch::new(Step::D, 4), Duration::Quarter),
            Note::new(Pitch::new(Step::E, 4), Duration::Eighth),
            Note::new(Pitch::new(Step::F, 4), Duration::Eighth),
            Note::new(Pitch::new(Step::G, 4), Duration::Eighth),
            Note::new(Pitch::new(Step::A, 4), Duration::Eighth),
        ];
        let events = to_playback_events(
            &score,
            &PlaybackOptions {
                swing: Some(2.0 / 3.0),
                ..Default::default()
            },
        );
        assert!((events[0].time_beats).abs() < 1e-9);
        assert!((events[0].duration_beats - 0.5).abs() < 1e-9);
        assert!((events[2].time_beats - 1.5).abs() < 1e-9);
        assert!((events[2].duration_beats - 0.5).abs() < 1e-9);
        assert!((events[3].time_beats - 2.0).abs() < 1e-9);
        assert!((events[3].duration_beats - 2.0 / 3.0).abs() < 1e-9);
        assert!((events[4].time_beats - 8.0 / 3.0).abs() < 1e-9);
        assert!((events[4].duration_beats - 1.0 / 3.0).abs() < 1e-9);
        assert!((events[5].time_beats - 3.0).abs() < 1e-9);
        assert!((events[5].duration_beats - 0.5).abs() < 1e-9);
    }

    #[test]
    fn swing_keeps_the_offbeat_delay_after_an_eighth_rest() {
        let mut score = Score::new("rest swing", 120, 4, 4, 0, 1);
        score.parts[0].staves[0].measures[0].voices[0] = vec![
            Note::rest(Duration::Eighth),
            Note::new(Pitch::new(Step::C, 4), Duration::Eighth),
            Note::new(Pitch::new(Step::D, 4), Duration::Quarter),
        ];
        let events = to_playback_events(
            &score,
            &PlaybackOptions {
                swing: Some(2.0 / 3.0),
                ..Default::default()
            },
        );
        assert!((events[0].time_beats - 2.0 / 3.0).abs() < 1e-9);
        assert!((events[0].duration_beats - 1.0 / 3.0).abs() < 1e-9);
        assert!((events[1].time_beats - 1.0).abs() < 1e-9);
    }

    #[test]
    fn invalid_swing_ratios_keep_straight_finite_timing() {
        let mut score = Score::new("invalid swing", 120, 4, 4, 0, 1);
        score.parts[0].staves[0].measures[0].voices[0] = vec![
            Note::new(Pitch::new(Step::C, 4), Duration::Eighth),
            Note::new(Pitch::new(Step::D, 4), Duration::Eighth),
        ];
        for ratio in [f64::NAN, f64::INFINITY, -1.0, 0.5, 1.0] {
            let events = to_playback_events(
                &score,
                &PlaybackOptions {
                    swing: Some(ratio),
                    ..Default::default()
                },
            );
            assert_eq!(events.len(), 2);
            assert_eq!(events[0].duration_beats, 0.5);
            assert_eq!(events[1].time_beats, 0.5);
            assert_eq!(events[1].duration_beats, 0.5);
            assert!(events.iter().all(|event| event.time_secs.is_finite()));
        }
    }

    #[test]
    fn pickup_swing_uses_metric_position_in_the_full_bar() {
        let mut score = Score::new("pickup swing", 120, 4, 4, 0, 1);
        let measure = &mut score.parts[0].staves[0].measures[0];
        measure.actual_length = Some(crate::MeasureLength {
            numerator: 3,
            denominator: 8,
        });
        measure.voices[0] = vec![
            Note::new(Pitch::new(Step::C, 4), Duration::Eighth),
            Note::new(Pitch::new(Step::D, 4), Duration::Eighth),
            Note::new(Pitch::new(Step::E, 4), Duration::Eighth),
        ];
        let events = to_playback_events(
            &score,
            &PlaybackOptions {
                swing: Some(2.0 / 3.0),
                ..Default::default()
            },
        );
        assert_eq!(events[0].duration_beats, 0.5);
        assert!((events[1].time_beats - 0.5).abs() < 1e-9);
        assert!((events[1].duration_beats - 2.0 / 3.0).abs() < 1e-9);
        assert!((events[2].time_beats - 7.0 / 6.0).abs() < 1e-9);
        assert!((events[2].duration_beats - 1.0 / 3.0).abs() < 1e-9);
    }

    #[test]
    fn swing_non_eighth_not_affected() {
        let mut score = Score::new("T", 120, 4, 4, 0, 1);
        score.parts[0].staves[0].measures[0].voices[0] =
            vec![Note::new(Pitch::new(Step::C, 4), Duration::Quarter)];
        let options = PlaybackOptions {
            swing: Some(0.67),
            ..Default::default()
        };
        let events = to_playback_events(&score, &options);
        assert!(
            (events[0].duration_beats - 1.0).abs() < 1e-9,
            "quarter note unaffected"
        );
    }

    #[test]
    fn swing_none_is_straight() {
        let mut score = Score::new("T", 120, 4, 4, 0, 1);
        score.parts[0].staves[0].measures[0].voices[0] =
            vec![Note::new(Pitch::new(Step::C, 4), Duration::Eighth)];
        let options = PlaybackOptions {
            swing: None,
            ..Default::default()
        };
        let events = to_playback_events(&score, &options);
        assert!(
            (events[0].duration_beats - 0.5).abs() < 1e-9,
            "no swing = straight eighth"
        );
    }

    #[test]
    fn channel_matches_part_midi_channel() {
        let mut score = Score::new("T", 120, 4, 4, 0, 1);
        score.parts[0].midi_channel = 3;
        score.parts[0].staves[0].measures[0].voices[0] =
            vec![Note::new(Pitch::new(Step::C, 4), Duration::Quarter)];
        let events = to_playback_events(&score, &opts(None));
        assert_eq!(events[0].channel, 3);
    }

    #[test]
    fn swing_unit_default_is_eighth() {
        assert_eq!(PlaybackOptions::default().swing_unit, Duration::Eighth);
    }

    #[test]
    fn swing_unit_sixteenth() {
        let mut score = Score::new("T", 120, 4, 4, 0, 1);
        score.parts[0].staves[0].measures[0].voices[0] = vec![
            Note::new(Pitch::new(Step::C, 4), Duration::Sixteenth),
            Note::new(Pitch::new(Step::D, 4), Duration::Sixteenth),
        ];
        let options = PlaybackOptions {
            swing: Some(0.67),
            swing_unit: Duration::Sixteenth,
            ..Default::default()
        };
        let events = to_playback_events(&score, &options);
        let e_c = events.iter().find(|e| e.pitch_midi == 60).unwrap();
        let e_d = events.iter().find(|e| e.pitch_midi == 62).unwrap();
        assert!(
            (e_c.duration_beats - 0.335).abs() < 1e-9,
            "first 16th should be 0.335"
        );
        assert!(
            (e_d.duration_beats - 0.165).abs() < 1e-9,
            "second 16th should be 0.165"
        );
    }

    #[test]
    fn swing_resets_per_measure() {
        // 2 measures each with 2 eighth notes; each measure's first eighth should be "long"
        let mut score = Score::new("T", 120, 4, 4, 0, 2);
        let pair = || {
            vec![
                Note::new(Pitch::new(Step::C, 4), Duration::Eighth),
                Note::new(Pitch::new(Step::D, 4), Duration::Eighth),
            ]
        };
        score.parts[0].staves[0].measures[0].voices[0] = pair();
        score.parts[0].staves[0].measures[1].voices[0] = pair();
        let options = PlaybackOptions {
            swing: Some(0.67),
            ..Default::default()
        };
        let events = to_playback_events(&score, &options);
        // Four events sorted by time: m0-C, m0-D, m1-C, m1-D
        let durations: Vec<f64> = events.iter().map(|e| e.duration_beats).collect();
        // m0 first (long)
        assert!((durations[0] - 0.67).abs() < 1e-9, "m0 first note long");
        // m0 second (short)
        assert!((durations[1] - 0.33).abs() < 1e-9, "m0 second note short");
        // m1 first (long again — reset)
        assert!(
            (durations[2] - 0.67).abs() < 1e-9,
            "m1 first note long (reset)"
        );
        // m1 second (short)
        assert!((durations[3] - 0.33).abs() < 1e-9, "m1 second note short");
    }

    #[test]
    fn multi_voice_events_preserve_source_voice_addresses() {
        let mut score = Score::new("T", 120, 4, 4, 0, 1);
        score.parts[0].staves[0].measures[0].voices[0] =
            vec![Note::new(Pitch::new(Step::C, 4), Duration::Quarter)];
        score.parts[0].staves[0].measures[0].voices[1] =
            vec![Note::new(Pitch::new(Step::E, 4), Duration::Quarter)];

        let events = to_playback_events(&score, &PlaybackOptions::default());
        let addresses: Vec<&str> = events
            .iter()
            .filter_map(|event| event.address.as_deref())
            .collect();
        assert!(addresses.contains(&"0:0:0:0:0"));
        assert!(addresses.contains(&"0:0:0:1:0"));
    }

    #[test]
    fn playback_exposes_original_musicxml_voice_number_alongside_slot_address() {
        let mut score = Score::new("T", 120, 4, 4, 0, 1);
        let measure = &mut score.parts[0].staves[0].measures[0];
        measure.voices[1] = vec![Note::new(Pitch::new(Step::E, 4), Duration::Quarter)];
        measure.source_voice_numbers[1] = Some(5);

        let events = to_playback_events(&score, &PlaybackOptions::default());
        let event = events
            .iter()
            .find(|event| event.address.as_deref() == Some("0:0:0:1:0"))
            .expect("event from slot 1");
        assert_eq!(event.source.as_ref().map(|source| source.voice), Some(1));
        assert_eq!(event.source_voice_number, Some(5));
    }

    // ── compute_playback_position ─────────────────────────────────────────────

    #[test]
    fn playback_position_at_zero_is_measure_0_beat_0() {
        let score = Score::new("T", 120, 4, 4, 0, 4);
        let pos = compute_playback_position(&score, &PlaybackOptions::default(), 0.0).unwrap();
        assert_eq!(pos.measure_index, 0);
        assert!(pos.beat.abs() < 1e-9);
    }

    #[test]
    fn playback_position_at_half_measure_is_beat_2() {
        // 4/4, 120 BPM → 1 measure = 2.0 s; 0.5 s = beat 1.0
        let score = Score::new("T", 120, 4, 4, 0, 4);
        let pos = compute_playback_position(&score, &PlaybackOptions::default(), 0.5).unwrap();
        assert_eq!(pos.measure_index, 0);
        assert!(
            (pos.beat - 1.0).abs() < 1e-9,
            "expected beat 1.0, got {}",
            pos.beat
        );
    }

    #[test]
    fn playback_position_beyond_score_is_none() {
        // 4/4, 120 BPM, 1 measure = 2.0 s; 10.0 s is beyond
        let score = Score::new("T", 120, 4, 4, 0, 1);
        assert!(compute_playback_position(&score, &PlaybackOptions::default(), 10.0).is_none());
    }

    #[test]
    fn playback_position_tempo_change_takes_effect() {
        // measure 0: 120 BPM (2.0 s), measure 1: 60 BPM (4.0 s)
        // At elapsed=2.5 s → inside measure 1, 0.5 s into it → beat 0.5
        let mut score = Score::new("T", 120, 4, 4, 0, 2);
        score.parts[0].staves[0].measures[1].tempo = Some(60);
        let pos = compute_playback_position(&score, &PlaybackOptions::default(), 2.5).unwrap();
        assert_eq!(pos.measure_index, 1);
        assert!(
            (pos.beat - 0.5).abs() < 1e-9,
            "expected beat 0.5, got {}",
            pos.beat
        );
    }

    #[test]
    fn playback_position_loop_region_starts_at_zero() {
        // loop_region=[1,2] → elapsed=0 should map to measure 1, beat 0
        let score = Score::new("T", 120, 4, 4, 0, 4);
        let options = PlaybackOptions {
            loop_region: Some((1, 2)),
            ..Default::default()
        };
        let pos = compute_playback_position(&score, &options, 0.0).unwrap();
        assert_eq!(pos.measure_index, 1);
        assert!(pos.beat.abs() < 1e-9);
    }

    // ── MetronomeConfig ───────────────────────────────────────────────────────

    #[test]
    fn metronome_injects_beat_events() {
        // 4/4, 1 measure → should inject 4 metronome events
        let score = Score::new("T", 120, 4, 4, 0, 1);
        let options = PlaybackOptions {
            metronome: Some(MetronomeConfig::default()),
            ..Default::default()
        };
        let events = to_playback_events(&score, &options);
        let metro_events: Vec<_> = events.iter().filter(|e| e.is_metronome).collect();
        assert_eq!(metro_events.len(), 4, "expected 4 metronome clicks in 4/4");
    }

    #[test]
    fn metronome_accent_is_first_beat() {
        let score = Score::new("T", 120, 4, 4, 0, 1);
        let metro = MetronomeConfig::default();
        let options = PlaybackOptions {
            metronome: Some(metro.clone()),
            ..Default::default()
        };
        let events = to_playback_events(&score, &options);
        let mut metro_events: Vec<_> = events.iter().filter(|e| e.is_metronome).collect();
        metro_events.sort_by(|a, b| a.time_beats.partial_cmp(&b.time_beats).unwrap());
        assert_eq!(metro_events[0].pitch_midi, metro.accent_pitch);
        assert_eq!(metro_events[0].velocity, metro.accent_velocity);
    }

    #[test]
    fn metronome_regular_beat_pitch() {
        let score = Score::new("T", 120, 4, 4, 0, 1);
        let metro = MetronomeConfig::default();
        let options = PlaybackOptions {
            metronome: Some(metro.clone()),
            ..Default::default()
        };
        let events = to_playback_events(&score, &options);
        let mut metro_events: Vec<_> = events.iter().filter(|e| e.is_metronome).collect();
        metro_events.sort_by(|a, b| a.time_beats.partial_cmp(&b.time_beats).unwrap());
        for ev in &metro_events[1..] {
            assert_eq!(ev.pitch_midi, metro.beat_pitch);
            assert_eq!(ev.velocity, metro.beat_velocity);
        }
    }

    #[test]
    fn metronome_integrates_measure_tempo_ramp_and_carries_ending_tempo() {
        let mut score = Score::new("T", 120, 4, 4, 0, 2);
        score.parts[0].staves[0].measures[0].tempo_ramp_to = Some(60);
        let options = PlaybackOptions {
            metronome: Some(MetronomeConfig::default()),
            ..Default::default()
        };

        let mut clicks: Vec<_> = to_playback_events(&score, &options)
            .into_iter()
            .filter(|event| event.is_metronome)
            .collect();
        clicks.sort_by(|left, right| left.time_beats.total_cmp(&right.time_beats));

        let expected_second_beat = tempo_ramp_seconds(120.0, Some(60.0), 4.0, 1.0);
        let expected_second_measure = tempo_ramp_seconds(120.0, Some(60.0), 4.0, 4.0);
        assert!((clicks[1].time_secs - expected_second_beat).abs() < 1e-9);
        assert!((clicks[4].time_secs - expected_second_measure).abs() < 1e-9);
        assert!((clicks[5].time_secs - (expected_second_measure + 1.0)).abs() < 1e-9);
    }

    #[test]
    fn metronome_events_are_marked() {
        let score = Score::new("T", 120, 4, 4, 0, 1);
        let options = PlaybackOptions {
            metronome: Some(MetronomeConfig::default()),
            ..Default::default()
        };
        let events = to_playback_events(&score, &options);
        assert!(events.iter().any(|e| e.is_metronome));
    }

    #[test]
    fn metronome_none_produces_no_extra_events() {
        let score = Score::new("T", 120, 4, 4, 0, 1);
        let events = to_playback_events(&score, &PlaybackOptions::default());
        assert!(events.iter().all(|e| !e.is_metronome));
    }

    #[test]
    fn offline_render_manifest_uses_event_end_as_exact_frame_length() {
        let mut score = Score::new("T", 120, 4, 4, 0, 1);
        score.parts[0].staves[0].measures[0].voices[0][0] =
            Note::new(Pitch::new(Step::C, 4), Duration::Quarter);
        let request = OfflineRenderRequest {
            format: OfflineRenderFormat::Flac,
            sample_rate_hz: 48_000,
            channels: 2,
            provider_identity: Some("test-provider@1".into()),
            ..Default::default()
        };

        let manifest = build_offline_render_manifest(&score, &PlaybackOptions::default(), &request)
            .expect("valid render manifest");
        assert_eq!(manifest.contract_version, OFFLINE_RENDER_CONTRACT_VERSION);
        assert!(manifest.validate().is_ok());
        assert_eq!(manifest.format, OfflineRenderFormat::Flac);
        assert_eq!(manifest.duration_frames, 24_000);
        assert_eq!(manifest.events.len(), 1);
        assert_eq!(manifest.frame_events.len(), 1);
        assert_eq!(manifest.frame_events[0].start_frame, 0);
        assert_eq!(manifest.frame_events[0].duration_frames, 24_000);
        assert_eq!(manifest.frame_events[0].end_frame, 24_000);
        assert_eq!(manifest.playback_options, PlaybackOptions::default());
        assert_eq!(
            manifest.provider_identity.as_deref(),
            Some("test-provider@1")
        );
    }

    #[test]
    fn offline_render_manifest_rejects_out_of_range_audio_shape() {
        let score = Score::new("T", 120, 4, 4, 0, 1);
        let request = OfflineRenderRequest {
            sample_rate_hz: 0,
            ..Default::default()
        };
        assert!(matches!(
            build_offline_render_manifest(&score, &PlaybackOptions::default(), &request),
            Err(crate::Error::InvalidOfflineRenderRequest)
        ));
    }

    #[test]
    fn offline_render_manifest_selection_keeps_source_address_and_release_tail() {
        let mut score = Score::new("T", 120, 4, 4, 0, 1);
        score.parts[0].staves[0].measures[0].voices[0] = vec![
            Note::new(Pitch::new(Step::C, 4), Duration::Quarter),
            Note::new(Pitch::new(Step::D, 4), Duration::Quarter),
        ];
        let events = to_playback_events(&score, &PlaybackOptions::default());
        score.parts[0].midi_control_changes.push(MidiControlChange {
            tick: 480,
            channel: 0,
            controller: 7,
            value: 100,
        });
        let request = OfflineRenderRequest {
            sample_rate_hz: 8_000,
            release_tail_millis: 125,
            scope: OfflineRenderScope::Selection {
                addresses: vec![events[1].source.clone().expect("source address")],
            },
            ..Default::default()
        };
        let manifest = build_offline_render_manifest(&score, &PlaybackOptions::default(), &request)
            .expect("selection manifest");
        assert_eq!(manifest.events.len(), 1);
        assert_eq!(manifest.events[0].source, events[1].source);
        assert_eq!(manifest.frame_events[0].start_frame, 0);
        assert!(manifest.semantic_events.iter().any(|event| matches!(
            event.kind,
            OfflineRenderSemanticEventKind::Controller {
                channel: 0,
                controller: 7,
                value: 100
            }
        ) && event.frame == 0));
        assert_eq!(manifest.release_tail_frames, 1_000);
        assert_eq!(manifest.duration_frames, 5_000);
    }

    #[test]
    fn offline_render_request_owned_options_override_legacy_argument() {
        let mut score = Score::new("T", 120, 4, 4, 0, 1);
        score.parts[0].staves[0].measures[0].voices[0][0] =
            Note::new(Pitch::new(Step::C, 4), Duration::Quarter);
        let request_options = PlaybackOptions {
            bpm_override: Some(60),
            ..Default::default()
        };
        let manifest = build_offline_render_manifest(
            &score,
            &PlaybackOptions::default(),
            &OfflineRenderRequest {
                sample_rate_hz: 48_000,
                playback_options: Some(request_options.clone()),
                ..Default::default()
            },
        )
        .expect("request-owned playback options");
        assert_eq!(manifest.playback_options, request_options);
        assert_eq!(manifest.frame_events[0].duration_frames, 48_000);
    }

    #[test]
    fn offline_manifest_projects_typed_midi_events_to_exact_frames() {
        let mut score = Score::new("MIDI semantics", 120, 4, 4, 0, 1);
        score.parts[0].midi_pitch_bends.push(MidiPitchBend {
            tick: 480,
            channel: 2,
            value: -512,
        });
        score.parts[0].midi_program_changes.push(MidiProgramChange {
            tick: 480,
            channel: 2,
            program: 41,
        });
        score.parts[0].midi_aftertouch.push(MidiAftertouch {
            tick: 480,
            channel: 2,
            key: Some(64),
            value: 88,
        });
        let manifest = build_offline_render_manifest(
            &score,
            &PlaybackOptions::default(),
            &OfflineRenderRequest {
                sample_rate_hz: 48_000,
                ..Default::default()
            },
        )
        .expect("manifest builds");
        for kind in [
            OfflineRenderSemanticEventKind::PitchBend {
                channel: 2,
                value: -512,
            },
            OfflineRenderSemanticEventKind::ProgramChange {
                channel: 2,
                program: 41,
            },
            OfflineRenderSemanticEventKind::Aftertouch {
                channel: 2,
                key: Some(64),
                value: 88,
            },
        ] {
            assert!(manifest.semantic_events.iter().any(|event| {
                event.kind == kind
                    && event.frame == 24_000
                    && event
                        .measure
                        .as_ref()
                        .is_some_and(|address| address.part == 0 && address.measure == 0)
            }));
        }
    }

    #[test]
    fn offline_manifest_frames_cover_repeat_ramp_fermata_pedal_bend_and_instrument_change() {
        let mut score = Score::new("fixture", 120, 4, 4, 0, 2);
        let mut first = Note::new(Pitch::new(Step::C, 4), Duration::Quarter);
        first.pedal_start = true;
        first.articulations = vec![Articulation::Fermata, Articulation::BreathMark];
        first.guitar_bend_curve = vec![GuitarBendPoint {
            position_per_mille: 500,
            alter_cents: 100,
        }];
        score.parts[0].staves[0].measures[0].voices[0] = vec![first];
        score.parts[0].staves[0].measures[0].barline_left =
            super::super::notation::Barline::RepeatStart;
        score.parts[0].staves[0].measures[0].tempo_ramp_to = Some(60);
        score.parts[0].staves[0].measures[0].navigation = Some("Segno".to_string());
        score.parts[0].midi_control_changes.push(MidiControlChange {
            tick: 480,
            channel: 0,
            controller: 11,
            value: 96,
        });

        let mut second = Note::new(Pitch::new(Step::D, 4), Duration::Quarter);
        second.pedal_end = true;
        score.parts[0].staves[0].measures[1].voices[0] = vec![second];
        score.parts[0].staves[0].measures[1].barline_right =
            super::super::notation::Barline::RepeatEnd;
        let mut flute = crate::InstrumentDefinition::new("flute", "Flute");
        flute.midi_channel = 2;
        flute.midi_program = 73;
        score.parts[0].staves[0].measures[1].instrument_change = Some(flute);

        let request = OfflineRenderRequest {
            sample_rate_hz: 48_000,
            playback_options: Some(PlaybackOptions {
                fermata_multiplier: 1.5,
                fermata_hold_beats: 0.25,
                ..Default::default()
            }),
            ..Default::default()
        };
        let manifest = build_offline_render_manifest(&score, &PlaybackOptions::default(), &request)
            .expect("fixture manifest");
        assert_eq!(manifest.frame_events.len(), 4);
        let measures: Vec<usize> = manifest
            .frame_events
            .iter()
            .map(|event| event.event.source.as_ref().unwrap().measure)
            .collect();
        assert_eq!(measures, vec![0, 1, 0, 1]);
        assert!(manifest.frame_events[0].event.pedal);
        assert_eq!(manifest.frame_events[0].event.post_note_pause_beats, 0.25);
        assert_eq!(manifest.frame_events[0].event.pitch_bend_curve.len(), 1);
        assert_eq!(
            manifest.frame_events[1].event.instrument_id.as_deref(),
            Some("flute")
        );
        assert_eq!(manifest.frame_events[3].event.program, 73);
        assert!(manifest.semantic_events.iter().any(|event| {
            matches!(
                &event.kind,
                OfflineRenderSemanticEventKind::InstrumentChange {
                    instrument_id,
                    channel: 2,
                    program: 73,
                    transpose_semitones: 0,
                } if instrument_id == "flute"
            ) && event
                .measure
                .as_ref()
                .is_some_and(|address| address.measure == 1)
                && event.frame == manifest.frame_events[1].start_frame
        }));
        assert!(manifest.semantic_events.iter().any(|event| matches!(
            event.kind,
            OfflineRenderSemanticEventKind::Pedal { down: true }
        ) && event.frame
            == manifest.frame_events[0].start_frame));
        assert!(manifest.semantic_events.iter().any(|event| matches!(
            event.kind,
            OfflineRenderSemanticEventKind::Pedal { down: false }
        ) && event.frame
            == manifest.frame_events[1].start_frame));
        assert!(manifest.semantic_events.iter().any(|event| matches!(
            event.kind,
            OfflineRenderSemanticEventKind::Articulation {
                articulation: Articulation::Fermata
            }
        )));
        assert!(manifest.semantic_events.iter().any(|event| matches!(
            event.kind,
            OfflineRenderSemanticEventKind::GuitarBend { .. }
        )));
        let tempo_events = manifest
            .semantic_events
            .iter()
            .filter(|event| matches!(event.kind, OfflineRenderSemanticEventKind::Tempo { .. }))
            .count();
        let navigation_events = manifest
            .semantic_events
            .iter()
            .filter(|event| {
                matches!(
                    event.kind,
                    OfflineRenderSemanticEventKind::Navigation { .. }
                )
            })
            .count();
        let control_frames: Vec<u64> = manifest
            .semantic_events
            .iter()
            .filter_map(|event| {
                matches!(
                    event.kind,
                    OfflineRenderSemanticEventKind::Controller {
                        channel: 0,
                        controller: 11,
                        value: 96
                    }
                )
                .then_some(event.frame)
            })
            .collect();
        assert_eq!(tempo_events, 2);
        assert_eq!(navigation_events, 2);
        assert_eq!(control_frames.len(), 2);
        let ramp_duration = tempo_ramp_seconds(120.0, Some(60.0), 4.0, 4.0);
        // The first fermata holds for half a beat at the ramp's beat-one tempo.
        // On the repeat the ramp starts at 60 BPM, so the second hold is 0.5 s.
        let first_hold = 0.5 * 60.0 / 105.0;
        let second_hold = 0.5;
        assert_eq!(
            control_frames[0],
            ((tempo_ramp_seconds(120.0, Some(60.0), 4.0, 1.0) + first_hold) * 48_000.0).round()
                as u64
        );
        assert_eq!(
            control_frames[1],
            ((ramp_duration + 5.0 + first_hold + second_hold) * 48_000.0).round() as u64
        );

        let expected_starts = [
            0.0,
            ramp_duration + first_hold,
            ramp_duration + first_hold + 4.0,
            ramp_duration + first_hold + 8.0 + second_hold,
        ];
        for (frame_event, expected_secs) in manifest.frame_events.iter().zip(expected_starts) {
            assert_eq!(
                frame_event.start_frame,
                (expected_secs * 48_000.0).round() as u64
            );
        }
    }

    #[test]
    fn offline_render_manifest_reports_unresolved_selection_address() {
        let score = Score::new("T", 120, 4, 4, 0, 1);
        let request = OfflineRenderRequest {
            scope: OfflineRenderScope::Selection {
                addresses: vec![NoteAddr {
                    part: 0,
                    staff: 0,
                    measure: 0,
                    voice: 0,
                    note: 99,
                }],
            },
            ..Default::default()
        };
        let manifest = build_offline_render_manifest(&score, &PlaybackOptions::default(), &request)
            .expect("empty selection is representable");
        assert_eq!(manifest.events.len(), 0);
        assert_eq!(
            manifest.diagnostics,
            vec![
                OfflineRenderDiagnostic {
                    kind: OfflineRenderDiagnosticKind::UnresolvedSelectionAddress,
                    source: Some(NoteAddr {
                        part: 0,
                        staff: 0,
                        measure: 0,
                        voice: 0,
                        note: 99,
                    }),
                },
                OfflineRenderDiagnostic {
                    kind: OfflineRenderDiagnosticKind::EmptySelection,
                    source: None,
                },
            ]
        );
    }

    #[test]
    fn offline_render_manifest_v1_json_migrates_with_v2_defaults() {
        let legacy = serde_json::json!({
            "contract_version": 1,
            "playback_contract_version": 2,
            "format": "Wav",
            "sample_rate_hz": 48_000,
            "channels": 2,
            "duration_frames": 0,
            "events": []
        });
        let manifest: OfflineRenderManifest =
            serde_json::from_value(legacy).expect("v1 manifest remains readable");
        assert_eq!(manifest.contract_version, 1);
        assert_eq!(manifest.scope, OfflineRenderScope::FullScore);
        assert_eq!(manifest.release_tail_frames, 0);
        assert_eq!(manifest.playback_options, PlaybackOptions::default());
        assert!(manifest.frame_events.is_empty());
        assert!(manifest.diagnostics.is_empty());
        assert!(manifest.validate().is_ok());
    }

    #[test]
    fn offline_render_manifest_validation_rejects_tampered_frame_and_tail_boundaries() {
        let mut score = Score::new("T", 120, 4, 4, 0, 1);
        score.parts[0].staves[0].measures[0].voices[0] =
            vec![Note::new(Pitch::new(Step::C, 4), Duration::Quarter)];
        let manifest = build_offline_render_manifest(
            &score,
            &PlaybackOptions::default(),
            &OfflineRenderRequest {
                sample_rate_hz: 48_000,
                release_tail_millis: 100,
                ..Default::default()
            },
        )
        .expect("manifest builds");
        assert!(manifest.validate().is_ok());

        let mut invalid_tail = manifest.clone();
        invalid_tail.duration_frames = invalid_tail.duration_frames.saturating_sub(1);
        assert!(matches!(
            invalid_tail.validate(),
            Err(crate::Error::InvalidOfflineRenderRequest)
        ));

        let mut invalid_frame = manifest;
        invalid_frame.frame_events[0].end_frame =
            invalid_frame.frame_events[0].end_frame.saturating_add(1);
        assert!(matches!(
            invalid_frame.validate(),
            Err(crate::Error::InvalidOfflineRenderRequest)
        ));
    }

    #[test]
    fn routing_manifest_prefers_instrument_bus_and_isolates_metronome() {
        let mut score = Score::new("routing", 120, 4, 4, 0, 1);
        let mut instrument = crate::InstrumentDefinition::new("flute", "Flute");
        instrument.midi_channel = 2;
        instrument.midi_program = 73;
        score.parts[0].instrument = Some(instrument);
        score.parts[0].staves[0].measures[0].voices[0] =
            vec![Note::new(Pitch::new(Step::C, 4), Duration::Quarter)];
        let options = PlaybackOptions {
            metronome: Some(MetronomeConfig::default()),
            ..Default::default()
        };
        let mut config = PlaybackRoutingConfig {
            provider_identity: Some("sf2-host@1".into()),
            ..Default::default()
        };
        config.part_buses.insert(0, "parts".into());
        config
            .instrument_buses
            .insert("flute".into(), "winds".into());
        config.aux_sends.push(PlaybackAuxSend {
            source_bus: "winds".into(),
            destination_bus: "reverb".into(),
            gain_db: -12.0,
        });
        config.effect_routes.push(PlaybackEffectRoute {
            bus_id: "reverb".into(),
            effect_id: "convolution".into(),
            enabled: true,
        });

        let manifest = build_playback_routing_manifest(&score, &options, &config)
            .expect("valid routing manifest");
        assert_eq!(manifest.contract_version, PLAYBACK_ROUTING_CONTRACT_VERSION);
        assert_eq!(manifest.provider_identity.as_deref(), Some("sf2-host@1"));
        assert!(manifest.routes.iter().any(|route| {
            route.instrument_id.as_deref() == Some("flute") && route.bus_id == "winds"
        }));
        assert!(
            manifest
                .routes
                .iter()
                .any(|route| route.is_metronome && route.bus_id == "metronome")
        );
        assert_eq!(manifest.aux_sends.len(), 1);
        assert_eq!(manifest.effect_routes.len(), 1);
    }

    #[test]
    fn routing_manifest_rejects_unsafe_bus_and_non_finite_send_gain() {
        let score = Score::new("routing", 120, 4, 4, 0, 1);
        let config = PlaybackRoutingConfig {
            master_bus: "not a bus".into(),
            ..Default::default()
        };
        assert!(matches!(
            build_playback_routing_manifest(&score, &PlaybackOptions::default(), &config),
            Err(crate::Error::InvalidPlaybackRouting)
        ));

        let mut config = PlaybackRoutingConfig::default();
        config.aux_sends.push(PlaybackAuxSend {
            source_bus: "part".into(),
            destination_bus: "master".into(),
            gain_db: f64::NAN,
        });
        assert!(matches!(
            build_playback_routing_manifest(&score, &PlaybackOptions::default(), &config),
            Err(crate::Error::InvalidPlaybackRouting)
        ));
    }

    #[test]
    fn timing_corpus_reports_score_schedule_results_without_audio_claims() {
        let mut score = Score::new("corpus", 120, 4, 4, 0, 1);
        score.parts[0].staves[0].measures[0].voices[0] =
            vec![Note::new(Pitch::new(Step::C, 4), Duration::Quarter)];
        let expected_events = to_playback_events(&score, &PlaybackOptions::default());
        let report = evaluate_playback_timing_corpus(&[PlaybackTimingCase {
            id: "quarter-note".into(),
            score,
            options: PlaybackOptions::default(),
            expected_events,
            tolerance: PlaybackTimingTolerance::default(),
        }])
        .expect("valid timing corpus");
        assert_eq!(
            report.contract_version,
            PLAYBACK_TIMING_CORPUS_CONTRACT_VERSION
        );
        assert_eq!(report.total_cases, 1);
        assert_eq!(report.passed_cases, 1);
        assert!(report.cases[0].report.within_tolerance);
    }

    #[test]
    fn timing_corpus_rejects_empty_or_duplicate_case_ids() {
        assert!(matches!(
            evaluate_playback_timing_corpus(&[]),
            Err(crate::Error::InvalidPlaybackTimingCorpus)
        ));
        let score = Score::new("corpus", 120, 4, 4, 0, 1);
        let case = PlaybackTimingCase {
            id: "duplicate".into(),
            expected_events: to_playback_events(&score, &PlaybackOptions::default()),
            score,
            options: PlaybackOptions::default(),
            tolerance: PlaybackTimingTolerance::default(),
        };
        assert!(matches!(
            evaluate_playback_timing_corpus(&[case.clone(), case]),
            Err(crate::Error::InvalidPlaybackTimingCorpus)
        ));
    }

    fn comparison_event(time_secs: f64, duration_secs: f64) -> PlaybackEvent {
        PlaybackEvent {
            address: Some("0:0:0:0:0".into()),
            source: Some(NoteAddr {
                part: 0,
                staff: 0,
                measure: 0,
                voice: 0,
                note: 0,
            }),
            source_voice_number: None,
            time_beats: 0.0,
            time_secs,
            pitch_midi: 60,
            pitch_midi_cents: 6000,
            pitch_bend_curve: Vec::new(),
            post_note_pause_beats: 0.0,
            articulations: Vec::new(),
            chord_symbol: None,
            guitar_technique: None,
            velocity: 64,
            duration_beats: 1.0,
            duration_secs,
            pedal: false,
            part_index: 0,
            channel: 0,
            program: 0,
            instrument_id: None,
            is_metronome: false,
        }
    }

    #[test]
    fn legacy_playback_event_json_defaults_bend_curve() {
        let event: PlaybackEvent = serde_json::from_str(
            r#"{"address":null,"source":null,"source_voice_number":null,"time_beats":0.0,"time_secs":0.0,"pitch_midi":60,"pitch_midi_cents":6000,"velocity":64,"duration_beats":1.0,"duration_secs":0.5,"pedal":false,"part_index":0,"channel":0,"is_metronome":false}"#,
        )
        .expect("legacy playback event remains readable");
        assert!(event.pitch_bend_curve.is_empty());
        assert_eq!(event.guitar_technique, None);
    }

    #[test]
    fn tempo_ramp_uses_integrated_event_timing_and_carries_target_forward() {
        let mut score = Score::new("ramp", 120, 4, 4, 0, 2);
        for measure in &mut score.parts[0].staves[0].measures {
            measure.voices[0] = vec![
                crate::Note::new(crate::Pitch::new(crate::Step::C, 4), crate::Duration::Half),
                crate::Note::new(crate::Pitch::new(crate::Step::D, 4), crate::Duration::Half),
            ];
        }
        score.parts[0].staves[0].measures[0].tempo_ramp_to = Some(60);
        let events = to_playback_events(&score, &PlaybackOptions::default());
        assert_eq!(events.len(), 4);
        let expected_measure_secs = 4.0 * 60.0 / (60.0 - 120.0) * (60.0f64 / 120.0).ln();
        assert!((events[2].time_secs - expected_measure_secs).abs() < 1e-9);
        assert!((events[0].duration_secs - 1.1507282898).abs() < 1e-6);
        assert!((events[2].duration_secs - 2.0).abs() < 1e-9);
    }

    #[test]
    fn breath_and_caesura_expose_deterministic_post_note_pause() {
        let mut score = Score::new("pause", 120, 4, 4, 0, 1);
        let mut breath = crate::Note::new(
            crate::Pitch::new(crate::Step::C, 4),
            crate::Duration::Quarter,
        );
        breath.articulations.push(Articulation::BreathMark);
        let mut caesura = crate::Note::new(
            crate::Pitch::new(crate::Step::D, 4),
            crate::Duration::Quarter,
        );
        caesura
            .articulations
            .extend([Articulation::BreathMark, Articulation::Caesura]);
        score.parts[0].staves[0].measures[0].voices[0] = vec![breath, caesura];

        let events = to_playback_events(&score, &PlaybackOptions::default());
        assert_eq!(events.len(), 2);
        assert_eq!(events[0].post_note_pause_beats, 0.25);
        assert_eq!(events[1].post_note_pause_beats, 0.5);
        assert_eq!(
            events[1].articulations,
            vec![Articulation::BreathMark, Articulation::Caesura]
        );
    }

    #[test]
    fn measure_instrument_change_resolves_on_playback_events() {
        let mut score = Score::new("instrument", 120, 4, 4, 0, 2);
        let mut base = crate::InstrumentDefinition::new("piano", "Piano");
        base.midi_channel = 1;
        base.midi_program = 0;
        score.parts[0].instrument = Some(base);
        let mut change = crate::InstrumentDefinition::new("flute", "Flute");
        change.midi_channel = 2;
        change.midi_program = 73;
        change.transpose_semitones = -2;
        score.parts[0].staves[0].measures[1].instrument_change = Some(change);
        for measure in &mut score.parts[0].staves[0].measures {
            measure.voices[0] = vec![crate::Note::new(
                crate::Pitch::new(crate::Step::C, 4),
                crate::Duration::Whole,
            )];
        }

        let events = to_playback_events(&score, &PlaybackOptions::default());
        assert_eq!(events.len(), 2);
        assert_eq!(
            (
                events[0].channel,
                events[0].program,
                events[0].instrument_id.as_deref()
            ),
            (1, 0, Some("piano"))
        );
        assert_eq!(
            (
                events[1].channel,
                events[1].program,
                events[1].instrument_id.as_deref()
            ),
            (2, 73, Some("flute"))
        );
        assert_eq!(events[0].pitch_midi, 60);
        assert_eq!(events[1].pitch_midi, 58);
    }

    #[test]
    fn authored_midi_program_change_selects_the_next_note_at_its_source_tick() {
        let mut score = Score::new("program", 120, 4, 4, 0, 1);
        score.parts[0].staves[0].measures[0].voices[0] = vec![
            Note::new(Pitch::new(Step::C, 4), Duration::Quarter),
            Note::new(Pitch::new(Step::E, 4), Duration::Quarter),
        ];
        score.parts[0].midi_program_changes = vec![
            MidiProgramChange {
                tick: 480,
                channel: 1,
                program: 73,
            },
            MidiProgramChange {
                tick: 480,
                channel: 0,
                program: 40,
            },
        ];
        let events = to_playback_events(&score, &PlaybackOptions::default());
        assert_eq!(events.len(), 2);
        assert_eq!((events[0].program, events[1].program), (0, 40));
        assert_eq!((events[0].time_secs, events[1].time_secs), (0.0, 0.5));
    }

    #[test]
    fn generic_playback_event_preserves_authored_guitar_technique() {
        let mut score = Score::new("technique", 120, 4, 4, 0, 1);
        let mut note = Note::new(Pitch::new(Step::E, 4), Duration::Quarter);
        note.guitar_technique = Some(GuitarTechnique::HammerOn);
        score.parts[0].staves[0].measures[0].voices[0] = vec![note];

        let event = to_playback_events(&score, &PlaybackOptions::default())
            .into_iter()
            .next()
            .expect("one note event");
        assert_eq!(event.guitar_technique, Some(GuitarTechnique::HammerOn));
    }

    #[test]
    fn playback_timing_comparison_reports_tolerance_and_identity() {
        let expected = [comparison_event(1.0, 0.5)];
        let actual = [comparison_event(1.004, 0.503)];
        let report = compare_playback_timing(
            &expected,
            &actual,
            &PlaybackTimingTolerance {
                start_secs: 0.005,
                duration_secs: 0.005,
            },
        )
        .expect("comparison");
        assert!(report.within_tolerance);
        assert_eq!(report.matched_events, 1);
        assert_eq!(
            report.contract_version,
            PLAYBACK_COMPARISON_CONTRACT_VERSION
        );

        let mut typed_only = comparison_event(1.004, 0.503);
        typed_only.address = None;
        let report = compare_playback_timing(
            &expected,
            &[typed_only],
            &PlaybackTimingTolerance::default(),
        )
        .expect("typed source comparison");
        assert_eq!(report.matched_events, 1);

        let actual = [comparison_event(1.02, 0.6)];
        let report =
            compare_playback_timing(&expected, &actual, &PlaybackTimingTolerance::default())
                .expect("comparison");
        assert!(!report.within_tolerance);
        assert!(
            report
                .mismatches
                .iter()
                .any(|m| matches!(m, PlaybackTimingMismatch::StartTime { index: 0, .. }))
        );
        assert!(
            report
                .mismatches
                .iter()
                .any(|m| matches!(m, PlaybackTimingMismatch::Duration { index: 0, .. }))
        );
    }

    #[test]
    fn playback_timing_comparison_rejects_instrument_route_mismatch() {
        let expected = comparison_event(0.0, 0.5);
        let mut actual = expected.clone();
        actual.program = 73;
        assert!(
            compare_playback_timing(&[expected], &[actual], &PlaybackTimingTolerance::default(),)
                .expect("comparison")
                .mismatches
                .iter()
                .any(|mismatch| matches!(
                    mismatch,
                    PlaybackTimingMismatch::EventIdentity { index: 0 }
                ))
        );
    }

    #[test]
    fn playback_timing_comparison_rejects_invalid_tolerance() {
        let error = compare_playback_timing(
            &[],
            &[],
            &PlaybackTimingTolerance {
                start_secs: -0.1,
                duration_secs: 0.0,
            },
        );
        assert!(matches!(
            error,
            Err(crate::Error::InvalidPlaybackComparison)
        ));
    }

    #[test]
    fn tablature_performance_projection_keeps_position_and_reports_pitch_error() {
        let mut score = Score::new("Tab", 120, 4, 4, 0, 1);
        score.parts[0].staves[0].tablature = Some(super::super::notation::TablatureConfig {
            lines: 6,
            tuning_midi: vec![40, 45, 50, 55, 59, 64],
            capo: 0,
        });
        let notes = &mut score.parts[0].staves[0].measures[0].voices[0];
        *notes = vec![crate::Note::new(
            crate::Pitch::new(crate::Step::C, 4),
            crate::Duration::Quarter,
        )];
        notes[0].tab_position = Some(super::super::notation::TabPosition {
            string: 1,
            fret: 20,
        });
        notes[0].guitar_technique = Some(super::super::notation::GuitarTechnique::Bend);
        notes[0].guitar_bend_alter_cents = Some(150);
        notes[0].guitar_bend_curve = vec![
            super::super::score::GuitarBendPoint {
                position_per_mille: 0,
                alter_cents: 0,
            },
            super::super::score::GuitarBendPoint {
                position_per_mille: 500,
                alter_cents: 150,
            },
            super::super::score::GuitarBendPoint {
                position_per_mille: 1_000,
                alter_cents: 0,
            },
        ];
        let report = project_tablature_performance(&score, &PlaybackOptions::default())
            .expect("tablature projection");
        assert_eq!(report.events.len(), 1);
        assert_eq!(report.events[0].string, 1);
        assert_eq!(report.events[0].fret, 20);
        assert_eq!(
            report.events[0].technique,
            Some(super::super::notation::GuitarTechnique::Bend)
        );
        assert_eq!(report.events[0].bend_alter_cents, Some(150));
        assert_eq!(report.events[0].bend_curve.len(), 3);
        assert_eq!(report.events[0].bend_curve[1].position_per_mille, 500);
        assert_eq!(report.events[0].bend_curve[1].alter_cents, 150);
        assert_eq!(
            report.events[0].playback.pitch_bend_curve,
            report.events[0].bend_curve
        );
        assert!(report.diagnostics.is_empty());

        score.parts[0].staves[0].measures[0].voices[0][0].tab_position =
            Some(super::super::notation::TabPosition {
                string: 1,
                fret: 19,
            });
        let report = project_tablature_performance(&score, &PlaybackOptions::default())
            .expect("tablature projection");
        assert_eq!(report.events[0].pitch_error_cents, 100);
        assert!(matches!(
            report.diagnostics[0],
            TablaturePerformanceDiagnostic::PitchMismatch {
                error_cents: 100,
                ..
            }
        ));
    }

    #[test]
    fn tablature_performance_projection_does_not_invent_missing_positions() {
        let mut score = Score::new("Tab", 120, 4, 4, 0, 1);
        score.parts[0].staves[0].tablature = Some(super::super::notation::TablatureConfig {
            lines: 6,
            tuning_midi: vec![40, 45, 50, 55, 59, 64],
            capo: 0,
        });
        score.parts[0].staves[0].measures[0].voices[0].push(crate::Note::new(
            crate::Pitch::new(crate::Step::C, 4),
            crate::Duration::Quarter,
        ));
        let report = project_tablature_performance(&score, &PlaybackOptions::default())
            .expect("tablature projection");
        assert!(report.events.is_empty());
        assert!(matches!(
            report.diagnostics[0],
            TablaturePerformanceDiagnostic::MissingPosition { .. }
        ));
    }

    #[test]
    fn tablature_performance_event_accepts_legacy_json_without_technique() {
        let mut score = Score::new("Tab", 120, 4, 4, 0, 1);
        score.parts[0].staves[0].tablature = Some(super::super::notation::TablatureConfig {
            lines: 6,
            tuning_midi: vec![40, 45, 50, 55, 59, 64],
            capo: 0,
        });
        let mut note = crate::Note::new(
            crate::Pitch::new(crate::Step::C, 4),
            crate::Duration::Quarter,
        );
        note.tab_position = Some(super::super::notation::TabPosition {
            string: 1,
            fret: 20,
        });
        score.parts[0].staves[0].measures[0].voices[0] = vec![note];
        let report = project_tablature_performance(&score, &PlaybackOptions::default())
            .expect("tablature projection");
        let mut legacy = serde_json::to_value(&report.events[0]).expect("event JSON");
        legacy
            .as_object_mut()
            .expect("event object")
            .remove("technique");
        let restored: TablaturePerformanceEvent =
            serde_json::from_value(legacy).expect("legacy event JSON");
        assert_eq!(restored.technique, None);
    }

    #[test]
    fn tablature_round_trip_report_preserves_authored_positions() {
        let mut score = Score::new("Tab", 120, 4, 4, 0, 1);
        score.parts[0].staves[0].tablature = Some(super::super::notation::TablatureConfig {
            lines: 6,
            tuning_midi: vec![40, 45, 50, 55, 59, 64],
            capo: 2,
        });
        let mut note = crate::Note::new(
            crate::Pitch::new(crate::Step::C, 4),
            crate::Duration::Quarter,
        );
        note.tab_positions = vec![crate::TabPosition { string: 5, fret: 1 }];
        score.parts[0].staves[0].measures[0].voices[0] = vec![note];
        let report = tablature_round_trip_report(&score).expect("tab round-trip report");
        assert!(report.equivalent);
        assert_eq!(report.checked_notes, 1);
        assert_eq!(report.positioned_notes, 1);
        assert!(report.diagnostics.is_empty());
    }

    #[test]
    fn tablature_performance_uses_measure_local_tuning_change() {
        let mut score = Score::new("Local tuning", 120, 4, 4, 0, 2);
        let staff = &mut score.parts[0].staves[0];
        staff.tablature = Some(super::super::notation::TablatureConfig {
            lines: 6,
            tuning_midi: vec![40, 45, 50, 55, 59, 64],
            capo: 0,
        });
        staff.measures[1].tablature_change = Some(super::super::notation::TablatureConfig {
            lines: 6,
            tuning_midi: vec![38, 45, 50, 55, 59, 64],
            capo: 0,
        });
        let mut note = Note::new(Pitch::new(Step::C, 3), Duration::Quarter);
        note.tab_position = Some(TabPosition {
            string: 1,
            fret: 10,
        });
        staff.measures[1].voices[0] = vec![note];

        let report = project_tablature_performance(&score, &PlaybackOptions::default())
            .expect("tablature projection");
        assert_eq!(report.events.len(), 1);
        assert_eq!(report.events[0].expected_pitch_midi_cents, 4_800);
        assert!(!report.diagnostics.iter().any(|diagnostic| matches!(
            diagnostic,
            TablaturePerformanceDiagnostic::PitchMismatch { .. }
        )));
    }
}