diff --git a/reachability-lab/Cargo.toml b/reachability-lab/Cargo.toml index 1397e7f2..e66ec92a 100644 --- a/reachability-lab/Cargo.toml +++ b/reachability-lab/Cargo.toml @@ -4,9 +4,9 @@ # that must never enter the production build, CI, `--workspace` clippy, or add # holdout policy to the CLI/cockpit. Mirrors the ADR-0010 isolation precedent. # -# Scope of this crate (ADR-0032): song-mode and source-file-mode holdout — a -# fail-closed, single-authority boundary over a bound LoadedCorpus. Fragment mode -# and any measurement axes are separate later slices. +# Scope of this crate (ADR-0032): song, source-file, and fragment holdout — a +# fail-closed, single-authority boundary over a bound LoadedCorpus. Any +# measurement axes are separate later slices. [package] name = "griff-reachability-lab" diff --git a/reachability-lab/README.md b/reachability-lab/README.md index e60ffd3f..bc30f74b 100644 --- a/reachability-lab/README.md +++ b/reachability-lab/README.md @@ -13,9 +13,9 @@ The generator loads `Vec` — each carrying full `ChunkMeta` novelty references, and gesture stats. So a holdout decision can only be made **over `Vec`, before `corpus_material`**. This crate is that seam. -## Scope (ADR-0032 first slice) +## Scope -**Song and source-file modes**, fail-closed, over a single-authority +Song, source-file, and fragment holdout, fail-closed, over a single-authority `LoadedCorpus`: ```rust @@ -35,6 +35,13 @@ prepare_corpus_for_mode(corpus: LoadedCorpus, mode: CorpusMode, target: &TargetI and does **not** require `song_id`, so a hash-identified but song-uncurated corpus is a valid file-mode experiment. Its preflight rejects any participating chunk without `sha256` (no basename fallback). +- **`HoldoutTargetFragment`** → bind → source-file + fragment preflight → require + target `source_sha256` + `bar_range` → exclude every same-source chunk whose + **inclusive** range overlaps or contains the target → compile the survivors. + Ranges are inclusive; either side being `None` means **whole-source** overlap + (a valid target, not a missing field); `track_index` is provenance and never + narrows the exclusion; a malformed range (`first > last`), on the target or a + target-source manifest chunk, typed-refuses. Independent of song curation. `LoadedCorpus { manifest, loaded, skipped }` is **one authority**: every loaded record maps by `ChunkId` to exactly one manifest chunk whose **full** `ChunkMeta` @@ -55,11 +62,9 @@ templates, and gesture. ## Not in this crate -- Fragment mode (its range-overlap semantics — including the dangerous rule that - `bar_range == None` overlaps every range in the same source — get their own - slice, built over this source-file identity path). - Any measurement / eligibility / projection axis. -- Curation, production wiring, generation or scoring changes. +- `song_id` curation and tooling. +- Production wiring (CLI / cockpit), generation, scoring, or track-index recovery. ## Run diff --git a/reachability-lab/src/lib.rs b/reachability-lab/src/lib.rs index 5f5f5784..5a80664b 100644 --- a/reachability-lab/src/lib.rs +++ b/reachability-lab/src/lib.rs @@ -6,10 +6,12 @@ //! mode/target/error vocabulary; production CLI, cockpit, generation, and //! reranking acquire no holdout policy. //! -//! Implemented so far (ADR-0032), fail-closed over a single-authority -//! [`LoadedCorpus`]: **song mode** (`HoldoutTargetSong`) and **source-file -//! mode** (`HoldoutTargetSourceFile`, exact `sha256`, independent of song -//! curation). Fragment mode and any measurement axes are separate later slices. +//! Implemented (ADR-0032), fail-closed over a single-authority [`LoadedCorpus`]: +//! **song mode** (`HoldoutTargetSong`), **source-file mode** +//! (`HoldoutTargetSourceFile`, exact `sha256`), and **fragment mode** +//! (`HoldoutTargetFragment`, same source with inclusive `bar_range` overlap). +//! The two hash-based modes are independent of song curation. Any measurement +//! axes are separate later slices. use griff_core::corpus::{ song_holdout_preflight, ChunkId, ChunkMeta, CorpusManifest, SongHoldoutRefusal, SongId, @@ -45,17 +47,28 @@ pub enum CorpusMode { /// Exclude every chunk cut from the target source file (by exact `sha256`), /// fail-closed. Independent of song curation. HoldoutTargetSourceFile, + /// Exclude every chunk from the target source (`sha256`) whose inclusive + /// `bar_range` overlaps or contains the target range, fail-closed. + /// Independent of song curation and of track. + HoldoutTargetFragment, } /// The identity a holdout targets, with the field per mode kept explicit. Song -/// mode uses `song_id`; source-file mode uses `source_sha256`. The remaining -/// fragment / measurement fields (`bar_range`, `track_index`, `projection`, -/// `eligibility`) join with their own later slices. +/// mode uses `song_id`; source-file mode uses `source_sha256`; fragment mode uses +/// `source_sha256` + `bar_range`. `track_index` is provenance only. Measurement +/// fields (`projection`, `eligibility`) join with their own later slices. #[derive(Debug, Clone, Default)] pub struct TargetIdentity { /// The source file to hold out, by content hash (required by - /// `HoldoutTargetSourceFile`). + /// `HoldoutTargetSourceFile` and `HoldoutTargetFragment`). pub source_sha256: Option, + /// The inclusive `(first, last)` fragment range within the source + /// (`HoldoutTargetFragment`). `None` means the **whole source** — not a + /// missing field. + pub bar_range: Option<(u32, u32)>, + /// Provenance only in fragment mode — it never narrows exclusion, since an + /// overlapping chunk from another track can still leak the target. + pub track_index: Option, /// The composition to hold out (required by `HoldoutTargetSong`). pub song_id: Option, } @@ -82,6 +95,18 @@ pub enum HoldoutError { /// The target `sha256` is carried by no *loaded* chunk, so no holdout would /// actually happen (e.g. the target file failed to load). TargetSourceAbsent(String), + /// The target fragment range is malformed (`first_bar > last_bar`). Never + /// silently swapped, treated as disjoint, or degraded to `TargetFragmentAbsent`. + InvalidTargetBarRange { first_bar: u32, last_bar: u32 }, + /// The fragment preflight refused the corpus (a target-source manifest chunk + /// carried a malformed range). + FragmentPreflight(Vec), + /// No *loaded* chunk of the target source overlaps the target range, so no + /// holdout would actually happen. `bar_range` `None` means whole-source. + TargetFragmentAbsent { + source_sha256: String, + bar_range: Option<(u32, u32)>, + }, } /// A reason the source-file preflight refuses a corpus (ADR-0032): source-file @@ -94,6 +119,18 @@ pub enum SourceHoldoutRefusal { UnidentifiedSource(ChunkId), } +/// A reason the fragment preflight refuses a corpus (ADR-0032). +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum FragmentHoldoutRefusal { + /// A target-source manifest chunk carries a malformed range + /// (`first_bar > last_bar`). + InvalidBarRange { + chunk_id: ChunkId, + first_bar: u32, + last_bar: u32, + }, +} + /// A single-authority violation between the manifest and the loaded records. #[derive(Debug, Clone, PartialEq, Eq)] pub enum BindingRefusal { @@ -113,19 +150,40 @@ pub enum BindingRefusal { /// Prepare a loaded corpus for a run mode, fail-closed (ADR-0032). /// /// Returns `Ok(None)` for a genuinely corpus-free run (`NoCorpus`) and -/// `Ok(Some(_))` for a corpus-backed one. For `HoldoutTargetSong`: bind the -/// loaded records to the manifest (single authority), run -/// `song_holdout_preflight` over the whole manifest, require a target `song_id`, -/// exclude every `LoadedChunk` carrying it, and only then compile the rest. +/// `Ok(Some(_))` for a corpus-backed one. `LeakyDiagnostic` compiles the corpus +/// unfiltered. Each holdout mode binds the loaded records to the manifest (single +/// authority), runs its mode preflight, requires its target identity, excludes +/// the matching `LoadedChunk`s, and only then compiles the survivors — refusing +/// if nothing was excluded: +/// +/// - `HoldoutTargetSong` — `song_holdout_preflight`; target `song_id`; exclude +/// every representation of the song. +/// - `HoldoutTargetSourceFile` — source-file preflight (complete `sha256`); +/// target `source_sha256`; exclude every chunk of that file. +/// - `HoldoutTargetFragment` — source-file + fragment preflight; target +/// `source_sha256` + `bar_range`; exclude every same-source chunk whose +/// inclusive range overlaps the target (`None` on either side = whole source; +/// `track_index` never narrows it). +/// +/// The two hash-based modes do not run the song preflight and do not require +/// `song_id`. /// /// # Errors /// -/// [`HoldoutError`] when `HoldoutTargetSong` cannot proceed fail-closed: a -/// single-authority binding violation ([`HoldoutError::CorpusBinding`]), a -/// preflight refusal ([`HoldoutError::Preflight`]), a missing target -/// ([`HoldoutError::MissingTargetSongId`]), or a target carried by no loaded -/// chunk ([`HoldoutError::TargetSongAbsent`]). `NoCorpus` and `LeakyDiagnostic` -/// never refuse. +/// [`HoldoutError`], fail-closed, when a holdout mode cannot proceed: +/// - any mode: a single-authority binding violation +/// ([`HoldoutError::CorpusBinding`]); +/// - song: [`HoldoutError::Preflight`], [`HoldoutError::MissingTargetSongId`], +/// [`HoldoutError::TargetSongAbsent`]; +/// - source-file: [`HoldoutError::SourcePreflight`], +/// [`HoldoutError::MissingTargetSourceSha256`], +/// [`HoldoutError::TargetSourceAbsent`]; +/// - fragment: [`HoldoutError::SourcePreflight`], +/// [`HoldoutError::MissingTargetSourceSha256`], +/// [`HoldoutError::InvalidTargetBarRange`], [`HoldoutError::FragmentPreflight`], +/// [`HoldoutError::TargetFragmentAbsent`]. +/// +/// `NoCorpus` and `LeakyDiagnostic` never refuse. pub fn prepare_corpus_for_mode( corpus: LoadedCorpus, mode: CorpusMode, @@ -179,6 +237,80 @@ pub fn prepare_corpus_for_mode( } Ok(Some(corpus_material(kept, corpus.skipped))) } + CorpusMode::HoldoutTargetFragment => { + check_binding(&corpus)?; + source_file_preflight(&corpus.manifest).map_err(HoldoutError::SourcePreflight)?; + let target_sha = target + .source_sha256 + .as_ref() + .ok_or(HoldoutError::MissingTargetSourceSha256)?; + // A malformed target range is a typed refusal — never swapped, + // treated as disjoint, or degraded to TargetFragmentAbsent. + if let Some((first, last)) = target.bar_range { + if first > last { + return Err(HoldoutError::InvalidTargetBarRange { + first_bar: first, + last_bar: last, + }); + } + } + fragment_preflight(&corpus.manifest, target_sha) + .map_err(HoldoutError::FragmentPreflight)?; + // Exclude by exact sha256 AND inclusive range overlap; track_index is + // provenance only and never narrows the exclusion. + let (excluded, kept): (Vec, Vec) = + corpus.loaded.into_iter().partition(|chunk| { + chunk.meta.source.sha256.as_ref() == Some(target_sha) + && ranges_overlap(target.bar_range, chunk.meta.source.bar_range) + }); + if excluded.is_empty() { + return Err(HoldoutError::TargetFragmentAbsent { + source_sha256: target_sha.clone(), + bar_range: target.bar_range, + }); + } + Ok(Some(corpus_material(kept, corpus.skipped))) + } + } +} + +/// Inclusive range-overlap for holdout, applied **only after** exact `sha256` +/// equality. Either side being `None` means the whole source and overlaps any +/// range from that source; different source hashes never reach here. +fn ranges_overlap(target: Option<(u32, u32)>, chunk: Option<(u32, u32)>) -> bool { + match (target, chunk) { + (None, _) | (_, None) => true, + (Some((target_first, target_last)), Some((chunk_first, chunk_last))) => { + target_first <= chunk_last && chunk_first <= target_last + } + } +} + +/// Fail-closed fragment preflight: a manifest chunk of the target source whose +/// range is malformed (`first > last`) is refused before any range filtering, so +/// a bad range can never silently exclude nothing. `bar_range` `None` is valid +/// (whole-source) and never refused. +fn fragment_preflight( + manifest: &CorpusManifest, + target_sha: &str, +) -> Result<(), Vec> { + let refusals: Vec = manifest + .chunks + .iter() + .filter(|chunk| chunk.source.sha256.as_deref() == Some(target_sha)) + .filter_map(|chunk| match chunk.source.bar_range { + Some((first, last)) if first > last => Some(FragmentHoldoutRefusal::InvalidBarRange { + chunk_id: chunk.id.clone(), + first_bar: first, + last_bar: last, + }), + _ => None, + }) + .collect(); + if refusals.is_empty() { + Ok(()) + } else { + Err(refusals) } } @@ -379,8 +511,8 @@ mod tests { fn song_target(song: &str) -> TargetIdentity { TargetIdentity { - source_sha256: None, song_id: Some(SongId(song.to_owned())), + ..TargetIdentity::default() } } @@ -820,7 +952,7 @@ mod tests { fn file_target(sha: &str) -> TargetIdentity { TargetIdentity { source_sha256: Some(sha.to_owned()), - song_id: None, + ..TargetIdentity::default() } } @@ -1079,4 +1211,448 @@ mod tests { assert_eq!(a.rhythms, b.rhythms); assert_eq!(a.gesture, b.gesture); } + + // ── fragment mode (HoldoutTargetFragment) ─────────────────────────────── + + fn fragment_target(sha: &str, range: Option<(u32, u32)>) -> TargetIdentity { + TargetIdentity { + source_sha256: Some(sha.to_owned()), + bar_range: range, + track_index: None, + song_id: None, + } + } + + /// A hash-identified, song-uncurated chunk at `range` on `track`; its manifest + /// twin is identical so binding holds. + fn frag_tracked( + id: &str, + sha: &str, + range: Option<(u32, u32)>, + track: Option, + gesture: bool, + ) -> (ChunkMeta, LoadedChunk) { + let mut m = meta(id, Some(sha), None, gesture); + m.source.bar_range = range; + m.source.track_index = track; + let onset = range.map_or(0, |(first, _)| first.saturating_mul(120) % 1920); + let lc = LoadedChunk { + meta: m.clone(), + sliced: one_bar_score(onset, 60), + track: 0, + }; + (m, lc) + } + + fn frag(id: &str, sha: &str, range: Option<(u32, u32)>) -> (ChunkMeta, LoadedChunk) { + frag_tracked(id, sha, range, None, false) + } + + /// Build a corpus whose manifest exactly mirrors the loaded records, plus + /// optional manifest-only chunks (curated but unloaded) and skipped names. + fn frag_corpus( + loaded: Vec<(ChunkMeta, LoadedChunk)>, + manifest_only: Vec, + skipped: &[&str], + ) -> LoadedCorpus { + let mut manifest_chunks: Vec = loaded.iter().map(|(m, _)| m.clone()).collect(); + manifest_chunks.extend(manifest_only); + LoadedCorpus { + manifest: manifest_of(manifest_chunks), + loaded: loaded.into_iter().map(|(_, l)| l).collect(), + skipped: skipped.iter().map(|s| (*s).to_owned()).collect(), + } + } + + #[test] + fn ranges_overlap_predicate_is_inclusive_with_none_whole_source() { + assert!( + ranges_overlap(None, Some((10, 12))), + "target None overlaps all" + ); + assert!( + ranges_overlap(Some((10, 12)), None), + "chunk None overlaps all" + ); + assert!( + ranges_overlap(Some((0, 3)), Some((3, 5))), + "endpoint touch overlaps" + ); + assert!( + ranges_overlap(Some((0, 3)), Some((1, 2))), + "contained overlaps" + ); + assert!( + ranges_overlap(Some((1, 2)), Some((0, 5))), + "containing overlaps" + ); + assert!( + ranges_overlap(Some((0, 3)), Some((2, 5))), + "partial overlaps" + ); + assert!( + !ranges_overlap(Some((0, 2)), Some((3, 5))), + "disjoint does not overlap" + ); + } + + #[test] + fn fragment_mode_refuses_missing_target_sha256() { + let corpus = frag_corpus(vec![frag("a", "shaA", Some((0, 1)))], Vec::new(), &[]); + let target = TargetIdentity { + bar_range: Some((0, 1)), + ..TargetIdentity::default() + }; + let err = prepare_corpus_for_mode(corpus, CorpusMode::HoldoutTargetFragment, &target) + .expect_err("no target sha must refuse"); + assert_eq!(err, HoldoutError::MissingTargetSourceSha256); + } + + #[test] + fn fragment_mode_refuses_unidentified_manifest_chunk() { + let (m, lc) = frag("a", "shaA", Some((0, 1))); + let mut unhashed_m = meta("u", None, None, false); + unhashed_m.source.bar_range = Some((0, 1)); + let corpus = frag_corpus(vec![(m, lc)], vec![unhashed_m], &["u.gp5"]); + let err = prepare_corpus_for_mode( + corpus, + CorpusMode::HoldoutTargetFragment, + &fragment_target("shaA", None), + ) + .expect_err("sha256-less chunk must refuse"); + assert!(matches!(err, HoldoutError::SourcePreflight(_))); + } + + #[test] + fn fragment_mode_refuses_inverted_target_range() { + let corpus = frag_corpus(vec![frag("a", "shaA", Some((0, 3)))], Vec::new(), &[]); + let err = prepare_corpus_for_mode( + corpus, + CorpusMode::HoldoutTargetFragment, + &fragment_target("shaA", Some((5, 2))), + ) + .expect_err("inverted target range must refuse"); + assert_eq!( + err, + HoldoutError::InvalidTargetBarRange { + first_bar: 5, + last_bar: 2 + } + ); + } + + #[test] + fn fragment_mode_refuses_inverted_manifest_range_on_target_source() { + // A target-source manifest chunk with first > last, caught before filtering. + let (mut m, _) = frag("a", "shaA", Some((5, 2))); + m.source.bar_range = Some((5, 2)); + let lc = LoadedChunk { + meta: m.clone(), + sliced: one_bar_score(0, 60), + track: 0, + }; + let corpus = frag_corpus(vec![(m, lc)], Vec::new(), &[]); + let err = prepare_corpus_for_mode( + corpus, + CorpusMode::HoldoutTargetFragment, + &fragment_target("shaA", Some((0, 3))), + ) + .expect_err("inverted manifest range must refuse"); + assert!(matches!(err, HoldoutError::FragmentPreflight(ref rs) + if rs.iter().any(|r| matches!(r, FragmentHoldoutRefusal::InvalidBarRange { chunk_id, first_bar, last_bar } + if chunk_id.0 == "a" && *first_bar == 5 && *last_bar == 2)))); + } + + #[test] + fn fragment_target_none_excludes_every_chunk_of_target_hash() { + let corpus = frag_corpus( + vec![ + frag("a", "shaX", Some((0, 1))), + frag("b", "shaX", Some((5, 6))), + frag("c", "shaY", Some((0, 1))), + ], + Vec::new(), + &[], + ); + let held = prepare_corpus_for_mode( + corpus, + CorpusMode::HoldoutTargetFragment, + &fragment_target("shaX", None), + ) + .expect("ok") + .expect("some"); + assert_eq!( + held.references.len(), + 1, + "target None is whole-source: both shaX chunks excluded" + ); + } + + #[test] + fn fragment_chunk_none_overlaps_every_target_range() { + let corpus = frag_corpus( + vec![frag("a", "shaX", None), frag("c", "shaY", Some((0, 1)))], + Vec::new(), + &[], + ); + let held = prepare_corpus_for_mode( + corpus, + CorpusMode::HoldoutTargetFragment, + &fragment_target("shaX", Some((10, 12))), + ) + .expect("ok") + .expect("some"); + assert_eq!( + held.references.len(), + 1, + "whole-source chunk overlaps any target range" + ); + } + + #[test] + fn fragment_excludes_exact_contained_containing_partial_and_touching() { + let corpus = frag_corpus( + vec![ + frag("exact", "shaX", Some((0, 3))), + frag("contained", "shaX", Some((1, 2))), + frag("containing", "shaX", Some((0, 9))), + frag("partial", "shaX", Some((2, 5))), + frag("touching", "shaX", Some((3, 6))), + frag("keeper", "shaY", Some((0, 3))), + ], + Vec::new(), + &[], + ); + let held = prepare_corpus_for_mode( + corpus, + CorpusMode::HoldoutTargetFragment, + &fragment_target("shaX", Some((0, 3))), + ) + .expect("ok") + .expect("some"); + assert_eq!( + held.references.len(), + 1, + "every overlapping shaX chunk excluded; only the other source remains" + ); + } + + #[test] + fn fragment_keeps_disjoint_same_source_range() { + let corpus = frag_corpus( + vec![ + frag("target", "shaX", Some((0, 2))), + frag("disjoint", "shaX", Some((3, 5))), + ], + Vec::new(), + &[], + ); + let held = prepare_corpus_for_mode( + corpus, + CorpusMode::HoldoutTargetFragment, + &fragment_target("shaX", Some((0, 2))), + ) + .expect("ok") + .expect("some"); + assert_eq!( + held.references.len(), + 1, + "disjoint same-source fragment survives" + ); + } + + #[test] + fn fragment_keeps_overlapping_range_from_other_source() { + let corpus = frag_corpus( + vec![ + frag("target", "shaX", Some((0, 3))), + frag("other", "shaY", Some((0, 3))), + ], + Vec::new(), + &[], + ); + let held = prepare_corpus_for_mode( + corpus, + CorpusMode::HoldoutTargetFragment, + &fragment_target("shaX", Some((0, 3))), + ) + .expect("ok") + .expect("some"); + assert_eq!( + held.references.len(), + 1, + "different source hash never overlaps for holdout" + ); + } + + #[test] + fn fragment_excludes_overlap_across_tracks() { + let corpus = frag_corpus( + vec![ + frag_tracked("t0", "shaX", Some((0, 3)), Some(0), false), + frag_tracked("t1", "shaX", Some((0, 3)), Some(1), false), + frag("keeper", "shaY", Some((0, 3))), + ], + Vec::new(), + &[], + ); + // target names track 0, but track must not narrow exclusion. + let target = TargetIdentity { + source_sha256: Some("shaX".to_owned()), + bar_range: Some((0, 3)), + track_index: Some(0), + song_id: None, + }; + let held = prepare_corpus_for_mode(corpus, CorpusMode::HoldoutTargetFragment, &target) + .expect("ok") + .expect("some"); + assert_eq!( + held.references.len(), + 1, + "both tracks' overlapping chunks excluded" + ); + } + + #[test] + fn fragment_refuses_when_nothing_overlaps() { + let corpus = frag_corpus(vec![frag("a", "shaX", Some((5, 7)))], Vec::new(), &[]); + let err = prepare_corpus_for_mode( + corpus, + CorpusMode::HoldoutTargetFragment, + &fragment_target("shaX", Some((0, 2))), + ) + .expect_err("no overlap must refuse"); + assert_eq!( + err, + HoldoutError::TargetFragmentAbsent { + source_sha256: "shaX".to_owned(), + bar_range: Some((0, 2)) + } + ); + } + + #[test] + fn fragment_refuses_target_present_only_in_skipped() { + let (m, lc) = frag("keeper", "shaY", Some((0, 3))); + let mut mz = meta("z", Some("shaX"), None, false); + mz.source.bar_range = Some((0, 3)); + let corpus = frag_corpus(vec![(m, lc)], vec![mz], &["z.gp5"]); + let err = prepare_corpus_for_mode( + corpus, + CorpusMode::HoldoutTargetFragment, + &fragment_target("shaX", Some((0, 3))), + ) + .expect_err("target only in skipped must refuse"); + assert_eq!( + err, + HoldoutError::TargetFragmentAbsent { + source_sha256: "shaX".to_owned(), + bar_range: Some((0, 3)) + } + ); + } + + #[test] + fn fragment_succeeds_on_song_uncurated_corpus() { + let corpus = frag_corpus( + vec![ + frag("a", "shaX", Some((0, 3))), + frag("c", "shaY", Some((0, 3))), + ], + Vec::new(), + &[], + ); + let held = prepare_corpus_for_mode( + corpus, + CorpusMode::HoldoutTargetFragment, + &fragment_target("shaX", Some((0, 3))), + ) + .expect("uncurated songs are fine for fragment mode") + .expect("corpus-backed"); + assert_eq!(held.references.len(), 1); + } + + #[test] + fn fragment_zero_leakage_including_skipped() { + let (mx, lx) = frag_tracked("x", "shaX", Some((0, 3)), None, true); + let (my, ly) = frag("y", "shaY", Some((5, 7))); + let corpus = LoadedCorpus { + manifest: manifest_of(vec![mx, my]), + loaded: vec![lx, ly], + skipped: vec!["gone.gp5".to_owned()], + }; + let held = prepare_corpus_for_mode( + corpus, + CorpusMode::HoldoutTargetFragment, + &fragment_target("shaX", Some((0, 3))), + ) + .expect("ok") + .expect("some"); + let keeper_only = corpus_material( + vec![frag("y", "shaY", Some((5, 7))).1], + vec!["gone.gp5".to_owned()], + ); + assert_eq!(held.references, keeper_only.references); + assert_eq!(held.rhythms, keeper_only.rhythms); + assert_eq!(held.gesture, keeper_only.gesture); + assert_eq!(held.skipped, keeper_only.skipped); + assert!( + held.gesture.is_none(), + "excluded fragment's gesture did not leak" + ); + } + + #[test] + fn fragment_binding_runs_before_preflight() { + let manifest_meta = meta("a", Some("shaA"), None, false); + let mut loaded_meta = meta("a", Some("shaA"), None, false); + loaded_meta.source.track_index = Some(7); + let corpus = LoadedCorpus { + manifest: manifest_of(vec![manifest_meta]), + loaded: vec![LoadedChunk { + meta: loaded_meta, + sliced: one_bar_score(0, 60), + track: 0, + }], + skipped: Vec::new(), + }; + let err = prepare_corpus_for_mode( + corpus, + CorpusMode::HoldoutTargetFragment, + &fragment_target("shaA", Some((0, 0))), + ) + .expect_err("binding refuses first"); + assert!(matches!(err, HoldoutError::CorpusBinding(_))); + } + + #[test] + fn fragment_mode_is_deterministic() { + let build = || { + frag_corpus( + vec![ + frag("a", "shaX", Some((0, 3))), + frag("c", "shaY", Some((0, 3))), + ], + Vec::new(), + &[], + ) + }; + let a = prepare_corpus_for_mode( + build(), + CorpusMode::HoldoutTargetFragment, + &fragment_target("shaX", Some((0, 3))), + ) + .expect("ok") + .expect("some"); + let b = prepare_corpus_for_mode( + build(), + CorpusMode::HoldoutTargetFragment, + &fragment_target("shaX", Some((0, 3))), + ) + .expect("ok") + .expect("some"); + assert_eq!(a.references, b.references); + assert_eq!(a.rhythms, b.rhythms); + assert_eq!(a.gesture, b.gesture); + } }