From 9b99e7c62601efc338555cd886f0fd9923d2878c Mon Sep 17 00:00:00 2001 From: Codex-ytr83r Date: Sun, 13 Sep 2026 05:32:55 -0700 Subject: [PATCH] Index measured label field overlap lookups with exact differential oracles --- .../oa-desktop/src/behavior/scenario_label.rs | 105 ++++- .../behavior/scenario_label/field_tests.rs | 38 +- .../behavior/scenario_label/lookup_tests.rs | 381 ++++++++++++++++++ .../scenario-label-lookup-20260913/README.md | 26 ++ 4 files changed, 531 insertions(+), 19 deletions(-) create mode 100644 crates/oa-desktop/src/behavior/scenario_label/lookup_tests.rs create mode 100644 harness/experiments/scenario-label-lookup-20260913/README.md diff --git a/crates/oa-desktop/src/behavior/scenario_label.rs b/crates/oa-desktop/src/behavior/scenario_label.rs index bbef18f1..a948ee93 100644 --- a/crates/oa-desktop/src/behavior/scenario_label.rs +++ b/crates/oa-desktop/src/behavior/scenario_label.rs @@ -26,7 +26,11 @@ use iced::advanced::{ text::{Alignment, LineHeight, Shaping}, }; use iced::{Color, Font, Pixels, Point, Rectangle, Size, widget::canvas::Text}; -use std::{collections::VecDeque, ops::Range, sync::Arc}; +use std::{ + collections::{HashSet, VecDeque}, + ops::Range, + sync::Arc, +}; use unicode_segmentation::UnicodeSegmentation; const MAX_SOURCE_BYTES: usize = 64 * 1024; @@ -102,6 +106,7 @@ pub(super) struct Label { clusters: Vec, source_spans: Vec, retained_normalized: usize, + field_index: FieldIndex, } #[derive(Clone, Debug, PartialEq)] @@ -142,6 +147,69 @@ struct FieldCluster { missing: bool, } +/// Immutable overlap membership, built from Normalized's ordered, disjoint +/// scalar/separator spans. Clusters may overlap and need not be in visual order. +/// Construction costs O(C log S + I), storage O(S + C + I), where I is the +/// number of actual span/cluster overlaps, rather than the full S*C product. +#[derive(Clone, Debug)] +struct FieldIndex { + clusters_by_span: Vec>, + source_extents: Vec>, +} + +#[derive(Clone, Copy, Debug)] +struct SourceExtents { + minimum_end: usize, + maximum_start: usize, +} + +impl FieldIndex { + fn new(spans: &[SourceSpan], clusters: &[FieldCluster]) -> Self { + debug_assert!( + spans + .iter() + .all(|span| span.normalized.start < span.normalized.end) + ); + debug_assert!( + spans + .windows(2) + .all(|pair| pair[0].normalized.end <= pair[1].normalized.start) + ); + let mut result = Self { + clusters_by_span: vec![vec![]; spans.len()], + source_extents: vec![None; clusters.len()], + }; + for (index, cluster) in clusters.iter().enumerate() { + if cluster.normalized.start >= cluster.normalized.end { + continue; + } + let first = + spans.partition_point(|span| span.normalized.end <= cluster.normalized.start); + for (offset, span) in spans[first..].iter().enumerate() { + if span.normalized.start >= cluster.normalized.end { + break; + } + result.clusters_by_span[first + offset].push(index); + let extents = result.source_extents[index].get_or_insert(SourceExtents { + minimum_end: span.source.end, + maximum_start: span.source.start, + }); + extents.minimum_end = extents.minimum_end.min(span.source.end); + extents.maximum_start = extents.maximum_start.max(span.source.start); + } + } + result + } +} + +// Translation rejects nonfinite rectangle components before deduplication. +// For finite f32 values, bit equality differs from `==` only at signed zero. +// Normalize only the key: preserve the first rectangle and its original bits. +fn rectangle_key(bounds: Rectangle) -> [u32; 4] { + [bounds.x, bounds.y, bounds.width, bounds.height] + .map(|value| if value == 0. { 0 } else { value.to_bits() }) +} + impl Label { /// Geometry and coverage are separate: truncation is not missing-font /// coverage, and a positive .notdef advance is not represented field text. @@ -168,7 +236,7 @@ impl Label { shared_cluster: false, }; let mut selected = vec![false; self.clusters.len()]; - for span in &self.source_spans { + for (span_index, span) in self.source_spans.iter().enumerate() { if span.whitespace || !overlaps(&span.source, &field) { continue; } @@ -178,27 +246,25 @@ impl Label { append_range(&mut result.truncated, span.source.clone()); continue; } - let matching: Vec<_> = self - .clusters - .iter() - .enumerate() - .filter(|(_, cluster)| overlaps(&cluster.normalized, &span.normalized)) - .collect(); - result.shared_cluster |= matching.iter().any(|(_, cluster)| { + let matching = &self.field_index.clusters_by_span[span_index]; + result.shared_cluster |= matching.iter().any(|&index| { + let cluster = &self.clusters[index]; cluster.normalized.end > self.retained_normalized - || self.source_spans.iter().any(|other| { - overlaps(&other.normalized, &cluster.normalized) - && !overlaps(&other.source, &field) + || self.field_index.source_extents[index].is_some_and(|extents| { + // Any overlapping source span outside the requested + // field is exactly either a too-small end or too-large + // start. Include whitespace/nonpainting spans, as before. + extents.minimum_end <= field.start || extents.maximum_start >= field.end }) }); let issue = if span.non_painting { Some(FieldIssue::NonPaintingScalar) - } else if matching.iter().any(|(_, cluster)| cluster.missing) { + } else if matching.iter().any(|&index| self.clusters[index].missing) { Some(FieldIssue::MissingGlyph) } else if matching.is_empty() || matching .iter() - .all(|(_, cluster)| cluster.rectangles.is_empty()) + .all(|&index| self.clusters[index].rectangles.is_empty()) { Some(FieldIssue::NoAdvanceGeometry) } else { @@ -212,10 +278,11 @@ impl Label { continue; } append_range(&mut result.covered, span.source.clone()); - for (index, _) in matching { + for &index in matching { selected[index] = true; } } + let mut seen = HashSet::new(); for (cluster, selected) in self.clusters.iter().zip(selected) { if !selected { continue; @@ -225,7 +292,7 @@ impl Label { Point::new(position.x + bounds.x, position.y + bounds.y), bounds.size(), )?; - if !result.rectangles.contains(&translated) { + if seen.insert(rectangle_key(translated)) { result.rectangles.push(translated); } } @@ -502,6 +569,7 @@ impl Cache { ); field_clusters(entry, zoom)? }; + let field_index = FieldIndex::new(&normalized.spans, &clusters); let label = Arc::new(Label { source: source.into(), displayed, @@ -513,6 +581,7 @@ impl Cache { clusters, source_spans: normalized.spans, retained_normalized: retained, + field_index, }); if self.entries.len() == MAX_ENTRIES { self.entries.pop_front(); @@ -684,3 +753,7 @@ mod tests; #[cfg(test)] #[path = "scenario_label/field_tests.rs"] mod field_tests; + +#[cfg(test)] +#[path = "scenario_label/lookup_tests.rs"] +mod lookup_tests; diff --git a/crates/oa-desktop/src/behavior/scenario_label/field_tests.rs b/crates/oa-desktop/src/behavior/scenario_label/field_tests.rs index 1dd99908..5369a7f3 100644 --- a/crates/oa-desktop/src/behavior/scenario_label/field_tests.rs +++ b/crates/oa-desktop/src/behavior/scenario_label/field_tests.rs @@ -31,9 +31,12 @@ fn assert_ligature_fixture_face(oracle: &Paragraph) { let mut count = 0; for glyph in oracle.buffer().layout_runs().flat_map(|run| run.glyphs) { assert_eq!( - fonts.raw().db().with_face_data(glyph.font_id, |bytes, index| { - index == 0 && bytes == LIGATURE_FONT - }), + fonts + .raw() + .db() + .with_face_data(glyph.font_id, |bytes, index| { + index == 0 && bytes == LIGATURE_FONT + }), Some(true), "the actual shaped face must be the byte-pinned fixture" ); @@ -568,6 +571,13 @@ fn field_lookup_4096_scalars_and_combining_heavy_full_coverage() { .unwrap(); let resolve_ns = start.elapsed().as_nanos(); assert_eq!(label.displayed, source); + // The preserved 4c9 lookup runs on the exact same immutable shaped + // label. Its timing is separate from the optimized samples below. + let start = std::time::Instant::now(); + let original = label + .original_field_layout(&session, 1., Point::ORIGIN, 0..source.len()) + .unwrap(); + let original_lookup_ns = start.elapsed().as_nanos(); let mut lookup_ns = vec![]; for _ in 0..3 { let start = std::time::Instant::now(); @@ -579,11 +589,33 @@ fn field_lookup_4096_scalars_and_combining_heavy_full_coverage() { assert!(field.truncated.is_empty() && field.unresolved.is_empty()); assert!(!field.partially_retained && !field.shared_cluster); assert_complete_boxes(&field.rectangles, expected.clone()); + super::lookup_tests::assert_exact(&field, &original); + } + // Fresh label construction plus lookup, not just a retained-index + // measurement: moving the old quadratic work into resolve cannot hide. + let mut fresh_resolve_lookup_ns = vec![]; + for _ in 0..3 { + let mut fresh_cache = Cache::default(); + let start = std::time::Instant::now(); + let fresh = fresh_cache + .resolve(&session, &source, 1_000_000., 1., style) + .unwrap(); + let field = fresh + .field_layout(&session, 1., Point::ORIGIN, 0..source.len()) + .unwrap(); + fresh_resolve_lookup_ns.push(start.elapsed().as_nanos()); + super::lookup_tests::assert_exact(&field, &original); + assert_complete_boxes(&field.rectangles, expected.clone()); } records.push(serde_json::json!({ "case": name, "scalars": 4096, "graphemes": expected_graphemes, "source_bytes": source.len(), "expected_rectangles": expected.len(), "resolved_fonts": identities, "resolve_ns": resolve_ns, "lookup_ns": lookup_ns, + "original_lookup_ns": original_lookup_ns, + "fresh_resolve_lookup_ns": fresh_resolve_lookup_ns, + "source_spans": label.source_spans.len(), "clusters": label.clusters.len(), + "overlap_memberships": label.field_index.clusters_by_span.iter().map(Vec::len).sum::(), + "exact_original_result_including_rectangle_bits": "passed", "full_coverage_and_exact_geometry": "passed", })); } diff --git a/crates/oa-desktop/src/behavior/scenario_label/lookup_tests.rs b/crates/oa-desktop/src/behavior/scenario_label/lookup_tests.rs new file mode 100644 index 00000000..b2ce8b4f --- /dev/null +++ b/crates/oa-desktop/src/behavior/scenario_label/lookup_tests.rs @@ -0,0 +1,381 @@ +//! Exact differential oracle from 4c9bc87e4e66bba573dd63b23df5ea039f85d0ca. +//! The old method body is retained verbatim; only its name/visibility changes. +//! Its unchanged validation/translation helpers remain in the parent module. +use super::*; + +pub(super) fn assert_exact(actual: &FieldLayout, expected: &FieldLayout) { + assert_eq!(actual, expected); + // PartialEq deliberately equates signed zero; the observable first box + // must nevertheless retain exactly the old representation and order. + for (actual, expected) in actual.rectangles.iter().zip(&expected.rectangles) { + let bits = |r: &Rectangle| [r.x, r.y, r.width, r.height].map(f32::to_bits); + assert_eq!(bits(actual), bits(expected)); + } +} + +fn compare( + label: &Label, + session: &RenderSession, + zoom: f32, + position: Point, + field: Range, +) { + let old = label.original_field_layout(session, zoom, position, field.clone()); + let new = label.field_layout(session, zoom, position, field); + match (new, old) { + (Ok(new), Ok(old)) => assert_exact(&new, &old), + (new, old) => assert_eq!(new, old), + } +} + +fn all_fields(label: &Label, session: &RenderSession, position: Point) { + let boundaries: Vec<_> = label + .source + .char_indices() + .map(|(i, _)| i) + .chain(std::iter::once(label.source.len())) + .collect(); + for &start in &boundaries { + for &end in &boundaries { + compare(label, session, label.measured_zoom, position, start..end); + } + } +} + +fn synthetic(source: &str, retained: usize, clusters: Vec) -> (RenderSession, Label) { + let session = RenderSession::after_fonts_settled_and_renderer_reset().unwrap(); + let normalized = Normalized::new(source); + let field_index = FieldIndex::new(&normalized.spans, &clusters); + let label = Label { + source: source.into(), + displayed: normalized.text, + retained_source: 0..source.len(), + bounds: Rectangle::with_size(Size::ZERO), + style: Style::default(), + measured_session: session.clone(), + measured_zoom: 1., + clusters, + source_spans: normalized.spans, + retained_normalized: retained, + field_index, + }; + (session, label) +} + +fn cluster(range: Range, rectangles: Vec, missing: bool) -> FieldCluster { + FieldCluster { + normalized: range, + rectangles, + missing, + } +} + +#[test] +fn indexed_lookup_matches_original_for_real_shaping_and_every_field_boundary() { + let session = RenderSession::after_fonts_settled_and_renderer_reset().unwrap(); + let sources = [ + "", + " \t\n ", + "ffi office", + " \talpha \r\n beta ", + "a\u{301}\u{fe0f} b\u{2060}c", + "אבג abc דהו", + "A😀Z", + ]; + let mut nonempty = 0; + for source in sources { + for shaping in [Shaping::Auto, Shaping::Advanced] { + for zoom in [0.5, 1.75] { + let mut cache = Cache::default(); + for width in [0., 25., 500.] { + let label = cache + .resolve( + &session, + source, + width, + zoom, + Style { + shaping, + ..Style::default() + }, + ) + .unwrap(); + nonempty += usize::from(!label.clusters.is_empty()); + all_fields(&label, &session, Point::ORIGIN); + all_fields(&label, &session, Point::new(-37.25, 16.125)); + } + } + } + } + assert!( + nonempty >= sources.len(), + "must compare actual shaped geometry as well as empty labels" + ); +} + +#[test] +fn indexed_lookup_matches_original_for_overlapping_and_reordered_clusters() { + // Normalization is "a + acute + VS16 + space + b + space + c". + // Cluster intervals overlap, nest, span separators, and occur in a + // deliberately non-source/non-visual order. This tests the join rather + // than assuming the simpler cluster partition of most actual fonts. + let source = " a\u{301}\u{fe0f} b c "; + assert_eq!(Normalized::new(source).text.len(), 10); + let a = Rectangle::new(Point::new(30., 3.), Size::new(4., 12.)); + let b = Rectangle::new(Point::new(-20., -1.), Size::new(7., 11.)); + let c = Rectangle::new(Point::new(9., 4.), Size::new(2., 10.)); + let cases = vec![ + cluster(7..10, vec![b, a], false), + cluster(0..6, vec![a, c, a], false), + cluster(1..3, vec![], false), + cluster(3..8, vec![c], true), + cluster(0..10, vec![b], false), + cluster(6..7, vec![c], false), + cluster(9..13, vec![a], false), // can extend into a synthetic ellipsis + cluster(3..3, vec![c], true), // empty interval cannot match anything + cluster(8..7, vec![b], true), // nor can a reversed interval + ]; + for reverse in [false, true] { + let mut clusters = cases.clone(); + if reverse { + clusters.reverse(); + } + for retained in [0, 1, 3, 6, 7, 8, 10] { + let (session, label) = synthetic(source, retained, clusters.clone()); + all_fields(&label, &session, Point::new(-0., -0.)); + all_fields(&label, &session, Point::new(0.125, -64.)); + } + } + let (session, priority) = synthetic( + "a\u{2060}b", + 5, + vec![ + cluster(0..1, vec![], false), + cluster(1..4, vec![a], true), + cluster(4..5, vec![b], true), + ], + ); + all_fields(&priority, &session, Point::ORIGIN); + let result = priority + .field_layout(&session, 1., Point::ORIGIN, 0..5) + .unwrap(); + assert_eq!( + result.unresolved, + vec![ + UnresolvedField { + source: 0..1, + reason: FieldIssue::NoAdvanceGeometry + }, + UnresolvedField { + source: 1..4, + reason: FieldIssue::NonPaintingScalar + }, + UnresolvedField { + source: 4..5, + reason: FieldIssue::MissingGlyph + }, + ] + ); + assert!(result.covered.is_empty() && result.rectangles.is_empty()); +} + +#[test] +fn indexed_lookup_preserves_first_rectangle_bits_and_shared_status() { + let negative = Rectangle::new(Point::new(-0., -0.), Size::new(6., 12.)); + let positive = Rectangle::new(Point::ORIGIN, Size::new(6., 12.)); + assert_eq!(negative, positive, "Rectangle equality merges signed zero"); + let other = Rectangle::new(Point::new(-20., 4.), Size::new(3., 12.)); + let (session, label) = synthetic( + "a b", + 3, + vec![ + cluster(2..3, vec![negative, other], false), + cluster(0..1, vec![positive, negative], false), + ], + ); + let result = label + .field_layout(&session, 1., Point::new(-0., -0.), 0..3) + .unwrap(); + assert_eq!(result.covered, vec![0..1, 2..3]); + assert!(!result.shared_cluster); + assert_eq!(result.rectangles.len(), 2); + assert_eq!(result.rectangles[0].x.to_bits(), (-0f32).to_bits()); + assert_eq!(result.rectangles[0].y.to_bits(), (-0f32).to_bits()); + assert_eq!(result.rectangles[1], other); + assert_exact( + &result, + &label + .original_field_layout(&session, 1., Point::new(-0., -0.), 0..3) + .unwrap(), + ); + + let (session, shared) = synthetic("a b", 3, vec![cluster(0..3, vec![other], false)]); + let partial = shared + .field_layout(&session, 1., Point::ORIGIN, 0..1) + .unwrap(); + assert_eq!(partial.covered, vec![0..1]); + assert!(partial.shared_cluster); + let complete = shared + .field_layout(&session, 1., Point::ORIGIN, 0..3) + .unwrap(); + assert!(!complete.shared_cluster); + all_fields(&shared, &session, Point::ORIGIN); + + // The same logical cluster crosses the retained prefix: its box remains + // shared while the source scalar after that prefix remains truncated. + let (session, clipped) = synthetic("abc", 2, vec![cluster(0..3, vec![other], false)]); + let clipped = clipped + .field_layout(&session, 1., Point::ORIGIN, 0..3) + .unwrap(); + assert_eq!(clipped.covered, vec![0..2]); + assert_eq!(clipped.truncated, vec![2..3]); + assert!(clipped.shared_cluster && clipped.partially_retained); +} + +#[test] +fn indexed_lookup_preserves_error_precedence_and_overflow_rejection() { + let (session, label) = synthetic( + "éa", + 3, + vec![cluster( + 0..3, + vec![Rectangle::new( + Point::new(f32::MAX, 0.), + Size::new(f32::MAX, 1.), + )], + false, + )], + ); + let stale = RenderSession::after_fonts_settled_and_renderer_reset().unwrap(); + assert_eq!( + label.field_layout(&stale, f32::NAN, Point::new(f32::NAN, 0.), 7..8), + Err(Error::StaleRenderSession) + ); + assert_eq!( + label.field_layout(&session, 2., Point::new(f32::NAN, 0.), 7..8), + Err(Error::StaleZoom) + ); + assert_eq!( + label.field_layout(&session, 1., Point::new(f32::NAN, 0.), 7..8), + Err(Error::InvalidPosition) + ); + assert_eq!( + label.field_layout(&session, 1., Point::ORIGIN, 1..2), + Err(Error::InvalidFieldRange) + ); + assert_eq!( + label.field_layout(&session, 1., Point::ORIGIN, 0..3), + Err(Error::InvalidPosition) + ); + // An unselected overflowing box must not turn a valid empty query into an error. + assert!( + label + .field_layout(&session, 1., Point::ORIGIN, 0..0) + .unwrap() + .rectangles + .is_empty() + ); + for guard in [&session, &stale] { + for zoom in [1., 2., f32::NAN] { + for position in [ + Point::ORIGIN, + Point::new(f32::NAN, 0.), + Point::new(f32::MAX, 0.), + ] { + for range in [0..0, 0..3, 1..2, 3..2, 0..4] { + compare(&label, guard, zoom, position, range); + } + } + } + } +} + +impl Label { + pub(super) fn original_field_layout( + &self, + session: &RenderSession, + zoom: f32, + position: Point, + field: Range, + ) -> Result { + self.check(session, zoom)?; + translated_bounds(position, Size::ZERO)?; + if field.start > field.end || self.source.get(field.clone()).is_none() { + return Err(Error::InvalidFieldRange); + } + let mut result = FieldLayout { + rectangles: vec![], + covered: vec![], + truncated: vec![], + unresolved: vec![], + partially_retained: false, + shared_cluster: false, + }; + let mut selected = vec![false; self.clusters.len()]; + for span in &self.source_spans { + if span.whitespace || !overlaps(&span.source, &field) { + continue; + } + // Source spans for text are exact UTF-8 scalars, not intervals + // between ends (which could assign trimmed whitespace to text). + if span.normalized.end > self.retained_normalized { + append_range(&mut result.truncated, span.source.clone()); + continue; + } + let matching: Vec<_> = self + .clusters + .iter() + .enumerate() + .filter(|(_, cluster)| overlaps(&cluster.normalized, &span.normalized)) + .collect(); + result.shared_cluster |= matching.iter().any(|(_, cluster)| { + cluster.normalized.end > self.retained_normalized + || self.source_spans.iter().any(|other| { + overlaps(&other.normalized, &cluster.normalized) + && !overlaps(&other.source, &field) + }) + }); + let issue = if span.non_painting { + Some(FieldIssue::NonPaintingScalar) + } else if matching.iter().any(|(_, cluster)| cluster.missing) { + Some(FieldIssue::MissingGlyph) + } else if matching.is_empty() + || matching + .iter() + .all(|(_, cluster)| cluster.rectangles.is_empty()) + { + Some(FieldIssue::NoAdvanceGeometry) + } else { + None + }; + if let Some(reason) = issue { + result.unresolved.push(UnresolvedField { + source: span.source.clone(), + reason, + }); + continue; + } + append_range(&mut result.covered, span.source.clone()); + for (index, _) in matching { + selected[index] = true; + } + } + for (cluster, selected) in self.clusters.iter().zip(selected) { + if !selected { + continue; + } + for bounds in &cluster.rectangles { + let translated = translated_bounds( + Point::new(position.x + bounds.x, position.y + bounds.y), + bounds.size(), + )?; + if !result.rectangles.contains(&translated) { + result.rectangles.push(translated); + } + } + } + result.partially_retained = !result.truncated.is_empty() + && (!result.covered.is_empty() || !result.unresolved.is_empty()); + Ok(result) + } +} diff --git a/harness/experiments/scenario-label-lookup-20260913/README.md b/harness/experiments/scenario-label-lookup-20260913/README.md new file mode 100644 index 00000000..3061fb5b --- /dev/null +++ b/harness/experiments/scenario-label-lookup-20260913/README.md @@ -0,0 +1,26 @@ +# Indexed field lookup experiment + +This unwired experiment extends source `4c9bc87e4e66bba573dd63b23df5ea039f85d0ca`. It does not adopt measured labels or field navigation in the renderer. This revision has **not been compiled or executed**. The baseline debug diagnostic reported roughly 2.4–6.6 seconds for a 4096-scalar plain field and 1.3–1.9 seconds for a 4096-scalar combining-heavy field; these are motivation, not results for this patch. + +`Label` now stores an overlap index built from the winning shaped buffer's clusters and the existing ordered, disjoint normalized scalar spans. For S spans, C clusters, and I actual span/cluster overlap memberships, index construction takes O(C log S + I) work and O(S + C + I) storage. A lookup visits the source spans and their indexed matches, then emits selected cluster rectangles in the original cluster/rectangle order. Hash membership replaces repeated linear rectangle searches. Signed zeros share a deduplication key, as with `Rectangle::PartialEq`, while the first original rectangle's bits remain unchanged. Hash iteration never determines output order. + +Per-cluster source end/start extrema preserve the old shared-cluster predicate, including whitespace and nonpainting spans. Source scalar overlap, truncation, missing-glyph and nonpainting precedence, partial/shared flags, invalid-range errors, session/font/zoom guards, and position/overflow rejection are unchanged. No new length limit is introduced. Index storage can be dense for intentionally overlapping synthetic clusters. Existing shaping and `field_clusters` extraction are unchanged, including that extractor's per-cluster linear rectangle deduplication; this is not a claim of globally linear shaping or preparation. + +The test-only `Label::original_field_layout` retains the baseline method body verbatim. Four new normal tests compare every `FieldLayout` field and every rectangle's exact component bits and position in the output: + +- Real Auto/Advanced shaping at two zooms and three widths, over every legal UTF-8 boundary pair, including scalar boundaries inside combining graphemes. +- Overlapping, reordered, whitespace-spanning, missing, empty and reversed cluster ranges; partial retention and nonpainting/coverage precedence. +- First-occurrence signed-zero bits, shared clusters and truncation. +- Guard/error precedence, malformed fields, nonfinite positions and overflow. + +The existing ignored `field_lookup_4096_scalars_and_combining_heavy_full_coverage` diagnostic retains its two inputs and independent Paragraph coverage/rectangle oracle. It now times the original lookup separately, three indexed queries on the retained label, and three fresh-cache resolve-plus-lookup operations. Exact old/new results and independent complete rectangle sets are checked outside timed intervals. The original lookup precedes indexed samples; font caches are warm. These are debug experiment measurements, not a latency guarantee or a cold-process benchmark. Fresh resolution includes index construction so its cost cannot disappear into an unmeasured preprocessing step. + +The isolated harness should list 29 tests: 25 normal and four ignored. The production desktop does not register this module. Reuse the explicit dependency-bound harness recipe for the baseline, replacing its source binding with this revision and adding `scenario_label/lookup_tests.rs` to the input closure. Required execution is the normal suite plus these three ignored tests, each in a fresh process: + +```text +scenario_label::field_tests::advanced_ligature_partial_field_uses_whole_shared_cluster_not_fraction +scenario_label::field_tests::auto_ascii_to_ellipsis_advanced_transition_uses_final_buffer +scenario_label::tests::actual_font_load_rejects_retained_label_and_old_session +``` + +Run the timing diagnostic separately with `--exact scenario_label::field_tests::field_lookup_4096_scalars_and_combining_heavy_full_coverage --ignored --nocapture --test-threads=1`. It remains optional functional-gate evidence; its exact full-coverage assertions are not waived. The new differential filter is `scenario_label::lookup_tests::` (four tests). The pinned-font checks retain their existing isolated-process contract. Other real-shaping differential cases use the current system default font and compare both methods on the same resolved buffer; they do not establish cross-machine glyph identity.