diff --git a/crates/html/src/conformance/execution.rs b/crates/html/src/conformance/execution.rs
index 6aa7b26f..94869b94 100644
--- a/crates/html/src/conformance/execution.rs
+++ b/crates/html/src/conformance/execution.rs
@@ -6,7 +6,12 @@
 use super::projection::{ObservationAllocationController, project_patches, project_tree};
 #[cfg(test)]
 use super::projection::{ObservationAllocationStep, ObservationFailureInjection};
-use super::{CanonicalParserResult, IncompleteObservationReason, ObservationState};
+use super::{
+    CanonicalParserResult, DomFinalizationChecks, IncompleteObservationReason,
+    InputFinalizationChecks, InvariantNotApplicableReason, InvariantOutcome, ObservationState,
+    ParserFinalizationReport, PatchFinalizationChecks, TokenizerFinalizationChecks,
+    TreeBuilderFinalizationChecks,
+};
 use crate::html5::PatchHistoryObservationConfig;
 use crate::html5::shared::{
     CapturedSurface, DocumentParseContext, ErrorPolicy, ObservationOccurrenceSequence,
@@ -15,6 +20,7 @@ use crate::html5::shared::{
     SurfaceCaptureRequest, UnsupportedFeatureObservationFailure,
 };
 use crate::html5::{ByteStreamDecoder, Html5Tokenizer, Input, TokenizeResult, TokenizerConfig};
+use crate::parser::{ConformanceFinalizationError, ConformanceFinalizedOutput};
 use crate::{HtmlParseOptions, HtmlParser};
 
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
@@ -194,6 +200,13 @@ pub enum ScalarObservationRequest {
     Capture,
 }
 
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub enum FinalInvariantRequest {
+    #[default]
+    NotRequested,
+    Capture,
+}
+
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum ParserObservationTarget {
     StandaloneTokenizer,
@@ -204,8 +217,94 @@ pub enum ParserObservationTarget {
 pub enum ParserObservationInput<'a> {
     Utf8(&'a str),
     Utf8Chunks(&'a [&'a str]),
+    Utf8FixedScalarChunks {
+        text: &'a str,
+        scalars_per_chunk: usize,
+    },
+    Utf8BoundaryChunks {
+        text: &'a str,
+        byte_offsets: &'a [usize],
+    },
     Bytes(&'a [u8]),
     ByteChunks(&'a [&'a [u8]]),
+    ByteFixedChunks {
+        bytes: &'a [u8],
+        bytes_per_chunk: usize,
+    },
+    ByteBoundaryChunks {
+        bytes: &'a [u8],
+        byte_offsets: &'a [usize],
+    },
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum ParserObservationDeliveryError {
+    BoundaryAtStart { boundary_index: usize },
+    BoundaryAtEnd { boundary_index: usize },
+    BoundaryOutOfRange { boundary_index: usize },
+    BoundaryNotIncreasing { boundary_index: usize },
+    UnicodeBoundaryNotScalar { boundary_index: usize },
+    ZeroFixedChunkExtent,
+    ArithmeticOverflow,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum ParserObservationDeliveryErrorIdentity {
+    BoundaryAtStart,
+    BoundaryAtEnd,
+    BoundaryOutOfRange,
+    BoundaryNotIncreasing,
+    UnicodeBoundaryNotScalar,
+    ZeroFixedChunkExtent,
+    ArithmeticOverflow,
+}
+
+impl ParserObservationDeliveryErrorIdentity {
+    pub const fn diagnostic_name(self) -> &'static str {
+        match self {
+            Self::BoundaryAtStart => "boundary-at-start",
+            Self::BoundaryAtEnd => "boundary-at-end",
+            Self::BoundaryOutOfRange => "boundary-out-of-range",
+            Self::BoundaryNotIncreasing => "boundary-not-increasing",
+            Self::UnicodeBoundaryNotScalar => "unicode-boundary-not-scalar",
+            Self::ZeroFixedChunkExtent => "zero-fixed-chunk-extent",
+            Self::ArithmeticOverflow => "arithmetic-overflow",
+        }
+    }
+}
+
+impl ParserObservationDeliveryError {
+    pub const fn diagnostic_name(self) -> &'static str {
+        match self {
+            Self::BoundaryAtStart { .. } => "boundary-at-start",
+            Self::BoundaryAtEnd { .. } => "boundary-at-end",
+            Self::BoundaryOutOfRange { .. } => "boundary-out-of-range",
+            Self::BoundaryNotIncreasing { .. } => "boundary-not-increasing",
+            Self::UnicodeBoundaryNotScalar { .. } => "unicode-boundary-not-scalar",
+            Self::ZeroFixedChunkExtent => "zero-fixed-chunk-extent",
+            Self::ArithmeticOverflow => "arithmetic-overflow",
+        }
+    }
+
+    pub const fn identity(self) -> ParserObservationDeliveryErrorIdentity {
+        match self {
+            Self::BoundaryAtStart { .. } => ParserObservationDeliveryErrorIdentity::BoundaryAtStart,
+            Self::BoundaryAtEnd { .. } => ParserObservationDeliveryErrorIdentity::BoundaryAtEnd,
+            Self::BoundaryOutOfRange { .. } => {
+                ParserObservationDeliveryErrorIdentity::BoundaryOutOfRange
+            }
+            Self::BoundaryNotIncreasing { .. } => {
+                ParserObservationDeliveryErrorIdentity::BoundaryNotIncreasing
+            }
+            Self::UnicodeBoundaryNotScalar { .. } => {
+                ParserObservationDeliveryErrorIdentity::UnicodeBoundaryNotScalar
+            }
+            Self::ZeroFixedChunkExtent => {
+                ParserObservationDeliveryErrorIdentity::ZeroFixedChunkExtent
+            }
+            Self::ArithmeticOverflow => ParserObservationDeliveryErrorIdentity::ArithmeticOverflow,
+        }
+    }
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -227,10 +326,14 @@ pub struct ParserObservationRequest<'a> {
     pub tree: ObservationRequest,
     /// Maximum semantic `DomPatch` operations. This is not a byte budget.
     pub patches: ObservationRequest,
+    /// Mandatory terminal parser audit for fixture-v2. Independent from every
+    /// bounded collection surface.
+    pub final_invariants: FinalInvariantRequest,
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum ParserObservationExecutionError {
+    InvalidDelivery(ParserObservationDeliveryError),
     ParserFatal(crate::ParserFatalError),
     ParserInvariant,
     TokenizerInvariant(ParserTokenizerInvariantError),
@@ -251,6 +354,7 @@ pub enum ParserObservationExecutionError {
 /// classifying `Display` or `Debug` text.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum ParserObservationExecutionIdentity {
+    InvalidDelivery(ParserObservationDeliveryErrorIdentity),
     ParserFatal(ParserFatalIdentity),
     ParserInvariant,
     TokenizerInvariant(ParserTokenizerInvariantError),
@@ -281,6 +385,9 @@ impl ParserObservationExecutionError {
     #[must_use]
     pub const fn identity(self) -> ParserObservationExecutionIdentity {
         match self {
+            Self::InvalidDelivery(error) => {
+                ParserObservationExecutionIdentity::InvalidDelivery(error.identity())
+            }
             Self::ParserFatal(error) => {
                 ParserObservationExecutionIdentity::ParserFatal(parser_fatal_identity(error))
             }
@@ -347,6 +454,13 @@ pub enum ObservationReservationSite {
     CanonicalTreeProjection,
     CanonicalPatchProjection,
     SnapshotLabelStorage,
+    FinalAuditLiveTreeStructuralProjection,
+    FinalAuditPatchArenaStructuralProjection,
+    FinalAuditDomStructuralTraversal,
+    FinalAuditOpenElementsIndex,
+    FinalAuditActiveFormattingIndex,
+    FinalAuditTemplateCoordinationIndex,
+    FinalAuditSemanticTraversal,
 }
 
 /// Allocation or representable-capacity failure while constructing a
@@ -361,7 +475,7 @@ impl ObservationResourceExhaustion {
         self.site
     }
 
-    pub(super) const fn at(site: ObservationReservationSite) -> Self {
+    pub(crate) const fn at(site: ObservationReservationSite) -> Self {
         Self { site }
     }
 }
@@ -437,6 +551,8 @@ pub enum ParserObservationInvariantError {
     DuplicatePatchCreation,
     MissingPatchCreationHistory,
     SnapshotLabelSequenceOverflow,
+    FinalAuditPatchCountOverflow,
+    DerivedDeliverySlicingInvariant,
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -450,6 +566,13 @@ pub enum UnsupportedFeatureObservationInvariantError {
 impl std::fmt::Display for ParserObservationExecutionError {
     fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
+            Self::InvalidDelivery(error) => {
+                write!(
+                    formatter,
+                    "invalid parser observation delivery: {}",
+                    error.diagnostic_name()
+                )
+            }
             Self::ParserFatal(error) => write!(formatter, "production HTML parser failed: {error}"),
             Self::ParserInvariant => formatter.write_str("production HTML parser invariant failed"),
             Self::TokenizerInvariant(invariant) => {
@@ -514,9 +637,10 @@ pub fn execute_parser_observation(
             PatchHistoryObservationConfig::capture(capacity)
         }
     };
-    let (capture, document_mode, tree, patches) = match request.target {
+    let (capture, document_mode, tree, patches, final_invariants) = match request.target {
         ParserObservationTarget::StandaloneTokenizer => {
-            let capture = execute_standalone_tokenizer(request.input, config)?;
+            let (capture, final_invariants) =
+                execute_standalone_tokenizer(request.input, config, request.final_invariants)?;
             let mode = match request.document_mode {
                 ScalarObservationRequest::NotRequested => ObservationState::NotRequested,
                 ScalarObservationRequest::Capture => ObservationState::NotApplicable {
@@ -525,21 +649,23 @@ pub fn execute_parser_observation(
             };
             let tree = not_applicable_or_not_requested(request.tree);
             let patches = not_applicable_or_not_requested(request.patches);
-            (capture, mode, tree, patches)
+            (capture, mode, tree, patches, final_invariants)
         }
         ParserObservationTarget::DocumentParser => {
-            let (capture, production_mode, tree, patches) = execute_document_parser(
-                request.input,
-                config,
-                patch_config,
-                request.tree,
-                request.patches,
-            )?;
+            let (capture, production_mode, tree, patches, final_invariants) =
+                execute_document_parser(
+                    request.input,
+                    config,
+                    patch_config,
+                    request.tree,
+                    request.patches,
+                    request.final_invariants,
+                )?;
             let mode = match request.document_mode {
                 ScalarObservationRequest::NotRequested => ObservationState::NotRequested,
                 ScalarObservationRequest::Capture => ObservationState::Captured(production_mode),
             };
-            (capture, mode, tree, patches)
+            (capture, mode, tree, patches, final_invariants)
         }
     };
     canonical_result(
@@ -549,6 +675,7 @@ pub fn execute_parser_observation(
         patches,
         request.target,
         request.transitions,
+        final_invariants,
     )
 }
 
@@ -561,21 +688,247 @@ fn not_applicable_or_not_requested<T>(request: ObservationRequest) -> Observatio
     }
 }
 
+#[cfg(test)]
+thread_local! {
+    static FORCE_DERIVED_DELIVERY_SLICING_FAILURE: std::cell::Cell<bool> =
+        const { std::cell::Cell::new(false) };
+}
+
+#[cfg(test)]
+struct DerivedDeliverySlicingFailureGuard {
+    previous: bool,
+}
+
+#[cfg(test)]
+impl Drop for DerivedDeliverySlicingFailureGuard {
+    fn drop(&mut self) {
+        FORCE_DERIVED_DELIVERY_SLICING_FAILURE.with(|flag| flag.set(self.previous));
+    }
+}
+
+#[cfg(test)]
+fn with_forced_derived_delivery_slicing_failure<R>(f: impl FnOnce() -> R) -> R {
+    let previous = FORCE_DERIVED_DELIVERY_SLICING_FAILURE.with(|flag| flag.replace(true));
+    let guard = DerivedDeliverySlicingFailureGuard { previous };
+    let result = f();
+    drop(guard);
+    result
+}
+
+#[cfg(test)]
+fn derived_delivery_slicing_failure_requested() -> bool {
+    FORCE_DERIVED_DELIVERY_SLICING_FAILURE.with(|flag| flag.replace(false))
+}
+
+fn deliver_utf8_fixed(
+    text: &str,
+    scalars_per_chunk: usize,
+    mut push: impl FnMut(&str) -> Result<(), ParserObservationExecutionError>,
+) -> Result<(), ParserObservationExecutionError> {
+    if scalars_per_chunk == 0 {
+        return Err(ParserObservationExecutionError::InvalidDelivery(
+            ParserObservationDeliveryError::ZeroFixedChunkExtent,
+        ));
+    }
+    if text.is_empty() {
+        return Ok(());
+    }
+
+    let mut start = 0usize;
+    let mut scalars = 0usize;
+    for (offset, _) in text.char_indices() {
+        if scalars == scalars_per_chunk {
+            #[cfg(test)]
+            if derived_delivery_slicing_failure_requested() {
+                return Err(ParserObservationExecutionError::ObservationInvariant(
+                    ParserObservationInvariantError::DerivedDeliverySlicingInvariant,
+                ));
+            }
+            let chunk = text.get(start..offset).ok_or(
+                ParserObservationExecutionError::ObservationInvariant(
+                    ParserObservationInvariantError::DerivedDeliverySlicingInvariant,
+                ),
+            )?;
+            if !chunk.is_empty() {
+                push(chunk)?;
+            }
+            start = offset;
+            scalars = 0;
+        }
+        scalars =
+            scalars
+                .checked_add(1)
+                .ok_or(ParserObservationExecutionError::ObservationInvariant(
+                    ParserObservationInvariantError::DerivedDeliverySlicingInvariant,
+                ))?;
+    }
+    #[cfg(test)]
+    if derived_delivery_slicing_failure_requested() {
+        return Err(ParserObservationExecutionError::ObservationInvariant(
+            ParserObservationInvariantError::DerivedDeliverySlicingInvariant,
+        ));
+    }
+    let chunk = text
+        .get(start..)
+        .ok_or(ParserObservationExecutionError::ObservationInvariant(
+            ParserObservationInvariantError::DerivedDeliverySlicingInvariant,
+        ))?;
+    if !chunk.is_empty() {
+        push(chunk)?;
+    }
+    Ok(())
+}
+
+fn deliver_utf8_boundaries(
+    text: &str,
+    byte_offsets: &[usize],
+    mut push: impl FnMut(&str) -> Result<(), ParserObservationExecutionError>,
+) -> Result<(), ParserObservationExecutionError> {
+    validate_boundaries(text.len(), byte_offsets, |offset| {
+        text.is_char_boundary(offset)
+    })?;
+    let mut start = 0usize;
+    for &end in byte_offsets {
+        let chunk =
+            text.get(start..end)
+                .ok_or(ParserObservationExecutionError::ObservationInvariant(
+                    ParserObservationInvariantError::DerivedDeliverySlicingInvariant,
+                ))?;
+        push(chunk)?;
+        start = end;
+    }
+    let chunk = text
+        .get(start..)
+        .ok_or(ParserObservationExecutionError::ObservationInvariant(
+            ParserObservationInvariantError::DerivedDeliverySlicingInvariant,
+        ))?;
+    if !chunk.is_empty() {
+        push(chunk)?;
+    }
+    Ok(())
+}
+
+fn deliver_byte_fixed(
+    bytes: &[u8],
+    bytes_per_chunk: usize,
+    mut push: impl FnMut(&[u8]) -> Result<(), ParserObservationExecutionError>,
+) -> Result<(), ParserObservationExecutionError> {
+    if bytes_per_chunk == 0 {
+        return Err(ParserObservationExecutionError::InvalidDelivery(
+            ParserObservationDeliveryError::ZeroFixedChunkExtent,
+        ));
+    }
+    let mut start = 0usize;
+    while start < bytes.len() {
+        let end = start
+            .checked_add(bytes_per_chunk)
+            .ok_or(ParserObservationExecutionError::ObservationInvariant(
+                ParserObservationInvariantError::DerivedDeliverySlicingInvariant,
+            ))?
+            .min(bytes.len());
+        #[cfg(test)]
+        if derived_delivery_slicing_failure_requested() {
+            return Err(ParserObservationExecutionError::ObservationInvariant(
+                ParserObservationInvariantError::DerivedDeliverySlicingInvariant,
+            ));
+        }
+        let chunk =
+            bytes
+                .get(start..end)
+                .ok_or(ParserObservationExecutionError::ObservationInvariant(
+                    ParserObservationInvariantError::DerivedDeliverySlicingInvariant,
+                ))?;
+        push(chunk)?;
+        start = end;
+    }
+    Ok(())
+}
+
+fn deliver_byte_boundaries(
+    bytes: &[u8],
+    byte_offsets: &[usize],
+    mut push: impl FnMut(&[u8]) -> Result<(), ParserObservationExecutionError>,
+) -> Result<(), ParserObservationExecutionError> {
+    validate_boundaries(bytes.len(), byte_offsets, |_| true)?;
+    let mut start = 0usize;
+    for &end in byte_offsets {
+        let chunk =
+            bytes
+                .get(start..end)
+                .ok_or(ParserObservationExecutionError::ObservationInvariant(
+                    ParserObservationInvariantError::DerivedDeliverySlicingInvariant,
+                ))?;
+        push(chunk)?;
+        start = end;
+    }
+    if start < bytes.len() {
+        let chunk =
+            bytes
+                .get(start..)
+                .ok_or(ParserObservationExecutionError::ObservationInvariant(
+                    ParserObservationInvariantError::DerivedDeliverySlicingInvariant,
+                ))?;
+        push(chunk)?;
+    }
+    Ok(())
+}
+
+fn validate_boundaries(
+    extent: usize,
+    boundaries: &[usize],
+    is_valid_boundary: impl Fn(usize) -> bool,
+) -> Result<(), ParserObservationExecutionError> {
+    let mut previous = 0usize;
+    for (boundary_index, &boundary) in boundaries.iter().enumerate() {
+        if boundary == 0 {
+            return Err(ParserObservationExecutionError::InvalidDelivery(
+                ParserObservationDeliveryError::BoundaryAtStart { boundary_index },
+            ));
+        }
+        if boundary == extent {
+            return Err(ParserObservationExecutionError::InvalidDelivery(
+                ParserObservationDeliveryError::BoundaryAtEnd { boundary_index },
+            ));
+        }
+        if boundary > extent {
+            return Err(ParserObservationExecutionError::InvalidDelivery(
+                ParserObservationDeliveryError::BoundaryOutOfRange { boundary_index },
+            ));
+        }
+        if boundary <= previous {
+            return Err(ParserObservationExecutionError::InvalidDelivery(
+                ParserObservationDeliveryError::BoundaryNotIncreasing { boundary_index },
+            ));
+        }
+        if !is_valid_boundary(boundary) {
+            return Err(ParserObservationExecutionError::InvalidDelivery(
+                ParserObservationDeliveryError::UnicodeBoundaryNotScalar { boundary_index },
+            ));
+        }
+        previous = boundary;
+    }
+    Ok(())
+}
+
+type DocumentObservationResult = (
+    ParserObservationCapture,
+    crate::DocumentMode,
+    ObservationState<super::ObservedTree>,
+    ObservationState<super::ObservedPatchStream>,
+    ObservationState<ParserFinalizationReport>,
+);
+
+type DocumentObservationExecutionResult =
+    Result<DocumentObservationResult, ParserObservationExecutionError>;
+
 fn execute_document_parser(
     input: ParserObservationInput<'_>,
     config: ParserObservationConfig,
     patch_config: PatchHistoryObservationConfig,
     tree_request: ObservationRequest,
     patch_request: ObservationRequest,
-) -> Result<
-    (
-        ParserObservationCapture,
-        crate::DocumentMode,
-        ObservationState<super::ObservedTree>,
-        ObservationState<super::ObservedPatchStream>,
-    ),
-    ParserObservationExecutionError,
-> {
+    final_request: FinalInvariantRequest,
+) -> DocumentObservationExecutionResult {
     let observation_requested = config.is_requested();
     let mut parser = HtmlParser::new_with_conformance_observations(
         HtmlParseOptions::default(),
@@ -592,6 +945,17 @@ fn execute_document_parser(
                 push_document_text(&mut parser, chunk)?;
             }
         }
+        ParserObservationInput::Utf8FixedScalarChunks {
+            text,
+            scalars_per_chunk,
+        } => deliver_utf8_fixed(text, scalars_per_chunk, |chunk| {
+            push_document_text(&mut parser, chunk)
+        })?,
+        ParserObservationInput::Utf8BoundaryChunks { text, byte_offsets } => {
+            deliver_utf8_boundaries(text, byte_offsets, |chunk| {
+                push_document_text(&mut parser, chunk)
+            })?
+        }
         ParserObservationInput::Bytes(bytes) => {
             push_document_bytes(&mut parser, bytes)?;
         }
@@ -600,11 +964,29 @@ fn execute_document_parser(
                 push_document_bytes(&mut parser, chunk)?;
             }
         }
+        ParserObservationInput::ByteFixedChunks {
+            bytes,
+            bytes_per_chunk,
+        } => deliver_byte_fixed(bytes, bytes_per_chunk, |chunk| {
+            push_document_bytes(&mut parser, chunk)
+        })?,
+        ParserObservationInput::ByteBoundaryChunks {
+            bytes,
+            byte_offsets,
+        } => deliver_byte_boundaries(bytes, byte_offsets, |chunk| {
+            push_document_bytes(&mut parser, chunk)
+        })?,
     }
     if let Err(error) = parser.finish() {
         return Err(document_parser_operation_error(&parser, error));
     }
-    finalize_document_parser(parser, observation_requested, tree_request, patch_request)
+    finalize_document_parser(
+        parser,
+        observation_requested,
+        tree_request,
+        patch_request,
+        final_request,
+    )
 }
 
 fn finalize_document_parser(
@@ -612,20 +994,14 @@ fn finalize_document_parser(
     observation_requested: bool,
     tree_request: ObservationRequest,
     patch_request: ObservationRequest,
-) -> Result<
-    (
-        ParserObservationCapture,
-        crate::DocumentMode,
-        ObservationState<super::ObservedTree>,
-        ObservationState<super::ObservedPatchStream>,
-    ),
-    ParserObservationExecutionError,
-> {
+    final_request: FinalInvariantRequest,
+) -> DocumentObservationExecutionResult {
     finalize_document_parser_with_allocations(
         parser,
         observation_requested,
         tree_request,
         patch_request,
+        final_request,
         &mut ObservationAllocationController::default(),
     )
 }
@@ -635,22 +1011,38 @@ fn finalize_document_parser_with_allocations(
     observation_requested: bool,
     tree_request: ObservationRequest,
     patch_request: ObservationRequest,
+    final_request: FinalInvariantRequest,
     allocations: &mut ObservationAllocationController,
-) -> Result<
-    (
-        ParserObservationCapture,
-        crate::DocumentMode,
-        ObservationState<super::ObservedTree>,
-        ObservationState<super::ObservedPatchStream>,
-    ),
-    ParserObservationExecutionError,
-> {
+) -> DocumentObservationExecutionResult {
     let document_mode = parser
         .document_mode_for_conformance()
         .map_err(|error| document_parser_operation_error(&parser, error))?;
-    let (output, capture, patch_history) = parser
-        .into_output_with_observations()
-        .map_err(parser_error_without_live_parser)?;
+    let (output, capture, patch_history, final_invariants) = match final_request {
+        FinalInvariantRequest::NotRequested => {
+            let (output, capture, patch_history) = parser
+                .into_output_with_observations()
+                .map_err(parser_error_without_live_parser)?;
+            (
+                output,
+                capture,
+                patch_history,
+                ObservationState::NotRequested,
+            )
+        }
+        FinalInvariantRequest::Capture => {
+            let mut reserve = |site| allocations.before_final_audit(site).map_err(|_| ());
+            let finalized = parser
+                .into_output_with_final_audit(&mut reserve)
+                .map_err(finalization_execution_error)?;
+            let report = document_finalization_report(&finalized);
+            (
+                finalized.output,
+                finalized.observations,
+                finalized.patch_history,
+                ObservationState::Captured(report),
+            )
+        }
+    };
     let capture = require_capture(capture, observation_requested)?;
     validate_capture(&capture)?;
     let tree = match tree_request {
@@ -672,7 +1064,82 @@ fn finalize_document_parser_with_allocations(
             project_patches(history, allocations)?
         }
     };
-    Ok((capture, document_mode, tree, patches))
+    Ok((capture, document_mode, tree, patches, final_invariants))
+}
+
+fn finalization_execution_error(
+    error: ConformanceFinalizationError,
+) -> ParserObservationExecutionError {
+    match error {
+        ConformanceFinalizationError::Parser(error) => parser_error_without_live_parser(error),
+        ConformanceFinalizationError::ObservationResource(error) => {
+            ParserObservationExecutionError::ResourceExhaustion(error)
+        }
+        ConformanceFinalizationError::PatchOperationCountOverflow => {
+            ParserObservationExecutionError::ObservationInvariant(
+                ParserObservationInvariantError::FinalAuditPatchCountOverflow,
+            )
+        }
+    }
+}
+
+fn document_finalization_report(
+    finalized: &ConformanceFinalizedOutput,
+) -> ParserFinalizationReport {
+    let session = &finalized.session_audit;
+    let tree = &session.tree_builder;
+    let witness = finalized.patch_witness;
+    let all_patches_materialized = patch_materialization_complete(witness);
+    ParserFinalizationReport {
+        input: InputFinalizationChecks {
+            decoder_carry_empty: outcome(session.decoder_carry_empty),
+            preprocessing_flushed: outcome(session.preprocessing_flushed),
+        },
+        tokenizer: TokenizerFinalizationChecks {
+            eof_emitted_once: outcome(session.tokenizer_eof_lifecycle_complete),
+            pending_constructs_flushed: outcome(session.tokenizer_pending_constructs_flushed),
+            output_accounted_for: outcome(session.tokenizer_output_accounted_for),
+        },
+        tree_builder: TreeBuilderFinalizationChecks {
+            pending_table_text_empty: outcome(tree.pending_table_text_empty),
+            insertion_mode_valid: outcome(tree.insertion_mode_valid),
+            open_elements_consistent: outcome(tree.open_elements_consistent),
+            active_formatting_consistent: outcome(tree.active_formatting_consistent),
+            template_modes_consistent: outcome(tree.template_modes_consistent),
+            form_pointer_valid: outcome(tree.form_pointer_valid),
+        },
+        dom: DomFinalizationChecks {
+            parent_child_links_valid: outcome(tree.parent_child_links_valid),
+            namespaces_valid: outcome(tree.namespaces_valid),
+            template_associations_valid: outcome(tree.template_associations_valid),
+        },
+        patches: PatchFinalizationChecks {
+            all_patches_materialized: outcome(all_patches_materialized),
+            live_tree_matches_materialized_dom: outcome(
+                finalized.live_structure_matches_patch_arena
+                    && finalized.patch_arena_matches_materialized_dom,
+            ),
+        },
+    }
+}
+
+const fn patch_materialization_complete(
+    witness: crate::parser::PatchMaterializationWitness,
+) -> bool {
+    witness.terminal_empty_drain_observed
+        && witness.builder_pending_patch_count_after_finish == 0
+        && witness.builder_pending_patch_count_after_terminal_drain == 0
+        && witness.emitter_pending_patch_count_after_terminal_drain == 0
+        && witness.drained_operation_count == witness.applied_operation_count
+        && witness.materialized_after_terminal_drain
+}
+
+const fn outcome(satisfied: bool) -> InvariantOutcome {
+    if satisfied {
+        InvariantOutcome::Satisfied
+    } else {
+        InvariantOutcome::Failed
+    }
 }
 
 fn push_document_text(
@@ -747,7 +1214,14 @@ fn parser_error_without_live_parser(
 fn execute_standalone_tokenizer(
     source: ParserObservationInput<'_>,
     config: ParserObservationConfig,
-) -> Result<ParserObservationCapture, ParserObservationExecutionError> {
+    final_request: FinalInvariantRequest,
+) -> Result<
+    (
+        ParserObservationCapture,
+        ObservationState<ParserFinalizationReport>,
+    ),
+    ParserObservationExecutionError,
+> {
     let observation_requested = config.is_requested();
     let mut ctx = if observation_requested {
         DocumentParseContext::with_observations(ErrorPolicy::default(), config)
@@ -769,6 +1243,21 @@ fn execute_standalone_tokenizer(
             }
             false
         }
+        ParserObservationInput::Utf8FixedScalarChunks {
+            text,
+            scalars_per_chunk,
+        } => {
+            deliver_utf8_fixed(text, scalars_per_chunk, |chunk| {
+                push_standalone_text(&mut tokenizer, &mut input, &mut ctx, chunk)
+            })?;
+            false
+        }
+        ParserObservationInput::Utf8BoundaryChunks { text, byte_offsets } => {
+            deliver_utf8_boundaries(text, byte_offsets, |chunk| {
+                push_standalone_text(&mut tokenizer, &mut input, &mut ctx, chunk)
+            })?;
+            false
+        }
         ParserObservationInput::Bytes(bytes) => {
             push_standalone_bytes(&mut tokenizer, &mut decoder, &mut input, &mut ctx, bytes)?;
             true
@@ -779,6 +1268,24 @@ fn execute_standalone_tokenizer(
             }
             true
         }
+        ParserObservationInput::ByteFixedChunks {
+            bytes,
+            bytes_per_chunk,
+        } => {
+            deliver_byte_fixed(bytes, bytes_per_chunk, |chunk| {
+                push_standalone_bytes(&mut tokenizer, &mut decoder, &mut input, &mut ctx, chunk)
+            })?;
+            true
+        }
+        ParserObservationInput::ByteBoundaryChunks {
+            bytes,
+            byte_offsets,
+        } => {
+            deliver_byte_boundaries(bytes, byte_offsets, |chunk| {
+                push_standalone_bytes(&mut tokenizer, &mut decoder, &mut input, &mut ctx, chunk)
+            })?;
+            true
+        }
     };
 
     if byte_input {
@@ -801,8 +1308,47 @@ fn execute_standalone_tokenizer(
         ));
     }
     drain_standalone_batch(&mut tokenizer, &mut input, &mut ctx);
-
-    take_standalone_capture(&mut ctx, observation_requested)
+    let final_invariants = match final_request {
+        FinalInvariantRequest::NotRequested => ObservationState::NotRequested,
+        FinalInvariantRequest::Capture => {
+            let audit = tokenizer.final_audit_for_conformance();
+            let not_applicable = InvariantOutcome::NotApplicable(
+                InvariantNotApplicableReason::StandaloneTokenizerRun,
+            );
+            ObservationState::Captured(ParserFinalizationReport {
+                input: InputFinalizationChecks {
+                    decoder_carry_empty: outcome(!decoder.has_pending_bytes()),
+                    preprocessing_flushed: outcome(!input.has_pending_preprocessing()),
+                },
+                tokenizer: TokenizerFinalizationChecks {
+                    eof_emitted_once: outcome(audit.eof_lifecycle_complete),
+                    pending_constructs_flushed: outcome(audit.pending_constructs_flushed),
+                    output_accounted_for: outcome(audit.output_queue_empty),
+                },
+                tree_builder: TreeBuilderFinalizationChecks {
+                    pending_table_text_empty: not_applicable.clone(),
+                    insertion_mode_valid: not_applicable.clone(),
+                    open_elements_consistent: not_applicable.clone(),
+                    active_formatting_consistent: not_applicable.clone(),
+                    template_modes_consistent: not_applicable.clone(),
+                    form_pointer_valid: not_applicable.clone(),
+                },
+                dom: DomFinalizationChecks {
+                    parent_child_links_valid: not_applicable.clone(),
+                    namespaces_valid: not_applicable.clone(),
+                    template_associations_valid: not_applicable.clone(),
+                },
+                patches: PatchFinalizationChecks {
+                    all_patches_materialized: not_applicable.clone(),
+                    live_tree_matches_materialized_dom: not_applicable,
+                },
+            })
+        }
+    };
+    Ok((
+        take_standalone_capture(&mut ctx, observation_requested)?,
+        final_invariants,
+    ))
 }
 
 fn push_standalone_text(
@@ -1036,6 +1582,7 @@ fn canonical_result(
     patches: ObservationState<super::ObservedPatchStream>,
     target: ParserObservationTarget,
     transitions_request: ObservationRequest,
+    final_invariants: ObservationState<ParserFinalizationReport>,
 ) -> Result<CanonicalParserResult, ParserObservationExecutionError> {
     validate_capture(&capture)?;
     let transitions = match target {
@@ -1053,7 +1600,7 @@ fn canonical_result(
         patches,
         transitions,
         unsupported_features: finish_surface(capture.unsupported_features),
-        final_invariants: ObservationState::NotRequested,
+        final_invariants,
     })
 }
 
@@ -1177,7 +1724,9 @@ fn finish_surface<T>(capture: CapturedSurface<T>) -> ObservationState<Vec<T>> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::conformance::{NotApplicableReason, ObservedPatchStream, ObservedTreeNode};
+    use crate::conformance::{
+        InvariantFailureCode, NotApplicableReason, ObservedPatchStream, ObservedTreeNode,
+    };
     use crate::html5::shared::{
         EventPosition, ImplementationDiagnosticCode, InputCoordinateSpace, ParseErrorCode,
         SourceBytePosition, SourcePositionUnavailableReason, Utf8ReplacementReason,
@@ -1224,10 +1773,320 @@ mod tests {
             document_mode: ScalarObservationRequest::NotRequested,
             tree: ObservationRequest::NotRequested,
             patches: ObservationRequest::NotRequested,
+            final_invariants: FinalInvariantRequest::NotRequested,
         })
         .expect("production tokenizer observation should succeed")
     }
 
+    fn final_audit_request(
+        target: ParserObservationTarget,
+        input: ParserObservationInput<'_>,
+    ) -> ParserObservationRequest<'_> {
+        let document = matches!(target, ParserObservationTarget::DocumentParser);
+        ParserObservationRequest {
+            target,
+            input,
+            tokens: ObservationRequest::Capture { capacity: 512 },
+            parse_errors: ObservationRequest::Capture { capacity: 512 },
+            implementation_diagnostics: ObservationRequest::Capture { capacity: 512 },
+            transitions: if document {
+                ObservationRequest::Capture { capacity: 2_048 }
+            } else {
+                ObservationRequest::NotRequested
+            },
+            unsupported_features: ObservationRequest::Capture { capacity: 512 },
+            document_mode: if document {
+                ScalarObservationRequest::Capture
+            } else {
+                ScalarObservationRequest::NotRequested
+            },
+            tree: if document {
+                ObservationRequest::Capture { capacity: 2_048 }
+            } else {
+                ObservationRequest::NotRequested
+            },
+            patches: if document {
+                ObservationRequest::Capture { capacity: 4_096 }
+            } else {
+                ObservationRequest::NotRequested
+            },
+            final_invariants: FinalInvariantRequest::Capture,
+        }
+    }
+
+    #[test]
+    fn delivery_fixed_and_explicit_shapes_match_whole_input_without_boundary_vectors() {
+        let source = "<!doctype html><p title='é'>a&amp;b</p>";
+        let whole = execute_parser_observation(final_audit_request(
+            ParserObservationTarget::DocumentParser,
+            ParserObservationInput::Utf8(source),
+        ))
+        .expect("whole Unicode observation");
+        let scalar_fixed = execute_parser_observation(final_audit_request(
+            ParserObservationTarget::DocumentParser,
+            ParserObservationInput::Utf8FixedScalarChunks {
+                text: source,
+                scalars_per_chunk: 1,
+            },
+        ))
+        .expect("fixed scalar observation");
+        let byte_fixed = execute_parser_observation(final_audit_request(
+            ParserObservationTarget::DocumentParser,
+            ParserObservationInput::ByteFixedChunks {
+                bytes: source.as_bytes(),
+                bytes_per_chunk: 1,
+            },
+        ))
+        .expect("fixed byte observation");
+        assert_eq!(whole, scalar_fixed);
+        assert_eq!(whole, byte_fixed);
+    }
+
+    #[test]
+    fn delivery_errors_have_closed_typed_identities_and_never_panic() {
+        for (input, expected, identity) in [
+            (
+                ParserObservationInput::Utf8FixedScalarChunks {
+                    text: "x",
+                    scalars_per_chunk: 0,
+                },
+                ParserObservationDeliveryError::ZeroFixedChunkExtent,
+                ParserObservationDeliveryErrorIdentity::ZeroFixedChunkExtent,
+            ),
+            (
+                ParserObservationInput::Utf8BoundaryChunks {
+                    text: "é",
+                    byte_offsets: &[1],
+                },
+                ParserObservationDeliveryError::UnicodeBoundaryNotScalar { boundary_index: 0 },
+                ParserObservationDeliveryErrorIdentity::UnicodeBoundaryNotScalar,
+            ),
+            (
+                ParserObservationInput::ByteBoundaryChunks {
+                    bytes: b"abc",
+                    byte_offsets: &[0],
+                },
+                ParserObservationDeliveryError::BoundaryAtStart { boundary_index: 0 },
+                ParserObservationDeliveryErrorIdentity::BoundaryAtStart,
+            ),
+            (
+                ParserObservationInput::ByteBoundaryChunks {
+                    bytes: b"abc",
+                    byte_offsets: &[2, 1],
+                },
+                ParserObservationDeliveryError::BoundaryNotIncreasing { boundary_index: 1 },
+                ParserObservationDeliveryErrorIdentity::BoundaryNotIncreasing,
+            ),
+        ] {
+            let error = execute_parser_observation(final_audit_request(
+                ParserObservationTarget::StandaloneTokenizer,
+                input,
+            ))
+            .expect_err("invalid delivery must be rejected");
+            assert!(matches!(
+                &error,
+                ParserObservationExecutionError::InvalidDelivery(actual) if *actual == expected
+            ));
+            assert_eq!(
+                error.identity(),
+                ParserObservationExecutionIdentity::InvalidDelivery(identity)
+            );
+        }
+    }
+
+    #[test]
+    fn internally_derived_slicing_failure_is_an_observation_invariant() {
+        let error = with_forced_derived_delivery_slicing_failure(|| {
+            execute_parser_observation(final_audit_request(
+                ParserObservationTarget::StandaloneTokenizer,
+                ParserObservationInput::Utf8FixedScalarChunks {
+                    text: "ab",
+                    scalars_per_chunk: 1,
+                },
+            ))
+            .expect_err("test seam must reject the derived slice")
+        });
+        assert_eq!(
+            error,
+            ParserObservationExecutionError::ObservationInvariant(
+                ParserObservationInvariantError::DerivedDeliverySlicingInvariant,
+            )
+        );
+        assert_eq!(
+            error.identity(),
+            ParserObservationExecutionIdentity::ObservationInvariant(
+                ParserObservationInvariantError::DerivedDeliverySlicingInvariant,
+            )
+        );
+    }
+
+    #[test]
+    fn delivery_byte_chunks_preserve_crlf_and_incomplete_utf8_eof_semantics() {
+        for bytes in [
+            b"a\r\nb\r".as_slice(),
+            b"a\rb".as_slice(),
+            &[0xff][..],
+            &[0xf0, 0x9f][..],
+        ] {
+            let whole = execute_parser_observation(final_audit_request(
+                ParserObservationTarget::StandaloneTokenizer,
+                ParserObservationInput::Bytes(bytes),
+            ))
+            .expect("whole bytes");
+            let chunked = execute_parser_observation(final_audit_request(
+                ParserObservationTarget::StandaloneTokenizer,
+                ParserObservationInput::ByteFixedChunks {
+                    bytes,
+                    bytes_per_chunk: 1,
+                },
+            ))
+            .expect("fixed bytes");
+            assert_eq!(whole, chunked);
+        }
+    }
+
+    #[test]
+    fn final_audit_reports_all_fields_and_standalone_not_applicable_outcomes() {
+        let standalone = execute_parser_observation(final_audit_request(
+            ParserObservationTarget::StandaloneTokenizer,
+            ParserObservationInput::Utf8("<p>x"),
+        ))
+        .expect("standalone audit");
+        let ObservationState::Captured(standalone) = standalone.final_invariants else {
+            panic!("standalone final report");
+        };
+        assert_eq!(standalone.fields().count(), 16);
+        assert_eq!(
+            standalone
+                .fields()
+                .filter(|(_, outcome)| matches!(
+                    outcome,
+                    InvariantOutcome::NotApplicable(
+                        InvariantNotApplicableReason::StandaloneTokenizerRun
+                    )
+                ))
+                .count(),
+            11
+        );
+        assert!(!standalone.has_failure());
+
+        let document = execute_parser_observation(final_audit_request(
+            ParserObservationTarget::DocumentParser,
+            ParserObservationInput::Utf8(
+                "<!doctype html><table>x<tr><td><b>y</table><template><svg><foreignObject><p>z",
+            ),
+        ))
+        .expect("document audit");
+        let ObservationState::Captured(document) = document.final_invariants else {
+            panic!("document final report");
+        };
+        assert_eq!(document.fields().count(), 16);
+        assert!(
+            document
+                .fields()
+                .all(|(_, outcome)| matches!(outcome, InvariantOutcome::Satisfied))
+        );
+    }
+
+    #[test]
+    fn final_audit_failed_field_iteration_is_allocation_free_and_canonical() {
+        let failed = InvariantOutcome::Failed;
+        let report = ParserFinalizationReport {
+            input: InputFinalizationChecks {
+                decoder_carry_empty: failed.clone(),
+                preprocessing_flushed: failed.clone(),
+            },
+            tokenizer: TokenizerFinalizationChecks {
+                eof_emitted_once: failed.clone(),
+                pending_constructs_flushed: failed.clone(),
+                output_accounted_for: failed.clone(),
+            },
+            tree_builder: TreeBuilderFinalizationChecks {
+                pending_table_text_empty: failed.clone(),
+                insertion_mode_valid: failed.clone(),
+                open_elements_consistent: failed.clone(),
+                active_formatting_consistent: failed.clone(),
+                template_modes_consistent: failed.clone(),
+                form_pointer_valid: failed.clone(),
+            },
+            dom: DomFinalizationChecks {
+                parent_child_links_valid: failed.clone(),
+                namespaces_valid: failed.clone(),
+                template_associations_valid: failed.clone(),
+            },
+            patches: PatchFinalizationChecks {
+                all_patches_materialized: failed.clone(),
+                live_tree_matches_materialized_dom: failed,
+            },
+        };
+        assert_eq!(
+            report
+                .failed_fields()
+                .map(|(_, code)| code)
+                .collect::<Vec<_>>(),
+            [
+                InvariantFailureCode::DecoderCarryNotEmpty,
+                InvariantFailureCode::PreprocessingNotFlushed,
+                InvariantFailureCode::EofEmissionInvalid,
+                InvariantFailureCode::PendingTokenizerConstruct,
+                InvariantFailureCode::TokenizerOutputUnaccounted,
+                InvariantFailureCode::PendingTableText,
+                InvariantFailureCode::InvalidInsertionMode,
+                InvariantFailureCode::OpenElementsInconsistent,
+                InvariantFailureCode::ActiveFormattingInconsistent,
+                InvariantFailureCode::TemplateModesInconsistent,
+                InvariantFailureCode::FormPointerInvalid,
+                InvariantFailureCode::ParentChildRelationshipInvalid,
+                InvariantFailureCode::NamespaceRelationshipInvalid,
+                InvariantFailureCode::TemplateAssociationInvalid,
+                InvariantFailureCode::PatchMaterializationIncomplete,
+                InvariantFailureCode::LiveTreeMismatch,
+            ]
+        );
+    }
+
+    #[test]
+    fn final_audit_patch_witness_requires_every_terminal_lifecycle_fact() {
+        let complete = crate::parser::PatchMaterializationWitness {
+            terminal_empty_drain_observed: true,
+            builder_pending_patch_count_after_finish: 0,
+            builder_pending_patch_count_after_terminal_drain: 0,
+            emitter_pending_patch_count_after_terminal_drain: 0,
+            drained_operation_count: 7,
+            applied_operation_count: 7,
+            materialized_after_terminal_drain: true,
+        };
+        assert!(patch_materialization_complete(complete));
+        for incomplete in [
+            crate::parser::PatchMaterializationWitness {
+                terminal_empty_drain_observed: false,
+                ..complete
+            },
+            crate::parser::PatchMaterializationWitness {
+                builder_pending_patch_count_after_finish: 1,
+                ..complete
+            },
+            crate::parser::PatchMaterializationWitness {
+                builder_pending_patch_count_after_terminal_drain: 1,
+                ..complete
+            },
+            crate::parser::PatchMaterializationWitness {
+                emitter_pending_patch_count_after_terminal_drain: 1,
+                ..complete
+            },
+            crate::parser::PatchMaterializationWitness {
+                applied_operation_count: 6,
+                ..complete
+            },
+            crate::parser::PatchMaterializationWitness {
+                materialized_after_terminal_drain: false,
+                ..complete
+            },
+        ] {
+            assert!(!patch_materialization_complete(incomplete));
+        }
+    }
+
     fn captured<T: std::fmt::Debug>(surface: &ObservationState<Vec<T>>) -> &[T] {
         match surface {
             ObservationState::Captured(items) => items,
@@ -1265,6 +2124,7 @@ mod tests {
             document_mode: ScalarObservationRequest::NotRequested,
             tree,
             patches: ObservationRequest::NotRequested,
+            final_invariants: FinalInvariantRequest::NotRequested,
         })
         .expect("AE13b4 production observation")
     }
@@ -1292,6 +2152,7 @@ mod tests {
             ObservationState::NotRequested,
             ParserObservationTarget::DocumentParser,
             ObservationRequest::NotRequested,
+            ObservationState::NotRequested,
         )
     }
 
@@ -1390,6 +2251,7 @@ mod tests {
             document_mode: ScalarObservationRequest::NotRequested,
             tree: ObservationRequest::NotRequested,
             patches: ObservationRequest::NotRequested,
+            final_invariants: FinalInvariantRequest::NotRequested,
         })
         .expect("unobserved conformance execution still runs production parsing");
         assert!(matches!(result.tokens, ObservationState::NotRequested));
@@ -1416,6 +2278,7 @@ mod tests {
             document_mode: ScalarObservationRequest::NotRequested,
             tree: ObservationRequest::NotRequested,
             patches: ObservationRequest::NotRequested,
+            final_invariants: FinalInvariantRequest::NotRequested,
         })
         .unwrap();
         assert_eq!(
@@ -2024,6 +2887,7 @@ mod tests {
             document_mode: ScalarObservationRequest::NotRequested,
             tree: ObservationRequest::NotRequested,
             patches: ObservationRequest::NotRequested,
+            final_invariants: FinalInvariantRequest::NotRequested,
         })
         .unwrap();
         assert_eq!(whole.transitions, chunked.transitions);
@@ -2041,6 +2905,7 @@ mod tests {
             document_mode: ScalarObservationRequest::NotRequested,
             tree: ObservationRequest::Capture { capacity: 256 },
             patches: ObservationRequest::NotRequested,
+            final_invariants: FinalInvariantRequest::NotRequested,
         })
         .unwrap();
         let unobserved_tree = execute_parser_observation(ParserObservationRequest {
@@ -2054,6 +2919,7 @@ mod tests {
             document_mode: ScalarObservationRequest::NotRequested,
             tree: ObservationRequest::Capture { capacity: 256 },
             patches: ObservationRequest::NotRequested,
+            final_invariants: FinalInvariantRequest::NotRequested,
         })
         .unwrap();
         assert_eq!(observed_tree.tree, unobserved_tree.tree);
@@ -2149,6 +3015,7 @@ mod tests {
                 true,
                 ObservationRequest::NotRequested,
                 ObservationRequest::NotRequested,
+                FinalInvariantRequest::NotRequested,
             ),
             Err(ParserObservationExecutionError::ParserInvariant)
         );
@@ -2173,6 +3040,26 @@ mod tests {
         );
     }
 
+    #[test]
+    fn final_audit_patch_application_failure_returns_no_partial_report() {
+        let mut parser = HtmlParser::new_with_conformance_observations(
+            HtmlParseOptions::default(),
+            ParserObservationConfig::default(),
+            PatchHistoryObservationConfig::capture(64),
+        )
+        .unwrap();
+        parser.push_str("<p>x</p>").unwrap();
+        parser.finish().unwrap();
+        parser.force_materialization_failure_for_test();
+        let mut reserve = |_| Ok(());
+        assert!(matches!(
+            parser.into_output_with_final_audit(&mut reserve),
+            Err(ConformanceFinalizationError::Parser(
+                crate::HtmlParseError::PatchValidation(_)
+            ))
+        ));
+    }
+
     #[test]
     fn requested_patch_observation_without_session_capture_is_an_execution_failure() {
         let mut parser = HtmlParser::new_with_observations(
@@ -2188,6 +3075,7 @@ mod tests {
                 false,
                 ObservationRequest::NotRequested,
                 ObservationRequest::Capture { capacity: 64 },
+                FinalInvariantRequest::NotRequested,
             ),
             Err(ParserObservationExecutionError::PatchHistoryCaptureMissing)
         );
@@ -2214,6 +3102,7 @@ mod tests {
                 false,
                 ObservationRequest::Capture { capacity: 16 },
                 ObservationRequest::NotRequested,
+                FinalInvariantRequest::NotRequested,
                 &mut allocations,
             ),
             Err(ParserObservationExecutionError::ResourceExhaustion(
@@ -2224,6 +3113,126 @@ mod tests {
         );
     }
 
+    #[test]
+    fn every_final_audit_reservation_site_fails_without_a_partial_report() {
+        let sites = [
+            (
+                ObservationReservationSite::FinalAuditLiveTreeStructuralProjection,
+                ObservationAllocationStep::FinalAuditLiveTreeStructuralProjection,
+            ),
+            (
+                ObservationReservationSite::FinalAuditPatchArenaStructuralProjection,
+                ObservationAllocationStep::FinalAuditPatchArenaStructuralProjection,
+            ),
+            (
+                ObservationReservationSite::FinalAuditDomStructuralTraversal,
+                ObservationAllocationStep::FinalAuditDomStructuralTraversal,
+            ),
+            (
+                ObservationReservationSite::FinalAuditOpenElementsIndex,
+                ObservationAllocationStep::FinalAuditOpenElementsIndex,
+            ),
+            (
+                ObservationReservationSite::FinalAuditActiveFormattingIndex,
+                ObservationAllocationStep::FinalAuditActiveFormattingIndex,
+            ),
+            (
+                ObservationReservationSite::FinalAuditTemplateCoordinationIndex,
+                ObservationAllocationStep::FinalAuditTemplateCoordinationIndex,
+            ),
+            (
+                ObservationReservationSite::FinalAuditSemanticTraversal,
+                ObservationAllocationStep::FinalAuditSemanticTraversal,
+            ),
+        ];
+        for (site, step) in sites {
+            let mut parser = HtmlParser::new_with_conformance_observations(
+                HtmlParseOptions::default(),
+                ParserObservationConfig::default(),
+                PatchHistoryObservationConfig::default(),
+            )
+            .expect("parser");
+            parser.push_str("<p>x</p>").expect("input");
+            parser.finish().expect("finish");
+            let mut allocations =
+                ObservationAllocationController::with_failure(ObservationFailureInjection {
+                    step,
+                    occurrence: NonZeroU64::MIN,
+                });
+            let result = finalize_document_parser_with_allocations(
+                parser,
+                false,
+                ObservationRequest::NotRequested,
+                ObservationRequest::NotRequested,
+                FinalInvariantRequest::Capture,
+                &mut allocations,
+            );
+            assert!(matches!(
+                result,
+                Err(ParserObservationExecutionError::ResourceExhaustion(error))
+                    if error.site() == site
+            ));
+        }
+    }
+
+    #[test]
+    fn final_audit_later_real_reservations_are_injectable_without_partial_reports() {
+        let later_sites = [
+            (
+                ObservationReservationSite::FinalAuditLiveTreeStructuralProjection,
+                ObservationAllocationStep::FinalAuditLiveTreeStructuralProjection,
+            ),
+            (
+                ObservationReservationSite::FinalAuditPatchArenaStructuralProjection,
+                ObservationAllocationStep::FinalAuditPatchArenaStructuralProjection,
+            ),
+            (
+                ObservationReservationSite::FinalAuditDomStructuralTraversal,
+                ObservationAllocationStep::FinalAuditDomStructuralTraversal,
+            ),
+            (
+                ObservationReservationSite::FinalAuditOpenElementsIndex,
+                ObservationAllocationStep::FinalAuditOpenElementsIndex,
+            ),
+            (
+                ObservationReservationSite::FinalAuditTemplateCoordinationIndex,
+                ObservationAllocationStep::FinalAuditTemplateCoordinationIndex,
+            ),
+            (
+                ObservationReservationSite::FinalAuditSemanticTraversal,
+                ObservationAllocationStep::FinalAuditSemanticTraversal,
+            ),
+        ];
+        for (site, step) in later_sites {
+            let mut parser = HtmlParser::new_with_conformance_observations(
+                HtmlParseOptions::default(),
+                ParserObservationConfig::default(),
+                PatchHistoryObservationConfig::default(),
+            )
+            .expect("parser");
+            parser.push_str("<div><span>x</span></div>").expect("input");
+            parser.finish().expect("finish");
+            let mut allocations =
+                ObservationAllocationController::with_failure(ObservationFailureInjection {
+                    step,
+                    occurrence: NonZeroU64::new(2).expect("non-zero"),
+                });
+            let result = finalize_document_parser_with_allocations(
+                parser,
+                false,
+                ObservationRequest::NotRequested,
+                ObservationRequest::NotRequested,
+                FinalInvariantRequest::Capture,
+                &mut allocations,
+            );
+            assert!(matches!(
+                result,
+                Err(ParserObservationExecutionError::ResourceExhaustion(error))
+                    if error.site() == site
+            ));
+        }
+    }
+
     #[test]
     fn live_patch_history_invariant_is_stable_fatal_but_exact_for_conformance() {
         let mut parser = HtmlParser::new_with_conformance_observations(
@@ -2576,6 +3585,7 @@ mod tests {
             document_mode: ScalarObservationRequest::NotRequested,
             tree: ObservationRequest::NotRequested,
             patches: ObservationRequest::NotRequested,
+            final_invariants: FinalInvariantRequest::NotRequested,
         })
         .unwrap();
         let ObservationState::Incomplete { partial, reason } = result.implementation_diagnostics
@@ -2986,6 +3996,7 @@ mod tests {
             document_mode: ScalarObservationRequest::NotRequested,
             tree: ObservationRequest::NotRequested,
             patches: ObservationRequest::NotRequested,
+            final_invariants: FinalInvariantRequest::NotRequested,
         })
         .expect("document parser observation");
         assert!(captured(&text_mode.parse_errors).iter().any(|event| {
@@ -4408,6 +5419,7 @@ mod tests {
             document_mode,
             tree: ObservationRequest::NotRequested,
             patches: ObservationRequest::NotRequested,
+            final_invariants: FinalInvariantRequest::NotRequested,
         })
         .expect("document observation should complete")
     }
@@ -4705,6 +5717,7 @@ mod tests {
                 document_mode: ScalarObservationRequest::Capture,
                 tree: ObservationRequest::NotRequested,
                 patches: ObservationRequest::NotRequested,
+                final_invariants: FinalInvariantRequest::NotRequested,
             })
             .expect("scalar-only production execution");
             assert_eq!(scalar_only.document_mode, result.document_mode);
@@ -4724,6 +5737,7 @@ mod tests {
             document_mode: ScalarObservationRequest::Capture,
             tree: ObservationRequest::NotRequested,
             patches: ObservationRequest::NotRequested,
+            final_invariants: FinalInvariantRequest::NotRequested,
         })
         .expect("standalone tokenizer execution");
         assert_eq!(
@@ -4752,6 +5766,7 @@ mod tests {
             document_mode: ScalarObservationRequest::NotRequested,
             tree: ObservationRequest::Capture { capacity: 256 },
             patches: ObservationRequest::Capture { capacity: 512 },
+            final_invariants: FinalInvariantRequest::NotRequested,
         })
         .expect("canonical document observation");
         assert!(matches!(result.tokens, ObservationState::NotRequested));
@@ -4963,6 +5978,7 @@ mod tests {
             document_mode: ScalarObservationRequest::NotRequested,
             tree: ObservationRequest::NotRequested,
             patches: ObservationRequest::Capture { capacity },
+            final_invariants: FinalInvariantRequest::NotRequested,
         })
         .unwrap()
         .patches
@@ -5019,6 +6035,7 @@ mod tests {
             document_mode: ScalarObservationRequest::NotRequested,
             tree: ObservationRequest::Capture { capacity: 32 },
             patches: ObservationRequest::Capture { capacity: 32 },
+            final_invariants: FinalInvariantRequest::NotRequested,
         })
         .unwrap();
         assert!(matches!(result.tokens, ObservationState::NotRequested));
@@ -5061,6 +6078,7 @@ mod tests {
                 capacity: depth + 5,
             },
             patches: ObservationRequest::NotRequested,
+            final_invariants: FinalInvariantRequest::NotRequested,
         })
         .unwrap();
         let ObservationState::Captured(tree) = result.tree else {
diff --git a/crates/html/src/conformance/mod.rs b/crates/html/src/conformance/mod.rs
index dfad7daa..0adb4bcd 100644
--- a/crates/html/src/conformance/mod.rs
+++ b/crates/html/src/conformance/mod.rs
@@ -23,11 +23,12 @@ pub use crate::html5::shared::{
     WhatwgParseErrorCode,
 };
 pub use execution::{
-    ObservationRequest, ObservationReservationSite, ObservationResourceExhaustion,
-    ParserFatalIdentity, ParserObservationExecutionError, ParserObservationExecutionIdentity,
-    ParserObservationInput, ParserObservationInvariantError, ParserObservationRequest,
-    ParserObservationTarget, ParserReservationSiteIdentity, ParserTokenizerInvariantError,
-    ScalarObservationRequest, UnsupportedFeatureObservationInvariantError,
-    execute_parser_observation,
+    FinalInvariantRequest, ObservationRequest, ObservationReservationSite,
+    ObservationResourceExhaustion, ParserFatalIdentity, ParserObservationDeliveryError,
+    ParserObservationDeliveryErrorIdentity, ParserObservationExecutionError,
+    ParserObservationExecutionIdentity, ParserObservationInput, ParserObservationInvariantError,
+    ParserObservationRequest, ParserObservationTarget, ParserReservationSiteIdentity,
+    ParserTokenizerInvariantError, ScalarObservationRequest,
+    UnsupportedFeatureObservationInvariantError, execute_parser_observation,
 };
 pub use model::*;
diff --git a/crates/html/src/conformance/model.rs b/crates/html/src/conformance/model.rs
index e305ca60..02a167cf 100644
--- a/crates/html/src/conformance/model.rs
+++ b/crates/html/src/conformance/model.rs
@@ -61,7 +61,10 @@ impl CanonicalParserResult {
     }
 
     pub fn has_failed_final_invariant(&self) -> bool {
-        !self.failed_final_invariants().is_empty()
+        matches!(
+            &self.final_invariants,
+            ObservationState::Captured(report) if report.has_failure()
+        )
     }
 
     pub fn failed_final_invariants(&self) -> Vec<InvariantFailureCode> {
@@ -210,24 +213,133 @@ pub struct ParserFinalizationReport {
 
 impl ParserFinalizationReport {
     pub fn has_failure(&self) -> bool {
-        !self.failures().is_empty()
+        self.failed_fields().next().is_some()
+    }
+
+    /// Fixed canonical field order without heap allocation.
+    pub fn fields(&self) -> impl Iterator<Item = (FinalInvariantField, &InvariantOutcome)> {
+        [
+            (
+                FinalInvariantField::DecoderCarryEmpty,
+                &self.input.decoder_carry_empty,
+            ),
+            (
+                FinalInvariantField::PreprocessingFlushed,
+                &self.input.preprocessing_flushed,
+            ),
+            (
+                FinalInvariantField::EofEmittedOnce,
+                &self.tokenizer.eof_emitted_once,
+            ),
+            (
+                FinalInvariantField::PendingConstructsFlushed,
+                &self.tokenizer.pending_constructs_flushed,
+            ),
+            (
+                FinalInvariantField::OutputAccountedFor,
+                &self.tokenizer.output_accounted_for,
+            ),
+            (
+                FinalInvariantField::PendingTableTextEmpty,
+                &self.tree_builder.pending_table_text_empty,
+            ),
+            (
+                FinalInvariantField::InsertionModeValid,
+                &self.tree_builder.insertion_mode_valid,
+            ),
+            (
+                FinalInvariantField::OpenElementsConsistent,
+                &self.tree_builder.open_elements_consistent,
+            ),
+            (
+                FinalInvariantField::ActiveFormattingConsistent,
+                &self.tree_builder.active_formatting_consistent,
+            ),
+            (
+                FinalInvariantField::TemplateModesConsistent,
+                &self.tree_builder.template_modes_consistent,
+            ),
+            (
+                FinalInvariantField::FormPointerValid,
+                &self.tree_builder.form_pointer_valid,
+            ),
+            (
+                FinalInvariantField::ParentChildLinksValid,
+                &self.dom.parent_child_links_valid,
+            ),
+            (
+                FinalInvariantField::NamespacesValid,
+                &self.dom.namespaces_valid,
+            ),
+            (
+                FinalInvariantField::TemplateAssociationsValid,
+                &self.dom.template_associations_valid,
+            ),
+            (
+                FinalInvariantField::AllPatchesMaterialized,
+                &self.patches.all_patches_materialized,
+            ),
+            (
+                FinalInvariantField::LiveTreeMatchesMaterializedDom,
+                &self.patches.live_tree_matches_materialized_dom,
+            ),
+        ]
+        .into_iter()
+    }
+
+    pub fn failed_fields(
+        &self,
+    ) -> impl Iterator<Item = (FinalInvariantField, InvariantFailureCode)> + '_ {
+        self.fields().filter_map(|(field, outcome)| {
+            matches!(outcome, InvariantOutcome::Failed).then_some((field, field.failure_code()))
+        })
     }
 
     pub fn failures(&self) -> Vec<InvariantFailureCode> {
-        let Self {
-            input,
-            tokenizer,
-            tree_builder,
-            dom,
-            patches,
-        } = self;
-        let mut failures = Vec::new();
-        input.append_failures(&mut failures);
-        tokenizer.append_failures(&mut failures);
-        tree_builder.append_failures(&mut failures);
-        dom.append_failures(&mut failures);
-        patches.append_failures(&mut failures);
-        failures
+        self.failed_fields().map(|(_, code)| code).collect()
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum FinalInvariantField {
+    DecoderCarryEmpty,
+    PreprocessingFlushed,
+    EofEmittedOnce,
+    PendingConstructsFlushed,
+    OutputAccountedFor,
+    PendingTableTextEmpty,
+    InsertionModeValid,
+    OpenElementsConsistent,
+    ActiveFormattingConsistent,
+    TemplateModesConsistent,
+    FormPointerValid,
+    ParentChildLinksValid,
+    NamespacesValid,
+    TemplateAssociationsValid,
+    AllPatchesMaterialized,
+    LiveTreeMatchesMaterializedDom,
+}
+
+impl FinalInvariantField {
+    pub const fn failure_code(self) -> InvariantFailureCode {
+        match self {
+            Self::DecoderCarryEmpty => InvariantFailureCode::DecoderCarryNotEmpty,
+            Self::PreprocessingFlushed => InvariantFailureCode::PreprocessingNotFlushed,
+            Self::EofEmittedOnce => InvariantFailureCode::EofEmissionInvalid,
+            Self::PendingConstructsFlushed => InvariantFailureCode::PendingTokenizerConstruct,
+            Self::OutputAccountedFor => InvariantFailureCode::TokenizerOutputUnaccounted,
+            Self::PendingTableTextEmpty => InvariantFailureCode::PendingTableText,
+            Self::InsertionModeValid => InvariantFailureCode::InvalidInsertionMode,
+            Self::OpenElementsConsistent => InvariantFailureCode::OpenElementsInconsistent,
+            Self::ActiveFormattingConsistent => InvariantFailureCode::ActiveFormattingInconsistent,
+            Self::TemplateModesConsistent => InvariantFailureCode::TemplateModesInconsistent,
+            Self::FormPointerValid => InvariantFailureCode::FormPointerInvalid,
+            Self::ParentChildLinksValid => InvariantFailureCode::ParentChildRelationshipInvalid,
+            Self::NamespacesValid => InvariantFailureCode::NamespaceRelationshipInvalid,
+            Self::TemplateAssociationsValid => InvariantFailureCode::TemplateAssociationInvalid,
+            Self::AllPatchesMaterialized => InvariantFailureCode::PatchMaterializationIncomplete,
+            Self::LiveTreeMatchesMaterializedDom => InvariantFailureCode::LiveTreeMismatch,
+        }
     }
 }
 
@@ -237,25 +349,6 @@ pub struct InputFinalizationChecks {
     pub preprocessing_flushed: InvariantOutcome,
 }
 
-impl InputFinalizationChecks {
-    fn append_failures(&self, failures: &mut Vec<InvariantFailureCode>) {
-        let Self {
-            decoder_carry_empty,
-            preprocessing_flushed,
-        } = self;
-        append_invariant_failure(
-            decoder_carry_empty,
-            InvariantFailureCode::DecoderCarryNotEmpty,
-            failures,
-        );
-        append_invariant_failure(
-            preprocessing_flushed,
-            InvariantFailureCode::PreprocessingNotFlushed,
-            failures,
-        );
-    }
-}
-
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct TokenizerFinalizationChecks {
     pub eof_emitted_once: InvariantOutcome,
@@ -263,31 +356,6 @@ pub struct TokenizerFinalizationChecks {
     pub output_accounted_for: InvariantOutcome,
 }
 
-impl TokenizerFinalizationChecks {
-    fn append_failures(&self, failures: &mut Vec<InvariantFailureCode>) {
-        let Self {
-            eof_emitted_once,
-            pending_constructs_flushed,
-            output_accounted_for,
-        } = self;
-        append_invariant_failure(
-            eof_emitted_once,
-            InvariantFailureCode::EofEmissionInvalid,
-            failures,
-        );
-        append_invariant_failure(
-            pending_constructs_flushed,
-            InvariantFailureCode::PendingTokenizerConstruct,
-            failures,
-        );
-        append_invariant_failure(
-            output_accounted_for,
-            InvariantFailureCode::TokenizerOutputUnaccounted,
-            failures,
-        );
-    }
-}
-
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct TreeBuilderFinalizationChecks {
     pub pending_table_text_empty: InvariantOutcome,
@@ -298,49 +366,6 @@ pub struct TreeBuilderFinalizationChecks {
     pub form_pointer_valid: InvariantOutcome,
 }
 
-impl TreeBuilderFinalizationChecks {
-    fn append_failures(&self, failures: &mut Vec<InvariantFailureCode>) {
-        let Self {
-            pending_table_text_empty,
-            insertion_mode_valid,
-            open_elements_consistent,
-            active_formatting_consistent,
-            template_modes_consistent,
-            form_pointer_valid,
-        } = self;
-        append_invariant_failure(
-            pending_table_text_empty,
-            InvariantFailureCode::PendingTableText,
-            failures,
-        );
-        append_invariant_failure(
-            insertion_mode_valid,
-            InvariantFailureCode::InvalidInsertionMode,
-            failures,
-        );
-        append_invariant_failure(
-            open_elements_consistent,
-            InvariantFailureCode::OpenElementsInconsistent,
-            failures,
-        );
-        append_invariant_failure(
-            active_formatting_consistent,
-            InvariantFailureCode::ActiveFormattingInconsistent,
-            failures,
-        );
-        append_invariant_failure(
-            template_modes_consistent,
-            InvariantFailureCode::TemplateModesInconsistent,
-            failures,
-        );
-        append_invariant_failure(
-            form_pointer_valid,
-            InvariantFailureCode::FormPointerInvalid,
-            failures,
-        );
-    }
-}
-
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct DomFinalizationChecks {
     pub parent_child_links_valid: InvariantOutcome,
@@ -348,66 +373,12 @@ pub struct DomFinalizationChecks {
     pub template_associations_valid: InvariantOutcome,
 }
 
-impl DomFinalizationChecks {
-    fn append_failures(&self, failures: &mut Vec<InvariantFailureCode>) {
-        let Self {
-            parent_child_links_valid,
-            namespaces_valid,
-            template_associations_valid,
-        } = self;
-        append_invariant_failure(
-            parent_child_links_valid,
-            InvariantFailureCode::ParentChildRelationshipInvalid,
-            failures,
-        );
-        append_invariant_failure(
-            namespaces_valid,
-            InvariantFailureCode::NamespaceRelationshipInvalid,
-            failures,
-        );
-        append_invariant_failure(
-            template_associations_valid,
-            InvariantFailureCode::TemplateAssociationInvalid,
-            failures,
-        );
-    }
-}
-
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct PatchFinalizationChecks {
     pub all_patches_materialized: InvariantOutcome,
     pub live_tree_matches_materialized_dom: InvariantOutcome,
 }
 
-impl PatchFinalizationChecks {
-    fn append_failures(&self, failures: &mut Vec<InvariantFailureCode>) {
-        let Self {
-            all_patches_materialized,
-            live_tree_matches_materialized_dom,
-        } = self;
-        append_invariant_failure(
-            all_patches_materialized,
-            InvariantFailureCode::PatchMaterializationIncomplete,
-            failures,
-        );
-        append_invariant_failure(
-            live_tree_matches_materialized_dom,
-            InvariantFailureCode::LiveTreeMismatch,
-            failures,
-        );
-    }
-}
-
-fn append_invariant_failure(
-    outcome: &InvariantOutcome,
-    code: InvariantFailureCode,
-    failures: &mut Vec<InvariantFailureCode>,
-) {
-    if matches!(outcome, InvariantOutcome::Failed) {
-        failures.push(code);
-    }
-}
-
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum InvariantOutcome {
     Satisfied,
diff --git a/crates/html/src/conformance/projection.rs b/crates/html/src/conformance/projection.rs
index a6608e2b..40a32476 100644
--- a/crates/html/src/conformance/projection.rs
+++ b/crates/html/src/conformance/projection.rs
@@ -46,6 +46,13 @@ pub(super) enum ObservationAllocationStep {
     PatchCreationHistoryStorage,
     SnapshotLabelMapStorage,
     SnapshotLabelStringStorage,
+    FinalAuditLiveTreeStructuralProjection,
+    FinalAuditPatchArenaStructuralProjection,
+    FinalAuditDomStructuralTraversal,
+    FinalAuditOpenElementsIndex,
+    FinalAuditActiveFormattingIndex,
+    FinalAuditTemplateCoordinationIndex,
+    FinalAuditSemanticTraversal,
 }
 
 #[cfg(test)]
@@ -59,6 +66,37 @@ impl ObservationAllocationController {
 }
 
 impl ObservationAllocationController {
+    pub(super) fn before_final_audit(
+        &mut self,
+        site: ObservationReservationSite,
+    ) -> Result<(), ObservationResourceExhaustion> {
+        let step = match site {
+            ObservationReservationSite::FinalAuditLiveTreeStructuralProjection => {
+                ObservationAllocationStep::FinalAuditLiveTreeStructuralProjection
+            }
+            ObservationReservationSite::FinalAuditPatchArenaStructuralProjection => {
+                ObservationAllocationStep::FinalAuditPatchArenaStructuralProjection
+            }
+            ObservationReservationSite::FinalAuditDomStructuralTraversal => {
+                ObservationAllocationStep::FinalAuditDomStructuralTraversal
+            }
+            ObservationReservationSite::FinalAuditOpenElementsIndex => {
+                ObservationAllocationStep::FinalAuditOpenElementsIndex
+            }
+            ObservationReservationSite::FinalAuditActiveFormattingIndex => {
+                ObservationAllocationStep::FinalAuditActiveFormattingIndex
+            }
+            ObservationReservationSite::FinalAuditTemplateCoordinationIndex => {
+                ObservationAllocationStep::FinalAuditTemplateCoordinationIndex
+            }
+            ObservationReservationSite::FinalAuditSemanticTraversal => {
+                ObservationAllocationStep::FinalAuditSemanticTraversal
+            }
+            _ => return Ok(()),
+        };
+        self.before_reservation(site, step)
+    }
+
     fn before_reservation(
         &mut self,
         site: ObservationReservationSite,
diff --git a/crates/html/src/html5/bridge/adapters.rs b/crates/html/src/html5/bridge/adapters.rs
index 148c6983..da209bfd 100644
--- a/crates/html/src/html5/bridge/adapters.rs
+++ b/crates/html/src/html5/bridge/adapters.rs
@@ -46,6 +46,10 @@ pub(crate) struct PatchEmitterAdapter {
 }
 
 impl PatchEmitterAdapter {
+    #[cfg(feature = "parser-conformance")]
+    pub(crate) fn buffered_patch_count_for_final_audit(&self) -> usize {
+        self.patches.len()
+    }
     pub(crate) fn new() -> Self {
         Self {
             patches: Vec::new(),
diff --git a/crates/html/src/html5/mod.rs b/crates/html/src/html5/mod.rs
index 5413c229..f9aa6fba 100644
--- a/crates/html/src/html5/mod.rs
+++ b/crates/html/src/html5/mod.rs
@@ -28,6 +28,8 @@ pub use fuzz::{
 ))]
 pub use fuzz::{Html5PipelineRegressionError, render_html5_pipeline_regression_snapshot};
 pub use session::Html5ParseSession;
+#[cfg(feature = "parser-conformance")]
+pub(crate) use session::Html5SessionFinalAudit;
 #[cfg(all(feature = "internal-api", feature = "parser-failure-injection"))]
 pub use shared::ParserFailureInjection;
 pub use shared::{
diff --git a/crates/html/src/html5/session/api.rs b/crates/html/src/html5/session/api.rs
index 3c5fc6b0..6b990296 100644
--- a/crates/html/src/html5/session/api.rs
+++ b/crates/html/src/html5/session/api.rs
@@ -14,6 +14,18 @@ use crate::html5::tokenizer::{Html5Tokenizer, TokenizerConfig};
 #[cfg(test)]
 use crate::html5::tree_builder::PatchSink;
 use crate::html5::tree_builder::{Html5TreeBuilder, TreeBuilderConfig};
+#[cfg(feature = "parser-conformance")]
+use crate::html5::tree_builder::{TreeBuilderFinalAudit, TreeBuilderFinalAuditAllocation};
+
+#[cfg(feature = "parser-conformance")]
+pub(crate) struct Html5SessionFinalAudit {
+    pub(crate) decoder_carry_empty: bool,
+    pub(crate) preprocessing_flushed: bool,
+    pub(crate) tokenizer_eof_lifecycle_complete: bool,
+    pub(crate) tokenizer_pending_constructs_flushed: bool,
+    pub(crate) tokenizer_output_accounted_for: bool,
+    pub(crate) tree_builder: TreeBuilderFinalAudit,
+}
 
 /// Feature-gated runtime entrypoint for the HTML5 parsing path.
 pub struct Html5ParseSession {
@@ -255,6 +267,44 @@ impl Html5ParseSession {
         self.patch_history_invariant
     }
 
+    #[cfg(feature = "parser-conformance")]
+    pub(crate) fn final_audit_for_conformance(
+        &self,
+        reserve: &mut impl FnMut(crate::conformance::ObservationReservationSite) -> Result<(), ()>,
+    ) -> Result<Html5SessionFinalAudit, TreeBuilderFinalAuditAllocation> {
+        let tokenizer = self.tokenizer.final_audit_for_conformance();
+        let mut tree_builder = self
+            .builder
+            .final_audit_for_conformance(&self.ctx.atoms, reserve)?;
+        tree_builder.insertion_mode_valid = tokenizer.active_text_mode.is_none()
+            && tree_builder.active_text_mode.is_none()
+            && tree_builder.original_insertion_mode.is_none()
+            && tree_builder.pending_tokenizer_control.is_none()
+            && !matches!(
+                tree_builder.insertion_mode,
+                crate::html5::tree_builder::modes::InsertionMode::Text
+                    | crate::html5::tree_builder::modes::InsertionMode::InTableText
+            );
+        Ok(Html5SessionFinalAudit {
+            decoder_carry_empty: !self.decoder.has_pending_bytes(),
+            preprocessing_flushed: !self.input.has_pending_preprocessing(),
+            tokenizer_eof_lifecycle_complete: tokenizer.eof_lifecycle_complete,
+            tokenizer_pending_constructs_flushed: tokenizer.pending_constructs_flushed,
+            tokenizer_output_accounted_for: tokenizer.output_queue_empty,
+            tree_builder,
+        })
+    }
+
+    #[cfg(feature = "parser-conformance")]
+    pub(crate) fn builder_pending_patch_count_for_final_audit(&self) -> usize {
+        self.builder.pending_patch_count_for_final_audit()
+    }
+
+    #[cfg(feature = "parser-conformance")]
+    pub(crate) fn emitter_pending_patch_count_for_final_audit(&self) -> usize {
+        self.patch_emitter.buffered_patch_count_for_final_audit()
+    }
+
     #[cfg(feature = "parser-conformance")]
     pub(crate) fn take_patch_history_for_conformance(
         &mut self,
@@ -333,6 +383,25 @@ impl Html5ParseSession {
         self.tokenizer.active_text_mode_for_test()
     }
 
+    #[cfg(all(test, feature = "parser-conformance"))]
+    pub(crate) fn set_terminal_text_state_for_test(
+        &mut self,
+        tokenizer_active_text_mode: Option<crate::html5::tokenizer::TextModeSpec>,
+        tree_builder_active_text_mode: Option<crate::html5::tokenizer::TextModeSpec>,
+        original_insertion_mode: Option<crate::html5::tree_builder::modes::InsertionMode>,
+        pending_tokenizer_control: Option<TokenizerControl>,
+        insertion_mode: crate::html5::tree_builder::modes::InsertionMode,
+    ) {
+        self.tokenizer
+            .set_active_text_mode_for_test(tokenizer_active_text_mode);
+        self.builder.set_terminal_text_state_for_test(
+            tree_builder_active_text_mode,
+            original_insertion_mode,
+            pending_tokenizer_control,
+            insertion_mode,
+        );
+    }
+
     #[cfg(all(test, feature = "parser-conformance"))]
     pub(crate) fn applied_tokenizer_controls_for_test(&self) -> &[TokenizerControl] {
         &self.applied_tokenizer_controls_for_test
diff --git a/crates/html/src/html5/session/mod.rs b/crates/html/src/html5/session/mod.rs
index 22eee373..199e5e03 100644
--- a/crates/html/src/html5/session/mod.rs
+++ b/crates/html/src/html5/session/mod.rs
@@ -5,6 +5,8 @@ mod counters;
 mod driver;
 
 pub use api::Html5ParseSession;
+#[cfg(feature = "parser-conformance")]
+pub(crate) use api::Html5SessionFinalAudit;
 
 #[cfg(all(test, feature = "html5"))]
 mod tests;
diff --git a/crates/html/src/html5/session/tests/text_mode.rs b/crates/html/src/html5/session/tests/text_mode.rs
index 53a24e32..3a8cd28a 100644
--- a/crates/html/src/html5/session/tests/text_mode.rs
+++ b/crates/html/src/html5/session/tests/text_mode.rs
@@ -384,6 +384,137 @@ fn session_head_script_restores_in_head_after_matching_close() {
     );
 }
 
+#[cfg(feature = "parser-conformance")]
+#[test]
+fn terminal_final_audit_requires_both_text_modes_and_controls_to_be_clear() {
+    use crate::html5::tokenizer::TextModeSpec;
+    use crate::html5::tree_builder::modes::InsertionMode;
+
+    fn terminal_audit(
+        tokenizer_mode: Option<TextModeSpec>,
+        builder_mode: Option<TextModeSpec>,
+        original_mode: Option<InsertionMode>,
+        pending_control: Option<crate::html5::tokenizer::TokenizerControl>,
+        insertion_mode: InsertionMode,
+    ) -> bool {
+        let context = DocumentParseContext::new();
+        let mut session = Html5ParseSession::new(
+            TokenizerConfig::default(),
+            TreeBuilderConfig::default(),
+            context,
+        )
+        .expect("session init");
+        session.push_str_for_test("<html><body><p>x</p>");
+        session.pump().expect("terminal fixture pump");
+        session.finish_for_test().expect("terminal fixture finish");
+        session.set_terminal_text_state_for_test(
+            tokenizer_mode,
+            builder_mode,
+            original_mode,
+            pending_control,
+            insertion_mode,
+        );
+        let mut reserve = |_| Ok(());
+        session
+            .final_audit_for_conformance(&mut reserve)
+            .expect("terminal audit should return a report")
+            .tree_builder
+            .insertion_mode_valid
+    }
+
+    let mode = {
+        let mut names = crate::names::NameInterner::new();
+        TextModeSpec::rcdata_textarea(
+            names
+                .intern_ascii_folded("textarea")
+                .expect("textarea atom"),
+        )
+    };
+    let other_mode = {
+        let mut names = crate::names::NameInterner::new();
+        TextModeSpec::script_data(names.intern_ascii_folded("script").expect("script atom"))
+    };
+
+    for (label, tokenizer_mode, builder_mode, original_mode, pending_control, insertion_mode) in [
+        (
+            "tokenizer-only",
+            Some(mode),
+            None,
+            None,
+            None,
+            InsertionMode::InBody,
+        ),
+        (
+            "tree-builder-only",
+            None,
+            Some(mode),
+            None,
+            None,
+            InsertionMode::InBody,
+        ),
+        (
+            "both-equal",
+            Some(mode),
+            Some(mode),
+            None,
+            None,
+            InsertionMode::InBody,
+        ),
+        (
+            "both-unequal",
+            Some(mode),
+            Some(other_mode),
+            None,
+            None,
+            InsertionMode::InBody,
+        ),
+        ("terminal-text", None, None, None, None, InsertionMode::Text),
+        (
+            "terminal-table-text",
+            None,
+            None,
+            None,
+            None,
+            InsertionMode::InTableText,
+        ),
+        (
+            "original-mode",
+            None,
+            None,
+            Some(InsertionMode::InBody),
+            None,
+            InsertionMode::InBody,
+        ),
+        (
+            "pending-control",
+            None,
+            None,
+            None,
+            Some(crate::html5::tokenizer::TokenizerControl::ExitTextMode),
+            InsertionMode::InBody,
+        ),
+    ] {
+        assert!(
+            !terminal_audit(
+                tokenizer_mode,
+                builder_mode,
+                original_mode,
+                pending_control,
+                insertion_mode,
+            ),
+            "{label} must fail terminal insertion-mode validity"
+        );
+    }
+
+    assert!(terminal_audit(
+        None,
+        None,
+        None,
+        None,
+        InsertionMode::InBody
+    ));
+}
+
 #[test]
 fn session_exits_text_mode_on_eof_recovery() {
     let mut ctx = DocumentParseContext::new();
diff --git a/crates/html/src/html5/tokenizer/api.rs b/crates/html/src/html5/tokenizer/api.rs
index e67a6fc4..a305981b 100644
--- a/crates/html/src/html5/tokenizer/api.rs
+++ b/crates/html/src/html5/tokenizer/api.rs
@@ -707,6 +707,11 @@ impl Html5Tokenizer {
         self.active_text_mode
     }
 
+    #[cfg(test)]
+    pub(crate) fn set_active_text_mode_for_test(&mut self, mode: Option<TextModeSpec>) {
+        self.active_text_mode = mode;
+    }
+
     #[cfg(test)]
     pub(crate) fn force_self_closing_flag_without_solidus_for_test(&mut self) {
         self.current_tag_self_closing = true;
diff --git a/crates/html/src/html5/tokenizer/invariants.rs b/crates/html/src/html5/tokenizer/invariants.rs
index e8f82043..de4cb2e7 100644
--- a/crates/html/src/html5/tokenizer/invariants.rs
+++ b/crates/html/src/html5/tokenizer/invariants.rs
@@ -35,6 +35,55 @@ pub(crate) enum TokenizerInvariantKind {
     ProcessingInstructionDataStartAfterCursor,
 }
 
+#[cfg(feature = "parser-conformance")]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) struct TokenizerFinalAudit {
+    pub(crate) eof_lifecycle_complete: bool,
+    pub(crate) pending_constructs_flushed: bool,
+    pub(crate) output_queue_empty: bool,
+    pub(crate) active_text_mode: Option<crate::html5::tokenizer::TextModeSpec>,
+}
+
+#[cfg(feature = "parser-conformance")]
+impl Html5Tokenizer {
+    /// Read-only terminal audit over the tokenizer's authoritative lifecycle
+    /// and pending-construction state. EOF emission has no parallel witness:
+    /// `finish_with_context` owns the guarded `end_of_stream`/`eof_emitted`
+    /// transition inspected here.
+    pub(crate) fn final_audit_for_conformance(&self) -> TokenizerFinalAudit {
+        TokenizerFinalAudit {
+            eof_lifecycle_complete: self.end_of_stream && self.eof_emitted == self.config.emit_eof,
+            pending_constructs_flushed: self.pending_text_mode_end_tag_matcher.is_none()
+                && self.pending_text_mode_end_tag.is_none()
+                && self.pending_text_start.is_none()
+                && self.pending_comment_start.is_none()
+                && !self.pending_comment_limit_reported
+                && self.pending_processing_instruction.is_none()
+                && self.pending_doctype_name.is_none()
+                && self.pending_doctype_name_start.is_none()
+                && self.pending_doctype_public_id.is_none()
+                && self.pending_doctype_system_id.is_none()
+                && !self.pending_doctype_force_quirks
+                && !self.pending_doctype_limit_reported
+                && self.tag_name_start.is_none()
+                && self.tag_name_end.is_none()
+                && !self.tag_name_complete
+                && !self.current_tag_is_end
+                && !self.current_tag_self_closing
+                && self.current_tag_self_closing_solidus_position.is_none()
+                && self.current_tag_attrs.is_empty()
+                && self.current_attr_name_start.is_none()
+                && self.current_attr_name_end.is_none()
+                && !self.current_attr_has_value
+                && self.current_attr_value_start.is_none()
+                && self.current_attr_value_end.is_none()
+                && !self.end_tag_prefix_consumed,
+            output_queue_empty: self.tokens.is_empty(),
+            active_text_mode: self.active_text_mode,
+        }
+    }
+}
+
 /// Debug/runtime tokenizer hardening checks.
 ///
 /// These checks are enabled in debug/test builds and in release when the
diff --git a/crates/html/src/html5/tree_builder/api.rs b/crates/html/src/html5/tree_builder/api.rs
index c8d9bc4f..2fd0c457 100644
--- a/crates/html/src/html5/tree_builder/api.rs
+++ b/crates/html/src/html5/tree_builder/api.rs
@@ -319,6 +319,10 @@ pub struct TreeBuilderStateSnapshot {
 }
 
 impl Html5TreeBuilder {
+    #[cfg(feature = "parser-conformance")]
+    pub(crate) fn pending_patch_count_for_final_audit(&self) -> usize {
+        self.patches.len()
+    }
     pub(in crate::html5::tree_builder) fn adjusted_current_node(
         &self,
     ) -> Option<crate::html5::tree_builder::foreign::AdjustedCurrentNode<'_>> {
@@ -660,6 +664,20 @@ impl Html5TreeBuilder {
         }
     }
 
+    #[cfg(test)]
+    pub(crate) fn set_terminal_text_state_for_test(
+        &mut self,
+        active_text_mode: Option<TextModeSpec>,
+        original_insertion_mode: Option<InsertionMode>,
+        pending_tokenizer_control: Option<TokenizerControl>,
+        insertion_mode: InsertionMode,
+    ) {
+        self.active_text_mode = active_text_mode;
+        self.original_insertion_mode = original_insertion_mode;
+        self.pending_tokenizer_control = pending_tokenizer_control;
+        self.insertion_mode = insertion_mode;
+    }
+
     #[cold]
     #[track_caller]
     pub(in crate::html5::tree_builder) fn assert_atom_table_binding(&self, atoms: &AtomTable) {
diff --git a/crates/html/src/html5/tree_builder/final_audit.rs b/crates/html/src/html5/tree_builder/final_audit.rs
new file mode 100644
index 00000000..40ffee5a
--- /dev/null
+++ b/crates/html/src/html5/tree_builder/final_audit.rs
@@ -0,0 +1,311 @@
+use std::collections::{HashMap, HashSet};
+
+use crate::ElementNamespace;
+use crate::attributes::parser_created_attribute_lists_equal_ordered;
+use crate::conformance::ObservationReservationSite;
+use crate::dom_patch::PatchKey;
+use crate::html5::shared::AtomTable;
+use crate::html5::tokenizer::{TextModeSpec, TokenizerControl};
+use crate::html5::tree_builder::formatting::{AfeEntry, AfeMarkerKind};
+use crate::html5::tree_builder::modes::InsertionMode;
+use crate::html5::tree_builder::stack::ExpandedNameKey;
+use crate::html5::tree_builder::{DomInvariantState, Html5TreeBuilder};
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum TreeBuilderFinalAuditAllocation {
+    OpenElementsIndex,
+    ActiveFormattingIndex,
+    TemplateCoordinationIndex,
+    DomStructuralTraversal,
+    LiveTreeStructuralProjection,
+}
+
+pub(crate) struct TreeBuilderFinalAudit {
+    pub(crate) pending_table_text_empty: bool,
+    pub(crate) insertion_mode_valid: bool,
+    pub(crate) open_elements_consistent: bool,
+    pub(crate) active_formatting_consistent: bool,
+    pub(crate) template_modes_consistent: bool,
+    pub(crate) form_pointer_valid: bool,
+    pub(crate) parent_child_links_valid: bool,
+    pub(crate) namespaces_valid: bool,
+    pub(crate) template_associations_valid: bool,
+    pub(crate) live_structure: DomInvariantState,
+    pub(crate) active_text_mode: Option<TextModeSpec>,
+    pub(crate) original_insertion_mode: Option<InsertionMode>,
+    pub(crate) pending_tokenizer_control: Option<TokenizerControl>,
+    pub(crate) insertion_mode: InsertionMode,
+}
+
+impl Html5TreeBuilder {
+    pub(crate) fn final_audit_for_conformance(
+        &self,
+        atoms: &AtomTable,
+        reserve: &mut impl FnMut(ObservationReservationSite) -> Result<(), ()>,
+    ) -> Result<TreeBuilderFinalAudit, TreeBuilderFinalAuditAllocation> {
+        let open_elements_consistent = self.audit_open_elements(atoms, reserve)?;
+        let active_formatting_consistent = self.audit_active_formatting(atoms, reserve)?;
+        let template_modes_consistent = self.audit_template_coordination(reserve)?;
+        let live = self
+            .live_tree
+            .try_final_audit(reserve)
+            .map_err(|_| TreeBuilderFinalAuditAllocation::DomStructuralTraversal)?;
+        let live_structure = self
+            .live_tree
+            .try_invariant_state_for_final_audit(reserve)
+            .map_err(|_| TreeBuilderFinalAuditAllocation::LiveTreeStructuralProjection)?;
+        let insertion_mode_valid = self.original_insertion_mode.is_none()
+            && self.active_text_mode.is_none()
+            && self.pending_tokenizer_control.is_none()
+            && !matches!(
+                self.insertion_mode,
+                InsertionMode::Text | InsertionMode::InTableText
+            );
+        let form_pointer_valid = self.form_element_pointer.is_none_or(|pointer| {
+            self.live_tree
+                .element_semantics_for_final_audit(pointer.key())
+                .is_some_and(|(name, _)| name.is(ElementNamespace::Html, "form"))
+        });
+        Ok(TreeBuilderFinalAudit {
+            pending_table_text_empty: self.pending_table_text.is_none(),
+            insertion_mode_valid,
+            open_elements_consistent,
+            active_formatting_consistent,
+            template_modes_consistent,
+            form_pointer_valid,
+            parent_child_links_valid: live.parent_child_links_valid,
+            namespaces_valid: live.namespaces_valid,
+            template_associations_valid: live.template_associations_valid,
+            live_structure,
+            active_text_mode: self.active_text_mode,
+            original_insertion_mode: self.original_insertion_mode,
+            pending_tokenizer_control: self.pending_tokenizer_control,
+            insertion_mode: self.insertion_mode,
+        })
+    }
+
+    fn audit_open_elements(
+        &self,
+        atoms: &AtomTable,
+        reserve: &mut impl FnMut(ObservationReservationSite) -> Result<(), ()>,
+    ) -> Result<bool, TreeBuilderFinalAuditAllocation> {
+        let mut keys = HashSet::new();
+        reserve(ObservationReservationSite::FinalAuditOpenElementsIndex)
+            .map_err(|_| TreeBuilderFinalAuditAllocation::OpenElementsIndex)?;
+        keys.try_reserve(self.open_elements.len())
+            .map_err(|_| TreeBuilderFinalAuditAllocation::OpenElementsIndex)?;
+        let mut counts = HashMap::<ExpandedNameKey, usize>::new();
+        reserve(ObservationReservationSite::FinalAuditOpenElementsIndex)
+            .map_err(|_| TreeBuilderFinalAuditAllocation::OpenElementsIndex)?;
+        counts
+            .try_reserve(self.open_elements.len())
+            .map_err(|_| TreeBuilderFinalAuditAllocation::OpenElementsIndex)?;
+        let mut valid = true;
+        for entry in self.open_elements.iter_entries() {
+            if entry.key() == PatchKey::INVALID || !keys.insert(entry.key()) {
+                valid = false;
+            }
+            let Some(atom_name) = atoms.resolve(entry.name()) else {
+                valid = false;
+                continue;
+            };
+            if u64::from(entry.name().interner_id()) != self.atom_table_id {
+                valid = false;
+            }
+            if !self
+                .live_tree
+                .element_semantics_for_final_audit(entry.key())
+                .is_some_and(|(name, _)| {
+                    name.namespace() == entry.namespace() && name.local_name().as_str() == atom_name
+                })
+            {
+                valid = false;
+            }
+            let count = counts.entry(entry.expanded_name_key()).or_insert(0);
+            let Some(next) = count.checked_add(1) else {
+                valid = false;
+                continue;
+            };
+            *count = next;
+        }
+        if counts.len() != self.open_elements.cached_name_counts().len() {
+            valid = false;
+        }
+        for (name, expected) in self.open_elements.cached_name_counts() {
+            if counts.get(name) != Some(expected) {
+                valid = false;
+            }
+        }
+        Ok(valid)
+    }
+
+    fn audit_active_formatting(
+        &self,
+        atoms: &AtomTable,
+        reserve: &mut impl FnMut(ObservationReservationSite) -> Result<(), ()>,
+    ) -> Result<bool, TreeBuilderFinalAuditAllocation> {
+        let mut keys = HashSet::new();
+        reserve(ObservationReservationSite::FinalAuditActiveFormattingIndex)
+            .map_err(|_| TreeBuilderFinalAuditAllocation::ActiveFormattingIndex)?;
+        keys.try_reserve(self.active_formatting.len())
+            .map_err(|_| TreeBuilderFinalAuditAllocation::ActiveFormattingIndex)?;
+        let mut valid = true;
+        for entry in self.active_formatting.entries() {
+            match entry {
+                AfeEntry::Element(element) => {
+                    if element.key == PatchKey::INVALID || !keys.insert(element.key) {
+                        valid = false;
+                    }
+                    let Some(atom_name) = atoms.resolve(element.name) else {
+                        valid = false;
+                        continue;
+                    };
+                    if !self
+                        .live_tree
+                        .element_semantics_for_final_audit(element.key)
+                        .is_some_and(|(name, attrs)| {
+                            name.namespace() == ElementNamespace::Html
+                                && name.local_name().as_str() == atom_name
+                                && parser_created_attribute_lists_equal_ordered(
+                                    &element.attrs,
+                                    attrs,
+                                )
+                        })
+                    {
+                        valid = false;
+                    }
+                }
+                AfeEntry::Marker(marker) => {
+                    let owner = marker.owner;
+                    let Some(owner) = owner else {
+                        valid = false;
+                        continue;
+                    };
+                    let Some((name, _)) = self.live_tree.element_semantics_for_final_audit(owner)
+                    else {
+                        valid = false;
+                        continue;
+                    };
+                    let owner_valid = match marker.kind {
+                        AfeMarkerKind::FormattingBoundary => {
+                            name.namespace() == ElementNamespace::Html
+                                && matches!(
+                                    name.local_name().as_str(),
+                                    "applet" | "marquee" | "object"
+                                )
+                        }
+                        AfeMarkerKind::Caption => name.is(ElementNamespace::Html, "caption"),
+                        AfeMarkerKind::TableCell => {
+                            name.is(ElementNamespace::Html, "td")
+                                || name.is(ElementNamespace::Html, "th")
+                        }
+                        AfeMarkerKind::Template => {
+                            name.is(ElementNamespace::Html, "template")
+                                && self
+                                    .live_tree
+                                    .template_state_for_final_audit(owner)
+                                    .is_some_and(|(is_template, contents, child_count)| {
+                                        is_template && contents.is_some() && child_count == 0
+                                    })
+                        }
+                    };
+                    if !owner_valid {
+                        valid = false;
+                    }
+                }
+            }
+        }
+        Ok(valid)
+    }
+
+    fn audit_template_coordination(
+        &self,
+        reserve: &mut impl FnMut(ObservationReservationSite) -> Result<(), ()>,
+    ) -> Result<bool, TreeBuilderFinalAuditAllocation> {
+        let mut open_templates = HashMap::<PatchKey, usize>::new();
+        reserve(ObservationReservationSite::FinalAuditTemplateCoordinationIndex)
+            .map_err(|_| TreeBuilderFinalAuditAllocation::TemplateCoordinationIndex)?;
+        open_templates
+            .try_reserve(self.open_elements.len())
+            .map_err(|_| TreeBuilderFinalAuditAllocation::TemplateCoordinationIndex)?;
+        let mut open_template_order = Vec::new();
+        reserve(ObservationReservationSite::FinalAuditTemplateCoordinationIndex)
+            .map_err(|_| TreeBuilderFinalAuditAllocation::TemplateCoordinationIndex)?;
+        open_template_order
+            .try_reserve(self.open_elements.len())
+            .map_err(|_| TreeBuilderFinalAuditAllocation::TemplateCoordinationIndex)?;
+        let mut depth = 0usize;
+        let mut valid = true;
+        for entry in self.open_elements.iter_entries() {
+            if entry.namespace() == ElementNamespace::Html
+                && entry.name() == self.known_tags.template
+            {
+                if open_templates.insert(entry.key(), depth).is_some() {
+                    valid = false;
+                }
+                open_template_order.push(entry.key());
+                depth = match depth.checked_add(1) {
+                    Some(next) => next,
+                    None => {
+                        valid = false;
+                        depth
+                    }
+                };
+            }
+        }
+        if depth != self.template_modes.len() {
+            valid = false;
+        }
+        for (index, mode) in self.template_modes.entries().iter().enumerate() {
+            let template_state = self.live_tree.template_state_for_final_audit(mode.owner());
+            if open_templates.get(&mode.owner()) != Some(&index)
+                || !template_state.is_some_and(|(is_template, contents, child_count)| {
+                    is_template && contents.is_some() && child_count == 0
+                })
+            {
+                valid = false;
+            }
+        }
+        let mut marker_owners = HashSet::new();
+        reserve(ObservationReservationSite::FinalAuditTemplateCoordinationIndex)
+            .map_err(|_| TreeBuilderFinalAuditAllocation::TemplateCoordinationIndex)?;
+        marker_owners
+            .try_reserve(self.active_formatting.len())
+            .map_err(|_| TreeBuilderFinalAuditAllocation::TemplateCoordinationIndex)?;
+        let mut open_marker_order = Vec::new();
+        reserve(ObservationReservationSite::FinalAuditTemplateCoordinationIndex)
+            .map_err(|_| TreeBuilderFinalAuditAllocation::TemplateCoordinationIndex)?;
+        open_marker_order
+            .try_reserve(self.active_formatting.len())
+            .map_err(|_| TreeBuilderFinalAuditAllocation::TemplateCoordinationIndex)?;
+        for entry in self.active_formatting.entries() {
+            if let AfeEntry::Marker(marker) = entry
+                && marker.kind == AfeMarkerKind::Template
+            {
+                let Some(owner) = marker.owner else {
+                    valid = false;
+                    continue;
+                };
+                if !marker_owners.insert(owner) {
+                    valid = false;
+                }
+                if open_templates.contains_key(&owner) {
+                    open_marker_order.push(owner);
+                } else if !self
+                    .live_tree
+                    .template_state_for_final_audit(owner)
+                    .is_some_and(|(is_template, contents, _)| is_template && contents.is_some())
+                {
+                    // EOF recovery deliberately permits diagnostic markers for
+                    // already-closed template hosts. Their typed owner must
+                    // still name a live template association.
+                    valid = false;
+                }
+            }
+        }
+        if open_marker_order.as_slice() != open_template_order.as_slice() {
+            valid = false;
+        }
+        Ok(valid)
+    }
+}
diff --git a/crates/html/src/html5/tree_builder/formatting.rs b/crates/html/src/html5/tree_builder/formatting.rs
index 4ac64ae6..1378fee6 100644
--- a/crates/html/src/html5/tree_builder/formatting.rs
+++ b/crates/html/src/html5/tree_builder/formatting.rs
@@ -158,6 +158,99 @@ impl ActiveFormattingList {
         marker.owner = owner;
     }
 
+    #[cfg(test)]
+    pub(in crate::html5::tree_builder) fn corrupt_marker_owner_for_test(
+        &mut self,
+        kind: AfeMarkerKind,
+        owner: Option<PatchKey>,
+    ) {
+        let marker = self
+            .items
+            .iter_mut()
+            .rev()
+            .find_map(|entry| match entry {
+                AfeEntry::Marker(marker) if marker.kind == kind => Some(marker),
+                _ => None,
+            })
+            .expect("requested production marker");
+        marker.owner = owner;
+    }
+
+    #[cfg(test)]
+    pub(in crate::html5::tree_builder) fn corrupt_element_for_test(
+        &mut self,
+        mutate: impl FnOnce(&mut AfeElementEntry),
+    ) {
+        let element = self
+            .items
+            .iter_mut()
+            .rev()
+            .find_map(|entry| match entry {
+                AfeEntry::Element(element) => Some(element),
+                AfeEntry::Marker(_) => None,
+            })
+            .expect("requested production AFE element");
+        mutate(element);
+    }
+
+    #[cfg(test)]
+    pub(in crate::html5::tree_builder) fn remove_template_marker_at_for_test(
+        &mut self,
+        index: usize,
+    ) {
+        let marker_index = self
+            .items
+            .iter()
+            .enumerate()
+            .filter_map(|(index, entry)| match entry {
+                AfeEntry::Marker(marker) if marker.kind == AfeMarkerKind::Template => Some(index),
+                _ => None,
+            })
+            .nth(index)
+            .expect("template marker index");
+        self.items.remove(marker_index);
+    }
+
+    #[cfg(test)]
+    pub(in crate::html5::tree_builder) fn insert_template_marker_at_for_test(
+        &mut self,
+        index: usize,
+        owner: PatchKey,
+    ) {
+        let marker_index = self
+            .items
+            .iter()
+            .enumerate()
+            .filter_map(|(index, entry)| match entry {
+                AfeEntry::Marker(marker) if marker.kind == AfeMarkerKind::Template => Some(index),
+                _ => None,
+            })
+            .nth(index)
+            .unwrap_or(self.items.len());
+        self.items.insert(
+            marker_index,
+            AfeEntry::Marker(AfeMarker::new(AfeMarkerKind::Template, Some(owner))),
+        );
+    }
+
+    #[cfg(test)]
+    pub(in crate::html5::tree_builder) fn swap_template_markers_for_test(
+        &mut self,
+        left: usize,
+        right: usize,
+    ) {
+        let indices = self
+            .items
+            .iter()
+            .enumerate()
+            .filter_map(|(index, entry)| match entry {
+                AfeEntry::Marker(marker) if marker.kind == AfeMarkerKind::Template => Some(index),
+                _ => None,
+            })
+            .collect::<Vec<_>>();
+        self.items.swap(indices[left], indices[right]);
+    }
+
     /// Pushes a formatting element entry while enforcing the HTML5 Noah's Ark
     /// duplicate bound within the suffix after the last marker.
     ///
diff --git a/crates/html/src/html5/tree_builder/invariants/model.rs b/crates/html/src/html5/tree_builder/invariants/model.rs
index c7302a96..8fb7419f 100644
--- a/crates/html/src/html5/tree_builder/invariants/model.rs
+++ b/crates/html/src/html5/tree_builder/invariants/model.rs
@@ -45,12 +45,12 @@ impl DomInvariantNodeKind {
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct DomInvariantNode {
-    pub(in crate::html5::tree_builder) kind: DomInvariantNodeKind,
-    pub(in crate::html5::tree_builder) parent: Option<PatchKey>,
-    pub(in crate::html5::tree_builder) children: Vec<PatchKey>,
-    pub(in crate::html5::tree_builder) template_contents: Option<PatchKey>,
-    pub(in crate::html5::tree_builder) fragment_host: Option<PatchKey>,
-    pub(in crate::html5::tree_builder) is_template_element: bool,
+    pub(crate) kind: DomInvariantNodeKind,
+    pub(crate) parent: Option<PatchKey>,
+    pub(crate) children: Vec<PatchKey>,
+    pub(crate) template_contents: Option<PatchKey>,
+    pub(crate) fragment_host: Option<PatchKey>,
+    pub(crate) is_template_element: bool,
 }
 
 impl DomInvariantNode {
@@ -82,8 +82,8 @@ impl DomInvariantNode {
 
 #[derive(Clone, Debug, Default, PartialEq, Eq)]
 pub struct DomInvariantState {
-    pub(in crate::html5::tree_builder) nodes: Vec<Option<DomInvariantNode>>,
-    pub(in crate::html5::tree_builder) root: Option<PatchKey>,
+    pub(crate) nodes: Vec<Option<DomInvariantNode>>,
+    pub(crate) root: Option<PatchKey>,
 }
 
 impl DomInvariantState {
diff --git a/crates/html/src/html5/tree_builder/live_tree.rs b/crates/html/src/html5/tree_builder/live_tree.rs
index e1e87b5c..812b3b67 100644
--- a/crates/html/src/html5/tree_builder/live_tree.rs
+++ b/crates/html/src/html5/tree_builder/live_tree.rs
@@ -86,7 +86,150 @@ pub(in crate::html5::tree_builder) struct LiveTree {
     root: Option<PatchKey>,
 }
 
+#[cfg(feature = "parser-conformance")]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(in crate::html5::tree_builder) struct LiveTreeFinalAudit {
+    pub(in crate::html5::tree_builder) parent_child_links_valid: bool,
+    pub(in crate::html5::tree_builder) namespaces_valid: bool,
+    pub(in crate::html5::tree_builder) template_associations_valid: bool,
+}
+
 impl LiveTree {
+    #[cfg(feature = "parser-conformance")]
+    pub(in crate::html5::tree_builder) fn try_final_audit(
+        &self,
+        reserve: &mut impl FnMut(crate::conformance::ObservationReservationSite) -> Result<(), ()>,
+    ) -> Result<LiveTreeFinalAudit, ()> {
+        use std::collections::HashSet;
+
+        let mut visited = HashSet::new();
+        reserve(crate::conformance::ObservationReservationSite::FinalAuditDomStructuralTraversal)?;
+        visited.try_reserve(self.nodes.len()).map_err(|_| ())?;
+        let mut stack = Vec::new();
+        if let Some(root) = self.root {
+            reserve(
+                crate::conformance::ObservationReservationSite::FinalAuditDomStructuralTraversal,
+            )?;
+            stack.try_reserve(1).map_err(|_| ())?;
+            stack.push((root, None));
+        }
+
+        let mut parent_child_links_valid =
+            self.root.is_some() || self.nodes.iter().all(Option::is_none);
+        let mut namespaces_valid = true;
+        let mut template_associations_valid = true;
+        while let Some((key, expected_parent)) = stack.pop() {
+            if key == PatchKey::INVALID || !visited.insert(key) {
+                parent_child_links_valid = false;
+                continue;
+            }
+            let Some(index) = usize::try_from(key.0).ok() else {
+                parent_child_links_valid = false;
+                continue;
+            };
+            let Some(node) = self.nodes.get(index).and_then(Option::as_ref) else {
+                parent_child_links_valid = false;
+                continue;
+            };
+            if node.parent != expected_parent {
+                parent_child_links_valid = false;
+            }
+            match node.kind {
+                LiveNodeKind::Element => {
+                    if let Some(name) = node.expanded_name.as_ref() {
+                        if node.is_template_element != name.is(ElementNamespace::Html, "template") {
+                            namespaces_valid = false;
+                        }
+                    } else {
+                        namespaces_valid = false;
+                    }
+                    // Qualified attribute namespace/prefix shapes are valid by
+                    // construction; the audit consumes the typed values and
+                    // never reparses qualified-name strings.
+                    for attribute in &node.attributes {
+                        let _ = (
+                            attribute.name().namespace(),
+                            attribute.name().prefix(),
+                            attribute.name().local_name(),
+                        );
+                    }
+                }
+                LiveNodeKind::Document
+                | LiveNodeKind::DocumentType
+                | LiveNodeKind::DocumentFragment(_)
+                | LiveNodeKind::Text
+                | LiveNodeKind::Comment
+                | LiveNodeKind::ProcessingInstruction => {
+                    if node.expanded_name.is_some() {
+                        namespaces_valid = false;
+                    }
+                }
+            }
+            for child in node.children.iter().rev() {
+                reserve(crate::conformance::ObservationReservationSite::FinalAuditDomStructuralTraversal)?;
+                stack.try_reserve(1).map_err(|_| ())?;
+                stack.push((*child, Some(key)));
+            }
+            match (node.kind, node.template_contents, node.fragment_host) {
+                (LiveNodeKind::Element, Some(contents), None) if node.is_template_element => {
+                    if !node.children.is_empty() {
+                        // Parser-created template hosts keep ordinary children
+                        // out of the host; content belongs to the associated
+                        // template-contents fragment.
+                        template_associations_valid = false;
+                    }
+                    let association = usize::try_from(contents.0)
+                        .ok()
+                        .and_then(|index| self.nodes.get(index))
+                        .and_then(Option::as_ref)
+                        .is_some_and(|contents_node| {
+                            contents_node.kind
+                                == LiveNodeKind::DocumentFragment(
+                                    ParserCreatedFragmentKind::TemplateContents,
+                                )
+                                && contents_node.fragment_host == Some(key)
+                                && contents_node.parent.is_none()
+                        });
+                    if !association {
+                        template_associations_valid = false;
+                    }
+                    reserve(crate::conformance::ObservationReservationSite::FinalAuditDomStructuralTraversal)?;
+                    stack.try_reserve(1).map_err(|_| ())?;
+                    stack.push((contents, None));
+                }
+                (LiveNodeKind::Element, None, None) if !node.is_template_element => {}
+                (
+                    LiveNodeKind::DocumentFragment(ParserCreatedFragmentKind::TemplateContents),
+                    None,
+                    Some(host),
+                ) => {
+                    if usize::try_from(host.0)
+                        .ok()
+                        .and_then(|index| self.nodes.get(index))
+                        .and_then(Option::as_ref)
+                        .and_then(|host_node| host_node.template_contents)
+                        != Some(key)
+                    {
+                        template_associations_valid = false;
+                    }
+                }
+                (LiveNodeKind::Document, None, None)
+                | (LiveNodeKind::DocumentType, None, None)
+                | (LiveNodeKind::Text, None, None)
+                | (LiveNodeKind::Comment, None, None)
+                | (LiveNodeKind::ProcessingInstruction, None, None) => {}
+                _ => template_associations_valid = false,
+            }
+        }
+        if visited.len() != self.nodes.iter().filter(|node| node.is_some()).count() {
+            parent_child_links_valid = false;
+        }
+        Ok(LiveTreeFinalAudit {
+            parent_child_links_valid,
+            namespaces_valid,
+            template_associations_valid,
+        })
+    }
     pub(in crate::html5::tree_builder) fn try_reserve_through_key(
         &mut self,
         key: PatchKey,
@@ -225,6 +368,31 @@ impl LiveTree {
         self.node_mut(host).template_contents = None;
     }
 
+    #[cfg(test)]
+    pub(in crate::html5::tree_builder) fn corrupt_element_name_for_test(
+        &mut self,
+        key: PatchKey,
+        name: ExpandedElementName,
+    ) {
+        self.node_mut(key).expanded_name = Some(name);
+    }
+
+    #[cfg(test)]
+    pub(in crate::html5::tree_builder) fn corrupt_template_host_with_ordinary_child_for_test(
+        &mut self,
+        host: PatchKey,
+        name: ExpandedElementName,
+    ) {
+        let child = PatchKey(
+            u32::try_from(self.nodes.len()).expect("test live-tree key space must fit in u32"),
+        );
+        let mut node = LiveNode::new(LiveNodeKind::Element);
+        node.parent = Some(host);
+        node.expanded_name = Some(name);
+        self.nodes.push(Some(node));
+        self.node_mut(host).children.push(child);
+    }
+
     pub(in crate::html5::tree_builder) fn is_template_element(&self, key: PatchKey) -> bool {
         self.node(key).is_template_element
     }
@@ -239,6 +407,32 @@ impl LiveTree {
             .map(|name| (name, node.attributes.as_slice()))
     }
 
+    #[cfg(feature = "parser-conformance")]
+    pub(in crate::html5::tree_builder) fn element_semantics_for_final_audit(
+        &self,
+        key: PatchKey,
+    ) -> Option<(&ExpandedElementName, &[ParserCreatedAttribute])> {
+        let index = usize::try_from(key.0).ok()?;
+        let node = self.nodes.get(index)?.as_ref()?;
+        node.expanded_name
+            .as_ref()
+            .map(|name| (name, node.attributes.as_slice()))
+    }
+
+    #[cfg(feature = "parser-conformance")]
+    pub(in crate::html5::tree_builder) fn template_state_for_final_audit(
+        &self,
+        key: PatchKey,
+    ) -> Option<(bool, Option<PatchKey>, usize)> {
+        let index = usize::try_from(key.0).ok()?;
+        let node = self.nodes.get(index)?.as_ref()?;
+        Some((
+            node.is_template_element,
+            node.template_contents,
+            node.children.len(),
+        ))
+    }
+
     pub(in crate::html5::tree_builder) fn contains(&self, key: PatchKey) -> bool {
         key != PatchKey::INVALID && self.nodes.get(key.0 as usize).is_some_and(Option::is_some)
     }
@@ -300,6 +494,54 @@ impl LiveTree {
         state
     }
 
+    #[cfg(feature = "parser-conformance")]
+    pub(in crate::html5::tree_builder) fn try_invariant_state_for_final_audit(
+        &self,
+        reserve: &mut impl FnMut(crate::conformance::ObservationReservationSite) -> Result<(), ()>,
+    ) -> Result<DomInvariantState, ()> {
+        let mut nodes = Vec::new();
+        reserve(
+            crate::conformance::ObservationReservationSite::FinalAuditLiveTreeStructuralProjection,
+        )?;
+        nodes.try_reserve_exact(self.nodes.len()).map_err(|_| ())?;
+        nodes.resize_with(self.nodes.len(), || None);
+        for (index, maybe_node) in self.nodes.iter().enumerate() {
+            let Some(node) = maybe_node else {
+                continue;
+            };
+            let mut children = Vec::new();
+            reserve(crate::conformance::ObservationReservationSite::FinalAuditLiveTreeStructuralProjection)?;
+            children
+                .try_reserve_exact(node.children.len())
+                .map_err(|_| ())?;
+            children.extend_from_slice(&node.children);
+            let kind = match node.kind {
+                LiveNodeKind::Document => DomInvariantNodeKind::Document,
+                LiveNodeKind::DocumentType => DomInvariantNodeKind::DocumentType,
+                LiveNodeKind::Element => DomInvariantNodeKind::Element,
+                LiveNodeKind::DocumentFragment(kind) => {
+                    DomInvariantNodeKind::DocumentFragment(kind)
+                }
+                LiveNodeKind::Text => DomInvariantNodeKind::Text,
+                LiveNodeKind::Comment => DomInvariantNodeKind::Comment,
+                LiveNodeKind::ProcessingInstruction => DomInvariantNodeKind::ProcessingInstruction,
+            };
+            let slot = nodes.get_mut(index).ok_or(())?;
+            *slot = Some(DomInvariantNode {
+                kind,
+                parent: node.parent,
+                children,
+                template_contents: node.template_contents,
+                fragment_host: node.fragment_host,
+                is_template_element: node.is_template_element,
+            });
+        }
+        Ok(DomInvariantState {
+            nodes,
+            root: self.root,
+        })
+    }
+
     fn insert_node(&mut self, key: PatchKey, kind: LiveNodeKind) {
         assert_ne!(key, PatchKey::INVALID, "live tree keys must be non-zero");
         self.ensure_slot(key);
diff --git a/crates/html/src/html5/tree_builder/mod.rs b/crates/html/src/html5/tree_builder/mod.rs
index 3f6f2574..3720db79 100644
--- a/crates/html/src/html5/tree_builder/mod.rs
+++ b/crates/html/src/html5/tree_builder/mod.rs
@@ -13,6 +13,8 @@ mod body_recovery;
 mod coalescing;
 mod dispatch;
 pub(crate) mod document;
+#[cfg(feature = "parser-conformance")]
+mod final_audit;
 mod foreign;
 mod formatting;
 #[cfg(any(test, feature = "html5-fuzzing"))]
@@ -42,6 +44,8 @@ pub use api::{
     Html5TreeBuilder, SuspendReason, TreeBuilderConfig, TreeBuilderControlFlow, TreeBuilderError,
     TreeBuilderInternalError, TreeBuilderLimits, TreeBuilderStepResult,
 };
+#[cfg(feature = "parser-conformance")]
+pub(crate) use final_audit::{TreeBuilderFinalAudit, TreeBuilderFinalAuditAllocation};
 #[cfg(any(test, feature = "html5-fuzzing"))]
 pub(crate) use formatting::AfeDiagnosticEntry;
 #[cfg(test)]
diff --git a/crates/html/src/html5/tree_builder/stack/mod.rs b/crates/html/src/html5/tree_builder/stack/mod.rs
index 1ece283d..ee7ca186 100644
--- a/crates/html/src/html5/tree_builder/stack/mod.rs
+++ b/crates/html/src/html5/tree_builder/stack/mod.rs
@@ -10,6 +10,8 @@ mod types;
 mod tests;
 
 pub(crate) use open_elements::OpenElementsStack;
+#[cfg(feature = "parser-conformance")]
+pub(crate) use types::ExpandedNameKey;
 pub(crate) use types::{
     ExactOpenElementRemoval, InBodyEndTagScan, OpenElement, ScopeKeyMatch, ScopeKind, ScopeTagSet,
 };
diff --git a/crates/html/src/html5/tree_builder/stack/open_elements.rs b/crates/html/src/html5/tree_builder/stack/open_elements.rs
index 9b067d5c..aacae3cf 100644
--- a/crates/html/src/html5/tree_builder/stack/open_elements.rs
+++ b/crates/html/src/html5/tree_builder/stack/open_elements.rs
@@ -269,11 +269,21 @@ impl OpenElementsStack {
         self.items.iter().map(|entry| entry.name())
     }
 
-    #[cfg(any(test, feature = "parser_invariants", feature = "html5-fuzzing"))]
+    #[cfg(any(
+        test,
+        feature = "parser_invariants",
+        feature = "html5-fuzzing",
+        feature = "parser-conformance"
+    ))]
     pub(crate) fn iter_entries(&self) -> impl Iterator<Item = OpenElement> + '_ {
         self.items.iter().copied()
     }
 
+    #[cfg(feature = "parser-conformance")]
+    pub(crate) fn cached_name_counts(&self) -> &[(ExpandedNameKey, usize)] {
+        &self.name_counts
+    }
+
     #[cfg(any(test, feature = "parser_invariants", feature = "html5-fuzzing"))]
     pub(crate) fn name_cache_matches_stack(&self) -> bool {
         let mut expected = Vec::<(ExpandedNameKey, usize)>::new();
diff --git a/crates/html/src/html5/tree_builder/template_state.rs b/crates/html/src/html5/tree_builder/template_state.rs
index b796c205..081ffa67 100644
--- a/crates/html/src/html5/tree_builder/template_state.rs
+++ b/crates/html/src/html5/tree_builder/template_state.rs
@@ -127,6 +127,15 @@ impl TemplateModeStack {
         self.entries.last_mut().expect("open template mode").owner = owner;
     }
 
+    #[cfg(test)]
+    pub(in crate::html5::tree_builder) fn swap_entries_for_test(
+        &mut self,
+        left: usize,
+        right: usize,
+    ) {
+        self.entries.swap(left, right);
+    }
+
     #[cfg(any(test, feature = "internal-api", feature = "html5-fuzzing"))]
     pub(in crate::html5::tree_builder) fn snapshot(
         &self,
diff --git a/crates/html/src/html5/tree_builder/tests/invariants.rs b/crates/html/src/html5/tree_builder/tests/invariants.rs
index 5162f2d6..5297b142 100644
--- a/crates/html/src/html5/tree_builder/tests/invariants.rs
+++ b/crates/html/src/html5/tree_builder/tests/invariants.rs
@@ -47,3 +47,486 @@ fn tree_builder_rejects_foreign_atom_table() {
         "builder should remain usable with its bound atom table after rejection"
     );
 }
+
+#[cfg(feature = "parser-conformance")]
+mod final_audit_tests {
+    use super::super::helpers::{EmptyResolver, enter_in_body};
+    use crate::attributes::{ParserCreatedAttribute, QualifiedAttributeName};
+    use crate::dom_patch::PatchKey;
+    use crate::html5::shared::{Attribute, AttributeValue, DocumentParseContext, Token};
+    use crate::html5::tree_builder::formatting::{AfeEntry, AfeMarkerKind};
+    use crate::html5::tree_builder::{Html5TreeBuilder, TreeBuilderConfig};
+    use crate::{ElementNamespace, ExpandedElementName};
+
+    fn audit(
+        builder: &Html5TreeBuilder,
+        context: &DocumentParseContext,
+    ) -> crate::html5::tree_builder::TreeBuilderFinalAudit {
+        let mut reserve = |_| Ok(());
+        builder
+            .final_audit_for_conformance(&context.atoms, &mut reserve)
+            .expect("final audit should not allocate in the corruption tests")
+    }
+
+    fn builder_in_body() -> (Html5TreeBuilder, DocumentParseContext) {
+        let mut context = DocumentParseContext::with_tree_observations_for_test();
+        let resolver = EmptyResolver;
+        let mut builder = Html5TreeBuilder::new(TreeBuilderConfig::default(), &mut context)
+            .expect("tree builder init");
+        let _ = enter_in_body(&mut builder, &mut context, &resolver);
+        (builder, context)
+    }
+
+    fn process(builder: &mut Html5TreeBuilder, context: &mut DocumentParseContext, token: Token) {
+        let _ = builder
+            .process(
+                &token,
+                &mut crate::html5::tree_builder::TreeBuilderProcessContext::new(context),
+                &EmptyResolver,
+            )
+            .expect("production construction should remain recoverable");
+    }
+
+    fn formatting_builder() -> (Html5TreeBuilder, DocumentParseContext) {
+        let (mut builder, mut context) = builder_in_body();
+        let b = context.atoms.intern_ascii_folded("b").expect("b atom");
+        let href = context
+            .atoms
+            .intern_ascii_folded("href")
+            .expect("href atom");
+        let title = context
+            .atoms
+            .intern_ascii_folded("title")
+            .expect("title atom");
+        process(
+            &mut builder,
+            &mut context,
+            Token::StartTag {
+                name: b,
+                attrs: vec![
+                    Attribute {
+                        name: href,
+                        value: AttributeValue::Owned("one".to_owned()),
+                    },
+                    Attribute {
+                        name: title,
+                        value: AttributeValue::Owned("two".to_owned()),
+                    },
+                ],
+                self_closing: false,
+            },
+        );
+        let _ = builder.drain_patches();
+        (builder, context)
+    }
+
+    #[test]
+    fn final_audit_active_formatting_requires_exact_live_attributes_and_unique_keys() {
+        enum Mutation {
+            Value,
+            LocalName,
+            Prefix,
+            Reorder,
+            Remove,
+            Extra,
+        }
+
+        for mutation in [
+            Mutation::Value,
+            Mutation::LocalName,
+            Mutation::Prefix,
+            Mutation::Reorder,
+            Mutation::Remove,
+            Mutation::Extra,
+        ] {
+            let (mut builder, mut context) = formatting_builder();
+            let replacement = context
+                .atoms
+                .intern_ascii_folded("replacement")
+                .expect("replacement atom");
+            let replacement_local = context
+                .atoms
+                .resolve_local_name(replacement)
+                .expect("replacement local");
+            let href = context
+                .atoms
+                .intern_ascii_folded("href")
+                .expect("href atom");
+            builder
+                .active_formatting
+                .corrupt_element_for_test(|element| match mutation {
+                    Mutation::Value => {
+                        let attribute = element.attrs[0].clone();
+                        element.attrs[0] = ParserCreatedAttribute::new(
+                            attribute.name().clone(),
+                            "changed".to_owned(),
+                        );
+                    }
+                    Mutation::LocalName => {
+                        let attribute = element.attrs[0].clone();
+                        element.attrs[0] = ParserCreatedAttribute::new(
+                            QualifiedAttributeName::unqualified(replacement_local.clone()),
+                            attribute.value().to_owned(),
+                        );
+                    }
+                    Mutation::Prefix => {
+                        let attribute = element.attrs[0].clone();
+                        let href_local =
+                            context.atoms.resolve_local_name(href).expect("href local");
+                        element.attrs[0] = ParserCreatedAttribute::new(
+                            QualifiedAttributeName::xlink(href_local),
+                            attribute.value().to_owned(),
+                        );
+                    }
+                    Mutation::Reorder => element.attrs.reverse(),
+                    Mutation::Remove => {
+                        element.attrs.pop();
+                    }
+                    Mutation::Extra => element.attrs.push(ParserCreatedAttribute::new(
+                        QualifiedAttributeName::unqualified(replacement_local.clone()),
+                        "extra".to_owned(),
+                    )),
+                });
+            let result = audit(&builder, &context);
+            assert!(!result.active_formatting_consistent, "mutation must fail");
+        }
+
+        let (mut builder, context) = formatting_builder();
+        let (key, live_attrs) = builder
+            .active_formatting
+            .entries()
+            .iter()
+            .find_map(|entry| match entry {
+                AfeEntry::Element(element) => builder
+                    .live_tree
+                    .element_semantics_for_final_audit(element.key)
+                    .map(|(_, attrs)| (element.key, attrs.to_vec())),
+                AfeEntry::Marker(_) => None,
+            })
+            .expect("production formatting element");
+        let _ = key;
+        builder
+            .active_formatting
+            .corrupt_element_for_test(|element| {
+                element.attrs.reverse();
+                assert!(
+                    crate::html5::tree_builder::attributes::same_attributes_for_html_parser(
+                        &element.attrs,
+                        &live_attrs,
+                    )
+                );
+            });
+        let report = audit(&builder, &context);
+        assert!(!report.active_formatting_consistent);
+        assert!(report.parent_child_links_valid);
+        assert!(report.template_associations_valid);
+
+        let (mut builder, mut context) = formatting_builder();
+        let i = context.atoms.intern_ascii_folded("i").expect("i atom");
+        process(
+            &mut builder,
+            &mut context,
+            Token::StartTag {
+                name: i,
+                attrs: Vec::new(),
+                self_closing: false,
+            },
+        );
+        let first_key = builder
+            .active_formatting
+            .entries()
+            .iter()
+            .find_map(|entry| match entry {
+                AfeEntry::Element(element) => Some(element.key),
+                AfeEntry::Marker(_) => None,
+            })
+            .expect("first formatting element");
+        builder
+            .active_formatting
+            .corrupt_element_for_test(|element| {
+                element.key = first_key;
+            });
+        assert!(!audit(&builder, &context).active_formatting_consistent);
+    }
+
+    fn marker_builder(kind: AfeMarkerKind) -> (Html5TreeBuilder, DocumentParseContext, PatchKey) {
+        let (mut builder, mut context) = builder_in_body();
+        match kind {
+            AfeMarkerKind::FormattingBoundary => {
+                let applet = context
+                    .atoms
+                    .intern_ascii_folded("applet")
+                    .expect("applet atom");
+                process(
+                    &mut builder,
+                    &mut context,
+                    Token::StartTag {
+                        name: applet,
+                        attrs: Vec::new(),
+                        self_closing: false,
+                    },
+                );
+            }
+            AfeMarkerKind::Caption => {
+                let table = context
+                    .atoms
+                    .intern_ascii_folded("table")
+                    .expect("table atom");
+                let caption = context
+                    .atoms
+                    .intern_ascii_folded("caption")
+                    .expect("caption atom");
+                process(
+                    &mut builder,
+                    &mut context,
+                    Token::StartTag {
+                        name: table,
+                        attrs: Vec::new(),
+                        self_closing: false,
+                    },
+                );
+                process(
+                    &mut builder,
+                    &mut context,
+                    Token::StartTag {
+                        name: caption,
+                        attrs: Vec::new(),
+                        self_closing: false,
+                    },
+                );
+            }
+            AfeMarkerKind::TableCell => {
+                for name in ["table", "tbody", "tr", "td"] {
+                    let name = context.atoms.intern_ascii_folded(name).expect("table atom");
+                    process(
+                        &mut builder,
+                        &mut context,
+                        Token::StartTag {
+                            name,
+                            attrs: Vec::new(),
+                            self_closing: false,
+                        },
+                    );
+                }
+            }
+            AfeMarkerKind::Template => {
+                let template = context
+                    .atoms
+                    .intern_ascii_folded("template")
+                    .expect("template atom");
+                process(
+                    &mut builder,
+                    &mut context,
+                    Token::StartTag {
+                        name: template,
+                        attrs: Vec::new(),
+                        self_closing: false,
+                    },
+                );
+            }
+        }
+        let owner = builder
+            .active_formatting
+            .entries()
+            .iter()
+            .rev()
+            .find_map(|entry| match entry {
+                AfeEntry::Marker(marker) if marker.kind == kind => marker.owner,
+                _ => None,
+            })
+            .expect("production marker owner");
+        let _ = builder.drain_patches();
+        (builder, context, owner)
+    }
+
+    #[test]
+    fn final_audit_validates_each_marker_owner_kind_and_namespace() {
+        for kind in [
+            AfeMarkerKind::FormattingBoundary,
+            AfeMarkerKind::Caption,
+            AfeMarkerKind::TableCell,
+            AfeMarkerKind::Template,
+        ] {
+            for corruption in 0..5 {
+                let (mut builder, context, owner) = marker_builder(kind);
+                match corruption {
+                    0 => builder
+                        .active_formatting
+                        .corrupt_marker_owner_for_test(kind, None),
+                    1 => builder
+                        .active_formatting
+                        .corrupt_marker_owner_for_test(kind, Some(PatchKey::INVALID)),
+                    2 => {
+                        let body = builder
+                            .state_snapshot()
+                            .open_element_keys
+                            .into_iter()
+                            .find(|key| {
+                                builder
+                                    .live_tree
+                                    .element_semantics_for_final_audit(*key)
+                                    .is_some_and(|(name, _)| name.is_html("body"))
+                            })
+                            .expect("body owner");
+                        builder
+                            .active_formatting
+                            .corrupt_marker_owner_for_test(kind, Some(body));
+                    }
+                    3 => {
+                        builder
+                            .active_formatting
+                            .corrupt_marker_owner_for_test(kind, builder.document_key);
+                    }
+                    4 => {
+                        let (name, _) = builder
+                            .live_tree
+                            .element_semantics_for_final_audit(owner)
+                            .expect("marker owner");
+                        builder.live_tree.corrupt_element_name_for_test(
+                            owner,
+                            ExpandedElementName::new(
+                                ElementNamespace::Svg,
+                                name.local_name().clone(),
+                            ),
+                        );
+                    }
+                    _ => unreachable!(),
+                }
+                assert!(
+                    !audit(&builder, &context).active_formatting_consistent,
+                    "marker corruption {corruption} for {kind:?} must fail"
+                );
+            }
+        }
+    }
+
+    fn nested_template_builder() -> (
+        Html5TreeBuilder,
+        DocumentParseContext,
+        PatchKey,
+        PatchKey,
+        PatchKey,
+    ) {
+        let (mut builder, mut context) = builder_in_body();
+        let template = context
+            .atoms
+            .intern_ascii_folded("template")
+            .expect("template atom");
+        process(
+            &mut builder,
+            &mut context,
+            Token::StartTag {
+                name: template,
+                attrs: Vec::new(),
+                self_closing: false,
+            },
+        );
+        let outer = builder
+            .template_modes
+            .current()
+            .expect("outer mode")
+            .owner();
+        process(
+            &mut builder,
+            &mut context,
+            Token::StartTag {
+                name: template,
+                attrs: Vec::new(),
+                self_closing: false,
+            },
+        );
+        let closed = builder
+            .template_modes
+            .current()
+            .expect("inner mode")
+            .owner();
+        process(&mut builder, &mut context, Token::EndTag { name: template });
+        process(
+            &mut builder,
+            &mut context,
+            Token::StartTag {
+                name: template,
+                attrs: Vec::new(),
+                self_closing: false,
+            },
+        );
+        let open = builder
+            .template_modes
+            .current()
+            .expect("second mode")
+            .owner();
+        let _ = builder.drain_patches();
+        (builder, context, outer, closed, open)
+    }
+
+    #[test]
+    fn final_audit_compares_open_template_ordinals_and_ignores_valid_residual_markers() {
+        let (mut builder, context, _, _, _) = nested_template_builder();
+        builder
+            .active_formatting
+            .remove_template_marker_at_for_test(1);
+        assert!(!audit(&builder, &context).template_modes_consistent);
+
+        let (mut builder, context, outer, _, _) = nested_template_builder();
+        builder
+            .active_formatting
+            .insert_template_marker_at_for_test(2, outer);
+        assert!(!audit(&builder, &context).template_modes_consistent);
+
+        let (mut builder, context, _, _, _) = nested_template_builder();
+        builder
+            .active_formatting
+            .swap_template_markers_for_test(0, 1);
+        assert!(!audit(&builder, &context).template_modes_consistent);
+
+        let (mut builder, context, _, _, _) = nested_template_builder();
+        builder
+            .template_modes
+            .corrupt_current_owner_for_test(PatchKey::INVALID);
+        assert!(!audit(&builder, &context).template_modes_consistent);
+
+        let (mut builder, context, _, _, _) = nested_template_builder();
+        builder.template_modes.swap_entries_for_test(0, 1);
+        assert!(!audit(&builder, &context).template_modes_consistent);
+
+        for position in 0..=2 {
+            let (mut builder, context, _, closed, _) = nested_template_builder();
+            builder
+                .active_formatting
+                .insert_template_marker_at_for_test(position, closed);
+            assert!(audit(&builder, &context).template_modes_consistent);
+        }
+    }
+
+    #[test]
+    fn final_audit_rejects_template_hosts_with_ordinary_children() {
+        let (mut builder, mut context) = builder_in_body();
+        let template = context
+            .atoms
+            .intern_ascii_folded("template")
+            .expect("template atom");
+        let div = context.atoms.intern_ascii_folded("div").expect("div atom");
+        process(
+            &mut builder,
+            &mut context,
+            Token::StartTag {
+                name: template,
+                attrs: Vec::new(),
+                self_closing: false,
+            },
+        );
+        let host = builder
+            .template_modes
+            .current()
+            .expect("template mode")
+            .owner();
+        let div_name = ExpandedElementName::new(
+            ElementNamespace::Html,
+            context.atoms.resolve_local_name(div).expect("div local"),
+        );
+        builder
+            .live_tree
+            .corrupt_template_host_with_ordinary_child_for_test(host, div_name);
+        assert!(!audit(&builder, &context).template_associations_valid);
+    }
+}
diff --git a/crates/html/src/parser/mod.rs b/crates/html/src/parser/mod.rs
index d40ed1e2..9936500e 100644
--- a/crates/html/src/parser/mod.rs
+++ b/crates/html/src/parser/mod.rs
@@ -19,4 +19,8 @@ pub use self::options::{
 };
 pub use self::output::ParseOutput;
 pub use self::session::HtmlParser;
+#[cfg(feature = "parser-conformance")]
+pub(crate) use self::session::{
+    ConformanceFinalizationError, ConformanceFinalizedOutput, PatchMaterializationWitness,
+};
 pub use self::types::{HtmlParseCounters, HtmlParseError, HtmlParseEvent};
diff --git a/crates/html/src/parser/session.rs b/crates/html/src/parser/session.rs
index db02f82e..f9b30d8c 100644
--- a/crates/html/src/parser/session.rs
+++ b/crates/html/src/parser/session.rs
@@ -1,5 +1,9 @@
+#[cfg(feature = "parser-conformance")]
+use crate::conformance::{ObservationReservationSite, ObservationResourceExhaustion};
 use crate::dom_patch::{DomPatch, DomPatchBatch};
 use crate::html5::Html5ParseSession;
+#[cfg(feature = "parser-conformance")]
+use crate::html5::Html5SessionFinalAudit;
 use crate::html5::ParserFatalError;
 use crate::html5::shared::DocumentParseContext;
 #[cfg(all(
@@ -10,6 +14,8 @@ use crate::html5::shared::ParserFailureInjection;
 #[cfg(feature = "parser-conformance")]
 use crate::html5::shared::{ParserObservationCapture, ParserObservationConfig};
 #[cfg(feature = "parser-conformance")]
+use crate::html5::tree_builder::TreeBuilderFinalAuditAllocation;
+#[cfg(feature = "parser-conformance")]
 use crate::html5::{PatchHistoryObservationConfig, RawPatchHistoryCapture};
 use crate::patch_validation::PatchValidationArena;
 
@@ -50,6 +56,36 @@ pub struct HtmlParser {
     poisoned: bool,
 }
 
+#[cfg(feature = "parser-conformance")]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) struct PatchMaterializationWitness {
+    pub(crate) terminal_empty_drain_observed: bool,
+    pub(crate) builder_pending_patch_count_after_finish: usize,
+    pub(crate) builder_pending_patch_count_after_terminal_drain: usize,
+    pub(crate) emitter_pending_patch_count_after_terminal_drain: usize,
+    pub(crate) drained_operation_count: u64,
+    pub(crate) applied_operation_count: u64,
+    pub(crate) materialized_after_terminal_drain: bool,
+}
+
+#[cfg(feature = "parser-conformance")]
+pub(crate) struct ConformanceFinalizedOutput {
+    pub(crate) output: ParseOutput,
+    pub(crate) observations: Option<ParserObservationCapture>,
+    pub(crate) patch_history: Option<RawPatchHistoryCapture>,
+    pub(crate) session_audit: Html5SessionFinalAudit,
+    pub(crate) patch_witness: PatchMaterializationWitness,
+    pub(crate) live_structure_matches_patch_arena: bool,
+    pub(crate) patch_arena_matches_materialized_dom: bool,
+}
+
+#[cfg(feature = "parser-conformance")]
+pub(crate) enum ConformanceFinalizationError {
+    Parser(HtmlParseError),
+    ObservationResource(ObservationResourceExhaustion),
+    PatchOperationCountOverflow,
+}
+
 impl HtmlParser {
     /// Create a new streaming HTML parser backed by the HTML5 pipeline.
     pub fn new(options: HtmlParseOptions) -> Result<Self, HtmlParseError> {
@@ -230,7 +266,7 @@ impl HtmlParser {
         Ok(patches)
     }
 
-    /// Drain the next available atomic patch batch.
+    /// Drain the next available ordered patch batch.
     ///
     /// As with `take_patches()`, previously drained non-empty batches are not
     /// replayed by `into_output()`.
@@ -394,6 +430,121 @@ impl HtmlParser {
         Ok((output, diagnostics, patch_history))
     }
 
+    #[cfg(feature = "parser-conformance")]
+    pub(crate) fn into_output_with_final_audit(
+        mut self,
+        reserve: &mut impl FnMut(crate::conformance::ObservationReservationSite) -> Result<(), ()>,
+    ) -> Result<ConformanceFinalizedOutput, ConformanceFinalizationError> {
+        let builder_pending_patch_count_after_finish =
+            self.session.builder_pending_patch_count_for_final_audit();
+        let session_audit =
+            self.session
+                .final_audit_for_conformance(reserve)
+                .map_err(|allocation| {
+                    ConformanceFinalizationError::ObservationResource(
+                        ObservationResourceExhaustion::at(tree_audit_reservation_site(allocation)),
+                    )
+                })?;
+
+        let mut drained_operation_count = 0u64;
+        let mut applied_operation_count = 0u64;
+        let terminal_empty_drain_observed;
+        loop {
+            let batch = self
+                .session
+                .take_patch_batch()
+                .map_err(HtmlParseError::from)
+                .map_err(ConformanceFinalizationError::Parser)?;
+            let Some(batch) = batch else {
+                terminal_empty_drain_observed = true;
+                break;
+            };
+            let operation_count = u64::try_from(batch.patches.len())
+                .map_err(|_| ConformanceFinalizationError::PatchOperationCountOverflow)?;
+            drained_operation_count = drained_operation_count
+                .checked_add(operation_count)
+                .ok_or(ConformanceFinalizationError::PatchOperationCountOverflow)?;
+
+            // Trusted application is deliberately in-place. A failure returns
+            // immediately; the partially updated private arena is never
+            // inspected, materialized, audited, or exposed.
+            self.arena
+                .apply_batch_trusted(&batch.patches)
+                .map_err(|error| {
+                    ConformanceFinalizationError::Parser(HtmlParseError::PatchValidation(
+                        error.to_string(),
+                    ))
+                })?;
+            applied_operation_count = applied_operation_count
+                .checked_add(operation_count)
+                .ok_or(ConformanceFinalizationError::PatchOperationCountOverflow)?;
+        }
+
+        let builder_pending_patch_count_after_terminal_drain =
+            self.session.builder_pending_patch_count_for_final_audit();
+        let emitter_pending_patch_count_after_terminal_drain =
+            self.session.emitter_pending_patch_count_for_final_audit();
+        let patch_structure = self
+            .arena
+            .try_invariant_state_for_final_audit(reserve)
+            .map_err(|_| {
+                ConformanceFinalizationError::ObservationResource(
+                    ObservationResourceExhaustion::at(
+                        ObservationReservationSite::FinalAuditPatchArenaStructuralProjection,
+                    ),
+                )
+            })?;
+        let live_structure_matches_patch_arena =
+            session_audit.tree_builder.live_structure == patch_structure;
+        let document = self.arena.materialize().map_err(|error| {
+            ConformanceFinalizationError::Parser(HtmlParseError::PatchValidation(error.to_string()))
+        })?;
+        let patch_arena_matches_materialized_dom = self
+            .arena
+            .semantic_equals_materialized_dom_for_final_audit(&document, reserve)
+            .map_err(|_| {
+                ConformanceFinalizationError::ObservationResource(
+                    ObservationResourceExhaustion::at(
+                        ObservationReservationSite::FinalAuditSemanticTraversal,
+                    ),
+                )
+            })?;
+        let observations = self
+            .session
+            .take_observations_for_conformance()
+            .map_err(HtmlParseError::from)
+            .map_err(ConformanceFinalizationError::Parser)?;
+        let patch_history = self
+            .session
+            .take_patch_history_for_conformance()
+            .map_err(HtmlParseError::from)
+            .map_err(ConformanceFinalizationError::Parser)?;
+        let output = ParseOutput {
+            document,
+            patches: Vec::new(),
+            contains_full_patch_history: false,
+            counters: self.counters(),
+            parse_errors: self.parse_errors(),
+        };
+        Ok(ConformanceFinalizedOutput {
+            output,
+            observations,
+            patch_history,
+            session_audit,
+            patch_witness: PatchMaterializationWitness {
+                terminal_empty_drain_observed,
+                builder_pending_patch_count_after_finish,
+                builder_pending_patch_count_after_terminal_drain,
+                emitter_pending_patch_count_after_terminal_drain,
+                drained_operation_count,
+                applied_operation_count,
+                materialized_after_terminal_drain: true,
+            },
+            live_structure_matches_patch_arena,
+            patch_arena_matches_materialized_dom,
+        })
+    }
+
     fn materialize_output(&mut self) -> Result<ParseOutput, HtmlParseError> {
         let mut patches = Vec::new();
         while let Some(batch) = self.take_patch_batch_internal(false)? {
@@ -464,3 +615,26 @@ impl HtmlParser {
         Ok(())
     }
 }
+
+#[cfg(feature = "parser-conformance")]
+fn tree_audit_reservation_site(
+    allocation: TreeBuilderFinalAuditAllocation,
+) -> ObservationReservationSite {
+    match allocation {
+        TreeBuilderFinalAuditAllocation::OpenElementsIndex => {
+            ObservationReservationSite::FinalAuditOpenElementsIndex
+        }
+        TreeBuilderFinalAuditAllocation::ActiveFormattingIndex => {
+            ObservationReservationSite::FinalAuditActiveFormattingIndex
+        }
+        TreeBuilderFinalAuditAllocation::TemplateCoordinationIndex => {
+            ObservationReservationSite::FinalAuditTemplateCoordinationIndex
+        }
+        TreeBuilderFinalAuditAllocation::DomStructuralTraversal => {
+            ObservationReservationSite::FinalAuditDomStructuralTraversal
+        }
+        TreeBuilderFinalAuditAllocation::LiveTreeStructuralProjection => {
+            ObservationReservationSite::FinalAuditLiveTreeStructuralProjection
+        }
+    }
+}
diff --git a/crates/html/src/patch_validation/apply.rs b/crates/html/src/patch_validation/apply.rs
index ff475ce5..189a644c 100644
--- a/crates/html/src/patch_validation/apply.rs
+++ b/crates/html/src/patch_validation/apply.rs
@@ -538,7 +538,7 @@ impl PatchValidationArena {
                         template_contents, ..
                     } = &mut host_node.kind
                     else {
-                        unreachable!("validated template host kind changed during atomic apply")
+                        unreachable!("validated template host kind changed during batch apply")
                     };
                     *template_contents = Some(*contents);
                 }
diff --git a/crates/html/src/patch_validation/mod.rs b/crates/html/src/patch_validation/mod.rs
index c5199123..d10c15e3 100644
--- a/crates/html/src/patch_validation/mod.rs
+++ b/crates/html/src/patch_validation/mod.rs
@@ -2,6 +2,8 @@ mod apply;
 mod error;
 mod materialize;
 mod model;
+#[cfg(feature = "parser-conformance")]
+mod semantic_compare;
 mod validate;
 
 pub use error::PatchValidationError;
diff --git a/crates/html/src/patch_validation/model.rs b/crates/html/src/patch_validation/model.rs
index b18a227f..76a901fb 100644
--- a/crates/html/src/patch_validation/model.rs
+++ b/crates/html/src/patch_validation/model.rs
@@ -66,8 +66,9 @@ impl PatchNode {
 /// Minimal patch-applier/validator shared by runtime-facing parser APIs and
 /// test/fuzz harnesses.
 ///
-/// The arena applies batches atomically, validates the resulting structure after
-/// every batch, and can materialize the final DOM when needed.
+/// The public validator stages batches for transactional application. Internal
+/// trusted callers may instead use the deliberately in-place path when any
+/// failure terminates the owning session and the private arena is discarded.
 ///
 /// Allocation policy:
 /// - `Clear` resets the live tree state
@@ -79,3 +80,81 @@ pub struct PatchValidationArena {
     pub(crate) allocated: HashSet<PatchKey>,
     pub(crate) root: Option<PatchKey>,
 }
+
+#[cfg(feature = "parser-conformance")]
+impl PatchValidationArena {
+    pub(crate) fn try_invariant_state_for_final_audit(
+        &self,
+        reserve: &mut impl FnMut(crate::conformance::ObservationReservationSite) -> Result<(), ()>,
+    ) -> Result<crate::html5::tree_builder::DomInvariantState, ()> {
+        use crate::html5::tree_builder::{
+            DomInvariantNode, DomInvariantNodeKind, DomInvariantState,
+        };
+
+        let mut maximum = None;
+        for key in self.nodes.keys() {
+            let index = usize::try_from(key.0).map_err(|_| ())?;
+            maximum = Some(maximum.map_or(index, |current: usize| current.max(index)));
+        }
+        let length = match maximum {
+            Some(index) => index.checked_add(1).ok_or(())?,
+            None => 0,
+        };
+        let mut nodes = Vec::new();
+        reserve(crate::conformance::ObservationReservationSite::FinalAuditPatchArenaStructuralProjection)?;
+        nodes.try_reserve_exact(length).map_err(|_| ())?;
+        nodes.resize_with(length, || None);
+        for (key, node) in &self.nodes {
+            let mut children = Vec::new();
+            reserve(crate::conformance::ObservationReservationSite::FinalAuditPatchArenaStructuralProjection)?;
+            children
+                .try_reserve_exact(node.children.len())
+                .map_err(|_| ())?;
+            children.extend_from_slice(&node.children);
+            let (kind, template_contents, fragment_host, is_template_element) = match &node.kind {
+                PatchKind::Document { .. } => (DomInvariantNodeKind::Document, None, None, false),
+                PatchKind::DocumentType { .. } => {
+                    (DomInvariantNodeKind::DocumentType, None, None, false)
+                }
+                PatchKind::Element {
+                    name,
+                    template_contents,
+                    ..
+                } => (
+                    DomInvariantNodeKind::Element,
+                    *template_contents,
+                    None,
+                    name.is(crate::ElementNamespace::Html, "template"),
+                ),
+                PatchKind::DocumentFragment { kind, host } => (
+                    DomInvariantNodeKind::DocumentFragment(*kind),
+                    None,
+                    Some(*host),
+                    false,
+                ),
+                PatchKind::Text { .. } => (DomInvariantNodeKind::Text, None, None, false),
+                PatchKind::Comment { .. } => (DomInvariantNodeKind::Comment, None, None, false),
+                PatchKind::ProcessingInstruction { .. } => (
+                    DomInvariantNodeKind::ProcessingInstruction,
+                    None,
+                    None,
+                    false,
+                ),
+            };
+            let index = usize::try_from(key.0).map_err(|_| ())?;
+            let slot = nodes.get_mut(index).ok_or(())?;
+            *slot = Some(DomInvariantNode {
+                kind,
+                parent: node.parent,
+                children,
+                template_contents,
+                fragment_host,
+                is_template_element,
+            });
+        }
+        Ok(DomInvariantState {
+            nodes,
+            root: self.root,
+        })
+    }
+}
diff --git a/crates/html/src/patch_validation/semantic_compare.rs b/crates/html/src/patch_validation/semantic_compare.rs
new file mode 100644
index 00000000..0d750549
--- /dev/null
+++ b/crates/html/src/patch_validation/semantic_compare.rs
@@ -0,0 +1,235 @@
+use crate::dom_patch::PatchKey;
+use crate::types::{DocumentFragmentNode, Node, ParserCreatedFragmentKind};
+
+use super::model::{PatchKind, PatchValidationArena};
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) struct FinalAuditSemanticTraversalAllocation;
+
+#[derive(Clone, Copy)]
+enum MaterializedRef<'a> {
+    Node(&'a Node),
+    Fragment(&'a DocumentFragmentNode),
+}
+
+#[derive(Clone, Copy)]
+enum TraversalPhase {
+    ComparePayload,
+    OrdinaryChildren,
+    TemplateContents,
+    Complete,
+}
+
+#[derive(Clone, Copy)]
+struct SemanticCompareFrame<'a> {
+    arena_node: PatchKey,
+    materialized_node: MaterializedRef<'a>,
+    next_child_index: usize,
+    phase: TraversalPhase,
+}
+
+impl PatchValidationArena {
+    /// Compare the complete semantic patch-arena model with materialized DOM
+    /// without snapshots, parser IDs, or recursive traversal. The stack keeps
+    /// one frame per active ancestor and never retains all sibling pairs.
+    pub(crate) fn semantic_equals_materialized_dom_for_final_audit(
+        &self,
+        document: &Node,
+        reserve: &mut impl FnMut(crate::conformance::ObservationReservationSite) -> Result<(), ()>,
+    ) -> Result<bool, FinalAuditSemanticTraversalAllocation> {
+        self.semantic_compare_for_final_audit(document, None, reserve)
+    }
+
+    #[cfg(test)]
+    pub(crate) fn semantic_compare_depth_for_test(
+        &self,
+        document: &Node,
+    ) -> Result<(bool, usize), FinalAuditSemanticTraversalAllocation> {
+        let mut maximum_depth = 0usize;
+        let mut reserve = |_| Ok(());
+        let matches = self.semantic_compare_for_final_audit(
+            document,
+            Some(&mut maximum_depth),
+            &mut reserve,
+        )?;
+        Ok((matches, maximum_depth))
+    }
+
+    fn semantic_compare_for_final_audit(
+        &self,
+        document: &Node,
+        mut maximum_depth: Option<&mut usize>,
+        reserve: &mut impl FnMut(crate::conformance::ObservationReservationSite) -> Result<(), ()>,
+    ) -> Result<bool, FinalAuditSemanticTraversalAllocation> {
+        let Some(root) = self.root else {
+            return Ok(false);
+        };
+        let mut stack = Vec::new();
+        reserve(crate::conformance::ObservationReservationSite::FinalAuditSemanticTraversal)
+            .map_err(|_| FinalAuditSemanticTraversalAllocation)?;
+        stack
+            .try_reserve(1)
+            .map_err(|_| FinalAuditSemanticTraversalAllocation)?;
+        stack.push(SemanticCompareFrame {
+            arena_node: root,
+            materialized_node: MaterializedRef::Node(document),
+            next_child_index: 0,
+            phase: TraversalPhase::ComparePayload,
+        });
+        record_depth(&mut maximum_depth, stack.len());
+
+        while let Some(frame) = stack.last_mut() {
+            let Some(arena) = self.nodes.get(&frame.arena_node) else {
+                return Ok(false);
+            };
+            match frame.phase {
+                TraversalPhase::ComparePayload => {
+                    if !payload_matches(&arena.kind, frame.materialized_node) {
+                        return Ok(false);
+                    }
+                    frame.phase = TraversalPhase::OrdinaryChildren;
+                }
+                TraversalPhase::OrdinaryChildren => {
+                    let materialized_children = children(frame.materialized_node);
+                    if arena.children.len() != materialized_children.len() {
+                        return Ok(false);
+                    }
+                    if frame.next_child_index < arena.children.len() {
+                        let index = frame.next_child_index;
+                        frame.next_child_index = index
+                            .checked_add(1)
+                            .ok_or(FinalAuditSemanticTraversalAllocation)?;
+                        let Some(arena_child) = arena.children.get(index).copied() else {
+                            return Ok(false);
+                        };
+                        let Some(materialized_child) = materialized_children.get(index) else {
+                            return Ok(false);
+                        };
+                        reserve(crate::conformance::ObservationReservationSite::FinalAuditSemanticTraversal)
+                            .map_err(|_| FinalAuditSemanticTraversalAllocation)?;
+                        stack
+                            .try_reserve(1)
+                            .map_err(|_| FinalAuditSemanticTraversalAllocation)?;
+                        stack.push(SemanticCompareFrame {
+                            arena_node: arena_child,
+                            materialized_node: MaterializedRef::Node(materialized_child),
+                            next_child_index: 0,
+                            phase: TraversalPhase::ComparePayload,
+                        });
+                        record_depth(&mut maximum_depth, stack.len());
+                    } else {
+                        frame.phase = TraversalPhase::TemplateContents;
+                    }
+                }
+                TraversalPhase::TemplateContents => {
+                    let arena_contents = arena.template_contents();
+                    let materialized_contents = match frame.materialized_node {
+                        MaterializedRef::Node(Node::Element { element }) => {
+                            element.template_contents()
+                        }
+                        MaterializedRef::Node(_) | MaterializedRef::Fragment(_) => None,
+                    };
+                    match (arena_contents, materialized_contents) {
+                        (None, None) => frame.phase = TraversalPhase::Complete,
+                        (Some(key), Some(contents)) => {
+                            frame.phase = TraversalPhase::Complete;
+                            reserve(crate::conformance::ObservationReservationSite::FinalAuditSemanticTraversal)
+                                .map_err(|_| FinalAuditSemanticTraversalAllocation)?;
+                            stack
+                                .try_reserve(1)
+                                .map_err(|_| FinalAuditSemanticTraversalAllocation)?;
+                            stack.push(SemanticCompareFrame {
+                                arena_node: key,
+                                materialized_node: MaterializedRef::Fragment(contents),
+                                next_child_index: 0,
+                                phase: TraversalPhase::ComparePayload,
+                            });
+                            record_depth(&mut maximum_depth, stack.len());
+                        }
+                        (None, Some(_)) | (Some(_), None) => return Ok(false),
+                    }
+                }
+                TraversalPhase::Complete => {
+                    let _ = stack.pop();
+                }
+            }
+        }
+        Ok(true)
+    }
+}
+
+fn record_depth(maximum: &mut Option<&mut usize>, current: usize) {
+    if let Some(maximum) = maximum.as_deref_mut()
+        && current > *maximum
+    {
+        *maximum = current;
+    }
+}
+
+fn children(node: MaterializedRef<'_>) -> &[Node] {
+    match node {
+        MaterializedRef::Node(node) => match node.children() {
+            Some(children) => children,
+            None => &[],
+        },
+        MaterializedRef::Fragment(fragment) => fragment.children(),
+    }
+}
+
+fn payload_matches(kind: &PatchKind, materialized: MaterializedRef<'_>) -> bool {
+    match (kind, materialized) {
+        (
+            PatchKind::Document { doctype: expected },
+            MaterializedRef::Node(Node::Document { doctype, .. }),
+        ) => expected == doctype,
+        (
+            PatchKind::DocumentType {
+                name: expected_name,
+                public_id: expected_public,
+                system_id: expected_system,
+            },
+            MaterializedRef::Node(Node::DocumentType {
+                name,
+                public_id,
+                system_id,
+                ..
+            }),
+        ) => expected_name == name && expected_public == public_id && expected_system == system_id,
+        (
+            PatchKind::Element {
+                name,
+                attributes,
+                template_contents,
+            },
+            MaterializedRef::Node(Node::Element { element }),
+        ) => {
+            name == element.expanded_name()
+                && attributes.as_slice() == element.attributes()
+                && template_contents.is_some() == element.template_contents().is_some()
+        }
+        (PatchKind::DocumentFragment { kind, .. }, MaterializedRef::Fragment(fragment)) => {
+            *kind == ParserCreatedFragmentKind::TemplateContents
+                && fragment.kind() == ParserCreatedFragmentKind::TemplateContents
+        }
+        (PatchKind::Text { text: expected }, MaterializedRef::Node(Node::Text { text, .. })) => {
+            expected == text
+        }
+        (
+            PatchKind::Comment { text: expected },
+            MaterializedRef::Node(Node::Comment { text, .. }),
+        ) => expected == text,
+        (
+            PatchKind::ProcessingInstruction {
+                target: expected_target,
+                data: expected_data,
+            },
+            MaterializedRef::Node(Node::ProcessingInstruction {
+                processing_instruction,
+            }),
+        ) => {
+            expected_target == processing_instruction.target()
+                && expected_data == processing_instruction.data()
+        }
+        _ => false,
+    }
+}
diff --git a/crates/html/src/patch_validation/tests.rs b/crates/html/src/patch_validation/tests.rs
index 46f1ce72..ca3c93cc 100644
--- a/crates/html/src/patch_validation/tests.rs
+++ b/crates/html/src/patch_validation/tests.rs
@@ -1,6 +1,6 @@
 use super::PatchValidationArena;
 use crate::dom_patch::PatchKey;
-use crate::test_support::html_name;
+use crate::test_support::{html_attribute, html_name};
 use crate::{DomPatch, Node};
 
 #[test]
@@ -39,6 +39,306 @@ fn patch_validation_arena_accepts_valid_batches_and_materializes() {
     }
 }
 
+#[cfg(feature = "parser-conformance")]
+#[test]
+fn semantic_compare_wide_tree_uses_ancestor_depth_not_sibling_count() {
+    const WIDTH: u32 = 2_000;
+    let mut patches = Vec::new();
+    patches.push(DomPatch::CreateDocument {
+        key: PatchKey(1),
+        doctype: None,
+    });
+    patches.push(DomPatch::CreateElement {
+        key: PatchKey(2),
+        name: html_name("html"),
+        attributes: Vec::new(),
+    });
+    patches.push(DomPatch::AppendChild {
+        parent: PatchKey(1),
+        child: PatchKey(2),
+    });
+    for offset in 0..WIDTH {
+        let key = PatchKey(3 + offset);
+        patches.push(DomPatch::CreateElement {
+            key,
+            name: html_name("div"),
+            attributes: Vec::new(),
+        });
+        patches.push(DomPatch::AppendChild {
+            parent: PatchKey(2),
+            child: key,
+        });
+    }
+    let mut arena = PatchValidationArena::default();
+    arena.apply_batch(&patches).expect("wide tree batch");
+    let document = arena.materialize().expect("wide tree materialization");
+    let (matches, maximum_depth) = arena
+        .semantic_compare_depth_for_test(&document)
+        .expect("wide semantic traversal");
+    assert!(matches);
+    assert_eq!(maximum_depth, 3);
+}
+
+#[cfg(feature = "parser-conformance")]
+#[test]
+fn semantic_compare_deep_tree_is_iterative_and_tracks_active_ancestors() {
+    const DEPTH: u32 = 300;
+    let mut patches = Vec::new();
+    patches.push(DomPatch::CreateDocument {
+        key: PatchKey(1),
+        doctype: None,
+    });
+    let mut parent = PatchKey(1);
+    for offset in 0..DEPTH {
+        let key = PatchKey(2 + offset);
+        patches.push(DomPatch::CreateElement {
+            key,
+            name: html_name("div"),
+            attributes: Vec::new(),
+        });
+        patches.push(DomPatch::AppendChild { parent, child: key });
+        parent = key;
+    }
+    let mut arena = PatchValidationArena::default();
+    arena.apply_batch(&patches).expect("deep tree batch");
+    let document = arena.materialize().expect("deep tree materialization");
+    let (matches, maximum_depth) = arena
+        .semantic_compare_depth_for_test(&document)
+        .expect("deep semantic traversal");
+    assert!(matches);
+    assert_eq!(maximum_depth, DEPTH as usize + 1);
+}
+
+#[cfg(feature = "parser-conformance")]
+#[test]
+fn semantic_compare_rejects_complete_payload_and_child_order_mismatches() {
+    let patches = vec![
+        DomPatch::CreateDocument {
+            key: PatchKey(1),
+            doctype: Some("legacy-html".to_string()),
+        },
+        DomPatch::CreateDocumentType {
+            key: PatchKey(2),
+            name: Some("html".to_string()),
+            public_id: Some("public".to_string()),
+            system_id: Some("system".to_string()),
+        },
+        DomPatch::AppendChild {
+            parent: PatchKey(1),
+            child: PatchKey(2),
+        },
+        DomPatch::CreateElement {
+            key: PatchKey(3),
+            name: html_name("html"),
+            attributes: Vec::new(),
+        },
+        DomPatch::AppendChild {
+            parent: PatchKey(1),
+            child: PatchKey(3),
+        },
+        DomPatch::CreateElement {
+            key: PatchKey(4),
+            name: html_name("template"),
+            attributes: vec![
+                html_attribute("a", Some("1")),
+                html_attribute("b", Some("2")),
+            ],
+        },
+        DomPatch::CreateTemplateContents {
+            host: PatchKey(4),
+            contents: PatchKey(5),
+        },
+        DomPatch::AppendChild {
+            parent: PatchKey(3),
+            child: PatchKey(4),
+        },
+        DomPatch::CreateText {
+            key: PatchKey(6),
+            text: "text".to_string(),
+        },
+        DomPatch::AppendChild {
+            parent: PatchKey(5),
+            child: PatchKey(6),
+        },
+        DomPatch::CreateComment {
+            key: PatchKey(7),
+            text: "inside".to_string(),
+        },
+        DomPatch::AppendChild {
+            parent: PatchKey(5),
+            child: PatchKey(7),
+        },
+        DomPatch::CreateComment {
+            key: PatchKey(8),
+            text: "outside".to_string(),
+        },
+        DomPatch::AppendChild {
+            parent: PatchKey(3),
+            child: PatchKey(8),
+        },
+        DomPatch::CreateProcessingInstruction {
+            key: PatchKey(9),
+            target: "target".to_string(),
+            data: "data".to_string(),
+        },
+        DomPatch::AppendChild {
+            parent: PatchKey(3),
+            child: PatchKey(9),
+        },
+    ];
+    let mut arena = PatchValidationArena::default();
+    arena.apply_batch(&patches).expect("semantic seed batch");
+    let document = arena.materialize().expect("semantic seed materializes");
+    let mut reserve = |_| Ok(());
+    assert!(
+        arena
+            .semantic_equals_materialized_dom_for_final_audit(&document, &mut reserve)
+            .expect("semantic seed comparison")
+    );
+
+    let assert_mismatch = |mutate: &dyn Fn(&mut Node)| {
+        let mut changed = arena.materialize().expect("fresh semantic materialization");
+        mutate(&mut changed);
+        let mut reserve = |_| Ok(());
+        assert!(
+            !arena
+                .semantic_equals_materialized_dom_for_final_audit(&changed, &mut reserve)
+                .expect("mismatch comparison")
+        );
+    };
+
+    assert_mismatch(&|document| {
+        let Node::Document { doctype, .. } = document else {
+            panic!("document root");
+        };
+        *doctype = Some("changed".to_string());
+    });
+    assert_mismatch(&|document| {
+        let Node::Document { children, .. } = document else {
+            panic!("document root");
+        };
+        let Node::DocumentType {
+            name,
+            public_id,
+            system_id,
+            ..
+        } = &mut children[0]
+        else {
+            panic!("doctype child");
+        };
+        *name = Some("changed".to_string());
+        *public_id = Some("changed".to_string());
+        *system_id = Some("changed".to_string());
+    });
+    assert_mismatch(&|document| {
+        let Node::Document { children, .. } = document else {
+            panic!("document root");
+        };
+        let replacement = {
+            let Node::Element { element } = &mut children[1] else {
+                panic!("html child");
+            };
+            Node::new_element(
+                html_name("body"),
+                element.attributes().to_vec(),
+                Vec::new(),
+                std::mem::take(element.children_mut()),
+            )
+        };
+        children[1] = replacement;
+    });
+    assert_mismatch(&|document| {
+        let template = template_element_mut(document);
+        template.attributes_mut().swap(0, 1);
+    });
+    assert_mismatch(&|document| {
+        let template = template_element_mut(document);
+        template.attributes_mut()[0] = html_attribute("a", Some("changed"));
+    });
+    assert_mismatch(&|document| {
+        let contents = template_element_mut(document)
+            .template_contents_mut()
+            .expect("template contents");
+        let Node::Text { text, .. } = &mut contents.children_mut()[0] else {
+            panic!("text child");
+        };
+        text.push_str("-changed");
+    });
+    assert_mismatch(&|document| {
+        let contents = template_element_mut(document)
+            .template_contents_mut()
+            .expect("template contents");
+        let Node::Comment { text, .. } = &mut contents.children_mut()[1] else {
+            panic!("comment child");
+        };
+        text.push_str("-changed");
+    });
+    assert_mismatch(&|document| {
+        let Node::Document { children, .. } = document else {
+            panic!("document root");
+        };
+        let Node::Element { element } = &mut children[1] else {
+            panic!("html child");
+        };
+        element.children_mut().swap(1, 2);
+    });
+    assert_mismatch(&|document| {
+        let Node::Document { children, .. } = document else {
+            panic!("document root");
+        };
+        let Node::Element { element } = &mut children[1] else {
+            panic!("html child");
+        };
+        let Node::ProcessingInstruction {
+            processing_instruction,
+        } = &mut element.children_mut()[2]
+        else {
+            panic!("processing instruction child");
+        };
+        *processing_instruction =
+            crate::types::ProcessingInstructionNode::try_from_parser_created_parts(
+                crate::types::Id::INVALID,
+                "changed".to_string(),
+                "changed".to_string(),
+            )
+            .expect("valid changed processing instruction");
+    });
+    assert_mismatch(&|document| {
+        let contents = template_element_mut(document)
+            .template_contents_mut()
+            .expect("template contents");
+        contents.children_mut().swap(0, 1);
+    });
+    assert_mismatch(&|document| {
+        let Node::Document { children, .. } = document else {
+            panic!("document root");
+        };
+        let Node::Element { element } = &mut children[1] else {
+            panic!("html child");
+        };
+        let attributes = match &element.children()[0] {
+            Node::Element { element } => element.attributes().to_vec(),
+            _ => panic!("template child"),
+        };
+        element.children_mut()[0] =
+            Node::new_element(html_name("template"), attributes, Vec::new(), Vec::new());
+    });
+}
+
+#[cfg(feature = "parser-conformance")]
+fn template_element_mut(document: &mut Node) -> &mut crate::ElementNode {
+    let Node::Document { children, .. } = document else {
+        panic!("document root");
+    };
+    let Node::Element { element: html } = &mut children[1] else {
+        panic!("html child");
+    };
+    let Node::Element { element: template } = &mut html.children_mut()[0] else {
+        panic!("template child");
+    };
+    template
+}
+
 #[test]
 fn patch_validation_arena_reports_clear_ordering_actionably() {
     let mut arena = PatchValidationArena::default();
diff --git a/crates/html/tests/fixtures/html5/conformance/README.md b/crates/html/tests/fixtures/html5/conformance/README.md
index 8cd4e09c..7400dd69 100644
--- a/crates/html/tests/fixtures/html5/conformance/README.md
+++ b/crates/html/tests/fixtures/html5/conformance/README.md
@@ -21,14 +21,26 @@ byte delivery, and any byte-sensitive case. `input.html` containing a carriage
 return is rejected. Always update the mandatory SHA-256 from the exact stored
 bytes; the loader never trims input.
 
-AE13b5 executes supported whole-input standalone-tokenizer and document
-fixtures from typed canonical observations. Ordinary surfaces are unioned on
-the reference delivery; transition expectations may name another declared
-whole delivery. Each planned delivery executes once. Unused declared whole
-deliveries are capability-checked but do not execute.
+AE13c executes supported standalone-tokenizer and document fixtures through an
+authoritative whole-input baseline plus bounded declared and representative
+scalar/byte strategies. Semantic aliases execute once. Fixed-one and
+fixed-seven delivery are incremental and allocate no boundary vector; the
+edge-triplet strategy is bounded and generic. Strategy generation never scans
+HTML syntax. Every applicable canonical surface and the mandatory production
+final audit must match the baseline.
+
+Parity compares typed canonical values before serialization. The runner keeps
+one owned baseline and disposes successful parity-only candidates; it does not
+deep-clone the baseline. Final-audit failure injection is attached to each real
+fallible reservation and reports the exact observation-resource site. Explicit
+scalar boundary resolution is the fixture-harness resource
+`scalar-boundary-execution-offsets`; fixed scalar delivery remains allocation
+independent of chunk count. Boundary digests are lazy, streaming diagnostic
+metadata and are never used for semantic equality.
 
 Canonical sidecars use the exact AE13b5 formats, including `html5-token-v2`,
-`html5-dom-v3`, and `html5-dompatch-v3`. Header-only diagnostic, transition,
+`html5-dom-v3`, `html5-dompatch-v3`, and the exact 16-record
+`html5-final-invariants-v1`. Header-only diagnostic, transition,
 unsupported-feature, tree, and patch snapshots represent requested empty
 collections. Fixture-v1 remains an isolated compatibility format.
 
diff --git a/crates/html/tests/fixtures/html5/conformance/active-formatting-recovery/final-invariants.txt b/crates/html/tests/fixtures/html5/conformance/active-formatting-recovery/final-invariants.txt
new file mode 100644
index 00000000..22f788a2
--- /dev/null
+++ b/crates/html/tests/fixtures/html5/conformance/active-formatting-recovery/final-invariants.txt
@@ -0,0 +1,17 @@
+# format: html5-final-invariants-v1
+INVARIANT ordinal=1 field=decoder-carry-empty outcome=satisfied
+INVARIANT ordinal=2 field=preprocessing-flushed outcome=satisfied
+INVARIANT ordinal=3 field=eof-emitted-once outcome=satisfied
+INVARIANT ordinal=4 field=pending-constructs-flushed outcome=satisfied
+INVARIANT ordinal=5 field=output-accounted-for outcome=satisfied
+INVARIANT ordinal=6 field=pending-table-text-empty outcome=satisfied
+INVARIANT ordinal=7 field=insertion-mode-valid outcome=satisfied
+INVARIANT ordinal=8 field=open-elements-consistent outcome=satisfied
+INVARIANT ordinal=9 field=active-formatting-consistent outcome=satisfied
+INVARIANT ordinal=10 field=template-modes-consistent outcome=satisfied
+INVARIANT ordinal=11 field=form-pointer-valid outcome=satisfied
+INVARIANT ordinal=12 field=parent-child-links-valid outcome=satisfied
+INVARIANT ordinal=13 field=namespaces-valid outcome=satisfied
+INVARIANT ordinal=14 field=template-associations-valid outcome=satisfied
+INVARIANT ordinal=15 field=all-patches-materialized outcome=satisfied
+INVARIANT ordinal=16 field=live-tree-matches-materialized-dom outcome=satisfied
diff --git a/crates/html/tests/fixtures/html5/conformance/active-formatting-recovery/fixture.toml b/crates/html/tests/fixtures/html5/conformance/active-formatting-recovery/fixture.toml
new file mode 100644
index 00000000..c8948119
--- /dev/null
+++ b/crates/html/tests/fixtures/html5/conformance/active-formatting-recovery/fixture.toml
@@ -0,0 +1,28 @@
+format = "borrowser-html-parser-fixture-v2"
+id = "active-formatting-recovery"
+[source]
+kind = "native"
+[input]
+path = "input.html"
+kind = "utf8-text"
+sha256 = "2d1294691049f3b801f919e67ee92c09ff429a889045caa427b6c050f6995b4c"
+[execution]
+reference_delivery = "whole-unicode"
+[execution.target]
+kind = "document"
+scripting = "disabled"
+[[execution.deliveries]]
+name = "whole-unicode"
+unit = "unicode-scalars"
+strategy = "whole"
+[[execution.deliveries]]
+name = "declared-scalar-split"
+unit = "unicode-scalars"
+strategy = "boundaries"
+boundaries = [1]
+[expectations]
+final_invariants = "final-invariants.txt"
+[disposition]
+status = "active"
+[metadata]
+description = "Active-formatting reconstruction and adoption recovery remain chunk-independent."
diff --git a/crates/html/tests/fixtures/html5/conformance/active-formatting-recovery/input.html b/crates/html/tests/fixtures/html5/conformance/active-formatting-recovery/input.html
new file mode 100644
index 00000000..c8af9651
--- /dev/null
+++ b/crates/html/tests/fixtures/html5/conformance/active-formatting-recovery/input.html
@@ -0,0 +1 @@
+<!doctype html><p><b><i>x</b>y</i>
diff --git a/crates/html/tests/fixtures/html5/conformance/character-reference-boundaries/final-invariants.txt b/crates/html/tests/fixtures/html5/conformance/character-reference-boundaries/final-invariants.txt
new file mode 100644
index 00000000..22f788a2
--- /dev/null
+++ b/crates/html/tests/fixtures/html5/conformance/character-reference-boundaries/final-invariants.txt
@@ -0,0 +1,17 @@
+# format: html5-final-invariants-v1
+INVARIANT ordinal=1 field=decoder-carry-empty outcome=satisfied
+INVARIANT ordinal=2 field=preprocessing-flushed outcome=satisfied
+INVARIANT ordinal=3 field=eof-emitted-once outcome=satisfied
+INVARIANT ordinal=4 field=pending-constructs-flushed outcome=satisfied
+INVARIANT ordinal=5 field=output-accounted-for outcome=satisfied
+INVARIANT ordinal=6 field=pending-table-text-empty outcome=satisfied
+INVARIANT ordinal=7 field=insertion-mode-valid outcome=satisfied
+INVARIANT ordinal=8 field=open-elements-consistent outcome=satisfied
+INVARIANT ordinal=9 field=active-formatting-consistent outcome=satisfied
+INVARIANT ordinal=10 field=template-modes-consistent outcome=satisfied
+INVARIANT ordinal=11 field=form-pointer-valid outcome=satisfied
+INVARIANT ordinal=12 field=parent-child-links-valid outcome=satisfied
+INVARIANT ordinal=13 field=namespaces-valid outcome=satisfied
+INVARIANT ordinal=14 field=template-associations-valid outcome=satisfied
+INVARIANT ordinal=15 field=all-patches-materialized outcome=satisfied
+INVARIANT ordinal=16 field=live-tree-matches-materialized-dom outcome=satisfied
diff --git a/crates/html/tests/fixtures/html5/conformance/character-reference-boundaries/fixture.toml b/crates/html/tests/fixtures/html5/conformance/character-reference-boundaries/fixture.toml
new file mode 100644
index 00000000..2a6b91cb
--- /dev/null
+++ b/crates/html/tests/fixtures/html5/conformance/character-reference-boundaries/fixture.toml
@@ -0,0 +1,28 @@
+format = "borrowser-html-parser-fixture-v2"
+id = "character-reference-boundaries"
+[source]
+kind = "native"
+[input]
+path = "input.html"
+kind = "utf8-text"
+sha256 = "c2ac69f8cc71b9a4a129955ce2481fa35740f89ebb67566296bb0e95fdfd4d07"
+[execution]
+reference_delivery = "whole-unicode"
+[execution.target]
+kind = "document"
+scripting = "disabled"
+[[execution.deliveries]]
+name = "whole-unicode"
+unit = "unicode-scalars"
+strategy = "whole"
+[[execution.deliveries]]
+name = "declared-scalar-split"
+unit = "unicode-scalars"
+strategy = "boundaries"
+boundaries = [1]
+[expectations]
+final_invariants = "final-invariants.txt"
+[disposition]
+status = "active"
+[metadata]
+description = "Named, numeric, and ambiguous character-reference recovery remains chunk-independent."
diff --git a/crates/html/tests/fixtures/html5/conformance/character-reference-boundaries/input.html b/crates/html/tests/fixtures/html5/conformance/character-reference-boundaries/input.html
new file mode 100644
index 00000000..567ff402
--- /dev/null
+++ b/crates/html/tests/fixtures/html5/conformance/character-reference-boundaries/input.html
@@ -0,0 +1 @@
+<!doctype html><p>&amp;&#x1F600;&notit;</p>
diff --git a/crates/html/tests/fixtures/html5/conformance/foreign-content-integration/final-invariants.txt b/crates/html/tests/fixtures/html5/conformance/foreign-content-integration/final-invariants.txt
new file mode 100644
index 00000000..22f788a2
--- /dev/null
+++ b/crates/html/tests/fixtures/html5/conformance/foreign-content-integration/final-invariants.txt
@@ -0,0 +1,17 @@
+# format: html5-final-invariants-v1
+INVARIANT ordinal=1 field=decoder-carry-empty outcome=satisfied
+INVARIANT ordinal=2 field=preprocessing-flushed outcome=satisfied
+INVARIANT ordinal=3 field=eof-emitted-once outcome=satisfied
+INVARIANT ordinal=4 field=pending-constructs-flushed outcome=satisfied
+INVARIANT ordinal=5 field=output-accounted-for outcome=satisfied
+INVARIANT ordinal=6 field=pending-table-text-empty outcome=satisfied
+INVARIANT ordinal=7 field=insertion-mode-valid outcome=satisfied
+INVARIANT ordinal=8 field=open-elements-consistent outcome=satisfied
+INVARIANT ordinal=9 field=active-formatting-consistent outcome=satisfied
+INVARIANT ordinal=10 field=template-modes-consistent outcome=satisfied
+INVARIANT ordinal=11 field=form-pointer-valid outcome=satisfied
+INVARIANT ordinal=12 field=parent-child-links-valid outcome=satisfied
+INVARIANT ordinal=13 field=namespaces-valid outcome=satisfied
+INVARIANT ordinal=14 field=template-associations-valid outcome=satisfied
+INVARIANT ordinal=15 field=all-patches-materialized outcome=satisfied
+INVARIANT ordinal=16 field=live-tree-matches-materialized-dom outcome=satisfied
diff --git a/crates/html/tests/fixtures/html5/conformance/foreign-content-integration/fixture.toml b/crates/html/tests/fixtures/html5/conformance/foreign-content-integration/fixture.toml
new file mode 100644
index 00000000..9a519358
--- /dev/null
+++ b/crates/html/tests/fixtures/html5/conformance/foreign-content-integration/fixture.toml
@@ -0,0 +1,28 @@
+format = "borrowser-html-parser-fixture-v2"
+id = "foreign-content-integration"
+[source]
+kind = "native"
+[input]
+path = "input.html"
+kind = "utf8-text"
+sha256 = "9846bfa95b313a045fcf274668262ac3a5c7dfafbce1a69c396e4decf893bc67"
+[execution]
+reference_delivery = "whole-unicode"
+[execution.target]
+kind = "document"
+scripting = "disabled"
+[[execution.deliveries]]
+name = "whole-unicode"
+unit = "unicode-scalars"
+strategy = "whole"
+[[execution.deliveries]]
+name = "declared-scalar-split"
+unit = "unicode-scalars"
+strategy = "boundaries"
+boundaries = [1]
+[expectations]
+final_invariants = "final-invariants.txt"
+[disposition]
+status = "active"
+[metadata]
+description = "SVG and MathML namespace boundaries and HTML integration points remain chunk-independent."
diff --git a/crates/html/tests/fixtures/html5/conformance/foreign-content-integration/input.html b/crates/html/tests/fixtures/html5/conformance/foreign-content-integration/input.html
new file mode 100644
index 00000000..060c2530
--- /dev/null
+++ b/crates/html/tests/fixtures/html5/conformance/foreign-content-integration/input.html
@@ -0,0 +1 @@
+<!doctype html><svg><foreignObject><p>x</p></foreignObject><circle/></svg><math><annotation-xml encoding="text/html"><p>y</p></annotation-xml></math>
diff --git a/crates/html/tests/fixtures/html5/conformance/form-pointer-state/final-invariants.txt b/crates/html/tests/fixtures/html5/conformance/form-pointer-state/final-invariants.txt
new file mode 100644
index 00000000..22f788a2
--- /dev/null
+++ b/crates/html/tests/fixtures/html5/conformance/form-pointer-state/final-invariants.txt
@@ -0,0 +1,17 @@
+# format: html5-final-invariants-v1
+INVARIANT ordinal=1 field=decoder-carry-empty outcome=satisfied
+INVARIANT ordinal=2 field=preprocessing-flushed outcome=satisfied
+INVARIANT ordinal=3 field=eof-emitted-once outcome=satisfied
+INVARIANT ordinal=4 field=pending-constructs-flushed outcome=satisfied
+INVARIANT ordinal=5 field=output-accounted-for outcome=satisfied
+INVARIANT ordinal=6 field=pending-table-text-empty outcome=satisfied
+INVARIANT ordinal=7 field=insertion-mode-valid outcome=satisfied
+INVARIANT ordinal=8 field=open-elements-consistent outcome=satisfied
+INVARIANT ordinal=9 field=active-formatting-consistent outcome=satisfied
+INVARIANT ordinal=10 field=template-modes-consistent outcome=satisfied
+INVARIANT ordinal=11 field=form-pointer-valid outcome=satisfied
+INVARIANT ordinal=12 field=parent-child-links-valid outcome=satisfied
+INVARIANT ordinal=13 field=namespaces-valid outcome=satisfied
+INVARIANT ordinal=14 field=template-associations-valid outcome=satisfied
+INVARIANT ordinal=15 field=all-patches-materialized outcome=satisfied
+INVARIANT ordinal=16 field=live-tree-matches-materialized-dom outcome=satisfied
diff --git a/crates/html/tests/fixtures/html5/conformance/form-pointer-state/fixture.toml b/crates/html/tests/fixtures/html5/conformance/form-pointer-state/fixture.toml
new file mode 100644
index 00000000..2311c0c2
--- /dev/null
+++ b/crates/html/tests/fixtures/html5/conformance/form-pointer-state/fixture.toml
@@ -0,0 +1,28 @@
+format = "borrowser-html-parser-fixture-v2"
+id = "form-pointer-state"
+[source]
+kind = "native"
+[input]
+path = "input.html"
+kind = "utf8-text"
+sha256 = "d4f9d28efbe1d9fea5dd38f8dd373f7d210bd286f8b7da39f4b5da5540609b50"
+[execution]
+reference_delivery = "whole-unicode"
+[execution.target]
+kind = "document"
+scripting = "disabled"
+[[execution.deliveries]]
+name = "whole-unicode"
+unit = "unicode-scalars"
+strategy = "whole"
+[[execution.deliveries]]
+name = "declared-scalar-split"
+unit = "unicode-scalars"
+strategy = "boundaries"
+boundaries = [1]
+[expectations]
+final_invariants = "final-invariants.txt"
+[disposition]
+status = "active"
+[metadata]
+description = "Nested-form recovery and the form element pointer remain chunk-independent."
diff --git a/crates/html/tests/fixtures/html5/conformance/form-pointer-state/input.html b/crates/html/tests/fixtures/html5/conformance/form-pointer-state/input.html
new file mode 100644
index 00000000..9f91fe8d
--- /dev/null
+++ b/crates/html/tests/fixtures/html5/conformance/form-pointer-state/input.html
@@ -0,0 +1 @@
+<!doctype html><form id=a><div><form id=b><input></form></div>
diff --git a/crates/html/tests/fixtures/html5/conformance/processing-instruction-boundaries/final-invariants.txt b/crates/html/tests/fixtures/html5/conformance/processing-instruction-boundaries/final-invariants.txt
new file mode 100644
index 00000000..22f788a2
--- /dev/null
+++ b/crates/html/tests/fixtures/html5/conformance/processing-instruction-boundaries/final-invariants.txt
@@ -0,0 +1,17 @@
+# format: html5-final-invariants-v1
+INVARIANT ordinal=1 field=decoder-carry-empty outcome=satisfied
+INVARIANT ordinal=2 field=preprocessing-flushed outcome=satisfied
+INVARIANT ordinal=3 field=eof-emitted-once outcome=satisfied
+INVARIANT ordinal=4 field=pending-constructs-flushed outcome=satisfied
+INVARIANT ordinal=5 field=output-accounted-for outcome=satisfied
+INVARIANT ordinal=6 field=pending-table-text-empty outcome=satisfied
+INVARIANT ordinal=7 field=insertion-mode-valid outcome=satisfied
+INVARIANT ordinal=8 field=open-elements-consistent outcome=satisfied
+INVARIANT ordinal=9 field=active-formatting-consistent outcome=satisfied
+INVARIANT ordinal=10 field=template-modes-consistent outcome=satisfied
+INVARIANT ordinal=11 field=form-pointer-valid outcome=satisfied
+INVARIANT ordinal=12 field=parent-child-links-valid outcome=satisfied
+INVARIANT ordinal=13 field=namespaces-valid outcome=satisfied
+INVARIANT ordinal=14 field=template-associations-valid outcome=satisfied
+INVARIANT ordinal=15 field=all-patches-materialized outcome=satisfied
+INVARIANT ordinal=16 field=live-tree-matches-materialized-dom outcome=satisfied
diff --git a/crates/html/tests/fixtures/html5/conformance/processing-instruction-boundaries/fixture.toml b/crates/html/tests/fixtures/html5/conformance/processing-instruction-boundaries/fixture.toml
new file mode 100644
index 00000000..a694b421
--- /dev/null
+++ b/crates/html/tests/fixtures/html5/conformance/processing-instruction-boundaries/fixture.toml
@@ -0,0 +1,28 @@
+format = "borrowser-html-parser-fixture-v2"
+id = "processing-instruction-boundaries"
+[source]
+kind = "native"
+[input]
+path = "input.html"
+kind = "utf8-text"
+sha256 = "3ede96a0f270ad9d2f668285f24cf78e4a91eb31edaadc98c9c7d061fd92d288"
+[execution]
+reference_delivery = "whole-unicode"
+[execution.target]
+kind = "document"
+scripting = "disabled"
+[[execution.deliveries]]
+name = "whole-unicode"
+unit = "unicode-scalars"
+strategy = "whole"
+[[execution.deliveries]]
+name = "declared-scalar-split"
+unit = "unicode-scalars"
+strategy = "boundaries"
+boundaries = [1]
+[expectations]
+final_invariants = "final-invariants.txt"
+[disposition]
+status = "active"
+[metadata]
+description = "Processing-instruction target and data construction remain chunk-independent."
diff --git a/crates/html/tests/fixtures/html5/conformance/processing-instruction-boundaries/input.html b/crates/html/tests/fixtures/html5/conformance/processing-instruction-boundaries/input.html
new file mode 100644
index 00000000..c20923fe
--- /dev/null
+++ b/crates/html/tests/fixtures/html5/conformance/processing-instruction-boundaries/input.html
@@ -0,0 +1 @@
+<?target data?><!doctype html><p>x
diff --git a/crates/html/tests/fixtures/html5/conformance/table-buffering-foster-parenting/final-invariants.txt b/crates/html/tests/fixtures/html5/conformance/table-buffering-foster-parenting/final-invariants.txt
new file mode 100644
index 00000000..22f788a2
--- /dev/null
+++ b/crates/html/tests/fixtures/html5/conformance/table-buffering-foster-parenting/final-invariants.txt
@@ -0,0 +1,17 @@
+# format: html5-final-invariants-v1
+INVARIANT ordinal=1 field=decoder-carry-empty outcome=satisfied
+INVARIANT ordinal=2 field=preprocessing-flushed outcome=satisfied
+INVARIANT ordinal=3 field=eof-emitted-once outcome=satisfied
+INVARIANT ordinal=4 field=pending-constructs-flushed outcome=satisfied
+INVARIANT ordinal=5 field=output-accounted-for outcome=satisfied
+INVARIANT ordinal=6 field=pending-table-text-empty outcome=satisfied
+INVARIANT ordinal=7 field=insertion-mode-valid outcome=satisfied
+INVARIANT ordinal=8 field=open-elements-consistent outcome=satisfied
+INVARIANT ordinal=9 field=active-formatting-consistent outcome=satisfied
+INVARIANT ordinal=10 field=template-modes-consistent outcome=satisfied
+INVARIANT ordinal=11 field=form-pointer-valid outcome=satisfied
+INVARIANT ordinal=12 field=parent-child-links-valid outcome=satisfied
+INVARIANT ordinal=13 field=namespaces-valid outcome=satisfied
+INVARIANT ordinal=14 field=template-associations-valid outcome=satisfied
+INVARIANT ordinal=15 field=all-patches-materialized outcome=satisfied
+INVARIANT ordinal=16 field=live-tree-matches-materialized-dom outcome=satisfied
diff --git a/crates/html/tests/fixtures/html5/conformance/table-buffering-foster-parenting/fixture.toml b/crates/html/tests/fixtures/html5/conformance/table-buffering-foster-parenting/fixture.toml
new file mode 100644
index 00000000..5f297467
--- /dev/null
+++ b/crates/html/tests/fixtures/html5/conformance/table-buffering-foster-parenting/fixture.toml
@@ -0,0 +1,28 @@
+format = "borrowser-html-parser-fixture-v2"
+id = "table-buffering-foster-parenting"
+[source]
+kind = "native"
+[input]
+path = "input.html"
+kind = "utf8-text"
+sha256 = "5eb4a0d7b2910e9179f221f8b888fb1ae999f0c4f38afd3b1e067d3fef62cc18"
+[execution]
+reference_delivery = "whole-unicode"
+[execution.target]
+kind = "document"
+scripting = "disabled"
+[[execution.deliveries]]
+name = "whole-unicode"
+unit = "unicode-scalars"
+strategy = "whole"
+[[execution.deliveries]]
+name = "declared-scalar-split"
+unit = "unicode-scalars"
+strategy = "boundaries"
+boundaries = [1]
+[expectations]
+final_invariants = "final-invariants.txt"
+[disposition]
+status = "active"
+[metadata]
+description = "Pending table text and foster-parenting recovery remain chunk-independent."
diff --git a/crates/html/tests/fixtures/html5/conformance/table-buffering-foster-parenting/input.html b/crates/html/tests/fixtures/html5/conformance/table-buffering-foster-parenting/input.html
new file mode 100644
index 00000000..5927a10c
--- /dev/null
+++ b/crates/html/tests/fixtures/html5/conformance/table-buffering-foster-parenting/input.html
@@ -0,0 +1 @@
+<!doctype html><table>before<tr><td>x</td></tr>after</table>
diff --git a/crates/html/tests/fixtures/html5/conformance/tag-attribute-boundaries/final-invariants.txt b/crates/html/tests/fixtures/html5/conformance/tag-attribute-boundaries/final-invariants.txt
new file mode 100644
index 00000000..22f788a2
--- /dev/null
+++ b/crates/html/tests/fixtures/html5/conformance/tag-attribute-boundaries/final-invariants.txt
@@ -0,0 +1,17 @@
+# format: html5-final-invariants-v1
+INVARIANT ordinal=1 field=decoder-carry-empty outcome=satisfied
+INVARIANT ordinal=2 field=preprocessing-flushed outcome=satisfied
+INVARIANT ordinal=3 field=eof-emitted-once outcome=satisfied
+INVARIANT ordinal=4 field=pending-constructs-flushed outcome=satisfied
+INVARIANT ordinal=5 field=output-accounted-for outcome=satisfied
+INVARIANT ordinal=6 field=pending-table-text-empty outcome=satisfied
+INVARIANT ordinal=7 field=insertion-mode-valid outcome=satisfied
+INVARIANT ordinal=8 field=open-elements-consistent outcome=satisfied
+INVARIANT ordinal=9 field=active-formatting-consistent outcome=satisfied
+INVARIANT ordinal=10 field=template-modes-consistent outcome=satisfied
+INVARIANT ordinal=11 field=form-pointer-valid outcome=satisfied
+INVARIANT ordinal=12 field=parent-child-links-valid outcome=satisfied
+INVARIANT ordinal=13 field=namespaces-valid outcome=satisfied
+INVARIANT ordinal=14 field=template-associations-valid outcome=satisfied
+INVARIANT ordinal=15 field=all-patches-materialized outcome=satisfied
+INVARIANT ordinal=16 field=live-tree-matches-materialized-dom outcome=satisfied
diff --git a/crates/html/tests/fixtures/html5/conformance/tag-attribute-boundaries/fixture.toml b/crates/html/tests/fixtures/html5/conformance/tag-attribute-boundaries/fixture.toml
new file mode 100644
index 00000000..bfb5af39
--- /dev/null
+++ b/crates/html/tests/fixtures/html5/conformance/tag-attribute-boundaries/fixture.toml
@@ -0,0 +1,28 @@
+format = "borrowser-html-parser-fixture-v2"
+id = "tag-attribute-boundaries"
+[source]
+kind = "native"
+[input]
+path = "input.html"
+kind = "utf8-text"
+sha256 = "13945839303f2c8823b92220d9555060cd18abf2af292d1c709a4cde74d18702"
+[execution]
+reference_delivery = "whole-unicode"
+[execution.target]
+kind = "document"
+scripting = "disabled"
+[[execution.deliveries]]
+name = "whole-unicode"
+unit = "unicode-scalars"
+strategy = "whole"
+[[execution.deliveries]]
+name = "declared-scalar-split"
+unit = "unicode-scalars"
+strategy = "boundaries"
+boundaries = [1]
+[expectations]
+final_invariants = "final-invariants.txt"
+[disposition]
+status = "active"
+[metadata]
+description = "Tag delimiters and ordered attribute names and values remain chunk-independent."
diff --git a/crates/html/tests/fixtures/html5/conformance/tag-attribute-boundaries/input.html b/crates/html/tests/fixtures/html5/conformance/tag-attribute-boundaries/input.html
new file mode 100644
index 00000000..617fba62
--- /dev/null
+++ b/crates/html/tests/fixtures/html5/conformance/tag-attribute-boundaries/input.html
@@ -0,0 +1 @@
+<!doctype html><div data-x="é value" disabled>ok</div>
diff --git a/crates/html/tests/fixtures/html5/conformance/template-state-eof/final-invariants.txt b/crates/html/tests/fixtures/html5/conformance/template-state-eof/final-invariants.txt
new file mode 100644
index 00000000..22f788a2
--- /dev/null
+++ b/crates/html/tests/fixtures/html5/conformance/template-state-eof/final-invariants.txt
@@ -0,0 +1,17 @@
+# format: html5-final-invariants-v1
+INVARIANT ordinal=1 field=decoder-carry-empty outcome=satisfied
+INVARIANT ordinal=2 field=preprocessing-flushed outcome=satisfied
+INVARIANT ordinal=3 field=eof-emitted-once outcome=satisfied
+INVARIANT ordinal=4 field=pending-constructs-flushed outcome=satisfied
+INVARIANT ordinal=5 field=output-accounted-for outcome=satisfied
+INVARIANT ordinal=6 field=pending-table-text-empty outcome=satisfied
+INVARIANT ordinal=7 field=insertion-mode-valid outcome=satisfied
+INVARIANT ordinal=8 field=open-elements-consistent outcome=satisfied
+INVARIANT ordinal=9 field=active-formatting-consistent outcome=satisfied
+INVARIANT ordinal=10 field=template-modes-consistent outcome=satisfied
+INVARIANT ordinal=11 field=form-pointer-valid outcome=satisfied
+INVARIANT ordinal=12 field=parent-child-links-valid outcome=satisfied
+INVARIANT ordinal=13 field=namespaces-valid outcome=satisfied
+INVARIANT ordinal=14 field=template-associations-valid outcome=satisfied
+INVARIANT ordinal=15 field=all-patches-materialized outcome=satisfied
+INVARIANT ordinal=16 field=live-tree-matches-materialized-dom outcome=satisfied
diff --git a/crates/html/tests/fixtures/html5/conformance/template-state-eof/fixture.toml b/crates/html/tests/fixtures/html5/conformance/template-state-eof/fixture.toml
new file mode 100644
index 00000000..e126a2fc
--- /dev/null
+++ b/crates/html/tests/fixtures/html5/conformance/template-state-eof/fixture.toml
@@ -0,0 +1,28 @@
+format = "borrowser-html-parser-fixture-v2"
+id = "template-state-eof"
+[source]
+kind = "native"
+[input]
+path = "input.html"
+kind = "utf8-text"
+sha256 = "a4a1c1e7f45208cd1be92292ceb418e5a3e5d1699014931d283fc07f80959d80"
+[execution]
+reference_delivery = "whole-unicode"
+[execution.target]
+kind = "document"
+scripting = "disabled"
+[[execution.deliveries]]
+name = "whole-unicode"
+unit = "unicode-scalars"
+strategy = "whole"
+[[execution.deliveries]]
+name = "declared-scalar-split"
+unit = "unicode-scalars"
+strategy = "boundaries"
+boundaries = [1]
+[expectations]
+final_invariants = "final-invariants.txt"
+[disposition]
+status = "active"
+[metadata]
+description = "Nested template insertion modes, associations, and template EOF recovery remain chunk-independent."
diff --git a/crates/html/tests/fixtures/html5/conformance/template-state-eof/input.html b/crates/html/tests/fixtures/html5/conformance/template-state-eof/input.html
new file mode 100644
index 00000000..32835d66
--- /dev/null
+++ b/crates/html/tests/fixtures/html5/conformance/template-state-eof/input.html
@@ -0,0 +1 @@
+<!doctype html><template><table><tr><td>x<template>y
diff --git a/crates/html/tests/fixtures/html5/conformance/text-mode-boundaries/final-invariants.txt b/crates/html/tests/fixtures/html5/conformance/text-mode-boundaries/final-invariants.txt
new file mode 100644
index 00000000..22f788a2
--- /dev/null
+++ b/crates/html/tests/fixtures/html5/conformance/text-mode-boundaries/final-invariants.txt
@@ -0,0 +1,17 @@
+# format: html5-final-invariants-v1
+INVARIANT ordinal=1 field=decoder-carry-empty outcome=satisfied
+INVARIANT ordinal=2 field=preprocessing-flushed outcome=satisfied
+INVARIANT ordinal=3 field=eof-emitted-once outcome=satisfied
+INVARIANT ordinal=4 field=pending-constructs-flushed outcome=satisfied
+INVARIANT ordinal=5 field=output-accounted-for outcome=satisfied
+INVARIANT ordinal=6 field=pending-table-text-empty outcome=satisfied
+INVARIANT ordinal=7 field=insertion-mode-valid outcome=satisfied
+INVARIANT ordinal=8 field=open-elements-consistent outcome=satisfied
+INVARIANT ordinal=9 field=active-formatting-consistent outcome=satisfied
+INVARIANT ordinal=10 field=template-modes-consistent outcome=satisfied
+INVARIANT ordinal=11 field=form-pointer-valid outcome=satisfied
+INVARIANT ordinal=12 field=parent-child-links-valid outcome=satisfied
+INVARIANT ordinal=13 field=namespaces-valid outcome=satisfied
+INVARIANT ordinal=14 field=template-associations-valid outcome=satisfied
+INVARIANT ordinal=15 field=all-patches-materialized outcome=satisfied
+INVARIANT ordinal=16 field=live-tree-matches-materialized-dom outcome=satisfied
diff --git a/crates/html/tests/fixtures/html5/conformance/text-mode-boundaries/fixture.toml b/crates/html/tests/fixtures/html5/conformance/text-mode-boundaries/fixture.toml
new file mode 100644
index 00000000..d3f5b5e9
--- /dev/null
+++ b/crates/html/tests/fixtures/html5/conformance/text-mode-boundaries/fixture.toml
@@ -0,0 +1,28 @@
+format = "borrowser-html-parser-fixture-v2"
+id = "text-mode-boundaries"
+[source]
+kind = "native"
+[input]
+path = "input.html"
+kind = "utf8-text"
+sha256 = "763fa9ecce235f6b942b7f5065fd90343b4613a0045fff54be9a92577d8e1610"
+[execution]
+reference_delivery = "whole-unicode"
+[execution.target]
+kind = "document"
+scripting = "disabled"
+[[execution.deliveries]]
+name = "whole-unicode"
+unit = "unicode-scalars"
+strategy = "whole"
+[[execution.deliveries]]
+name = "declared-scalar-split"
+unit = "unicode-scalars"
+strategy = "boundaries"
+boundaries = [1]
+[expectations]
+final_invariants = "final-invariants.txt"
+[disposition]
+status = "active"
+[metadata]
+description = "RCDATA, RAWTEXT, and supported script-data termination remain chunk-independent."
diff --git a/crates/html/tests/fixtures/html5/conformance/text-mode-boundaries/input.html b/crates/html/tests/fixtures/html5/conformance/text-mode-boundaries/input.html
new file mode 100644
index 00000000..71e4ef9a
--- /dev/null
+++ b/crates/html/tests/fixtures/html5/conformance/text-mode-boundaries/input.html
@@ -0,0 +1 @@
+<!doctype html><title>a&amp;b</title><style>x<&y</style><script>if(a<b){c&d}</script>
diff --git a/crates/html/tests/fixtures/html5/conformance/tokenizer-eof-recovery/final-invariants.txt b/crates/html/tests/fixtures/html5/conformance/tokenizer-eof-recovery/final-invariants.txt
new file mode 100644
index 00000000..22f788a2
--- /dev/null
+++ b/crates/html/tests/fixtures/html5/conformance/tokenizer-eof-recovery/final-invariants.txt
@@ -0,0 +1,17 @@
+# format: html5-final-invariants-v1
+INVARIANT ordinal=1 field=decoder-carry-empty outcome=satisfied
+INVARIANT ordinal=2 field=preprocessing-flushed outcome=satisfied
+INVARIANT ordinal=3 field=eof-emitted-once outcome=satisfied
+INVARIANT ordinal=4 field=pending-constructs-flushed outcome=satisfied
+INVARIANT ordinal=5 field=output-accounted-for outcome=satisfied
+INVARIANT ordinal=6 field=pending-table-text-empty outcome=satisfied
+INVARIANT ordinal=7 field=insertion-mode-valid outcome=satisfied
+INVARIANT ordinal=8 field=open-elements-consistent outcome=satisfied
+INVARIANT ordinal=9 field=active-formatting-consistent outcome=satisfied
+INVARIANT ordinal=10 field=template-modes-consistent outcome=satisfied
+INVARIANT ordinal=11 field=form-pointer-valid outcome=satisfied
+INVARIANT ordinal=12 field=parent-child-links-valid outcome=satisfied
+INVARIANT ordinal=13 field=namespaces-valid outcome=satisfied
+INVARIANT ordinal=14 field=template-associations-valid outcome=satisfied
+INVARIANT ordinal=15 field=all-patches-materialized outcome=satisfied
+INVARIANT ordinal=16 field=live-tree-matches-materialized-dom outcome=satisfied
diff --git a/crates/html/tests/fixtures/html5/conformance/tokenizer-eof-recovery/fixture.toml b/crates/html/tests/fixtures/html5/conformance/tokenizer-eof-recovery/fixture.toml
new file mode 100644
index 00000000..29f14414
--- /dev/null
+++ b/crates/html/tests/fixtures/html5/conformance/tokenizer-eof-recovery/fixture.toml
@@ -0,0 +1,28 @@
+format = "borrowser-html-parser-fixture-v2"
+id = "tokenizer-eof-recovery"
+[source]
+kind = "native"
+[input]
+path = "input.html"
+kind = "utf8-text"
+sha256 = "0a478015cc6f8fd7de92ddd658f5f19a4ee645e5854b2da12a5955c59c15d58b"
+[execution]
+reference_delivery = "whole-unicode"
+[execution.target]
+kind = "document"
+scripting = "disabled"
+[[execution.deliveries]]
+name = "whole-unicode"
+unit = "unicode-scalars"
+strategy = "whole"
+[[execution.deliveries]]
+name = "declared-scalar-split"
+unit = "unicode-scalars"
+strategy = "boundaries"
+boundaries = [1]
+[expectations]
+final_invariants = "final-invariants.txt"
+[disposition]
+status = "active"
+[metadata]
+description = "Tokenizer EOF recovery flushes pending comment and tag-like constructs identically."
diff --git a/crates/html/tests/fixtures/html5/conformance/tokenizer-eof-recovery/input.html b/crates/html/tests/fixtures/html5/conformance/tokenizer-eof-recovery/input.html
new file mode 100644
index 00000000..22f8de9a
--- /dev/null
+++ b/crates/html/tests/fixtures/html5/conformance/tokenizer-eof-recovery/input.html
@@ -0,0 +1 @@
+<!doctype html><!--open<div title='x
diff --git a/crates/html/tests/fixtures/html5/conformance/utf8-decoding-preprocessing/final-invariants.txt b/crates/html/tests/fixtures/html5/conformance/utf8-decoding-preprocessing/final-invariants.txt
new file mode 100644
index 00000000..6bb10935
--- /dev/null
+++ b/crates/html/tests/fixtures/html5/conformance/utf8-decoding-preprocessing/final-invariants.txt
@@ -0,0 +1,17 @@
+# format: html5-final-invariants-v1
+INVARIANT ordinal=1 field=decoder-carry-empty outcome=satisfied
+INVARIANT ordinal=2 field=preprocessing-flushed outcome=satisfied
+INVARIANT ordinal=3 field=eof-emitted-once outcome=satisfied
+INVARIANT ordinal=4 field=pending-constructs-flushed outcome=satisfied
+INVARIANT ordinal=5 field=output-accounted-for outcome=satisfied
+INVARIANT ordinal=6 field=pending-table-text-empty outcome=not-applicable:standalone-tokenizer-run
+INVARIANT ordinal=7 field=insertion-mode-valid outcome=not-applicable:standalone-tokenizer-run
+INVARIANT ordinal=8 field=open-elements-consistent outcome=not-applicable:standalone-tokenizer-run
+INVARIANT ordinal=9 field=active-formatting-consistent outcome=not-applicable:standalone-tokenizer-run
+INVARIANT ordinal=10 field=template-modes-consistent outcome=not-applicable:standalone-tokenizer-run
+INVARIANT ordinal=11 field=form-pointer-valid outcome=not-applicable:standalone-tokenizer-run
+INVARIANT ordinal=12 field=parent-child-links-valid outcome=not-applicable:standalone-tokenizer-run
+INVARIANT ordinal=13 field=namespaces-valid outcome=not-applicable:standalone-tokenizer-run
+INVARIANT ordinal=14 field=template-associations-valid outcome=not-applicable:standalone-tokenizer-run
+INVARIANT ordinal=15 field=all-patches-materialized outcome=not-applicable:standalone-tokenizer-run
+INVARIANT ordinal=16 field=live-tree-matches-materialized-dom outcome=not-applicable:standalone-tokenizer-run
diff --git a/crates/html/tests/fixtures/html5/conformance/utf8-decoding-preprocessing/fixture.toml b/crates/html/tests/fixtures/html5/conformance/utf8-decoding-preprocessing/fixture.toml
new file mode 100644
index 00000000..b2fe1285
--- /dev/null
+++ b/crates/html/tests/fixtures/html5/conformance/utf8-decoding-preprocessing/fixture.toml
@@ -0,0 +1,36 @@
+format = "borrowser-html-parser-fixture-v2"
+id = "utf8-decoding-preprocessing"
+
+[source]
+kind = "native"
+
+[input]
+path = "input.bin"
+kind = "raw-bytes"
+sha256 = "7c146e51598f9c7daa770f8c2aacc77fed2e4b82c18e754aff8b3ea5aad4b66b"
+
+[execution]
+reference_delivery = "whole-bytes"
+
+[execution.target]
+kind = "standalone-tokenizer"
+
+[[execution.deliveries]]
+name = "whole-bytes"
+unit = "bytes"
+strategy = "whole"
+
+[[execution.deliveries]]
+name = "declared-byte-splits"
+unit = "bytes"
+strategy = "boundaries"
+boundaries = [1, 2]
+
+[expectations]
+final_invariants = "final-invariants.txt"
+
+[disposition]
+status = "active"
+
+[metadata]
+description = "Raw decoder entry, multibyte UTF-8 splitting, preprocessing, and EOF finalization remain chunk-independent."
diff --git a/crates/html/tests/fixtures/html5/conformance/utf8-decoding-preprocessing/input.bin b/crates/html/tests/fixtures/html5/conformance/utf8-decoding-preprocessing/input.bin
new file mode 100644
index 00000000..321bb728
--- /dev/null
+++ b/crates/html/tests/fixtures/html5/conformance/utf8-decoding-preprocessing/input.bin
@@ -0,0 +1,2 @@
+Aé
+B
diff --git a/crates/html/tests/html5_parser_conformance.rs b/crates/html/tests/html5_parser_conformance.rs
index 36ab3688..16924a72 100644
--- a/crates/html/tests/html5_parser_conformance.rs
+++ b/crates/html/tests/html5_parser_conformance.rs
@@ -51,14 +51,19 @@ fn canonical_parser_conformance_corpus_executes_every_discovered_fixture() {
             .iter()
             .map(|delivery| delivery.delivery().as_str())
             .collect::<Vec<_>>(),
-        ["whole", "trace-whole"]
+        ["whole"]
     );
     let whole = structured.delivery_results()[0].result();
-    assert!(matches!(whole.transitions, ObservationState::NotRequested));
+    assert!(matches!(whole.transitions, ObservationState::Captured(_)));
     assert!(matches!(whole.tree, ObservationState::Captured(_)));
-    let trace = structured.delivery_results()[1].result();
-    assert!(matches!(trace.transitions, ObservationState::Captured(_)));
-    assert!(matches!(trace.tree, ObservationState::NotRequested));
+    assert_eq!(
+        structured.delivery_results()[0]
+            .aliases()
+            .iter()
+            .map(|alias| alias.as_str())
+            .collect::<Vec<_>>(),
+        ["whole", "trace-whole"]
+    );
 
     let unsupported = reports
         .iter()
diff --git a/crates/html_test_support/src/parser_fixture/disposition.rs b/crates/html_test_support/src/parser_fixture/disposition.rs
index 0210208c..c19053a3 100644
--- a/crates/html_test_support/src/parser_fixture/disposition.rs
+++ b/crates/html_test_support/src/parser_fixture/disposition.rs
@@ -15,7 +15,11 @@ pub(super) enum FixtureOutcomeClassification {
     ExecutionFailedV1(LegacyExecutionFailureClass),
     ExecutionFailedV2(ExecutionFailureClass),
     ExpectationMismatch(ExpectationSurface),
-    InvariantFailure(Vec<InvariantFailureCode>),
+    ParityMismatch(ExpectationSurface),
+    InvariantFailure {
+        first: Option<InvariantFailureCode>,
+        count: u8,
+    },
     IncompleteObservation,
 }
 
@@ -153,6 +157,9 @@ fn classify_outcome(outcome: &FixtureExecutionOutcome) -> FixtureOutcomeClassifi
         | FixtureExecutionOutcome::ExpectationMismatchV2 { surface, .. } => {
             FixtureOutcomeClassification::ExpectationMismatch(*surface)
         }
+        FixtureExecutionOutcome::ParityMismatchV2 { surface, .. } => {
+            FixtureOutcomeClassification::ParityMismatch(*surface)
+        }
         FixtureExecutionOutcome::UnsupportedExpectation { surface } => {
             FixtureOutcomeClassification::UnsupportedExpectation(*surface)
         }
@@ -166,8 +173,19 @@ fn classify_outcome(outcome: &FixtureExecutionOutcome) -> FixtureOutcomeClassifi
             FixtureOutcomeClassification::ExecutionFailedV2(*class)
         }
         FixtureExecutionOutcome::InvariantFailed { failures, .. } => {
-            FixtureOutcomeClassification::InvariantFailure(failures.clone())
+            FixtureOutcomeClassification::InvariantFailure {
+                first: failures.first().copied(),
+                count: u8::try_from(failures.len()).unwrap_or(u8::MAX),
+            }
         }
+        FixtureExecutionOutcome::FinalInvariantFailedV2 {
+            first_failure,
+            failure_count,
+            ..
+        } => FixtureOutcomeClassification::InvariantFailure {
+            first: Some(*first_failure),
+            count: *failure_count,
+        },
         FixtureExecutionOutcome::IncompleteObservation { .. }
         | FixtureExecutionOutcome::IncompleteObservationV2 { .. } => {
             FixtureOutcomeClassification::IncompleteObservation
@@ -190,8 +208,8 @@ fn failure_matches(
         ) => expected == actual,
         (
             ExpectedFailureClassification::InvariantFailure(expected),
-            FixtureOutcomeClassification::InvariantFailure(actual),
-        ) => actual.as_slice() == [*expected],
+            FixtureOutcomeClassification::InvariantFailure { first, count },
+        ) => *count == 1 && *first == Some(*expected),
         _ => false,
     }
 }
@@ -211,8 +229,8 @@ fn failure_matches_v2(
         ) => expected == actual,
         (
             ExpectedFailureClassificationV2::FinalInvariant(expected),
-            FixtureOutcomeClassification::InvariantFailure(actual),
-        ) => actual.as_slice() == [*expected],
+            FixtureOutcomeClassification::InvariantFailure { first, count },
+        ) => *count == 1 && *first == Some(*expected),
         _ => false,
     }
 }
@@ -264,7 +282,12 @@ fn outcome_name(value: &FixtureOutcomeClassification) -> String {
         FixtureOutcomeClassification::ExpectationMismatch(surface) => {
             format!("expectation-mismatch:{}", surface.name())
         }
-        FixtureOutcomeClassification::InvariantFailure(_) => "final-invariant-failure".to_string(),
+        FixtureOutcomeClassification::ParityMismatch(surface) => {
+            format!("parity-mismatch:{}", surface.name())
+        }
+        FixtureOutcomeClassification::InvariantFailure { .. } => {
+            "final-invariant-failure".to_string()
+        }
         FixtureOutcomeClassification::IncompleteObservation => "incomplete-observation".to_string(),
     }
 }
diff --git a/crates/html_test_support/src/parser_fixture/execution.rs b/crates/html_test_support/src/parser_fixture/execution.rs
index 71f6241c..243a3910 100644
--- a/crates/html_test_support/src/parser_fixture/execution.rs
+++ b/crates/html_test_support/src/parser_fixture/execution.rs
@@ -1,7 +1,7 @@
 use super::model::*;
-use super::validate::ValidatedFixtureSpec;
-use html::conformance::{ObservationRequest, ParserObservationRequest, ScalarObservationRequest};
-use std::collections::BTreeSet;
+use html::conformance::{
+    FinalInvariantRequest, ObservationRequest, ParserObservationRequest, ScalarObservationRequest,
+};
 
 /// Private canonical fixture-runner observation guardrails. These are
 /// defensive harness policy, not production parser limits, and fixture TOML or
@@ -39,110 +39,24 @@ pub(super) struct RequestedSurfaces {
     pub(super) patches: bool,
     pub(super) transitions: bool,
     pub(super) unsupported_features: bool,
+    pub(super) final_invariants: bool,
 }
 
 impl RequestedSurfaces {
-    pub(super) fn ordinary(expectations: &EnabledExpectations) -> Self {
+    pub(super) fn parity(target: &ValidatedParserTarget) -> Self {
+        let document = matches!(target, ValidatedParserTarget::Document { .. });
         Self {
-            tokens: expectations.is_declared(ExpectationSurface::Tokens),
-            parse_errors: expectations.is_declared(ExpectationSurface::ParseErrors),
-            implementation_diagnostics: expectations
-                .is_declared(ExpectationSurface::ImplementationDiagnostics),
-            document_mode: expectations.is_declared(ExpectationSurface::DocumentMode),
-            tree: expectations.is_declared(ExpectationSurface::Tree),
-            patches: expectations.is_declared(ExpectationSurface::Patches),
-            transitions: false,
-            unsupported_features: expectations.is_declared(ExpectationSurface::UnsupportedFeatures),
+            tokens: true,
+            parse_errors: true,
+            implementation_diagnostics: true,
+            document_mode: document,
+            tree: document,
+            patches: document,
+            transitions: document,
+            unsupported_features: true,
+            final_invariants: true,
         }
     }
-
-    fn union(&mut self, other: Self) {
-        self.tokens |= other.tokens;
-        self.parse_errors |= other.parse_errors;
-        self.implementation_diagnostics |= other.implementation_diagnostics;
-        self.document_mode |= other.document_mode;
-        self.tree |= other.tree;
-        self.patches |= other.patches;
-        self.transitions |= other.transitions;
-        self.unsupported_features |= other.unsupported_features;
-    }
-
-    pub(super) fn any(self) -> bool {
-        self.tokens
-            || self.parse_errors
-            || self.implementation_diagnostics
-            || self.document_mode
-            || self.tree
-            || self.patches
-            || self.transitions
-            || self.unsupported_features
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub(super) struct PlannedDelivery {
-    pub(super) name: DeliveryName,
-    pub(super) surfaces: RequestedSurfaces,
-}
-
-pub(super) fn build_delivery_plan(
-    fixture: &ValidatedFixtureSpec,
-) -> Result<Vec<PlannedDelivery>, ValidatedFixtureInvariantCode> {
-    let ordinary = RequestedSurfaces::ordinary(fixture.expectations());
-    let mut requested = Vec::<(DeliveryName, RequestedSurfaces)>::new();
-    if ordinary.any() {
-        requested.push((fixture.execution().reference_delivery().clone(), ordinary));
-    }
-    if let ExpectedSurface::Compare(transitions) = fixture.expectations().transitions() {
-        for transition in transitions {
-            requested.push((
-                transition.delivery().clone(),
-                RequestedSurfaces {
-                    transitions: true,
-                    ..RequestedSurfaces::default()
-                },
-            ));
-        }
-    }
-
-    let mut plan = Vec::new();
-    for delivery in fixture.execution().deliveries() {
-        let mut surfaces = RequestedSurfaces::default();
-        for (name, requested_surfaces) in &requested {
-            if name == delivery.name() {
-                surfaces.union(*requested_surfaces);
-            }
-        }
-        if surfaces.any() {
-            if plan
-                .iter()
-                .any(|planned: &PlannedDelivery| planned.name == *delivery.name())
-            {
-                return Err(ValidatedFixtureInvariantCode::DuplicatePlannedDelivery);
-            }
-            plan.push(PlannedDelivery {
-                name: delivery.name().clone(),
-                surfaces,
-            });
-        }
-    }
-    for (name, _) in requested {
-        if !plan.iter().any(|planned| planned.name == name) {
-            return Err(if name == *fixture.execution().reference_delivery() {
-                ValidatedFixtureInvariantCode::PlannedReferenceDeliveryMissing
-            } else {
-                ValidatedFixtureInvariantCode::PlannedDeliveryMissing
-            });
-        }
-    }
-    let unique = plan
-        .iter()
-        .map(|planned| planned.name.clone())
-        .collect::<BTreeSet<_>>();
-    if unique.len() != plan.len() {
-        return Err(ValidatedFixtureInvariantCode::DuplicatePlannedDelivery);
-    }
-    Ok(plan)
 }
 
 pub(super) fn observation_request<'a>(
@@ -172,9 +86,25 @@ pub(super) fn observation_request<'a>(
         },
         tree: request(surfaces.tree, guardrails.canonical_tree_units),
         patches: request(surfaces.patches, guardrails.patch_operations),
+        final_invariants: if surfaces.final_invariants {
+            FinalInvariantRequest::Capture
+        } else {
+            FinalInvariantRequest::NotRequested
+        },
     }
 }
 
+pub(super) fn observation_request_for_input<'a>(
+    target: html::conformance::ParserObservationTarget,
+    input: html::conformance::ParserObservationInput<'a>,
+    surfaces: RequestedSurfaces,
+    guardrails: FixtureObservationGuardrails,
+) -> ParserObservationRequest<'a> {
+    let mut request = observation_request(target, "", surfaces, guardrails);
+    request.input = input;
+    request
+}
+
 const fn request(enabled: bool, capacity: usize) -> ObservationRequest {
     if enabled {
         ObservationRequest::Capture { capacity }
diff --git a/crates/html_test_support/src/parser_fixture/failure_spelling.rs b/crates/html_test_support/src/parser_fixture/failure_spelling.rs
index 666e6e1f..54328c5d 100644
--- a/crates/html_test_support/src/parser_fixture/failure_spelling.rs
+++ b/crates/html_test_support/src/parser_fixture/failure_spelling.rs
@@ -1,10 +1,12 @@
 use super::model::{
-    ExecutionFailureClass, ParserObservationFailureClass, ValidatedFixtureInvariantCode,
+    ExecutionFailureClass, FixtureExecutionResourceSite, ParserObservationFailureClass,
+    ValidatedFixtureInvariantCode,
 };
 use html::conformance::{
-    ObservationReservationSite, ParserFatalIdentity, ParserObservationExecutionIdentity as I,
-    ParserObservationInvariantError as O, ParserReservationSiteIdentity as P,
-    ParserTokenizerInvariantError as T, UnsupportedFeatureObservationInvariantError as U,
+    ObservationReservationSite, ParserFatalIdentity, ParserObservationDeliveryErrorIdentity as D,
+    ParserObservationExecutionIdentity as I, ParserObservationInvariantError as O,
+    ParserReservationSiteIdentity as P, ParserTokenizerInvariantError as T,
+    UnsupportedFeatureObservationInvariantError as U,
 };
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -148,6 +150,8 @@ closed_codec!(
         O::DuplicatePatchCreation => "duplicate-patch-creation",
         O::MissingPatchCreationHistory => "missing-patch-creation-history",
         O::SnapshotLabelSequenceOverflow => "snapshot-label-sequence-overflow",
+        O::FinalAuditPatchCountOverflow => "final-audit-patch-count-overflow",
+        O::DerivedDeliverySlicingInvariant => "derived-delivery-slicing-invariant",
     }
 );
 
@@ -173,6 +177,29 @@ closed_codec!(
         ObservationReservationSite::CanonicalTreeProjection => "canonical-tree-projection",
         ObservationReservationSite::CanonicalPatchProjection => "canonical-patch-projection",
         ObservationReservationSite::SnapshotLabelStorage => "snapshot-label-storage",
+        ObservationReservationSite::FinalAuditLiveTreeStructuralProjection => "final-audit-live-tree-structural-projection",
+        ObservationReservationSite::FinalAuditPatchArenaStructuralProjection => "final-audit-patch-arena-structural-projection",
+        ObservationReservationSite::FinalAuditDomStructuralTraversal => "final-audit-dom-structural-traversal",
+        ObservationReservationSite::FinalAuditOpenElementsIndex => "final-audit-open-elements-index",
+        ObservationReservationSite::FinalAuditActiveFormattingIndex => "final-audit-active-formatting-index",
+        ObservationReservationSite::FinalAuditTemplateCoordinationIndex => "final-audit-template-coordination-index",
+        ObservationReservationSite::FinalAuditSemanticTraversal => "final-audit-semantic-traversal",
+    }
+);
+
+closed_codec!(
+    delivery_error_name,
+    parse_delivery_error,
+    all_delivery_errors,
+    D,
+    {
+        D::BoundaryAtStart => "boundary-at-start",
+        D::BoundaryAtEnd => "boundary-at-end",
+        D::BoundaryOutOfRange => "boundary-out-of-range",
+        D::BoundaryNotIncreasing => "boundary-not-increasing",
+        D::UnicodeBoundaryNotScalar => "unicode-boundary-not-scalar",
+        D::ZeroFixedChunkExtent => "zero-fixed-chunk-extent",
+        D::ArithmeticOverflow => "arithmetic-overflow",
     }
 );
 
@@ -195,6 +222,8 @@ closed_codec!(
         ValidatedFixtureInvariantCode::MissingExecutedDeliveryResult => "missing-executed-delivery-result",
         ValidatedFixtureInvariantCode::DuplicateExecutedDeliveryResult => "duplicate-executed-delivery-result",
         ValidatedFixtureInvariantCode::DuplicateExpectationIdentity => "duplicate-expectation-identity",
+        ValidatedFixtureInvariantCode::ValidatedBoundaryRejectedByExecutor => "validated-boundary-rejected-by-executor",
+        ValidatedFixtureInvariantCode::StrategyScheduleContradiction => "strategy-schedule-contradiction",
     }
 );
 
@@ -207,6 +236,10 @@ pub(super) fn parse_parser_observation_failure(
         ("parser-fatal-engine-invariant", None, None) => {
             I::ParserFatal(ParserFatalIdentity::EngineInvariant)
         }
+        ("invalid-delivery", Some(code), None) => I::InvalidDelivery(
+            parse_delivery_error(code)
+                .ok_or(FailureSpellingError::UnknownParserObservationIdentity)?,
+        ),
         ("parser-fatal-resource-exhaustion", None, Some(site)) => {
             I::ParserFatal(ParserFatalIdentity::ResourceExhaustion(
                 parse_parser_reservation_site(site)
@@ -249,7 +282,8 @@ pub(super) fn parse_parser_observation_failure(
 fn is_parser_observation_identity(identity: &str) -> bool {
     matches!(
         identity,
-        "parser-fatal-engine-invariant"
+        "invalid-delivery"
+            | "parser-fatal-engine-invariant"
             | "parser-fatal-resource-exhaustion"
             | "parser-invariant"
             | "tokenizer-invariant"
@@ -272,6 +306,11 @@ pub(super) const fn parser_observation_failure_spelling(
             code: None,
             site: None,
         },
+        I::InvalidDelivery(code) => ParserObservationFailureSpelling {
+            identity: "invalid-delivery",
+            code: Some(delivery_error_name(code)),
+            site: None,
+        },
         I::ParserFatal(ParserFatalIdentity::ResourceExhaustion(site)) => {
             ParserObservationFailureSpelling {
                 identity: "parser-fatal-resource-exhaustion",
@@ -355,8 +394,20 @@ pub(super) fn execution_failure_name(value: ExecutionFailureClass) -> String {
             "parser-observation:{}",
             parser_observation_failure_name(identity)
         ),
+        ExecutionFailureClass::FixtureExecutionResourceExhaustion(site) => format!(
+            "fixture-execution-resource-exhaustion:{}",
+            fixture_execution_resource_site_name(site)
+        ),
         ExecutionFailureClass::ValidatedFixtureInvariant(code) => {
             format!("validated-runner-invariant:{}", runner_invariant_name(code))
         }
     }
 }
+
+const fn fixture_execution_resource_site_name(site: FixtureExecutionResourceSite) -> &'static str {
+    match site {
+        FixtureExecutionResourceSite::ScalarBoundaryExecutionOffsets => {
+            "scalar-boundary-execution-offsets"
+        }
+    }
+}
diff --git a/crates/html_test_support/src/parser_fixture/load.rs b/crates/html_test_support/src/parser_fixture/load.rs
index dd234ce7..deb2ce95 100644
--- a/crates/html_test_support/src/parser_fixture/load.rs
+++ b/crates/html_test_support/src/parser_fixture/load.rs
@@ -1,4 +1,4 @@
-use super::model::{FIXTURE_FORMAT_V1, FIXTURE_FORMAT_V2, FixtureBundle, FixtureId};
+use super::model::{DeliveryName, FIXTURE_FORMAT_V1, FIXTURE_FORMAT_V2, FixtureBundle, FixtureId};
 use super::schema::{FixtureFileV1, FixtureFileV2, FixtureFormatEnvelope};
 use super::validate::{ValidatedFixtureSpec, validate_fixture_v1, validate_fixture_v2};
 use std::collections::{BTreeMap, BTreeSet};
@@ -69,6 +69,76 @@ pub struct FixtureLoadError {
     pub kind: FixtureLoadErrorKind,
 }
 
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum DeliveryValidationError {
+    TooManyDeclaredDeliveries {
+        declared: usize,
+        maximum: usize,
+    },
+    TooManyBoundaries {
+        delivery_index: usize,
+        declared_name: String,
+        declared: usize,
+        maximum: usize,
+    },
+    InvalidDeliveryName {
+        delivery_index: usize,
+        declared_name: String,
+    },
+    InvalidReferenceDeliveryName {
+        declared_name: String,
+    },
+    DuplicateDeliveryName {
+        delivery_index: usize,
+        declared_name: String,
+    },
+    UnitNotSupportedForInputDomain {
+        delivery: DeliveryName,
+    },
+    BoundariesMissing {
+        delivery: DeliveryName,
+    },
+    BoundariesUnexpected {
+        delivery: DeliveryName,
+    },
+    BoundaryAtStart {
+        delivery: DeliveryName,
+        boundary_index: usize,
+    },
+    BoundaryAtEnd {
+        delivery: DeliveryName,
+        boundary_index: usize,
+    },
+    BoundaryOutOfRange {
+        delivery: DeliveryName,
+        boundary_index: usize,
+    },
+    DuplicateBoundary {
+        delivery: DeliveryName,
+        boundary_index: usize,
+    },
+    UnsortedBoundary {
+        delivery: DeliveryName,
+        boundary_index: usize,
+    },
+    MissingDomainBaseline,
+    ReferenceIsNotDomainBaseline {
+        delivery: DeliveryName,
+    },
+    ReferenceDeliveryMissing {
+        delivery: DeliveryName,
+    },
+    TooManyUniqueStrategies {
+        planned: usize,
+        maximum: usize,
+    },
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum FixturePlanningInvariant {
+    StrategyOrdinalOverflow,
+}
+
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum FixtureLoadErrorKind {
     FixtureRootOutsideRepository,
@@ -95,6 +165,8 @@ pub enum FixtureLoadErrorKind {
     InvalidExtensionId(String),
     InvalidDisposition(String),
     InvalidCombination(String),
+    InvalidDelivery(DeliveryValidationError),
+    InternalPlanningInvariant(FixturePlanningInvariant),
 }
 
 impl std::fmt::Display for FixtureLoadError {
@@ -181,6 +253,112 @@ impl std::fmt::Display for FixtureLoadError {
             FixtureLoadErrorKind::InvalidCombination(message) => {
                 write!(f, "invalid fixture combination: {message}")
             }
+            FixtureLoadErrorKind::InvalidDelivery(error) => {
+                write!(f, "invalid fixture delivery: {error}")
+            }
+            FixtureLoadErrorKind::InternalPlanningInvariant(invariant) => match invariant {
+                FixturePlanningInvariant::StrategyOrdinalOverflow => {
+                    f.write_str("internal fixture-planning invariant: strategy ordinal overflow")
+                }
+            },
+        }
+    }
+}
+
+impl std::fmt::Display for DeliveryValidationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::TooManyDeclaredDeliveries { declared, maximum } => {
+                write!(f, "too-many-declared-deliveries:{declared}:{maximum}")
+            }
+            Self::TooManyBoundaries {
+                delivery_index,
+                declared_name,
+                declared,
+                maximum,
+            } => {
+                write!(
+                    f,
+                    "too-many-boundaries:{delivery_index}:{declared_name}:{declared}:{maximum}"
+                )
+            }
+            Self::InvalidDeliveryName {
+                delivery_index,
+                declared_name,
+            } => {
+                write!(f, "invalid-delivery-name:{delivery_index}:{declared_name}")
+            }
+            Self::InvalidReferenceDeliveryName { declared_name } => {
+                write!(f, "invalid-reference-delivery-name:{declared_name}")
+            }
+            Self::DuplicateDeliveryName {
+                delivery_index,
+                declared_name,
+            } => {
+                write!(
+                    f,
+                    "duplicate-delivery-name:{delivery_index}:{declared_name}"
+                )
+            }
+            Self::UnitNotSupportedForInputDomain { delivery } => {
+                write!(
+                    f,
+                    "unit-not-supported-for-input-domain:{}",
+                    delivery.as_str()
+                )
+            }
+            Self::BoundariesMissing { delivery } => {
+                write!(f, "boundaries-missing:{}", delivery.as_str())
+            }
+            Self::BoundariesUnexpected { delivery } => {
+                write!(f, "boundaries-unexpected:{}", delivery.as_str())
+            }
+            Self::BoundaryAtStart {
+                delivery,
+                boundary_index,
+            } => write!(
+                f,
+                "boundary-at-start:{}:{boundary_index}",
+                delivery.as_str()
+            ),
+            Self::BoundaryAtEnd {
+                delivery,
+                boundary_index,
+            } => write!(f, "boundary-at-end:{}:{boundary_index}", delivery.as_str()),
+            Self::BoundaryOutOfRange {
+                delivery,
+                boundary_index,
+            } => write!(
+                f,
+                "boundary-out-of-range:{}:{boundary_index}",
+                delivery.as_str()
+            ),
+            Self::DuplicateBoundary {
+                delivery,
+                boundary_index,
+            } => write!(
+                f,
+                "duplicate-boundary:{}:{boundary_index}",
+                delivery.as_str()
+            ),
+            Self::UnsortedBoundary {
+                delivery,
+                boundary_index,
+            } => write!(
+                f,
+                "unsorted-boundary:{}:{boundary_index}",
+                delivery.as_str()
+            ),
+            Self::MissingDomainBaseline => f.write_str("missing-domain-baseline"),
+            Self::ReferenceIsNotDomainBaseline { delivery } => {
+                write!(f, "reference-is-not-domain-baseline:{}", delivery.as_str())
+            }
+            Self::ReferenceDeliveryMissing { delivery } => {
+                write!(f, "reference-delivery-missing:{}", delivery.as_str())
+            }
+            Self::TooManyUniqueStrategies { planned, maximum } => {
+                write!(f, "too-many-unique-strategies:{planned}:{maximum}")
+            }
         }
     }
 }
diff --git a/crates/html_test_support/src/parser_fixture/mismatch.rs b/crates/html_test_support/src/parser_fixture/mismatch.rs
index d329540c..1c9cdef9 100644
--- a/crates/html_test_support/src/parser_fixture/mismatch.rs
+++ b/crates/html_test_support/src/parser_fixture/mismatch.rs
@@ -1,6 +1,7 @@
 use super::model::{DeliveryName, ExpectationSurface, SnapshotPath, ValidatedFixtureInvariantCode};
 use super::validate::ValidatedFixtureSpec;
 use crate::parser_snapshot::{CanonicalSnapshot, ParsedSnapshot};
+use html::conformance::CanonicalParserResult;
 use std::fmt::Write;
 
 pub(super) fn compare_snapshots(
@@ -110,7 +111,7 @@ pub(super) fn compare_snapshots(
     Ok(Some(message))
 }
 
-pub(super) const fn comparison_order() -> [ExpectationSurface; 8] {
+pub(super) const fn comparison_order() -> [ExpectationSurface; 9] {
     [
         ExpectationSurface::Tokens,
         ExpectationSurface::ParseErrors,
@@ -120,5 +121,103 @@ pub(super) const fn comparison_order() -> [ExpectationSurface; 8] {
         ExpectationSurface::Patches,
         ExpectationSurface::Transitions,
         ExpectationSurface::UnsupportedFeatures,
+        ExpectationSurface::FinalInvariants,
     ]
 }
+
+/// Compare parser observations as typed canonical values. Snapshot text is a
+/// diagnostic representation only and is intentionally not part of parity
+/// equality.
+pub(super) fn first_typed_parity_mismatch(
+    baseline: &CanonicalParserResult,
+    candidate: &CanonicalParserResult,
+) -> Result<Option<ExpectationSurface>, ValidatedFixtureInvariantCode> {
+    for surface in comparison_order() {
+        let equal = match surface {
+            ExpectationSurface::Tokens => baseline.tokens == candidate.tokens,
+            ExpectationSurface::ParseErrors => baseline.parse_errors == candidate.parse_errors,
+            ExpectationSurface::ImplementationDiagnostics => {
+                baseline.implementation_diagnostics == candidate.implementation_diagnostics
+            }
+            ExpectationSurface::DocumentMode => baseline.document_mode == candidate.document_mode,
+            ExpectationSurface::Tree => baseline.tree == candidate.tree,
+            ExpectationSurface::Patches => baseline.patches == candidate.patches,
+            ExpectationSurface::Transitions => baseline.transitions == candidate.transitions,
+            ExpectationSurface::UnsupportedFeatures => {
+                baseline.unsupported_features == candidate.unsupported_features
+            }
+            ExpectationSurface::FinalInvariants => {
+                baseline.final_invariants == candidate.final_invariants
+            }
+        };
+        if !equal {
+            return Ok(Some(surface));
+        }
+    }
+    Ok(None)
+}
+
+pub(super) fn compare_parity_snapshots(
+    fixture: &ValidatedFixtureSpec,
+    strategy: &str,
+    baseline: &CanonicalSnapshot,
+    candidate: &CanonicalSnapshot,
+) -> Result<Option<String>, ValidatedFixtureInvariantCode> {
+    if baseline.surface() != candidate.surface() || baseline.format() != candidate.format() {
+        return Err(ValidatedFixtureInvariantCode::ComparisonSurfaceContradiction);
+    }
+    let baseline_records = baseline.snapshot();
+    let candidate_records = candidate.snapshot();
+    let shared = baseline_records
+        .record_count()
+        .min(candidate_records.record_count());
+    let first = (0..shared)
+        .find(|index| {
+            baseline_records.record(*index).map(|record| record.line)
+                != candidate_records.record(*index).map(|record| record.line)
+        })
+        .or_else(|| {
+            (baseline_records.record_count() != candidate_records.record_count()).then_some(shared)
+        });
+    let Some(first) = first else {
+        return Ok(None);
+    };
+    let missing = "<missing>";
+    let baseline_record = baseline_records.record(first);
+    let candidate_record = candidate_records.record(first);
+    let location = baseline_record
+        .map(|record| record.location)
+        .or_else(|| candidate_record.map(|record| record.location))
+        .unwrap_or("end of snapshot");
+    let mut message = String::new();
+    let _ = writeln!(&mut message, "fixture: {}", fixture.id().as_str());
+    let _ = writeln!(
+        &mut message,
+        "fixture path: {}",
+        fixture.repository_relative_path()
+    );
+    let _ = writeln!(&mut message, "delivery strategy: {strategy}");
+    let _ = writeln!(
+        &mut message,
+        "canonical surface: {}",
+        baseline.surface().name()
+    );
+    let _ = writeln!(
+        &mut message,
+        "first meaningful difference: record {} ({location})",
+        first + 1
+    );
+    let _ = writeln!(
+        &mut message,
+        "baseline: {}",
+        baseline_record.map(|record| record.line).unwrap_or(missing)
+    );
+    let _ = writeln!(
+        &mut message,
+        "candidate: {}",
+        candidate_record
+            .map(|record| record.line)
+            .unwrap_or(missing)
+    );
+    Ok(Some(message))
+}
diff --git a/crates/html_test_support/src/parser_fixture/mod.rs b/crates/html_test_support/src/parser_fixture/mod.rs
index 6a282f68..e787f1ee 100644
--- a/crates/html_test_support/src/parser_fixture/mod.rs
+++ b/crates/html_test_support/src/parser_fixture/mod.rs
@@ -9,8 +9,8 @@ mod schema;
 mod validate;
 
 pub use load::{
-    FixtureLoadError, FixtureLoadErrorKind, FixtureRepository, FixtureRepositoryPolicy,
-    discover_and_load,
+    DeliveryValidationError, FixtureLoadError, FixtureLoadErrorKind, FixturePlanningInvariant,
+    FixtureRepository, FixtureRepositoryPolicy, discover_and_load,
 };
 pub(crate) use model::ExpectationSurface;
 pub use model::{
diff --git a/crates/html_test_support/src/parser_fixture/model.rs b/crates/html_test_support/src/parser_fixture/model.rs
index 0a1b2dba..a99e8d14 100644
--- a/crates/html_test_support/src/parser_fixture/model.rs
+++ b/crates/html_test_support/src/parser_fixture/model.rs
@@ -2,11 +2,13 @@ use html::ElementNamespace;
 use html::conformance::{
     CanonicalParserResult, InvariantFailureCode, ParserObservationExecutionIdentity,
 };
+use std::num::{NonZeroU32, NonZeroUsize};
 use std::path::PathBuf;
 
 pub const FIXTURE_FORMAT_V1: &str = "borrowser-html-parser-fixture-v1";
 pub const FIXTURE_FORMAT_V2: &str = "borrowser-html-parser-fixture-v2";
 
+#[cfg(test)]
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub(super) enum FixtureFormatVersion {
     V1,
@@ -202,6 +204,18 @@ pub(super) enum ValidatedDelivery {
     },
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(super) enum DeliveryCoordinateSpace {
+    UnicodeScalarOrdinals,
+    ByteOffsets,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(super) enum DeliveryTransport {
+    UnicodeScalars,
+    Bytes,
+}
+
 impl ValidatedDelivery {
     pub(super) fn name(&self) -> &DeliveryName {
         match self {
@@ -219,6 +233,22 @@ impl ValidatedDelivery {
             | Self::UnicodeScalarBoundaries { boundaries, .. } => Some(boundaries),
         }
     }
+
+    pub(super) const fn transport(&self) -> DeliveryTransport {
+        match self {
+            Self::WholeBytes { .. } | Self::ByteBoundaries { .. } => DeliveryTransport::Bytes,
+            Self::WholeUnicodeScalars { .. } | Self::UnicodeScalarBoundaries { .. } => {
+                DeliveryTransport::UnicodeScalars
+            }
+        }
+    }
+
+    pub(super) const fn coordinate_space(&self) -> DeliveryCoordinateSpace {
+        match self.transport() {
+            DeliveryTransport::UnicodeScalars => DeliveryCoordinateSpace::UnicodeScalarOrdinals,
+            DeliveryTransport::Bytes => DeliveryCoordinateSpace::ByteOffsets,
+        }
+    }
 }
 
 #[derive(Clone, Debug)]
@@ -228,6 +258,160 @@ pub(super) struct ValidatedExecution {
     deliveries: Vec<ValidatedDelivery>,
 }
 
+#[derive(Clone, Debug)]
+pub(super) struct ValidatedV1Execution(ValidatedExecution);
+
+#[derive(Clone, Debug)]
+pub(super) struct ValidatedV2Execution {
+    execution: ValidatedExecution,
+    strategies: Vec<ScheduledDeliveryStrategy>,
+}
+
+#[derive(Clone, Debug)]
+pub(super) enum ValidatedFixturePolicy {
+    V1Compatibility(ValidatedV1Execution),
+    V2Parity(ValidatedV2Execution),
+}
+
+impl ValidatedV1Execution {
+    pub(super) fn validated(execution: ValidatedExecution) -> Self {
+        Self(execution)
+    }
+
+    pub(super) fn execution(&self) -> &ValidatedExecution {
+        &self.0
+    }
+}
+
+impl ValidatedV2Execution {
+    pub(super) fn validated(
+        execution: ValidatedExecution,
+        strategies: Vec<ScheduledDeliveryStrategy>,
+    ) -> Self {
+        Self {
+            execution,
+            strategies,
+        }
+    }
+
+    pub(super) fn execution(&self) -> &ValidatedExecution {
+        &self.execution
+    }
+
+    pub(super) fn strategies(&self) -> &[ScheduledDeliveryStrategy] {
+        &self.strategies
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(super) struct StrategyOrdinal(NonZeroU32);
+
+impl StrategyOrdinal {
+    pub(super) fn checked_from_index(index: usize) -> Option<Self> {
+        let one_based = index.checked_add(1)?;
+        Some(Self(NonZeroU32::new(u32::try_from(one_based).ok()?)?))
+    }
+
+    pub(super) const fn get(self) -> u32 {
+        self.0.get()
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(super) enum DeliveryStrategyOrigin {
+    Baseline,
+    Declared(DeliveryName),
+    Representative(&'static str),
+}
+
+#[derive(Clone, Debug)]
+pub(super) enum CanonicalBoundarySequence {
+    Whole,
+    Fixed { units_per_chunk: NonZeroUsize },
+    Explicit(Box<[usize]>),
+}
+
+#[derive(Clone, Debug)]
+pub(super) struct ResolvedDeliveryStrategy {
+    pub(super) transport: DeliveryTransport,
+    pub(super) coordinate_space: DeliveryCoordinateSpace,
+    pub(super) input_extent: usize,
+    pub(super) boundaries: CanonicalBoundarySequence,
+}
+
+impl ResolvedDeliveryStrategy {
+    pub(super) fn semantic_boundary_count(&self) -> usize {
+        match &self.boundaries {
+            CanonicalBoundarySequence::Whole => 0,
+            CanonicalBoundarySequence::Explicit(boundaries) => boundaries.len(),
+            CanonicalBoundarySequence::Fixed { units_per_chunk } => self
+                .input_extent
+                .checked_sub(1)
+                .map_or(0, |interior| interior / units_per_chunk.get()),
+        }
+    }
+
+    pub(super) fn semantic_boundary_at(&self, index: usize) -> Option<usize> {
+        match &self.boundaries {
+            CanonicalBoundarySequence::Whole => None,
+            CanonicalBoundarySequence::Explicit(boundaries) => boundaries.get(index).copied(),
+            CanonicalBoundarySequence::Fixed { units_per_chunk } => index
+                .checked_add(1)
+                .and_then(|ordinal| ordinal.checked_mul(units_per_chunk.get()))
+                .filter(|boundary| *boundary < self.input_extent),
+        }
+    }
+
+    /// Representation-independent semantic equality. Fixed strategies are
+    /// never expanded and digests are never consulted.
+    pub(super) fn semantically_equals(&self, other: &Self) -> bool {
+        if self.transport != other.transport
+            || self.coordinate_space != other.coordinate_space
+            || self.input_extent != other.input_extent
+        {
+            return false;
+        }
+        let count = self.semantic_boundary_count();
+        if count != other.semantic_boundary_count() {
+            return false;
+        }
+        match (&self.boundaries, &other.boundaries) {
+            (CanonicalBoundarySequence::Whole, CanonicalBoundarySequence::Whole) => true,
+            (
+                CanonicalBoundarySequence::Fixed {
+                    units_per_chunk: left,
+                },
+                CanonicalBoundarySequence::Fixed {
+                    units_per_chunk: right,
+                },
+            ) => count == 0 || left == right,
+            (
+                CanonicalBoundarySequence::Explicit(left),
+                CanonicalBoundarySequence::Explicit(right),
+            ) => left == right,
+            _ if count == 0 => true,
+            _ => (0..count)
+                .all(|index| self.semantic_boundary_at(index) == other.semantic_boundary_at(index)),
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub(super) struct ScheduledDeliveryStrategy {
+    pub(super) ordinal: StrategyOrdinal,
+    pub(super) strategy: ResolvedDeliveryStrategy,
+    pub(super) origins: Vec<DeliveryStrategyOrigin>,
+}
+
+impl ValidatedFixturePolicy {
+    pub(super) fn execution(&self) -> &ValidatedExecution {
+        match self {
+            Self::V1Compatibility(execution) => execution.execution(),
+            Self::V2Parity(execution) => execution.execution(),
+        }
+    }
+}
+
 impl ValidatedExecution {
     pub(super) fn validated(
         target: ValidatedParserTarget,
@@ -456,9 +640,15 @@ pub(super) enum ExecutionFailureClass {
     SnapshotRead(ExpectationSurface),
     SnapshotFormat(ExpectationSurface),
     ParserObservation(ParserObservationFailureClass),
+    FixtureExecutionResourceExhaustion(FixtureExecutionResourceSite),
     ValidatedFixtureInvariant(ValidatedFixtureInvariantCode),
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(super) enum FixtureExecutionResourceSite {
+    ScalarBoundaryExecutionOffsets,
+}
+
 pub(super) type ParserObservationFailureClass = ParserObservationExecutionIdentity;
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -476,6 +666,8 @@ pub(super) enum ValidatedFixtureInvariantCode {
     MissingExecutedDeliveryResult,
     DuplicateExecutedDeliveryResult,
     DuplicateExpectationIdentity,
+    ValidatedBoundaryRejectedByExecutor,
+    StrategyScheduleContradiction,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -539,7 +731,12 @@ pub(super) enum FixtureExecutionOutcome {
         diff: String,
     },
     ExpectationMismatchV2 {
-        delivery: DeliveryName,
+        strategy: String,
+        surface: ExpectationSurface,
+        diff: String,
+    },
+    ParityMismatchV2 {
+        strategy: String,
         surface: ExpectationSurface,
         diff: String,
     },
@@ -561,11 +758,16 @@ pub(super) enum FixtureExecutionOutcome {
         result: Box<CanonicalParserResult>,
         failures: Vec<InvariantFailureCode>,
     },
+    FinalInvariantFailedV2 {
+        strategy: String,
+        first_failure: InvariantFailureCode,
+        failure_count: u8,
+    },
     IncompleteObservation {
         result: Box<CanonicalParserResult>,
     },
     IncompleteObservationV2 {
-        delivery: DeliveryName,
+        strategy: String,
         surface: ExpectationSurface,
         reason: html::conformance::IncompleteObservationReason,
         retained: usize,
@@ -599,12 +801,27 @@ enum CompletedFixtureResults {
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct FixtureDeliveryRunReport {
     delivery: DeliveryName,
+    strategy_ordinal: u32,
+    aliases: Vec<DeliveryName>,
+    origins: Vec<String>,
     result: CanonicalParserResult,
 }
 
 impl FixtureDeliveryRunReport {
-    pub(super) fn new(delivery: DeliveryName, result: CanonicalParserResult) -> Self {
-        Self { delivery, result }
+    pub(super) fn new(
+        delivery: DeliveryName,
+        strategy_ordinal: u32,
+        aliases: Vec<DeliveryName>,
+        origins: Vec<String>,
+        result: CanonicalParserResult,
+    ) -> Self {
+        Self {
+            delivery,
+            strategy_ordinal,
+            aliases,
+            origins,
+            result,
+        }
     }
 
     pub fn delivery(&self) -> &DeliveryName {
@@ -613,6 +830,22 @@ impl FixtureDeliveryRunReport {
     pub fn result(&self) -> &CanonicalParserResult {
         &self.result
     }
+
+    pub fn strategy_ordinal(&self) -> u32 {
+        self.strategy_ordinal
+    }
+
+    pub fn aliases(&self) -> &[DeliveryName] {
+        &self.aliases
+    }
+
+    pub fn origins(&self) -> &[String] {
+        &self.origins
+    }
+
+    fn names_delivery(&self, delivery: &DeliveryName) -> bool {
+        &self.delivery == delivery || self.aliases.iter().any(|alias| alias == delivery)
+    }
 }
 
 impl FixtureRunReport {
@@ -669,7 +902,7 @@ impl FixtureRunReport {
             } => reference_delivery.as_ref().and_then(|reference| {
                 deliveries
                     .iter()
-                    .find(|delivery| delivery.delivery() == reference)
+                    .find(|delivery| delivery.names_delivery(reference))
                     .map(FixtureDeliveryRunReport::result)
             }),
         }
diff --git a/crates/html_test_support/src/parser_fixture/runner.rs b/crates/html_test_support/src/parser_fixture/runner.rs
index 92957298..967e8405 100644
--- a/crates/html_test_support/src/parser_fixture/runner.rs
+++ b/crates/html_test_support/src/parser_fixture/runner.rs
@@ -1,10 +1,10 @@
 use super::disposition::{DispositionEvaluationError, evaluate_disposition};
 use super::execution::{
-    FixtureObservationGuardrails, RequestedSurfaces, build_delivery_plan, observation_request,
+    FixtureObservationGuardrails, RequestedSurfaces, observation_request_for_input,
 };
 use super::failure_spelling::{parser_observation_failure_name, runner_invariant_name};
 use super::load::{FixtureFileAccess, ProductionFixtureFileAccess};
-use super::mismatch::{compare_snapshots, comparison_order};
+use super::mismatch::{compare_parity_snapshots, compare_snapshots, first_typed_parity_mismatch};
 use super::model::*;
 use super::validate::ValidatedFixtureSpec;
 use crate::diff_lines;
@@ -15,9 +15,16 @@ use crate::token_snapshot::read_html5_token_v1;
 use crate::wpt_tokenizer::run_tokenizer_whole_observed;
 use html::conformance::{
     CanonicalParserResult, IncompleteObservationReason, ObservationState,
-    ParserObservationExecutionError, ParserObservationRequest, ParserObservationTarget,
-    execute_parser_observation,
+    ParserObservationExecutionError, ParserObservationExecutionIdentity, ParserObservationInput,
+    ParserObservationRequest, ParserObservationTarget, execute_parser_observation,
 };
+use std::fmt::Write;
+#[cfg(test)]
+thread_local! {
+    static FORCE_SCALAR_OFFSET_FAILURE: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
+    #[cfg(test)]
+    static SERIALIZE_SURFACE_CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
+}
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct FixtureRunError {
@@ -32,6 +39,10 @@ pub(super) enum FixtureFailureDetails {
         surface: ExpectationSurface,
         diff: String,
     },
+    ParityDiff {
+        surface: ExpectationSurface,
+        diff: String,
+    },
 }
 
 impl std::fmt::Display for FixtureRunError {
@@ -42,6 +53,9 @@ impl std::fmt::Display for FixtureRunError {
             Some(FixtureFailureDetails::ExpectationDiff { surface, diff }) => {
                 write!(f, "\n{} expectation mismatch\n{diff}", surface.name())
             }
+            Some(FixtureFailureDetails::ParityDiff { surface, diff }) => {
+                write!(f, "\n{} parity mismatch\n{diff}", surface.name())
+            }
             None => Ok(()),
         }
     }
@@ -148,10 +162,10 @@ pub(super) fn run_fixture_with_executor_and_access(
             classification: classification.clone(),
         }
     } else {
-        match fixture.format() {
-            FixtureFormatVersion::V1 => execute_fixture_v1(fixture, file_access),
-            FixtureFormatVersion::V2 => {
-                execute_fixture_v2_with_access(fixture, executor, file_access)
+        match fixture.policy() {
+            ValidatedFixturePolicy::V1Compatibility(_) => execute_fixture_v1(fixture, file_access),
+            ValidatedFixturePolicy::V2Parity(policy) => {
+                execute_fixture_v2_policy_with_access(fixture, policy, executor, file_access)
             }
         }
     };
@@ -192,10 +206,11 @@ pub(super) fn run_fixture_with_executor_and_access(
 #[cfg(test)]
 pub(super) fn execute_fixture(fixture: &ValidatedFixtureSpec) -> FixtureExecutionOutcome {
     let mut file_access = ProductionFixtureFileAccess;
-    match fixture.format() {
-        FixtureFormatVersion::V1 => execute_fixture_v1(fixture, &mut file_access),
-        FixtureFormatVersion::V2 => execute_fixture_v2_with_access(
+    match fixture.policy() {
+        ValidatedFixturePolicy::V1Compatibility(_) => execute_fixture_v1(fixture, &mut file_access),
+        ValidatedFixturePolicy::V2Parity(policy) => execute_fixture_v2_policy_with_access(
             fixture,
+            policy,
             &mut ProductionObservationExecutor,
             &mut file_access,
         ),
@@ -311,19 +326,6 @@ struct ParsedExpectation {
     snapshot: ParsedSnapshot,
 }
 
-#[derive(Debug)]
-struct ExecutedDelivery {
-    name: DeliveryName,
-    surfaces: RequestedSurfaces,
-    result: CanonicalParserResult,
-}
-
-#[derive(Debug)]
-struct SerializedDelivery {
-    name: DeliveryName,
-    snapshots: Vec<CanonicalSnapshot>,
-}
-
 pub(super) trait ParserObservationExecutor {
     fn execute(
         &mut self,
@@ -331,6 +333,54 @@ pub(super) trait ParserObservationExecutor {
     ) -> Result<CanonicalParserResult, ParserObservationExecutionError>;
 }
 
+enum ResolvedExecutionShape<'a> {
+    Utf8Whole(&'a str),
+    Utf8Fixed {
+        text: &'a str,
+        extent: usize,
+    },
+    Utf8Boundaries {
+        text: &'a str,
+        byte_offsets: Vec<usize>,
+    },
+    ByteWhole(&'a [u8]),
+    ByteFixed {
+        bytes: &'a [u8],
+        extent: usize,
+    },
+    ByteBoundaries {
+        bytes: &'a [u8],
+        byte_offsets: &'a [usize],
+    },
+}
+
+impl ResolvedExecutionShape<'_> {
+    fn input(&self) -> ParserObservationInput<'_> {
+        match self {
+            Self::Utf8Whole(text) => ParserObservationInput::Utf8(text),
+            Self::Utf8Fixed { text, extent } => ParserObservationInput::Utf8FixedScalarChunks {
+                text,
+                scalars_per_chunk: *extent,
+            },
+            Self::Utf8Boundaries { text, byte_offsets } => {
+                ParserObservationInput::Utf8BoundaryChunks { text, byte_offsets }
+            }
+            Self::ByteWhole(bytes) => ParserObservationInput::Bytes(bytes),
+            Self::ByteFixed { bytes, extent } => ParserObservationInput::ByteFixedChunks {
+                bytes,
+                bytes_per_chunk: *extent,
+            },
+            Self::ByteBoundaries {
+                bytes,
+                byte_offsets,
+            } => ParserObservationInput::ByteBoundaryChunks {
+                bytes,
+                byte_offsets,
+            },
+        }
+    }
+}
+
 struct ProductionObservationExecutor;
 
 impl ParserObservationExecutor for ProductionObservationExecutor {
@@ -347,16 +397,43 @@ pub(super) fn execute_fixture_v2_with(
     fixture: &ValidatedFixtureSpec,
     executor: &mut impl ParserObservationExecutor,
 ) -> FixtureExecutionOutcome {
-    execute_fixture_v2_with_access(fixture, executor, &mut ProductionFixtureFileAccess)
+    let ValidatedFixturePolicy::V2Parity(policy) = fixture.policy() else {
+        return execution_failed_v2(
+            ExecutionFailureClass::ValidatedFixtureInvariant(
+                ValidatedFixtureInvariantCode::StrategyScheduleContradiction,
+            ),
+            runner_invariant_name(ValidatedFixtureInvariantCode::StrategyScheduleContradiction),
+        );
+    };
+    execute_fixture_v2_policy_with_access(
+        fixture,
+        policy,
+        executor,
+        &mut ProductionFixtureFileAccess,
+    )
 }
 
+#[cfg(test)]
 pub(super) fn execute_fixture_v2_with_access(
     fixture: &ValidatedFixtureSpec,
     executor: &mut impl ParserObservationExecutor,
     file_access: &mut impl FixtureFileAccess,
+) -> FixtureExecutionOutcome {
+    let ValidatedFixturePolicy::V2Parity(policy) = fixture.policy() else {
+        return runner_contradiction(ValidatedFixtureInvariantCode::StrategyScheduleContradiction);
+    };
+    execute_fixture_v2_policy_with_access(fixture, policy, executor, file_access)
+}
+
+fn execute_fixture_v2_policy_with_access(
+    fixture: &ValidatedFixtureSpec,
+    policy: &ValidatedV2Execution,
+    executor: &mut impl ParserObservationExecutor,
+    file_access: &mut impl FixtureFileAccess,
 ) -> FixtureExecutionOutcome {
     execute_fixture_v2_with_guardrails_and_access(
         fixture,
+        policy,
         executor,
         FixtureObservationGuardrails::PRODUCTION,
         file_access,
@@ -369,8 +446,17 @@ pub(super) fn execute_fixture_v2_with_guardrails(
     executor: &mut impl ParserObservationExecutor,
     guardrails: FixtureObservationGuardrails,
 ) -> FixtureExecutionOutcome {
+    let ValidatedFixturePolicy::V2Parity(policy) = fixture.policy() else {
+        return execution_failed_v2(
+            ExecutionFailureClass::ValidatedFixtureInvariant(
+                ValidatedFixtureInvariantCode::StrategyScheduleContradiction,
+            ),
+            runner_invariant_name(ValidatedFixtureInvariantCode::StrategyScheduleContradiction),
+        );
+    };
     execute_fixture_v2_with_guardrails_and_access(
         fixture,
+        policy,
         executor,
         guardrails,
         &mut ProductionFixtureFileAccess,
@@ -379,6 +465,7 @@ pub(super) fn execute_fixture_v2_with_guardrails(
 
 pub(super) fn execute_fixture_v2_with_guardrails_and_access(
     fixture: &ValidatedFixtureSpec,
+    policy: &ValidatedV2Execution,
     executor: &mut impl ParserObservationExecutor,
     guardrails: FixtureObservationGuardrails,
     file_access: &mut impl FixtureFileAccess,
@@ -395,188 +482,651 @@ pub(super) fn execute_fixture_v2_with_guardrails_and_access(
         return unsupported(capability);
     }
 
-    let expectations = match read_expected_snapshots_v2(fixture, file_access) {
-        Ok(expectations) => expectations,
-        Err(outcome) => return outcome,
-    };
-    let plan = match build_delivery_plan(fixture) {
-        Ok(plan) => plan,
-        Err(code) => {
-            return execution_failed_v2(
-                ExecutionFailureClass::ValidatedFixtureInvariant(code),
-                runner_invariant_name(code),
-            );
-        }
-    };
-    let ExactInput::Utf8Text { text, .. } = fixture.input() else {
-        return unsupported(FixtureCapability::RawByteInput);
-    };
-    let target = match fixture.execution().target() {
+    let target = match policy.execution().target() {
         ValidatedParserTarget::StandaloneTokenizer => ParserObservationTarget::StandaloneTokenizer,
         ValidatedParserTarget::Document { .. } => ParserObservationTarget::DocumentParser,
         ValidatedParserTarget::Fragment { .. } => {
             return unsupported(FixtureCapability::FragmentParsing);
         }
     };
-
-    // Execute every planned delivery before state validation or comparison.
-    let mut executed = Vec::with_capacity(plan.len());
-    for planned in &plan {
-        let request = observation_request(target, text, planned.surfaces, guardrails);
-        match executor.execute(request) {
-            Ok(result) => executed.push(ExecutedDelivery {
-                name: planned.name.clone(),
-                surfaces: planned.surfaces,
-                result,
-            }),
-            Err(error) => {
-                let identity = error.identity();
-                return execution_failed_v2(
-                    ExecutionFailureClass::ParserObservation(identity),
-                    &format!(
-                        "fixture {} delivery {}: parser observation failure {}",
-                        fixture.id().as_str(),
-                        planned.name.as_str(),
-                        parser_observation_failure_name(identity)
-                    ),
-                );
-            }
-        }
+    let surfaces = RequestedSurfaces::parity(policy.execution().target());
+    let Some(baseline_strategy) = policy.strategies().first() else {
+        return runner_contradiction(ValidatedFixtureInvariantCode::StrategyScheduleContradiction);
+    };
+    if baseline_strategy.ordinal.get() != 1
+        || !baseline_strategy
+            .origins
+            .iter()
+            .any(|origin| matches!(origin, DeliveryStrategyOrigin::Baseline))
+    {
+        return runner_contradiction(ValidatedFixtureInvariantCode::StrategyScheduleContradiction);
     }
 
-    for delivery in &executed {
-        if let Some(issue) = first_state_issue(&delivery.result, delivery.surfaces) {
-            return match issue {
-                StateIssue::Incomplete {
-                    surface,
-                    reason,
-                    retained,
-                    dropped,
-                } => FixtureExecutionOutcome::IncompleteObservationV2 {
-                    delivery: delivery.name.clone(),
-                    surface,
-                    reason,
-                    retained,
-                    dropped,
-                },
-                StateIssue::Invariant(code) => execution_failed_v2(
-                    ExecutionFailureClass::ValidatedFixtureInvariant(code),
-                    &format!(
-                        "fixture {} delivery {}: {}",
-                        fixture.id().as_str(),
-                        delivery.name.as_str(),
-                        runner_invariant_name(code)
-                    ),
-                ),
+    let baseline_label = strategy_spelling(baseline_strategy);
+    let baseline = match execute_strategy(
+        fixture,
+        baseline_strategy,
+        target,
+        surfaces,
+        guardrails,
+        executor,
+    ) {
+        Ok(result) => result,
+        Err(outcome) => return outcome,
+    };
+    if let Some(outcome) = authoritative_failure(&baseline_label, &baseline, surfaces) {
+        return outcome;
+    }
+    let expectations = match read_expected_snapshots_v2(fixture, file_access) {
+        Ok(expectations) => expectations,
+        Err(outcome) => return outcome,
+    };
+    let mut first_expectation =
+        match compare_applicable_expectations(fixture, baseline_strategy, &expectations, &baseline)
+        {
+            Ok(mismatch) => mismatch,
+            Err(outcome) => return outcome,
+        };
+    let mut first_incomplete = None;
+    let mut first_final_invariant = None;
+    let mut first_parity = None;
+    let mut retained = Vec::new();
+    for (index, scheduled) in policy.strategies().iter().enumerate().skip(1) {
+        let expected_ordinal = u32::try_from(index)
+            .ok()
+            .and_then(|index| index.checked_add(1));
+        if expected_ordinal != Some(scheduled.ordinal.get()) {
+            return runner_contradiction(
+                ValidatedFixtureInvariantCode::StrategyScheduleContradiction,
+            );
+        }
+        let strategy = strategy_spelling(scheduled);
+        let result =
+            match execute_strategy(fixture, scheduled, target, surfaces, guardrails, executor) {
+                Ok(result) => result,
+                Err(outcome) => return outcome,
             };
+        match first_state_issue(&result, surfaces) {
+            Some(StateIssue::Incomplete {
+                surface,
+                reason,
+                retained: retained_count,
+                dropped,
+            }) => {
+                if first_incomplete.is_none() {
+                    first_incomplete = Some(FixtureExecutionOutcome::IncompleteObservationV2 {
+                        strategy: diagnostic_strategy_spelling(scheduled),
+                        surface,
+                        reason,
+                        retained: retained_count,
+                        dropped,
+                    });
+                }
+                continue;
+            }
+            Some(StateIssue::Invariant(code)) => return runner_contradiction(code),
+            None => {}
         }
-    }
-
-    // Serialize every requested surface before the first comparison.
-    let mut serialized = Vec::with_capacity(executed.len());
-    for delivery in &executed {
-        let mut snapshots = Vec::new();
-        for surface in requested_surface_order(delivery.surfaces) {
-            let snapshot =
-                match serialize_snapshot(surface, &delivery.result) {
-                    Ok(snapshot) => snapshot,
-                    Err(()) => return execution_failed_v2(
-                        ExecutionFailureClass::ValidatedFixtureInvariant(
-                            ValidatedFixtureInvariantCode::CanonicalSerializerSurfaceContradiction,
-                        ),
-                        runner_invariant_name(
-                            ValidatedFixtureInvariantCode::CanonicalSerializerSurfaceContradiction,
-                        ),
-                    ),
-                };
-            if snapshot.surface() != surface {
-                return execution_failed_v2(
-                    ExecutionFailureClass::ValidatedFixtureInvariant(
-                        ValidatedFixtureInvariantCode::CanonicalSerializerSurfaceContradiction,
-                    ),
-                    runner_invariant_name(
+        if let Some(failure) = candidate_final_invariant_failure(scheduled, &result) {
+            if first_final_invariant.is_none() {
+                first_final_invariant = Some(failure);
+            }
+            continue;
+        }
+        let typed_parity_surface = if first_parity.is_none() {
+            match first_typed_parity_mismatch(&baseline, &result) {
+                Ok(surface) => surface,
+                Err(code) => return runner_contradiction(code),
+            }
+        } else {
+            None
+        };
+        if let Some(surface) = typed_parity_surface {
+            let baseline_snapshot = match serialize_surface(&baseline, surface) {
+                Ok(snapshot) => snapshot,
+                Err(outcome) => return outcome,
+            };
+            let candidate_snapshot = match serialize_surface(&result, surface) {
+                Ok(snapshot) => snapshot,
+                Err(outcome) => return outcome,
+            };
+            match compare_parity_snapshots(
+                fixture,
+                &strategy,
+                &baseline_snapshot,
+                &candidate_snapshot,
+            ) {
+                Ok(Some(diff)) => {
+                    first_parity = Some(FixtureExecutionOutcome::ParityMismatchV2 {
+                        strategy: diagnostic_strategy_spelling(scheduled),
+                        surface,
+                        diff,
+                    });
+                }
+                Ok(None) => {
+                    return runner_contradiction(
                         ValidatedFixtureInvariantCode::CanonicalSerializerSurfaceContradiction,
-                    ),
-                );
+                    );
+                }
+                Err(code) => return runner_contradiction(code),
+            }
+        }
+        if first_expectation.is_none() {
+            match compare_applicable_expectations(fixture, scheduled, &expectations, &result) {
+                Ok(mismatch) => first_expectation = mismatch,
+                Err(outcome) => return outcome,
             }
-            snapshots.push(snapshot);
         }
-        serialized.push(SerializedDelivery {
-            name: delivery.name.clone(),
-            snapshots,
-        });
+        if strategy_requires_completed_result(scheduled, fixture.expectations()) {
+            retained.push(match retained_report(scheduled, result) {
+                Ok(report) => report,
+                Err(outcome) => return outcome,
+            });
+        }
     }
 
-    for expected in &expectations {
-        let delivery_name = expected
-            .transition_delivery
-            .as_ref()
-            .unwrap_or_else(|| fixture.execution().reference_delivery());
-        let Some(delivery) = serialized.iter().find(|value| &value.name == delivery_name) else {
-            return execution_failed_v2(
-                ExecutionFailureClass::ValidatedFixtureInvariant(
-                    ValidatedFixtureInvariantCode::MissingExecutedDeliveryResult,
+    if let Some(outcome) = first_incomplete {
+        return outcome;
+    }
+    if let Some(outcome) = first_final_invariant {
+        return outcome;
+    }
+    if let Some(outcome) = first_parity {
+        return outcome;
+    }
+    if let Some(outcome) = first_expectation {
+        return outcome;
+    }
+    let baseline_report = match retained_report(baseline_strategy, baseline) {
+        Ok(report) => report,
+        Err(outcome) => return outcome,
+    };
+    let mut deliveries = Vec::with_capacity(retained.len().saturating_add(1));
+    deliveries.push(baseline_report);
+    deliveries.extend(retained);
+    FixtureExecutionOutcome::CompletedV2 {
+        deliveries,
+        reference_delivery: Some(policy.execution().reference_delivery().clone()),
+    }
+}
+
+fn execute_strategy(
+    fixture: &ValidatedFixtureSpec,
+    scheduled: &ScheduledDeliveryStrategy,
+    target: ParserObservationTarget,
+    surfaces: RequestedSurfaces,
+    guardrails: FixtureObservationGuardrails,
+    executor: &mut impl ParserObservationExecutor,
+) -> Result<CanonicalParserResult, FixtureExecutionOutcome> {
+    let shape = match resolve_execution_shape(fixture.input(), &scheduled.strategy) {
+        Ok(shape) => shape,
+        Err(ResolveExecutionError::ScalarBoundaryOffsets) => {
+            return Err(execution_failed_v2(
+                ExecutionFailureClass::FixtureExecutionResourceExhaustion(
+                    FixtureExecutionResourceSite::ScalarBoundaryExecutionOffsets,
                 ),
-                runner_invariant_name(ValidatedFixtureInvariantCode::MissingExecutedDeliveryResult),
-            );
-        };
-        let Some(actual) = delivery
-            .snapshots
-            .iter()
-            .find(|snapshot| snapshot.surface() == expected.surface)
-        else {
+                &format!(
+                    "fixture {} path {} strategy {}: fixture execution resource exhaustion at scalar-boundary-execution-offsets",
+                    fixture.id().as_str(),
+                    fixture.repository_relative_path(),
+                    diagnostic_strategy_spelling(scheduled)
+                ),
+            ));
+        }
+        Err(ResolveExecutionError::Contradiction(code)) => return Err(runner_contradiction(code)),
+    };
+    let request = observation_request_for_input(target, shape.input(), surfaces, guardrails);
+    executor.execute(request).map_err(|error| {
+        let identity = error.identity();
+        if matches!(
+            identity,
+            ParserObservationExecutionIdentity::InvalidDelivery(_)
+        ) {
             return execution_failed_v2(
                 ExecutionFailureClass::ValidatedFixtureInvariant(
-                    ValidatedFixtureInvariantCode::CanonicalSerializerSurfaceContradiction,
+                    ValidatedFixtureInvariantCode::ValidatedBoundaryRejectedByExecutor,
                 ),
-                runner_invariant_name(
-                    ValidatedFixtureInvariantCode::CanonicalSerializerSurfaceContradiction,
+                &format!(
+                    "fixture {} path {} strategy {}: {}",
+                    fixture.id().as_str(),
+                    fixture.repository_relative_path(),
+                    diagnostic_strategy_spelling(scheduled),
+                    runner_invariant_name(
+                        ValidatedFixtureInvariantCode::ValidatedBoundaryRejectedByExecutor
+                    )
                 ),
             );
+        }
+        execution_failed_v2(
+            ExecutionFailureClass::ParserObservation(identity),
+            &format!(
+                "fixture {} path {} strategy {}: parser observation failure {}",
+                fixture.id().as_str(),
+                fixture.repository_relative_path(),
+                diagnostic_strategy_spelling(scheduled),
+                parser_observation_failure_name(identity)
+            ),
+        )
+    })
+}
+
+pub(super) enum ResolveExecutionError {
+    ScalarBoundaryOffsets,
+    Contradiction(ValidatedFixtureInvariantCode),
+}
+
+fn resolve_execution_shape<'a>(
+    input: &'a ExactInput,
+    strategy: &'a ResolvedDeliveryStrategy,
+) -> Result<ResolvedExecutionShape<'a>, ResolveExecutionError> {
+    match (input, strategy.transport, &strategy.boundaries) {
+        (
+            ExactInput::Utf8Text { text, .. },
+            DeliveryTransport::UnicodeScalars,
+            CanonicalBoundarySequence::Whole,
+        ) => Ok(ResolvedExecutionShape::Utf8Whole(text)),
+        (
+            ExactInput::Utf8Text { text, .. },
+            DeliveryTransport::UnicodeScalars,
+            CanonicalBoundarySequence::Fixed { units_per_chunk },
+        ) => Ok(ResolvedExecutionShape::Utf8Fixed {
+            text,
+            extent: units_per_chunk.get(),
+        }),
+        (
+            ExactInput::Utf8Text { text, .. },
+            DeliveryTransport::UnicodeScalars,
+            CanonicalBoundarySequence::Explicit(boundaries),
+        ) => Ok(ResolvedExecutionShape::Utf8Boundaries {
+            text,
+            byte_offsets: resolve_scalar_ordinals(text, strategy.input_extent, boundaries)?,
+        }),
+        (
+            ExactInput::Utf8Text { bytes, .. } | ExactInput::RawBytes { bytes, .. },
+            DeliveryTransport::Bytes,
+            CanonicalBoundarySequence::Whole,
+        ) => Ok(ResolvedExecutionShape::ByteWhole(bytes)),
+        (
+            ExactInput::Utf8Text { bytes, .. } | ExactInput::RawBytes { bytes, .. },
+            DeliveryTransport::Bytes,
+            CanonicalBoundarySequence::Fixed { units_per_chunk },
+        ) => Ok(ResolvedExecutionShape::ByteFixed {
+            bytes,
+            extent: units_per_chunk.get(),
+        }),
+        (
+            ExactInput::Utf8Text { bytes, .. } | ExactInput::RawBytes { bytes, .. },
+            DeliveryTransport::Bytes,
+            CanonicalBoundarySequence::Explicit(boundaries),
+        ) => Ok(ResolvedExecutionShape::ByteBoundaries {
+            bytes,
+            byte_offsets: boundaries,
+        }),
+        (ExactInput::RawBytes { .. }, DeliveryTransport::UnicodeScalars, _) => {
+            Err(ResolveExecutionError::Contradiction(
+                ValidatedFixtureInvariantCode::StrategyScheduleContradiction,
+            ))
+        }
+    }
+}
+
+pub(super) fn resolve_scalar_ordinals(
+    text: &str,
+    expected_extent: usize,
+    ordinals: &[usize],
+) -> Result<Vec<usize>, ResolveExecutionError> {
+    // Fixture-v2 validation bounds explicit boundaries to 4,096 entries.
+    // This harness allocation is not part of the production final-audit
+    // resource model; fixed strategies never allocate this vector.
+    let mut offsets = Vec::new();
+    #[cfg(test)]
+    if FORCE_SCALAR_OFFSET_FAILURE.with(|flag| flag.replace(false)) {
+        return Err(ResolveExecutionError::ScalarBoundaryOffsets);
+    }
+    offsets
+        .try_reserve_exact(ordinals.len())
+        .map_err(|_| ResolveExecutionError::ScalarBoundaryOffsets)?;
+    let mut next = 0usize;
+    let mut scalar_ordinal = 0usize;
+    for (byte_offset, _) in text.char_indices() {
+        if ordinals.get(next).copied() == Some(scalar_ordinal) {
+            offsets.push(byte_offset);
+            next = next
+                .checked_add(1)
+                .ok_or(ResolveExecutionError::Contradiction(
+                    ValidatedFixtureInvariantCode::StrategyScheduleContradiction,
+                ))?;
+        }
+        scalar_ordinal =
+            scalar_ordinal
+                .checked_add(1)
+                .ok_or(ResolveExecutionError::Contradiction(
+                    ValidatedFixtureInvariantCode::StrategyScheduleContradiction,
+                ))?;
+    }
+    if scalar_ordinal != expected_extent || next != ordinals.len() {
+        return Err(ResolveExecutionError::Contradiction(
+            ValidatedFixtureInvariantCode::StrategyScheduleContradiction,
+        ));
+    }
+    Ok(offsets)
+}
+
+#[cfg(test)]
+struct ScalarBoundaryOffsetFailureGuard {
+    previous: bool,
+}
+
+#[cfg(test)]
+impl Drop for ScalarBoundaryOffsetFailureGuard {
+    fn drop(&mut self) {
+        FORCE_SCALAR_OFFSET_FAILURE.with(|flag| flag.set(self.previous));
+    }
+}
+
+#[cfg(test)]
+pub(super) fn with_scalar_boundary_offset_failure<R>(f: impl FnOnce() -> R) -> R {
+    let previous = FORCE_SCALAR_OFFSET_FAILURE.with(|flag| flag.replace(true));
+    let guard = ScalarBoundaryOffsetFailureGuard { previous };
+    let result = f();
+    drop(guard);
+    result
+}
+
+fn authoritative_failure(
+    strategy: &str,
+    result: &CanonicalParserResult,
+    surfaces: RequestedSurfaces,
+) -> Option<FixtureExecutionOutcome> {
+    match first_state_issue(result, surfaces) {
+        Some(StateIssue::Incomplete {
+            surface,
+            reason,
+            retained,
+            dropped,
+        }) => Some(FixtureExecutionOutcome::IncompleteObservationV2 {
+            strategy: strategy.to_string(),
+            surface,
+            reason,
+            retained,
+            dropped,
+        }),
+        Some(StateIssue::Invariant(code)) => Some(runner_contradiction(code)),
+        None => final_invariant_failure(strategy, result),
+    }
+}
+
+fn final_invariant_failure(
+    strategy: &str,
+    result: &CanonicalParserResult,
+) -> Option<FixtureExecutionOutcome> {
+    let ObservationState::Captured(report) = &result.final_invariants else {
+        return None;
+    };
+    let mut failed = report.failed_fields();
+    let (_, first_failure) = failed.next()?;
+    let count = 1usize.checked_add(failed.count())?;
+    let failure_count = u8::try_from(count).ok()?;
+    Some(FixtureExecutionOutcome::FinalInvariantFailedV2 {
+        strategy: strategy.to_string(),
+        first_failure,
+        failure_count,
+    })
+}
+
+fn candidate_final_invariant_failure(
+    strategy: &ScheduledDeliveryStrategy,
+    result: &CanonicalParserResult,
+) -> Option<FixtureExecutionOutcome> {
+    let has_failure = matches!(
+        &result.final_invariants,
+        ObservationState::Captured(report) if report.has_failure()
+    );
+    has_failure.then(|| final_invariant_failure(&diagnostic_strategy_spelling(strategy), result))?
+}
+
+fn serialize_surface(
+    result: &CanonicalParserResult,
+    surface: ExpectationSurface,
+) -> Result<CanonicalSnapshot, FixtureExecutionOutcome> {
+    #[cfg(test)]
+    SERIALIZE_SURFACE_CALLS.with(|calls| calls.set(calls.get().saturating_add(1)));
+    let snapshot = serialize_snapshot(surface, result).map_err(|()| {
+        runner_contradiction(ValidatedFixtureInvariantCode::CanonicalSerializerSurfaceContradiction)
+    })?;
+    if snapshot.surface() != surface {
+        return Err(runner_contradiction(
+            ValidatedFixtureInvariantCode::CanonicalSerializerSurfaceContradiction,
+        ));
+    }
+    Ok(snapshot)
+}
+
+#[cfg(test)]
+struct SerializationCounterGuard {
+    previous: usize,
+}
+
+#[cfg(test)]
+impl Drop for SerializationCounterGuard {
+    fn drop(&mut self) {
+        SERIALIZE_SURFACE_CALLS.with(|calls| calls.set(self.previous));
+    }
+}
+
+#[cfg(test)]
+pub(super) fn with_serialization_counter<R>(f: impl FnOnce() -> R) -> (R, usize) {
+    let previous = SERIALIZE_SURFACE_CALLS.with(|calls| {
+        let previous = calls.get();
+        calls.set(0);
+        previous
+    });
+    let guard = SerializationCounterGuard { previous };
+    let result = f();
+    let count = SERIALIZE_SURFACE_CALLS.with(std::cell::Cell::get);
+    drop(guard);
+    (result, count)
+}
+
+fn compare_applicable_expectations(
+    fixture: &ValidatedFixtureSpec,
+    strategy: &ScheduledDeliveryStrategy,
+    expectations: &[ParsedExpectation],
+    result: &CanonicalParserResult,
+) -> Result<Option<FixtureExecutionOutcome>, FixtureExecutionOutcome> {
+    for expected in expectations {
+        let applies = match &expected.transition_delivery {
+            None => strategy
+                .origins
+                .iter()
+                .any(|origin| matches!(origin, DeliveryStrategyOrigin::Baseline)),
+            Some(delivery) => strategy.origins.iter().any(|origin| {
+                matches!(origin, DeliveryStrategyOrigin::Declared(name) if name == delivery)
+            }),
         };
+        if !applies {
+            continue;
+        }
+        let snapshot = serialize_surface(result, expected.surface)?;
         match compare_snapshots(
             fixture,
             expected.transition_delivery.as_ref(),
             &expected.path,
             &expected.snapshot,
-            actual,
+            &snapshot,
         ) {
             Ok(None) => {}
             Ok(Some(diff)) => {
-                return FixtureExecutionOutcome::ExpectationMismatchV2 {
-                    delivery: delivery_name.clone(),
+                return Ok(Some(FixtureExecutionOutcome::ExpectationMismatchV2 {
+                    strategy: diagnostic_strategy_spelling(strategy),
                     surface: expected.surface,
                     diff,
-                };
+                }));
             }
-            Err(code) => {
-                return execution_failed_v2(
-                    ExecutionFailureClass::ValidatedFixtureInvariant(code),
-                    runner_invariant_name(code),
-                );
+            Err(code) => return Err(runner_contradiction(code)),
+        }
+    }
+    Ok(None)
+}
+
+fn strategy_requires_completed_result(
+    strategy: &ScheduledDeliveryStrategy,
+    expectations: &EnabledExpectations,
+) -> bool {
+    let ExpectedSurface::Compare(transitions) = expectations.transitions() else {
+        return false;
+    };
+    transitions.iter().any(|expected| {
+        strategy.origins.iter().any(|origin| {
+            matches!(origin, DeliveryStrategyOrigin::Declared(name) if name == expected.delivery())
+        })
+    })
+}
+
+fn retained_report(
+    strategy: &ScheduledDeliveryStrategy,
+    result: CanonicalParserResult,
+) -> Result<FixtureDeliveryRunReport, FixtureExecutionOutcome> {
+    let aliases = strategy
+        .origins
+        .iter()
+        .filter_map(|origin| match origin {
+            DeliveryStrategyOrigin::Declared(name) => Some(name.clone()),
+            DeliveryStrategyOrigin::Baseline | DeliveryStrategyOrigin::Representative(_) => None,
+        })
+        .collect::<Vec<_>>();
+    let Some(delivery) = aliases.first().cloned() else {
+        return Err(runner_contradiction(
+            ValidatedFixtureInvariantCode::StrategyScheduleContradiction,
+        ));
+    };
+    let origins = strategy.origins.iter().map(origin_spelling).collect();
+    Ok(FixtureDeliveryRunReport::new(
+        delivery,
+        strategy.ordinal.get(),
+        aliases,
+        origins,
+        result,
+    ))
+}
+
+fn strategy_spelling(strategy: &ScheduledDeliveryStrategy) -> String {
+    strategy_spelling_with_digest(strategy, false)
+}
+
+fn diagnostic_strategy_spelling(strategy: &ScheduledDeliveryStrategy) -> String {
+    strategy_spelling_with_digest(strategy, true)
+}
+
+fn strategy_spelling_with_digest(
+    strategy: &ScheduledDeliveryStrategy,
+    include_digest: bool,
+) -> String {
+    let mut spelling = String::new();
+    let transport = match strategy.strategy.transport {
+        DeliveryTransport::UnicodeScalars => "unicode-scalars",
+        DeliveryTransport::Bytes => "bytes",
+    };
+    let coordinates = match strategy.strategy.coordinate_space {
+        DeliveryCoordinateSpace::UnicodeScalarOrdinals => "unicode-scalar-ordinals",
+        DeliveryCoordinateSpace::ByteOffsets => "byte-offsets",
+    };
+    let _ = write!(
+        &mut spelling,
+        "ordinal={} transport={} coordinates={} extent={} boundaries=",
+        strategy.ordinal.get(),
+        transport,
+        coordinates,
+        strategy.strategy.input_extent
+    );
+    match &strategy.strategy.boundaries {
+        CanonicalBoundarySequence::Whole => spelling.push_str("[]"),
+        CanonicalBoundarySequence::Fixed { units_per_chunk } => {
+            let _ = write!(&mut spelling, "fixed:{}", units_per_chunk.get());
+        }
+        CanonicalBoundarySequence::Explicit(boundaries) => {
+            if boundaries.len() <= 16 {
+                spelling.push('[');
+                for (index, boundary) in boundaries.iter().enumerate() {
+                    if index != 0 {
+                        spelling.push(',');
+                    }
+                    let _ = write!(&mut spelling, "{boundary}");
+                }
+                spelling.push(']');
+            } else if include_digest {
+                if let Some(digest) = delivery_boundary_digest(&strategy.strategy) {
+                    let _ = write!(
+                        &mut spelling,
+                        "count:{} digest:sha256:{digest}",
+                        boundaries.len()
+                    );
+                } else {
+                    spelling.push_str("count:unavailable");
+                }
+            } else {
+                let _ = write!(&mut spelling, "count:{} digest:deferred", boundaries.len());
             }
         }
     }
+    spelling.push_str(" origins=[");
+    for (index, origin) in strategy.origins.iter().enumerate() {
+        if index != 0 {
+            spelling.push(',');
+        }
+        spelling.push_str(&origin_spelling(origin));
+    }
+    spelling.push(']');
+    spelling
+}
 
-    let deliveries = executed
-        .into_iter()
-        .map(|delivery| FixtureDeliveryRunReport::new(delivery.name, delivery.result))
-        .collect();
-    FixtureExecutionOutcome::CompletedV2 {
-        deliveries,
-        reference_delivery: RequestedSurfaces::ordinary(fixture.expectations())
-            .any()
-            .then(|| fixture.execution().reference_delivery().clone()),
+/// Produce bounded, platform-independent diagnostic metadata. This is never
+/// used for strategy equality, ordering, or scheduling.
+fn delivery_boundary_digest(strategy: &ResolvedDeliveryStrategy) -> Option<String> {
+    let mut context = ring::digest::Context::new(&ring::digest::SHA256);
+    context.update(b"borrowser-html-delivery-boundaries-v1\0");
+    let transport = match strategy.transport {
+        DeliveryTransport::UnicodeScalars => 1,
+        DeliveryTransport::Bytes => 2,
+    };
+    context.update(&[transport]);
+    let coordinate_space = match strategy.coordinate_space {
+        DeliveryCoordinateSpace::UnicodeScalarOrdinals => 1,
+        DeliveryCoordinateSpace::ByteOffsets => 2,
+    };
+    context.update(&[coordinate_space]);
+    let count = u64::try_from(strategy.semantic_boundary_count()).ok()?;
+    context.update(&count.to_be_bytes());
+    for index in 0..strategy.semantic_boundary_count() {
+        let boundary = u64::try_from(strategy.semantic_boundary_at(index)?).ok()?;
+        context.update(&boundary.to_be_bytes());
+    }
+    let digest = context.finish();
+    let mut output = String::with_capacity(64);
+    const HEX: &[u8; 16] = b"0123456789abcdef";
+    for byte in digest.as_ref() {
+        output.push(HEX[(byte >> 4) as usize] as char);
+        output.push(HEX[(byte & 0x0f) as usize] as char);
     }
+    Some(output)
 }
 
-fn first_unsupported_expectation_v2(fixture: &ValidatedFixtureSpec) -> Option<ExpectationSurface> {
-    if fixture
-        .expectations()
-        .is_declared(ExpectationSurface::FinalInvariants)
-    {
-        return Some(ExpectationSurface::FinalInvariants);
+fn origin_spelling(origin: &DeliveryStrategyOrigin) -> String {
+    match origin {
+        DeliveryStrategyOrigin::Baseline => "baseline".to_string(),
+        DeliveryStrategyOrigin::Declared(name) => format!("declared:{}", name.as_str()),
+        DeliveryStrategyOrigin::Representative(name) => format!("representative:{name}"),
     }
+}
+
+fn runner_contradiction(code: ValidatedFixtureInvariantCode) -> FixtureExecutionOutcome {
+    execution_failed_v2(
+        ExecutionFailureClass::ValidatedFixtureInvariant(code),
+        runner_invariant_name(code),
+    )
+}
+
+fn first_unsupported_expectation_v2(fixture: &ValidatedFixtureSpec) -> Option<ExpectationSurface> {
     if matches!(
         fixture.execution().target(),
         ValidatedParserTarget::StandaloneTokenizer
@@ -600,9 +1150,6 @@ fn first_unsupported_semantics_v2(fixture: &ValidatedFixtureSpec) -> Option<Fixt
         ValidatedParserTarget::Fragment { .. } => return Some(FixtureCapability::FragmentParsing),
         ValidatedParserTarget::StandaloneTokenizer | ValidatedParserTarget::Document { .. } => {}
     }
-    if matches!(fixture.input(), ExactInput::RawBytes { .. }) {
-        return Some(FixtureCapability::RawByteInput);
-    }
     if matches!(
         fixture.execution().target(),
         ValidatedParserTarget::Document {
@@ -611,17 +1158,6 @@ fn first_unsupported_semantics_v2(fixture: &ValidatedFixtureSpec) -> Option<Fixt
     ) {
         return Some(FixtureCapability::ScriptingEnabled);
     }
-    for delivery in fixture.execution().deliveries() {
-        match delivery {
-            ValidatedDelivery::WholeBytes { .. } | ValidatedDelivery::ByteBoundaries { .. } => {
-                return Some(FixtureCapability::ByteDelivery);
-            }
-            ValidatedDelivery::UnicodeScalarBoundaries { .. } => {
-                return Some(FixtureCapability::UnicodeScalarChunking);
-            }
-            ValidatedDelivery::WholeUnicodeScalars { .. } => {}
-        }
-    }
     None
 }
 
@@ -680,6 +1216,15 @@ fn read_expected_snapshots_v2(
             file_access,
         )?);
     }
+    if let ExpectedSurface::Compare(path) = fixture.expectations().final_invariants() {
+        parsed.push(read_one_expected(
+            fixture,
+            ExpectationSurface::FinalInvariants,
+            path,
+            None,
+            file_access,
+        )?);
+    }
     Ok(parsed)
 }
 
@@ -822,20 +1367,11 @@ pub(super) fn first_state_issue(
         &result.unsupported_features,
         requested.unsupported_features
     );
-    match &result.final_invariants {
-        ObservationState::NotRequested => {}
-        ObservationState::Incomplete { .. } => {
-            return Some(StateIssue::Invariant(
-                ValidatedFixtureInvariantCode::UnrequestedSurfaceUnexpectedlyIncomplete,
-            ));
-        }
-        ObservationState::Captured(_) => {
-            return Some(StateIssue::Invariant(
-                ValidatedFixtureInvariantCode::UnrequestedSurfaceUnexpectedlyCaptured,
-            ));
-        }
-        ObservationState::NotApplicable { .. } => {}
-    }
+    check!(
+        ExpectationSurface::FinalInvariants,
+        &result.final_invariants,
+        requested.final_invariants
+    );
     None
 }
 
@@ -847,23 +1383,6 @@ fn incomplete_counts(reason: &IncompleteObservationReason) -> (usize, u64) {
     }
 }
 
-fn requested_surface_order(requested: RequestedSurfaces) -> Vec<ExpectationSurface> {
-    comparison_order()
-        .into_iter()
-        .filter(|surface| match surface {
-            ExpectationSurface::Tokens => requested.tokens,
-            ExpectationSurface::ParseErrors => requested.parse_errors,
-            ExpectationSurface::ImplementationDiagnostics => requested.implementation_diagnostics,
-            ExpectationSurface::DocumentMode => requested.document_mode,
-            ExpectationSurface::Tree => requested.tree,
-            ExpectationSurface::Patches => requested.patches,
-            ExpectationSurface::Transitions => requested.transitions,
-            ExpectationSurface::UnsupportedFeatures => requested.unsupported_features,
-            ExpectationSurface::FinalInvariants => false,
-        })
-        .collect()
-}
-
 fn finalize_result(
     result: CanonicalParserResult,
     mismatch: Option<(ExpectationSurface, String)>,
@@ -904,6 +1423,12 @@ pub(super) fn failure_details(
                 diff: diff.clone(),
             })
         }
+        FixtureExecutionOutcome::ParityMismatchV2 { surface, diff, .. } => {
+            Some(FixtureFailureDetails::ParityDiff {
+                surface: *surface,
+                diff: diff.clone(),
+            })
+        }
         FixtureExecutionOutcome::ExecutionFailed { message, .. } => {
             Some(FixtureFailureDetails::Message(message.clone()))
         }
@@ -914,17 +1439,29 @@ pub(super) fn failure_details(
         | FixtureExecutionOutcome::UnsupportedFixtureSemantics { .. }
         | FixtureExecutionOutcome::InvariantFailed { .. }
         | FixtureExecutionOutcome::IncompleteObservation { .. } => None,
+        FixtureExecutionOutcome::FinalInvariantFailedV2 {
+            strategy,
+            first_failure,
+            failure_count,
+        } => Some(FixtureFailureDetails::Message(format!(
+            "fixture {} path {}: mandatory final invariant failure; strategy: {}; first failed invariant: {}; failed invariant count: {}",
+            fixture.id().as_str(),
+            fixture.repository_relative_path(),
+            strategy,
+            invariant_failure_name(*first_failure),
+            failure_count
+        ))),
         FixtureExecutionOutcome::IncompleteObservationV2 {
-            delivery,
+            strategy,
             surface,
             reason,
             retained,
             dropped,
         } => Some(FixtureFailureDetails::Message(format!(
-            "fixture {} path {}: incomplete observation; delivery: {}; surface: {}; reason: {}; retained count: {}; dropped count: {}",
+            "fixture {} path {}: incomplete observation; strategy: {}; surface: {}; reason: {}; retained count: {}; dropped count: {}",
             fixture.id().as_str(),
             fixture.repository_relative_path(),
-            delivery.as_str(),
+            strategy,
             surface.name(),
             incomplete_reason_name(reason),
             retained,
@@ -942,6 +1479,28 @@ fn incomplete_reason_name(reason: &IncompleteObservationReason) -> &'static str
     }
 }
 
+fn invariant_failure_name(code: html::conformance::InvariantFailureCode) -> &'static str {
+    use html::conformance::InvariantFailureCode as I;
+    match code {
+        I::DecoderCarryNotEmpty => "decoder-carry-not-empty",
+        I::PreprocessingNotFlushed => "preprocessing-not-flushed",
+        I::EofEmissionInvalid => "eof-emission-invalid",
+        I::PendingTokenizerConstruct => "pending-tokenizer-construct",
+        I::TokenizerOutputUnaccounted => "tokenizer-output-unaccounted",
+        I::PendingTableText => "pending-table-text",
+        I::InvalidInsertionMode => "invalid-insertion-mode",
+        I::OpenElementsInconsistent => "open-elements-inconsistent",
+        I::ActiveFormattingInconsistent => "active-formatting-inconsistent",
+        I::TemplateModesInconsistent => "template-modes-inconsistent",
+        I::FormPointerInvalid => "form-pointer-invalid",
+        I::ParentChildRelationshipInvalid => "parent-child-relationship-invalid",
+        I::NamespaceRelationshipInvalid => "namespace-relationship-invalid",
+        I::TemplateAssociationInvalid => "template-association-invalid",
+        I::PatchMaterializationIncomplete => "patch-materialization-incomplete",
+        I::LiveTreeMismatch => "live-tree-mismatch",
+    }
+}
+
 fn first_unsupported_expectation(expectations: &EnabledExpectations) -> Option<ExpectationSurface> {
     [
         (expectations.parse_errors(), ExpectationSurface::ParseErrors),
@@ -1003,6 +1562,57 @@ fn snapshot_format_name(surface: ExpectationSurface) -> &'static str {
         ExpectationSurface::Patches => "html5-dompatch-v3",
         ExpectationSurface::Transitions => "html5-tree-transitions-v1",
         ExpectationSurface::UnsupportedFeatures => "html5-unsupported-features-v1",
-        ExpectationSurface::FinalInvariants => "unsupported-final-invariants",
+        ExpectationSurface::FinalInvariants => "html5-final-invariants-v1",
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn delivery_boundary_digest_has_a_platform_independent_vector() {
+        let strategy = ResolvedDeliveryStrategy {
+            transport: DeliveryTransport::UnicodeScalars,
+            coordinate_space: DeliveryCoordinateSpace::UnicodeScalarOrdinals,
+            input_extent: 4,
+            boundaries: CanonicalBoundarySequence::Explicit(Box::new([1, 3])),
+        };
+        assert_eq!(
+            delivery_boundary_digest(&strategy).as_deref(),
+            Some("665ff239e51e6367e65b858850b191d6d055ce17e1225742fa81b9afe73dcd59")
+        );
+    }
+
+    #[test]
+    fn fixed_delivery_boundary_digest_is_streamed_and_platform_independent() {
+        let strategy = ResolvedDeliveryStrategy {
+            transport: DeliveryTransport::Bytes,
+            coordinate_space: DeliveryCoordinateSpace::ByteOffsets,
+            input_extent: 100,
+            boundaries: CanonicalBoundarySequence::Fixed {
+                units_per_chunk: std::num::NonZeroUsize::new(10).unwrap(),
+            },
+        };
+        assert_eq!(
+            delivery_boundary_digest(&strategy).as_deref(),
+            Some("5fcbdf1b34b40eceff1cd08bc4f768ffbde3b289804a649d710f41a2b488214c")
+        );
+    }
+
+    #[test]
+    fn large_fixed_one_digest_does_not_require_boundary_storage() {
+        let strategy = ResolvedDeliveryStrategy {
+            transport: DeliveryTransport::Bytes,
+            coordinate_space: DeliveryCoordinateSpace::ByteOffsets,
+            input_extent: 1_000_000,
+            boundaries: CanonicalBoundarySequence::Fixed {
+                units_per_chunk: std::num::NonZeroUsize::MIN,
+            },
+        };
+        assert_eq!(
+            delivery_boundary_digest(&strategy).map(|digest| digest.len()),
+            Some(64)
+        );
     }
 }
diff --git a/crates/html_test_support/src/parser_fixture/tests.rs b/crates/html_test_support/src/parser_fixture/tests.rs
index ea1fcd40..0d3d593a 100644
--- a/crates/html_test_support/src/parser_fixture/tests.rs
+++ b/crates/html_test_support/src/parser_fixture/tests.rs
@@ -1,10 +1,14 @@
 use super::disposition::*;
+use super::mismatch::first_typed_parity_mismatch;
 use super::model::*;
-use super::runner::{FixtureFailureDetails, execute_fixture};
+use super::runner::{
+    FixtureFailureDetails, execute_fixture, resolve_scalar_ordinals,
+    with_scalar_boundary_offset_failure, with_serialization_counter,
+};
 use super::*;
 use html::conformance::{
     CanonicalParserResult, IncompleteObservationReason, InvariantFailureCode, ObservationState,
-    ParserObservationExecutionError, ParserObservationRequest,
+    ParserObservationDeliveryError, ParserObservationExecutionError, ParserObservationRequest,
 };
 use ring::digest::{SHA256, digest};
 use std::collections::BTreeSet;
@@ -31,6 +35,129 @@ struct CountingObservationExecutor {
     calls: usize,
 }
 
+#[test]
+fn scalar_boundary_offset_reservation_failure_is_typed_and_pre_parser() {
+    let error = with_scalar_boundary_offset_failure(|| {
+        resolve_scalar_ordinals("aé", 2, &[1]).expect_err("injected allocation failure")
+    });
+    assert!(matches!(
+        error,
+        super::runner::ResolveExecutionError::ScalarBoundaryOffsets
+    ));
+}
+
+#[test]
+fn scalar_boundary_offset_failure_stops_fixture_runner_before_candidate_parser() {
+    struct CountingProductionExecutor {
+        calls: usize,
+    }
+    impl super::runner::ParserObservationExecutor for CountingProductionExecutor {
+        fn execute(
+            &mut self,
+            request: ParserObservationRequest<'_>,
+        ) -> Result<CanonicalParserResult, ParserObservationExecutionError> {
+            self.calls += 1;
+            html::conformance::execute_parser_observation(request)
+        }
+    }
+
+    let repository = TestRepository::new();
+    let bundle = add_fixture_v2(&repository, "scalar-resource", "scalar-resource", b"hello");
+    rewrite(&bundle.join("fixture.toml"), |text| {
+        text.replace(
+            "[expectations]",
+            "[[execution.deliveries]]\nname = \"split\"\nunit = \"unicode-scalars\"\nstrategy = \"boundaries\"\nboundaries = [1]\n\n[expectations]",
+        )
+    });
+    let fixture = load_single_native_fixture(&repository);
+    let mut executor = CountingProductionExecutor { calls: 0 };
+    let outcome = with_scalar_boundary_offset_failure(|| {
+        super::runner::execute_fixture_v2_with(&fixture, &mut executor)
+    });
+    assert_eq!(
+        executor.calls, 1,
+        "only the whole baseline reaches the parser"
+    );
+    assert!(matches!(
+        &outcome,
+        FixtureExecutionOutcome::ExecutionFailedV2 {
+            class: ExecutionFailureClass::FixtureExecutionResourceExhaustion(
+                FixtureExecutionResourceSite::ScalarBoundaryExecutionOffsets
+            ),
+            ..
+        }
+    ));
+    assert_eq!(
+        super::failure_spelling::execution_failure_name(
+            ExecutionFailureClass::FixtureExecutionResourceExhaustion(
+                FixtureExecutionResourceSite::ScalarBoundaryExecutionOffsets,
+            ),
+        ),
+        "fixture-execution-resource-exhaustion:scalar-boundary-execution-offsets"
+    );
+}
+
+#[test]
+fn validated_fixture_delivery_rejection_is_a_runner_contradiction() {
+    struct RejectingCandidate {
+        calls: usize,
+    }
+    impl super::runner::ParserObservationExecutor for RejectingCandidate {
+        fn execute(
+            &mut self,
+            request: ParserObservationRequest<'_>,
+        ) -> Result<CanonicalParserResult, ParserObservationExecutionError> {
+            self.calls += 1;
+            if self.calls == 1 {
+                return html::conformance::execute_parser_observation(request);
+            }
+            Err(ParserObservationExecutionError::InvalidDelivery(
+                ParserObservationDeliveryError::BoundaryOutOfRange { boundary_index: 7 },
+            ))
+        }
+    }
+
+    let repository = TestRepository::new();
+    let bundle = add_fixture_v2(
+        &repository,
+        "validated-rejection",
+        "validated-rejection",
+        b"hello",
+    );
+    rewrite(&bundle.join("fixture.toml"), |text| {
+        text.replace(
+            "[expectations]",
+            "[[execution.deliveries]]\nname = \"split\"\nunit = \"unicode-scalars\"\nstrategy = \"boundaries\"\nboundaries = [1]\n\n[expectations]",
+        )
+    });
+    let fixture = load_single_native_fixture(&repository);
+    let mut executor = RejectingCandidate { calls: 0 };
+    let outcome = super::runner::execute_fixture_v2_with(&fixture, &mut executor);
+    assert_eq!(
+        executor.calls, 2,
+        "baseline and one rejected candidate execute"
+    );
+    assert!(matches!(
+        &outcome,
+        FixtureExecutionOutcome::ExecutionFailedV2 {
+            class: ExecutionFailureClass::ValidatedFixtureInvariant(
+                ValidatedFixtureInvariantCode::ValidatedBoundaryRejectedByExecutor,
+            ),
+            ..
+        }
+    ));
+    assert_eq!(
+        super::failure_spelling::runner_invariant_name(
+            ValidatedFixtureInvariantCode::ValidatedBoundaryRejectedByExecutor,
+        ),
+        "validated-boundary-rejected-by-executor"
+    );
+    assert!(!matches!(
+        &outcome,
+        FixtureExecutionOutcome::CompletedV2 { .. }
+    ));
+}
+
 impl super::runner::ParserObservationExecutor for CountingObservationExecutor {
     fn execute(
         &mut self,
@@ -235,6 +362,36 @@ fn fixture_loader_dispatches_exact_v1_and_v2_schemas_before_validation() {
     ));
 }
 
+#[test]
+fn fixture_v1_compatibility_path_has_no_representatives_or_mandatory_final_audit() {
+    use html::conformance::{ParserObservationExecutionError, ParserObservationRequest};
+    struct MustNotExecute;
+    impl super::runner::ParserObservationExecutor for MustNotExecute {
+        fn execute(
+            &mut self,
+            _: ParserObservationRequest<'_>,
+        ) -> Result<CanonicalParserResult, ParserObservationExecutionError> {
+            panic!("fixture-v1 must not enter the fixture-v2 strategy executor")
+        }
+    }
+
+    let repository = TestRepository::new();
+    add_fixture(&repository, "legacy", "legacy", b"hello");
+    let fixture = load_single_native_fixture(&repository);
+    assert!(matches!(
+        fixture.policy(),
+        ValidatedFixturePolicy::V1Compatibility(_)
+    ));
+    let report = super::runner::run_fixture_with_executor(&fixture, &mut MustNotExecute)
+        .expect("existing fixture-v1 bundle remains compatible");
+    let result = report.result().expect("fixture-v1 canonical result");
+    assert!(matches!(
+        result.final_invariants,
+        ObservationState::NotRequested
+    ));
+    assert!(report.delivery_results().is_empty());
+}
+
 #[test]
 fn fixture_v1_active_discovery_reads_sidecar_and_execution_rereads_it() {
     let repository = TestRepository::new();
@@ -480,6 +637,15 @@ fn fixture_v2_failure_spellings_round_trip_exhaustively_through_one_codec() {
             .copied()
             .map(I::ResourceExhaustion),
     );
+    identities.extend(
+        all_delivery_errors()
+            .iter()
+            .copied()
+            .map(I::InvalidDelivery),
+    );
+    for error in all_delivery_errors() {
+        assert_eq!(delivery_error_name(*error), error.diagnostic_name());
+    }
 
     let mut names = BTreeSet::new();
     for identity in identities {
@@ -564,6 +730,43 @@ fn disposition_mismatch_names_exact_expected_and_actual_parser_identities() {
     assert!(!diagnostic.contains("wording is not classification"));
 }
 
+#[test]
+fn fixture_v2_expected_final_invariant_requires_an_exact_singleton() {
+    let disposition = FixtureDisposition::ExpectedFailureV2 {
+        reason: "known final audit failure".to_string(),
+        failure: ExpectedFailureClassificationV2::FinalInvariant(
+            InvariantFailureCode::PendingTableText,
+        ),
+        reference: DispositionReference::TrackingIssue("#ae13c".to_string()),
+    };
+    let exact = FixtureExecutionOutcome::FinalInvariantFailedV2 {
+        strategy: "ordinal=1".to_string(),
+        first_failure: InvariantFailureCode::PendingTableText,
+        failure_count: 1,
+    };
+    assert_eq!(
+        evaluate_disposition(&disposition, &exact),
+        Ok(DispositionEvaluation::Pass)
+    );
+    for outcome in [
+        FixtureExecutionOutcome::FinalInvariantFailedV2 {
+            strategy: "ordinal=1".to_string(),
+            first_failure: InvariantFailureCode::PendingTableText,
+            failure_count: 2,
+        },
+        FixtureExecutionOutcome::FinalInvariantFailedV2 {
+            strategy: "ordinal=1".to_string(),
+            first_failure: InvariantFailureCode::InvalidInsertionMode,
+            failure_count: 1,
+        },
+    ] {
+        assert!(matches!(
+            evaluate_disposition(&disposition, &outcome),
+            Err(DispositionEvaluationError::UnexpectedOutcome { .. })
+        ));
+    }
+}
+
 #[test]
 fn required_unknown_extensions_are_selected_in_ascii_lexicographic_order() {
     fn selected(extension_tables: &str) -> FixtureCapability {
@@ -592,7 +795,7 @@ fn required_unknown_extensions_are_selected_in_ascii_lexicographic_order() {
 }
 
 #[test]
-fn fixture_v2_skipped_disposition_short_circuits_malformed_sidecars_and_unsupported_delivery() {
+fn fixture_v2_skipped_disposition_short_circuits_malformed_sidecars_and_execution() {
     use html::conformance::{ParserObservationExecutionError, ParserObservationRequest};
 
     struct CountingExecutor {
@@ -616,7 +819,7 @@ fn fixture_v2_skipped_disposition_short_circuits_malformed_sidecars_and_unsuppor
     fs::write(bundle.join("tokens.txt"), malformed).expect("large malformed sidecar");
     rewrite(&bundle.join("fixture.toml"), |text| {
         format!("{}\n[extensions.\"org.example.required-v1\"]\nrequired = true\nvalue = {{}}\n", text.replace("[source]\nkind = \"native\"", "[source]\nkind = \"external\"\nprovenance = \"upstream/case\"")
-            .replace("strategy = \"whole\"", "strategy = \"boundaries\"\nboundaries = [1]")
+            .replace("[expectations]", "[[execution.deliveries]]\nname = \"chunked\"\nunit = \"unicode-scalars\"\nstrategy = \"boundaries\"\nboundaries = [1]\n\n[expectations]")
             .replace("status = \"active\"", "status = \"skipped\"\nreason = \"chunking deferred\"\nclassification = { kind = \"unsupported-capability\", capability = { kind = \"unicode-scalar-chunking\" } }\nreference = { kind = \"tracking-issue\", value = \"#1\" }"))
     });
     let mut file_access = RecordingFileAccess {
@@ -651,10 +854,10 @@ fn skipped_fixture_precedes_unsupported_raw_input_without_reading_sidecars() {
     impl super::runner::ParserObservationExecutor for CountingExecutor {
         fn execute(
             &mut self,
-            _: ParserObservationRequest<'_>,
+            request: ParserObservationRequest<'_>,
         ) -> Result<CanonicalParserResult, ParserObservationExecutionError> {
             self.0 += 1;
-            Ok(canonical_result())
+            html::conformance::execute_parser_observation(request)
         }
     }
 
@@ -711,10 +914,10 @@ fn active_fixture_reads_each_expected_sidecar_once_after_metadata_validation() {
     impl super::runner::ParserObservationExecutor for CountingExecutor {
         fn execute(
             &mut self,
-            _: ParserObservationRequest<'_>,
+            request: ParserObservationRequest<'_>,
         ) -> Result<CanonicalParserResult, ParserObservationExecutionError> {
             self.0 += 1;
-            Ok(canonical_result())
+            html::conformance::execute_parser_observation(request)
         }
     }
 
@@ -740,7 +943,10 @@ fn active_fixture_reads_each_expected_sidecar_once_after_metadata_validation() {
         }
     ));
     assert_eq!(file_access.content_read_count("tokens.txt"), 1);
-    assert_eq!(executor.0, 0, "snapshot parsing precedes parser execution");
+    assert_eq!(
+        executor.0, 1,
+        "authoritative baseline precedes sidecar parsing"
+    );
 }
 
 #[test]
@@ -764,8 +970,9 @@ fn unsupported_input_and_unknown_extension_precede_malformed_v2_sidecars() {
         .remove(0);
     assert!(matches!(
         execute_fixture(&raw),
-        FixtureExecutionOutcome::UnsupportedFixtureSemantics {
-            capability: FixtureCapability::RawByteInput
+        FixtureExecutionOutcome::ExecutionFailedV2 {
+            class: ExecutionFailureClass::SnapshotFormat(ExpectationSurface::Tokens),
+            ..
         }
     ));
 
@@ -786,22 +993,42 @@ fn unsupported_input_and_unknown_extension_precede_malformed_v2_sidecars() {
 }
 
 #[test]
-fn declared_delivery_capability_and_planned_execution_are_distinct() {
+fn fixture_v2_semantically_aliases_duplicate_declarations_and_executes_chunking() {
     let supported = TestRepository::new();
     let bundle = add_fixture_v2(&supported, "supported", "supported", b"hello");
     rewrite(&bundle.join("fixture.toml"), |text| {
-        text.replace(
-        "[expectations]",
-        "[[execution.deliveries]]\nname = \"unused-whole\"\nunit = \"unicode-scalars\"\nstrategy = \"whole\"\n\n[expectations]",
-    )
+        text.replace("reference_delivery = \"whole\"", "reference_delivery = \"unused-whole\"")
+            .replace(
+                "[expectations]",
+                "[[execution.deliveries]]\nname = \"unused-whole\"\nunit = \"unicode-scalars\"\nstrategy = \"whole\"\n\n[expectations]",
+            )
     });
     let fixture = load_single_native_fixture(&supported);
-    let plan = super::execution::build_delivery_plan(&fixture).expect("plan");
+    assert_eq!(fixture.reference_delivery().as_str(), "unused-whole");
+    let ValidatedFixturePolicy::V2Parity(policy) = fixture.policy() else {
+        panic!("fixture-v2 policy");
+    };
     assert_eq!(
-        plan.iter()
-            .map(|delivery| delivery.name.as_str())
-            .collect::<Vec<_>>(),
-        ["whole"]
+        policy.strategies()[0]
+            .origins
+            .iter()
+            .filter(|origin| matches!(origin, DeliveryStrategyOrigin::Declared(_)))
+            .count(),
+        2
+    );
+    let FixtureExecutionOutcome::CompletedV2 {
+        deliveries,
+        reference_delivery: Some(reference_delivery),
+    } = execute_fixture(&fixture)
+    else {
+        panic!("aliased reference baseline should execute successfully");
+    };
+    assert_eq!(reference_delivery.as_str(), "unused-whole");
+    assert!(
+        deliveries[0]
+            .aliases()
+            .iter()
+            .any(|alias| alias == &reference_delivery)
     );
 
     let unsupported = TestRepository::new();
@@ -815,14 +1042,91 @@ fn declared_delivery_capability_and_planned_execution_are_distinct() {
     let fixture = load_single_native_fixture(&unsupported);
     assert!(matches!(
         execute_fixture(&fixture),
-        FixtureExecutionOutcome::UnsupportedFixtureSemantics {
-            capability: FixtureCapability::UnicodeScalarChunking
-        }
+        FixtureExecutionOutcome::CompletedV2 { .. }
     ));
 }
 
 #[test]
-fn fixture_v2_precedence_rejects_final_invariants_before_malformed_sidecars() {
+fn strategy_semantic_equality_uses_transport_coordinates_not_storage_shape() {
+    use std::num::NonZeroUsize;
+    let scalar_whole = ResolvedDeliveryStrategy {
+        transport: DeliveryTransport::UnicodeScalars,
+        coordinate_space: DeliveryCoordinateSpace::UnicodeScalarOrdinals,
+        input_extent: 1,
+        boundaries: CanonicalBoundarySequence::Whole,
+    };
+    let scalar_fixed = ResolvedDeliveryStrategy {
+        boundaries: CanonicalBoundarySequence::Fixed {
+            units_per_chunk: NonZeroUsize::MIN,
+        },
+        ..scalar_whole.clone()
+    };
+    let scalar_explicit = ResolvedDeliveryStrategy {
+        boundaries: CanonicalBoundarySequence::Explicit(Box::new([])),
+        ..scalar_whole.clone()
+    };
+    assert!(scalar_whole.semantically_equals(&scalar_fixed));
+    assert!(scalar_whole.semantically_equals(&scalar_explicit));
+
+    // The text "éx" has scalar extent 2 and byte extent 3. Coordinate 1
+    // therefore names different semantic strategies for the two transports,
+    // even though both declarations store the decimal value 1.
+    let scalar_boundary = ResolvedDeliveryStrategy {
+        transport: DeliveryTransport::UnicodeScalars,
+        coordinate_space: DeliveryCoordinateSpace::UnicodeScalarOrdinals,
+        input_extent: 2,
+        boundaries: CanonicalBoundarySequence::Explicit(Box::new([1])),
+    };
+    let byte_boundary = ResolvedDeliveryStrategy {
+        transport: DeliveryTransport::Bytes,
+        coordinate_space: DeliveryCoordinateSpace::ByteOffsets,
+        input_extent: 3,
+        boundaries: CanonicalBoundarySequence::Explicit(Box::new([1])),
+    };
+    assert!(!scalar_boundary.semantically_equals(&byte_boundary));
+}
+
+#[test]
+fn empty_and_one_scalar_v2_strategies_collapse_to_semantic_aliases() {
+    for (id, input) in [("empty", b"".as_slice()), ("one", b"x".as_slice())] {
+        let repository = TestRepository::new();
+        let bundle = add_fixture_v2(&repository, id, id, input);
+        rewrite(&bundle.join("fixture.toml"), |text| {
+            text.replace(
+                "[expectations]",
+                "[[execution.deliveries]]\nname = \"explicit-empty\"\nunit = \"unicode-scalars\"\nstrategy = \"boundaries\"\nboundaries = []\n\n[expectations]",
+            )
+        });
+        let fixture = load_single_native_fixture(&repository);
+        let ValidatedFixturePolicy::V2Parity(policy) = fixture.policy() else {
+            panic!("fixture-v2 policy");
+        };
+        assert_eq!(
+            policy.strategies().len(),
+            2,
+            "scalar baseline and byte baseline are the only semantic strategies for {id}"
+        );
+        assert!(policy.strategies()[0].origins.iter().any(
+            |origin| matches!(origin, DeliveryStrategyOrigin::Declared(name) if name.as_str() == "explicit-empty")
+        ));
+    }
+
+    let legacy = TestRepository::new();
+    let bundle = add_fixture(&legacy, "legacy-empty", "legacy-empty", b"");
+    rewrite(&bundle.join("fixture.toml"), |text| {
+        text.replace(
+            "strategy = \"whole\"",
+            "strategy = \"boundaries\"\nboundaries = []",
+        )
+    });
+    assert!(
+        discover_and_load(&legacy.native()).is_err(),
+        "fixture-v1 retains its non-empty declared-boundary compatibility rule"
+    );
+}
+
+#[test]
+fn fixture_v2_final_invariants_are_supported_and_snapshot_order_remains_canonical() {
     let repository = TestRepository::new();
     let bundle = add_fixture_v2(&repository, "precedence", "precedence", b"hello");
     fs::write(bundle.join("tokens.txt"), "malformed").expect("malformed tokens");
@@ -837,8 +1141,9 @@ fn fixture_v2_precedence_rejects_final_invariants_before_malformed_sidecars() {
     let fixture = load_single_native_fixture(&repository);
     assert!(matches!(
         execute_fixture(&fixture),
-        FixtureExecutionOutcome::UnsupportedExpectation {
-            surface: ExpectationSurface::FinalInvariants
+        FixtureExecutionOutcome::ExecutionFailedV2 {
+            class: ExecutionFailureClass::SnapshotFormat(ExpectationSurface::Tokens),
+            ..
         }
     ));
 }
@@ -863,18 +1168,44 @@ fn malformed_fixture_v2_sidecar_is_snapshot_format_for_its_exact_surface() {
 }
 
 #[test]
-fn fixture_v2_unions_requests_once_per_planned_delivery_and_separates_transition_only_delivery() {
+fn fixture_v2_executes_each_unique_strategy_once_with_the_surface_union() {
     use html::conformance::{
         ObservationRequest, ParserObservationExecutionError, ParserObservationRequest,
     };
     struct CountingExecutor {
         requests: Vec<(bool, bool, bool)>,
+        shapes: Vec<String>,
     }
     impl super::runner::ParserObservationExecutor for CountingExecutor {
         fn execute(
             &mut self,
             request: ParserObservationRequest<'_>,
         ) -> Result<CanonicalParserResult, ParserObservationExecutionError> {
+            let shape = match request.input {
+                html::conformance::ParserObservationInput::Utf8(_) => "utf8-whole".to_string(),
+                html::conformance::ParserObservationInput::Utf8FixedScalarChunks {
+                    scalars_per_chunk,
+                    ..
+                } => format!("utf8-fixed:{scalars_per_chunk}"),
+                html::conformance::ParserObservationInput::Utf8BoundaryChunks {
+                    byte_offsets,
+                    ..
+                } => format!("utf8-explicit:{byte_offsets:?}"),
+                html::conformance::ParserObservationInput::Bytes(_) => "bytes-whole".to_string(),
+                html::conformance::ParserObservationInput::ByteFixedChunks {
+                    bytes_per_chunk,
+                    ..
+                } => format!("bytes-fixed:{bytes_per_chunk}"),
+                html::conformance::ParserObservationInput::ByteBoundaryChunks {
+                    byte_offsets,
+                    ..
+                } => format!("bytes-explicit:{byte_offsets:?}"),
+                html::conformance::ParserObservationInput::Utf8Chunks(_)
+                | html::conformance::ParserObservationInput::ByteChunks(_) => {
+                    panic!("fixture-v2 does not use pre-materialized chunk arrays")
+                }
+            };
+            self.shapes.push(shape);
             self.requests.push((
                 matches!(request.tokens, ObservationRequest::Capture { .. }),
                 matches!(request.transitions, ObservationRequest::Capture { .. }),
@@ -901,20 +1232,262 @@ fn fixture_v2_unions_requests_once_per_planned_delivery_and_separates_transition
     .unwrap();
     rewrite(&bundle.join("fixture.toml"), |text| {
         text.replace("kind = \"standalone-tokenizer\"", "kind = \"document\"\nscripting = \"disabled\"")
-            .replace("[expectations]", "[[execution.deliveries]]\nname = \"trace-whole\"\nunit = \"unicode-scalars\"\nstrategy = \"whole\"\n\n[expectations]")
+            .replace("[expectations]", "[[execution.deliveries]]\nname = \"trace-whole\"\nunit = \"unicode-scalars\"\nstrategy = \"whole\"\n\n[[execution.deliveries]]\nname = \"declared-three\"\nunit = \"unicode-scalars\"\nstrategy = \"boundaries\"\nboundaries = [3]\n\n[expectations]")
             .replace("tokens = \"tokens.txt\"", "tokens = \"tokens.txt\"\nunsupported_features = \"unsupported-features.txt\"\n\n[[expectations.transitions]]\ndelivery = \"trace-whole\"\npath = \"transitions.txt\"")
     });
     let fixture = load_single_native_fixture(&repository);
     let mut executor = CountingExecutor {
         requests: Vec::new(),
+        shapes: Vec::new(),
     };
-    let _ = super::runner::execute_fixture_v2_with(&fixture, &mut executor);
+    let (_, serialization_calls) = with_serialization_counter(|| {
+        super::runner::execute_fixture_v2_with(&fixture, &mut executor)
+    });
+    assert_eq!(executor.requests.len(), 7);
+    assert!(
+        executor
+            .requests
+            .iter()
+            .all(|request| *request == (true, true, true))
+    );
+    assert_eq!(
+        executor.shapes.iter().collect::<BTreeSet<_>>().len(),
+        executor.shapes.len(),
+        "each semantically unique generated strategy executes once"
+    );
+    assert_eq!(
+        executor.shapes,
+        [
+            "utf8-whole",
+            "utf8-explicit:[3]",
+            "bytes-whole",
+            "utf8-fixed:1",
+            "utf8-explicit:[1, 2, 4]",
+            "bytes-fixed:1",
+            "bytes-explicit:[1, 2, 4]",
+        ]
+    );
     assert_eq!(
-        executor.requests,
-        [(true, false, true), (false, true, false)]
+        serialization_calls, 2,
+        "only the applicable baseline token and transition expectations are serialized"
     );
 }
 
+#[test]
+fn parity_mismatch_names_fixture_strategy_surface_and_first_record() {
+    use html::conformance::{
+        ObservedToken, ParserObservationExecutionError, ParserObservationRequest,
+    };
+    struct DivergingCandidate {
+        calls: usize,
+    }
+    impl super::runner::ParserObservationExecutor for DivergingCandidate {
+        fn execute(
+            &mut self,
+            request: ParserObservationRequest<'_>,
+        ) -> Result<CanonicalParserResult, ParserObservationExecutionError> {
+            self.calls += 1;
+            let mut result = html::conformance::execute_parser_observation(request)?;
+            if self.calls == 2
+                && let ObservationState::Captured(tokens) = &mut result.tokens
+                && let Some(ObservedToken::Character { data }) = tokens.first_mut()
+            {
+                data.push_str("-candidate-only");
+            }
+            Ok(result)
+        }
+    }
+    let repository = TestRepository::new();
+    add_fixture_v2(
+        &repository,
+        "parity-diagnostic",
+        "parity-diagnostic",
+        b"hello",
+    );
+    let fixture = load_single_native_fixture(&repository);
+    let (outcome, serialization_calls) = with_serialization_counter(|| {
+        super::runner::execute_fixture_v2_with(&fixture, &mut DivergingCandidate { calls: 0 })
+    });
+    assert_eq!(
+        serialization_calls, 3,
+        "baseline expectation plus the selected baseline/candidate token diagnostics"
+    );
+    assert!(matches!(
+        super::runner::failure_details(&fixture, &outcome),
+        Some(FixtureFailureDetails::ParityDiff {
+            surface: ExpectationSurface::Tokens,
+            ..
+        })
+    ));
+    let FixtureExecutionOutcome::ParityMismatchV2 {
+        strategy,
+        surface: ExpectationSurface::Tokens,
+        diff,
+    } = &outcome
+    else {
+        panic!("expected token parity mismatch: {outcome:?}");
+    };
+    assert!(strategy.contains("ordinal=2"), "{strategy}");
+    for expected in [
+        "fixture: parity-diagnostic",
+        "fixture path: fixtures/parity-diagnostic",
+        "delivery strategy: ordinal=2",
+        "canonical surface: tokens",
+        "first meaningful difference: record 1",
+    ] {
+        assert!(diff.contains(expected), "missing {expected}: {diff}");
+    }
+}
+
+#[test]
+fn successful_parity_candidate_does_not_serialize_candidate_surfaces() {
+    struct CountingProductionExecutor {
+        calls: usize,
+    }
+    impl super::runner::ParserObservationExecutor for CountingProductionExecutor {
+        fn execute(
+            &mut self,
+            request: ParserObservationRequest<'_>,
+        ) -> Result<CanonicalParserResult, ParserObservationExecutionError> {
+            self.calls += 1;
+            html::conformance::execute_parser_observation(request)
+        }
+    }
+    let repository = TestRepository::new();
+    add_fixture_v2(&repository, "parity-memory", "parity-memory", b"hello");
+    let fixture = load_single_native_fixture(&repository);
+    let (outcome, serialization_calls) = with_serialization_counter(|| {
+        super::runner::execute_fixture_v2_with(
+            &fixture,
+            &mut CountingProductionExecutor { calls: 0 },
+        )
+    });
+    assert!(
+        matches!(outcome, FixtureExecutionOutcome::CompletedV2 { .. }),
+        "{outcome:?}"
+    );
+    assert_eq!(
+        serialization_calls, 1,
+        "only the applicable baseline token expectation is serialized"
+    );
+}
+
+#[test]
+fn tree_parity_mismatch_serializes_only_the_selected_tree_surface() {
+    struct DivergingTree {
+        calls: usize,
+    }
+    impl super::runner::ParserObservationExecutor for DivergingTree {
+        fn execute(
+            &mut self,
+            request: ParserObservationRequest<'_>,
+        ) -> Result<CanonicalParserResult, ParserObservationExecutionError> {
+            self.calls += 1;
+            let mut result = html::conformance::execute_parser_observation(request)?;
+            if self.calls == 2
+                && let ObservationState::Captured(tree) = &mut result.tree
+            {
+                tree.roots.clear();
+            }
+            Ok(result)
+        }
+    }
+
+    let repository = TestRepository::new();
+    let bundle = add_fixture_v2(&repository, "tree-parity", "tree-parity", b"hello");
+    rewrite(&bundle.join("fixture.toml"), |text| {
+        text.replace(
+            "kind = \"standalone-tokenizer\"",
+            "kind = \"document\"\nscripting = \"disabled\"",
+        )
+    });
+    let fixture = load_single_native_fixture(&repository);
+    let (outcome, serialization_calls) = with_serialization_counter(|| {
+        super::runner::execute_fixture_v2_with(&fixture, &mut DivergingTree { calls: 0 })
+    });
+    assert!(matches!(
+        outcome,
+        FixtureExecutionOutcome::ParityMismatchV2 {
+            surface: ExpectationSurface::Tree,
+            ..
+        }
+    ));
+    assert_eq!(
+        serialization_calls, 3,
+        "baseline token expectation plus the selected baseline and candidate trees"
+    );
+}
+
+#[test]
+fn invalid_baseline_stops_before_candidates_and_sidecar_reads() {
+    use html::conformance::{ParserObservationExecutionError, ParserObservationRequest};
+    struct FailingBaseline {
+        calls: usize,
+    }
+    impl super::runner::ParserObservationExecutor for FailingBaseline {
+        fn execute(
+            &mut self,
+            _: ParserObservationRequest<'_>,
+        ) -> Result<CanonicalParserResult, ParserObservationExecutionError> {
+            self.calls += 1;
+            Err(ParserObservationExecutionError::ParserInvariant)
+        }
+    }
+    let repository = TestRepository::new();
+    add_fixture_v2(&repository, "baseline-stop", "baseline-stop", b"hello");
+    let fixture = load_single_native_fixture(&repository);
+    let mut executor = FailingBaseline { calls: 0 };
+    let outcome = super::runner::execute_fixture_v2_with(&fixture, &mut executor);
+    assert!(matches!(
+        outcome,
+        FixtureExecutionOutcome::ExecutionFailedV2 {
+            class: ExecutionFailureClass::ParserObservation(
+                html::conformance::ParserObservationExecutionIdentity::ParserInvariant
+            ),
+            ..
+        }
+    ));
+    assert_eq!(executor.calls, 1);
+}
+
+#[test]
+fn candidate_final_invariant_failure_is_not_parity_compared() {
+    use html::conformance::{
+        InvariantOutcome, ParserObservationExecutionError, ParserObservationRequest,
+    };
+    struct FailedCandidateAudit {
+        calls: usize,
+    }
+    impl super::runner::ParserObservationExecutor for FailedCandidateAudit {
+        fn execute(
+            &mut self,
+            request: ParserObservationRequest<'_>,
+        ) -> Result<CanonicalParserResult, ParserObservationExecutionError> {
+            self.calls += 1;
+            let mut result = html::conformance::execute_parser_observation(request)?;
+            if self.calls == 2
+                && let ObservationState::Captured(report) = &mut result.final_invariants
+            {
+                report.tree_builder.pending_table_text_empty = InvariantOutcome::Failed;
+            }
+            Ok(result)
+        }
+    }
+    let repository = TestRepository::new();
+    add_fixture_v2(&repository, "candidate-audit", "candidate-audit", b"hello");
+    let fixture = load_single_native_fixture(&repository);
+    let outcome =
+        super::runner::execute_fixture_v2_with(&fixture, &mut FailedCandidateAudit { calls: 0 });
+    assert!(matches!(
+        outcome,
+        FixtureExecutionOutcome::FinalInvariantFailedV2 {
+            first_failure: InvariantFailureCode::PendingTableText,
+            failure_count: 1,
+            ..
+        }
+    ));
+}
+
 #[test]
 fn parser_failure_and_incomplete_state_precede_snapshot_mismatch() {
     use html::conformance::{ParserObservationExecutionError, ParserObservationRequest};
@@ -1040,11 +1613,11 @@ fn transition_mismatch_selection_follows_fixture_declaration_order() {
     let fixture = load_single_native_fixture(&repository);
     match execute_fixture(&fixture) {
         FixtureExecutionOutcome::ExpectationMismatchV2 {
-            ref delivery,
+            ref strategy,
             surface: ExpectationSurface::Transitions,
             diff,
         } => {
-            assert_eq!(delivery.as_str(), "first-trace");
+            assert!(strategy.contains("declared:first-trace"), "{strategy}");
             assert!(diff.contains("transition delivery: first-trace"), "{diff}");
         }
         other => panic!("unexpected outcome: {other:?}"),
@@ -1069,6 +1642,7 @@ fn canonical_fixture_guardrails_are_fixed_and_expectation_independent() {
             patches: true,
             transitions: true,
             unsupported_features: true,
+            final_invariants: true,
         },
         guardrails,
     );
@@ -1247,8 +1821,6 @@ fn incomplete_diagnostics_retain_exact_identity_for_every_surface() {
     let repository = TestRepository::new();
     add_fixture_v2(&repository, "incomplete", "incomplete", b"hello");
     let fixture = load_single_native_fixture(&repository);
-    let delivery = DeliveryName::validated("whole".to_string());
-
     for surface in [
         ExpectationSurface::Tokens,
         ExpectationSurface::ParseErrors,
@@ -1258,9 +1830,10 @@ fn incomplete_diagnostics_retain_exact_identity_for_every_surface() {
         ExpectationSurface::Patches,
         ExpectationSurface::Transitions,
         ExpectationSurface::UnsupportedFeatures,
+        ExpectationSurface::FinalInvariants,
     ] {
         let outcome = FixtureExecutionOutcome::IncompleteObservationV2 {
-            delivery: delivery.clone(),
+            strategy: "ordinal=1 origins=[baseline,declared:whole]".to_string(),
             surface,
             reason: IncompleteObservationReason::StorageLimitExceeded {
                 retained: 11,
@@ -1275,7 +1848,7 @@ fn incomplete_diagnostics_retain_exact_identity_for_every_surface() {
             panic!("missing incomplete details for {}", surface.name());
         };
         for expected in [
-            "delivery: whole".to_string(),
+            "strategy:".to_string(),
             format!("surface: {}", surface.name()),
             "reason: storage-limit-exceeded".to_string(),
             "retained count: 11".to_string(),
@@ -1358,6 +1931,7 @@ fn injected_guardrails_cover_exact_and_capacity_plus_one_for_every_retained_surf
         patches: true,
         transitions: true,
         unsupported_features: true,
+        final_invariants: true,
     };
     let high = FixtureObservationGuardrails {
         tokens: 1_024,
@@ -1519,7 +2093,7 @@ fn incomplete_prefix_equal_to_expected_snapshot_cannot_reach_serialization_or_co
     assert!(matches!(
         outcome,
         FixtureExecutionOutcome::IncompleteObservationV2 {
-            ref delivery,
+            ref strategy,
             surface: ExpectationSurface::Tokens,
             reason: IncompleteObservationReason::StorageLimitExceeded {
                 retained: 2,
@@ -1527,14 +2101,14 @@ fn incomplete_prefix_equal_to_expected_snapshot_cannot_reach_serialization_or_co
             },
             retained: 2,
             dropped: 1,
-        } if delivery.as_str() == "whole"
+        } if strategy.contains("declared:whole")
     ));
 
     let error = super::runner::run_fixture_with_executor(&fixture, &mut IncompleteMatchingPrefix)
         .expect_err("incomplete capture cannot produce a completed report");
     let diagnostic = error.to_string();
     for expected in [
-        "delivery: whole",
+        "strategy:",
         "surface: tokens",
         "reason: storage-limit-exceeded",
         "retained count: 2",
@@ -1565,7 +2139,7 @@ fn successful_v2_report_borrows_reference_result_from_its_single_delivery_owner(
         .find(|fixture| fixture.id().as_str() == "document-structured-observations")
         .expect("multi-delivery canonical fixture");
     let report = run_fixture(fixture).expect("multi-delivery fixture passes");
-    assert_eq!(report.delivery_results().len(), 2);
+    assert_eq!(report.delivery_results().len(), 1);
     let reference = report.result().expect("ordinary reference result");
     let owned = report
         .delivery_results()
@@ -1574,6 +2148,14 @@ fn successful_v2_report_borrows_reference_result_from_its_single_delivery_owner(
         .expect("reference delivery")
         .result();
     assert!(std::ptr::eq(reference, owned));
+    assert_eq!(
+        report.delivery_results()[0]
+            .aliases()
+            .iter()
+            .map(DeliveryName::as_str)
+            .collect::<Vec<_>>(),
+        ["whole", "trace-whole"]
+    );
 }
 
 #[test]
@@ -1970,7 +2552,9 @@ fn illegal_input_delivery_and_target_combinations_are_rejected() {
     });
     assert!(matches!(
         discover_and_load(&repository.native()).unwrap_err().kind,
-        FixtureLoadErrorKind::InvalidCombination(_)
+        FixtureLoadErrorKind::InvalidDelivery(
+            DeliveryValidationError::UnitNotSupportedForInputDomain { .. }
+        )
     ));
 
     let repository = TestRepository::new();
@@ -1985,6 +2569,564 @@ fn illegal_input_delivery_and_target_combinations_are_rejected() {
         discover_and_load(&repository.native()).unwrap_err().kind,
         FixtureLoadErrorKind::InvalidCombination(_)
     ));
+
+    let repository = TestRepository::new();
+    let bundle = add_fixture_v2(&repository, "reference-name", "reference-name", b"hello");
+    rewrite(&bundle.join("fixture.toml"), |text| {
+        text.replace(
+            "reference_delivery = \"whole\"",
+            "reference_delivery = \"Bad Name\"",
+        )
+    });
+    assert!(matches!(
+        discover_and_load(&repository.native()).unwrap_err().kind,
+        FixtureLoadErrorKind::InvalidDelivery(
+            DeliveryValidationError::InvalidReferenceDeliveryName { ref declared_name }
+        ) if declared_name == "Bad Name"
+    ));
+}
+
+#[test]
+fn delivery_name_validation_reports_exact_typed_context() {
+    let repository = TestRepository::new();
+    let bundle = add_fixture_v2(&repository, "invalid-name", "invalid-name", b"hello");
+    rewrite(&bundle.join("fixture.toml"), |text| {
+        text.replace("name = \"whole\"", "name = \"Bad Name\"")
+    });
+    assert_eq!(
+        discover_and_load(&repository.native()).unwrap_err().kind,
+        FixtureLoadErrorKind::InvalidDelivery(DeliveryValidationError::InvalidDeliveryName {
+            delivery_index: 0,
+            declared_name: "Bad Name".to_string(),
+        })
+    );
+
+    let repository = TestRepository::new();
+    let bundle = add_fixture_v2(&repository, "duplicate-name", "duplicate-name", b"hello");
+    rewrite(&bundle.join("fixture.toml"), |text| {
+        text.replace(
+            "[expectations]",
+            "[[execution.deliveries]]\nname = \"whole\"\nunit = \"unicode-scalars\"\nstrategy = \"whole\"\n\n[expectations]",
+        )
+    });
+    assert_eq!(
+        discover_and_load(&repository.native()).unwrap_err().kind,
+        FixtureLoadErrorKind::InvalidDelivery(DeliveryValidationError::DuplicateDeliveryName {
+            delivery_index: 1,
+            declared_name: "whole".to_string(),
+        })
+    );
+}
+
+fn load_v2_delivery_error(
+    input: &[u8],
+    raw_bytes: bool,
+    transform: impl FnOnce(String) -> String,
+) -> FixtureLoadErrorKind {
+    let repository = TestRepository::new();
+    let bundle = add_fixture_v2(
+        &repository,
+        "typed-delivery-error",
+        "typed-delivery-error",
+        input,
+    );
+    let mut metadata = fs::read_to_string(bundle.join("fixture.toml")).expect("fixture metadata");
+    if raw_bytes {
+        fs::rename(bundle.join("input.html"), bundle.join("input.bin")).expect("raw input rename");
+        metadata = metadata
+            .replace("path = \"input.html\"", "path = \"input.bin\"")
+            .replace("kind = \"utf8-text\"", "kind = \"raw-bytes\"");
+    }
+    fs::write(bundle.join("fixture.toml"), transform(metadata)).expect("fixture metadata rewrite");
+    discover_and_load(&repository.native())
+        .expect_err("fixture must produce the requested typed validation error")
+        .kind
+}
+
+#[test]
+fn fixture_validator_emits_every_delivery_validation_error_with_exact_context() {
+    let error = load_v2_delivery_error(b"hello", false, |text| {
+        let mut extra = String::new();
+        for index in 0..32 {
+            extra.push_str(&format!(
+                "[[execution.deliveries]]\nname = \"split-{index}\"\nunit = \"unicode-scalars\"\nstrategy = \"boundaries\"\nboundaries = [{}]\n\n",
+                index + 1
+            ));
+        }
+        text.replace("[expectations]", &format!("{extra}[expectations]"))
+    });
+    assert_eq!(
+        error,
+        FixtureLoadErrorKind::InvalidDelivery(DeliveryValidationError::TooManyDeclaredDeliveries {
+            declared: 33,
+            maximum: 32,
+        })
+    );
+
+    let error = load_v2_delivery_error(b"hello", false, |text| {
+        let boundaries = (1..=4_097)
+            .map(|value| value.to_string())
+            .collect::<Vec<_>>()
+            .join(",");
+        text.replace(
+            "[expectations]",
+            &format!(
+                "[[execution.deliveries]]\nname = \"oversized\"\nunit = \"unicode-scalars\"\nstrategy = \"boundaries\"\nboundaries = [{boundaries}]\n\n[expectations]"
+            ),
+        )
+    });
+    assert_eq!(
+        error,
+        FixtureLoadErrorKind::InvalidDelivery(DeliveryValidationError::TooManyBoundaries {
+            delivery_index: 1,
+            declared_name: "oversized".to_owned(),
+            declared: 4_097,
+            maximum: 4_096,
+        })
+    );
+
+    let error = load_v2_delivery_error(b"hello", false, |text| {
+        text.replace("name = \"whole\"", "name = \"Bad Name\"")
+    });
+    assert_eq!(
+        error,
+        FixtureLoadErrorKind::InvalidDelivery(DeliveryValidationError::InvalidDeliveryName {
+            delivery_index: 0,
+            declared_name: "Bad Name".to_owned(),
+        })
+    );
+
+    let error = load_v2_delivery_error(b"hello", false, |text| {
+        text.replace(
+            "[expectations]",
+            "[[execution.deliveries]]\nname = \"whole\"\nunit = \"unicode-scalars\"\nstrategy = \"whole\"\n\n[expectations]",
+        )
+    });
+    assert_eq!(
+        error,
+        FixtureLoadErrorKind::InvalidDelivery(DeliveryValidationError::DuplicateDeliveryName {
+            delivery_index: 1,
+            declared_name: "whole".to_owned(),
+        })
+    );
+
+    let error = load_v2_delivery_error(b"hello", false, |text| {
+        text.replace(
+            "reference_delivery = \"whole\"",
+            "reference_delivery = \"Bad Ref\"",
+        )
+    });
+    assert_eq!(
+        error,
+        FixtureLoadErrorKind::InvalidDelivery(
+            DeliveryValidationError::InvalidReferenceDeliveryName {
+                declared_name: "Bad Ref".to_owned(),
+            }
+        )
+    );
+
+    let error = load_v2_delivery_error(b"hello", true, |text| text);
+    assert_eq!(
+        error,
+        FixtureLoadErrorKind::InvalidDelivery(
+            DeliveryValidationError::UnitNotSupportedForInputDomain {
+                delivery: DeliveryName::validated("whole".to_owned()),
+            }
+        )
+    );
+
+    let error = load_v2_delivery_error(b"hello", false, |text| {
+        text.replace(
+            "[expectations]",
+            "[[execution.deliveries]]\nname = \"split\"\nunit = \"unicode-scalars\"\nstrategy = \"boundaries\"\n\n[expectations]",
+        )
+    });
+    assert_eq!(
+        error,
+        FixtureLoadErrorKind::InvalidDelivery(DeliveryValidationError::BoundariesMissing {
+            delivery: DeliveryName::validated("split".to_owned()),
+        })
+    );
+
+    let error = load_v2_delivery_error(b"hello", false, |text| {
+        text.replace(
+            "[expectations]",
+            "[[execution.deliveries]]\nname = \"split\"\nunit = \"unicode-scalars\"\nstrategy = \"whole\"\nboundaries = [1]\n\n[expectations]",
+        )
+    });
+    assert_eq!(
+        error,
+        FixtureLoadErrorKind::InvalidDelivery(DeliveryValidationError::BoundariesUnexpected {
+            delivery: DeliveryName::validated("split".to_owned()),
+        })
+    );
+
+    for (boundaries, expected) in [
+        (
+            "[0]",
+            DeliveryValidationError::BoundaryAtStart {
+                delivery: DeliveryName::validated("split".to_owned()),
+                boundary_index: 0,
+            },
+        ),
+        (
+            "[5]",
+            DeliveryValidationError::BoundaryAtEnd {
+                delivery: DeliveryName::validated("split".to_owned()),
+                boundary_index: 0,
+            },
+        ),
+        (
+            "[6]",
+            DeliveryValidationError::BoundaryOutOfRange {
+                delivery: DeliveryName::validated("split".to_owned()),
+                boundary_index: 0,
+            },
+        ),
+        (
+            "[1, 1]",
+            DeliveryValidationError::DuplicateBoundary {
+                delivery: DeliveryName::validated("split".to_owned()),
+                boundary_index: 1,
+            },
+        ),
+        (
+            "[2, 1]",
+            DeliveryValidationError::UnsortedBoundary {
+                delivery: DeliveryName::validated("split".to_owned()),
+                boundary_index: 1,
+            },
+        ),
+    ] {
+        let error = load_v2_delivery_error(b"hello", false, |text| {
+            text.replace(
+                "[expectations]",
+                &format!(
+                    "[[execution.deliveries]]\nname = \"split\"\nunit = \"unicode-scalars\"\nstrategy = \"boundaries\"\nboundaries = {boundaries}\n\n[expectations]"
+                ),
+            )
+        });
+        assert_eq!(
+            error,
+            FixtureLoadErrorKind::InvalidDelivery(expected),
+            "boundary declaration {boundaries}"
+        );
+    }
+
+    let error = load_v2_delivery_error(b"hello", false, |text| {
+        text.replace(
+            "unit = \"unicode-scalars\"\nstrategy = \"whole\"",
+            "unit = \"bytes\"\nstrategy = \"whole\"",
+        )
+    });
+    assert_eq!(
+        error,
+        FixtureLoadErrorKind::InvalidDelivery(DeliveryValidationError::MissingDomainBaseline)
+    );
+
+    let error = load_v2_delivery_error(b"hello", false, |text| {
+        text.replace(
+            "reference_delivery = \"whole\"",
+            "reference_delivery = \"missing\"",
+        )
+    });
+    assert_eq!(
+        error,
+        FixtureLoadErrorKind::InvalidDelivery(DeliveryValidationError::ReferenceDeliveryMissing {
+            delivery: DeliveryName::validated("missing".to_owned()),
+        })
+    );
+
+    let error = load_v2_delivery_error(b"hello", false, |text| {
+        text.replace(
+            "reference_delivery = \"whole\"",
+            "reference_delivery = \"bytes\"",
+        )
+        .replace(
+            "[expectations]",
+            "[[execution.deliveries]]\nname = \"bytes\"\nunit = \"bytes\"\nstrategy = \"whole\"\n\n[expectations]",
+        )
+    });
+    assert_eq!(
+        error,
+        FixtureLoadErrorKind::InvalidDelivery(
+            DeliveryValidationError::ReferenceIsNotDomainBaseline {
+                delivery: DeliveryName::validated("bytes".to_owned()),
+            }
+        )
+    );
+
+    let error = load_v2_delivery_error(&[b'x'; 100], false, |text| {
+        let mut unique = String::new();
+        for index in 1..=23 {
+            unique.push_str(&format!(
+                "[[execution.deliveries]]\nname = \"unique-{index}\"\nunit = \"unicode-scalars\"\nstrategy = \"boundaries\"\nboundaries = [{index}]\n\n"
+            ));
+        }
+        text.replace("[expectations]", &format!("{unique}[expectations]"))
+    });
+    assert_eq!(
+        error,
+        FixtureLoadErrorKind::InvalidDelivery(DeliveryValidationError::TooManyUniqueStrategies {
+            planned: 25,
+            maximum: 24,
+        })
+    );
+}
+
+#[test]
+fn fixture_delivery_validation_precedence_is_exact_for_combined_defects() {
+    let error = load_v2_delivery_error(b"hello", false, |text| {
+        let mut extra = String::new();
+        for index in 0..32 {
+            extra.push_str(&format!(
+                "[[execution.deliveries]]\nname = \"Bad Name {index}\"\nunit = \"unicode-scalars\"\nstrategy = \"whole\"\n\n"
+            ));
+        }
+        text.replace("[expectations]", &format!("{extra}[expectations]"))
+    });
+    assert!(matches!(
+        error,
+        FixtureLoadErrorKind::InvalidDelivery(DeliveryValidationError::TooManyDeclaredDeliveries {
+            declared: 33,
+            maximum: 32,
+        })
+    ));
+
+    let error = load_v2_delivery_error(b"hello", false, |text| {
+        let boundaries = (1..=4_097)
+            .map(|value| value.to_string())
+            .collect::<Vec<_>>()
+            .join(",");
+        text.replace(
+            "[expectations]",
+            &format!(
+                "[[execution.deliveries]]\nname = \"Bad Name\"\nunit = \"unicode-scalars\"\nstrategy = \"boundaries\"\nboundaries = [{boundaries}]\n\n[expectations]"
+            ),
+        )
+    });
+    assert!(matches!(
+        error,
+        FixtureLoadErrorKind::InvalidDelivery(DeliveryValidationError::TooManyBoundaries {
+            delivery_index: 1,
+            declared_name,
+            declared: 4_097,
+            maximum: 4_096,
+        }) if declared_name == "Bad Name"
+    ));
+
+    let error = load_v2_delivery_error(b"hello", false, |text| {
+        text.replace(
+            "[expectations]",
+            "[[execution.deliveries]]\nname = \"Bad Name\"\nunit = \"unicode-scalars\"\nstrategy = \"boundaries\"\nboundaries = [0]\n\n[expectations]",
+        )
+    });
+    assert!(matches!(
+        error,
+        FixtureLoadErrorKind::InvalidDelivery(DeliveryValidationError::InvalidDeliveryName {
+            delivery_index: 1,
+            declared_name,
+        }) if declared_name == "Bad Name"
+    ));
+
+    let error = load_v2_delivery_error(b"hello", true, |text| {
+        text.replace(
+            "unit = \"unicode-scalars\"\nstrategy = \"whole\"",
+            "unit = \"bytes\"\nstrategy = \"boundaries\"\nboundaries = [0]",
+        )
+    });
+    assert!(matches!(
+        error,
+        FixtureLoadErrorKind::InvalidDelivery(DeliveryValidationError::BoundaryAtStart {
+            delivery,
+            boundary_index: 0,
+        }) if delivery.as_str() == "whole"
+    ));
+
+    let error = load_v2_delivery_error(b"hello", false, |text| {
+        text.replace(
+            "unit = \"unicode-scalars\"\nstrategy = \"whole\"",
+            "unit = \"bytes\"\nstrategy = \"whole\"",
+        )
+        .replace(
+            "reference_delivery = \"whole\"",
+            "reference_delivery = \"Bad Ref\"",
+        )
+    });
+    assert!(matches!(
+        error,
+        FixtureLoadErrorKind::InvalidDelivery(DeliveryValidationError::MissingDomainBaseline)
+    ));
+
+    let error = load_v2_delivery_error(b"hello", false, |text| {
+        text.replace("reference_delivery = \"whole\"", "reference_delivery = \"bytes\"")
+            .replace(
+                "[expectations]",
+                "[[execution.deliveries]]\nname = \"bytes\"\nunit = \"bytes\"\nstrategy = \"whole\"\n\n[expectations]",
+            )
+    });
+    assert!(matches!(
+        error,
+        FixtureLoadErrorKind::InvalidDelivery(DeliveryValidationError::ReferenceIsNotDomainBaseline {
+            delivery,
+        }) if delivery.as_str() == "bytes"
+    ));
+}
+
+#[test]
+fn fixture_v2_guardrails_reject_excess_before_execution_without_truncation() {
+    let deliveries_repository = TestRepository::new();
+    let deliveries_bundle = add_fixture_v2(
+        &deliveries_repository,
+        "too-many-deliveries",
+        "too-many-deliveries",
+        &[b'x'; 100],
+    );
+    let mut extra = String::new();
+    for index in 0..32 {
+        extra.push_str(&format!(
+            "[[execution.deliveries]]\nname = \"split-{index}\"\nunit = \"unicode-scalars\"\nstrategy = \"boundaries\"\nboundaries = [{}]\n\n",
+            index + 1
+        ));
+    }
+    rewrite(&deliveries_bundle.join("fixture.toml"), |text| {
+        text.replace("[expectations]", &format!("{extra}[expectations]"))
+    });
+    let error = discover_and_load(&deliveries_repository.native())
+        .expect_err("declared delivery guardrail");
+    assert!(matches!(
+        error.kind,
+        FixtureLoadErrorKind::InvalidDelivery(DeliveryValidationError::TooManyDeclaredDeliveries {
+            declared: 33,
+            maximum: 32,
+        })
+    ));
+
+    let boundaries_repository = TestRepository::new();
+    let boundaries_bundle = add_fixture_v2(
+        &boundaries_repository,
+        "too-many-boundaries",
+        "too-many-boundaries",
+        &vec![b'x'; 5_000],
+    );
+    let boundaries = (1..=4_097)
+        .map(|value| value.to_string())
+        .collect::<Vec<_>>()
+        .join(",");
+    rewrite(&boundaries_bundle.join("fixture.toml"), |text| {
+        text.replace(
+            "[expectations]",
+            &format!(
+                "[[execution.deliveries]]\nname = \"oversized\"\nunit = \"unicode-scalars\"\nstrategy = \"boundaries\"\nboundaries = [{boundaries}]\n\n[expectations]"
+            ),
+        )
+    });
+    let error = discover_and_load(&boundaries_repository.native()).expect_err("boundary guardrail");
+    assert!(matches!(
+        error.kind,
+        FixtureLoadErrorKind::InvalidDelivery(DeliveryValidationError::TooManyBoundaries {
+            delivery_index: 1,
+            ref declared_name,
+            declared: 4_097,
+            maximum: 4_096,
+        }) if declared_name == "oversized"
+    ));
+
+    let strategies_repository = TestRepository::new();
+    let strategies_bundle = add_fixture_v2(
+        &strategies_repository,
+        "too-many-strategies",
+        "too-many-strategies",
+        &[b'x'; 100],
+    );
+    let mut unique = String::new();
+    for index in 1..=23 {
+        unique.push_str(&format!(
+            "[[execution.deliveries]]\nname = \"unique-{index}\"\nunit = \"unicode-scalars\"\nstrategy = \"boundaries\"\nboundaries = [{index}]\n\n"
+        ));
+    }
+    rewrite(&strategies_bundle.join("fixture.toml"), |text| {
+        text.replace("[expectations]", &format!("{unique}[expectations]"))
+    });
+    let error =
+        discover_and_load(&strategies_repository.native()).expect_err("unique strategy guardrail");
+    assert!(matches!(
+        error.kind,
+        FixtureLoadErrorKind::InvalidDelivery(DeliveryValidationError::TooManyUniqueStrategies {
+            planned: 25,
+            maximum: 24,
+        })
+    ));
+}
+
+#[test]
+fn fixture_v2_delivery_validation_reports_exact_boundary_variants_and_order() {
+    let cases = [
+        (vec![0], "start"),
+        (vec![5], "end"),
+        (vec![6], "range"),
+        (vec![1, 1], "duplicate"),
+        (vec![2, 1], "unsorted"),
+    ];
+    for (boundaries, expected) in cases {
+        let repository = TestRepository::new();
+        let bundle = add_fixture_v2(&repository, "boundary", "boundary", b"hello");
+        let encoded = boundaries
+            .iter()
+            .map(usize::to_string)
+            .collect::<Vec<_>>()
+            .join(",");
+        rewrite(&bundle.join("fixture.toml"), |text| {
+            text.replace(
+                "[expectations]",
+                &format!(
+                    "[[execution.deliveries]]\nname = \"split\"\nunit = \"unicode-scalars\"\nstrategy = \"boundaries\"\nboundaries = [{encoded}]\n\n[expectations]"
+                ),
+            )
+        });
+        let error = discover_and_load(&repository.native()).expect_err("invalid boundaries");
+        let expected_name = DeliveryName::validated("split".to_string());
+        match (expected, error.kind) {
+            (
+                "start",
+                FixtureLoadErrorKind::InvalidDelivery(DeliveryValidationError::BoundaryAtStart {
+                    delivery,
+                    boundary_index: 0,
+                }),
+            ) => assert_eq!(delivery, expected_name),
+            (
+                "end",
+                FixtureLoadErrorKind::InvalidDelivery(DeliveryValidationError::BoundaryAtEnd {
+                    delivery,
+                    boundary_index: 0,
+                }),
+            ) => assert_eq!(delivery, expected_name),
+            (
+                "range",
+                FixtureLoadErrorKind::InvalidDelivery(
+                    DeliveryValidationError::BoundaryOutOfRange {
+                        delivery,
+                        boundary_index: 0,
+                    },
+                ),
+            ) => assert_eq!(delivery, expected_name),
+            (
+                "duplicate",
+                FixtureLoadErrorKind::InvalidDelivery(DeliveryValidationError::DuplicateBoundary {
+                    delivery,
+                    boundary_index: 1,
+                }),
+            ) => assert_eq!(delivery, expected_name),
+            (
+                "unsorted",
+                FixtureLoadErrorKind::InvalidDelivery(DeliveryValidationError::UnsortedBoundary {
+                    delivery,
+                    boundary_index: 1,
+                }),
+            ) => assert_eq!(delivery, expected_name),
+            _ => panic!("unexpected typed validation result"),
+        }
+    }
 }
 
 #[test]
@@ -3028,6 +4170,24 @@ fn canonical_result() -> CanonicalParserResult {
     }
 }
 
+#[test]
+fn typed_parity_comparison_precedes_snapshot_serialization() {
+    let baseline = canonical_result();
+    let mut candidate = canonical_result();
+    candidate.document_mode = ObservationState::NotApplicable {
+        reason: html::conformance::NotApplicableReason::DocumentParserRun,
+    };
+    assert_eq!(
+        first_typed_parity_mismatch(&baseline, &candidate).unwrap(),
+        Some(ExpectationSurface::DocumentMode)
+    );
+    let equal = canonical_result();
+    assert_eq!(
+        first_typed_parity_mismatch(&baseline, &equal).unwrap(),
+        None
+    );
+}
+
 #[test]
 fn adapted_repository_accepts_external_non_active_schema_for_policy_evaluation() {
     let repository = TestRepository::new();
diff --git a/crates/html_test_support/src/parser_fixture/validate.rs b/crates/html_test_support/src/parser_fixture/validate.rs
index 8c2df807..c95ce259 100644
--- a/crates/html_test_support/src/parser_fixture/validate.rs
+++ b/crates/html_test_support/src/parser_fixture/validate.rs
@@ -1,7 +1,8 @@
 use super::failure_spelling::{parse_parser_observation_failure, parse_runner_invariant};
 use super::load::{
-    FixtureFileAccess, FixtureLoadError, FixtureLoadErrorKind, FixtureRepositoryPolicy,
-    normalize_relative_path, validate_relative_path,
+    DeliveryValidationError, FixtureFileAccess, FixtureLoadError, FixtureLoadErrorKind,
+    FixturePlanningInvariant, FixtureRepositoryPolicy, normalize_relative_path,
+    validate_relative_path,
 };
 use super::model::*;
 use super::schema::*;
@@ -11,6 +12,7 @@ use ring::digest::{SHA256, digest};
 use std::collections::{BTreeMap, BTreeSet};
 use std::fmt::Write;
 use std::fs;
+use std::num::NonZeroUsize;
 use std::path::Path;
 
 /// A fixture whose complete serialized declaration passed its selected strict
@@ -20,12 +22,11 @@ use std::path::Path;
 /// partially validated value from otherwise plausible component values.
 #[derive(Clone, Debug)]
 pub struct ValidatedFixtureSpec {
-    format: FixtureFormatVersion,
     id: FixtureId,
     bundle: FixtureBundle,
     source: FixtureSource,
     input: ExactInput,
-    execution: ValidatedExecution,
+    policy: ValidatedFixturePolicy,
     expectations: EnabledExpectations,
     disposition: FixtureDisposition,
     description: Option<String>,
@@ -68,7 +69,7 @@ impl ValidatedFixtureSpec {
     }
 
     pub fn target_kind(&self) -> ParserTargetKind {
-        match self.execution.target() {
+        match self.execution().target() {
             ValidatedParserTarget::StandaloneTokenizer => ParserTargetKind::StandaloneTokenizer,
             ValidatedParserTarget::Document { .. } => ParserTargetKind::Document,
             ValidatedParserTarget::Fragment { .. } => ParserTargetKind::Fragment,
@@ -76,7 +77,7 @@ impl ValidatedFixtureSpec {
     }
 
     pub fn scripting_mode(&self) -> Option<ScriptingMode> {
-        match self.execution.target() {
+        match self.execution().target() {
             ValidatedParserTarget::StandaloneTokenizer => None,
             ValidatedParserTarget::Document { scripting }
             | ValidatedParserTarget::Fragment { scripting, .. } => Some(*scripting),
@@ -84,7 +85,7 @@ impl ValidatedFixtureSpec {
     }
 
     pub fn fragment_namespace(&self) -> Option<ElementNamespace> {
-        match self.execution.target() {
+        match self.execution().target() {
             ValidatedParserTarget::Fragment { context, .. } => Some(context.namespace()),
             ValidatedParserTarget::StandaloneTokenizer | ValidatedParserTarget::Document { .. } => {
                 None
@@ -93,7 +94,7 @@ impl ValidatedFixtureSpec {
     }
 
     pub fn fragment_local_name(&self) -> Option<&str> {
-        match self.execution.target() {
+        match self.execution().target() {
             ValidatedParserTarget::Fragment { context, .. } => Some(context.local_name()),
             ValidatedParserTarget::StandaloneTokenizer | ValidatedParserTarget::Document { .. } => {
                 None
@@ -102,18 +103,18 @@ impl ValidatedFixtureSpec {
     }
 
     pub fn reference_delivery(&self) -> &DeliveryName {
-        self.execution.reference_delivery()
+        self.execution().reference_delivery()
     }
 
     pub fn delivery_names(&self) -> impl ExactSizeIterator<Item = &DeliveryName> {
-        self.execution
+        self.execution()
             .deliveries()
             .iter()
             .map(ValidatedDelivery::name)
     }
 
     pub fn delivery_boundaries(&self, name: &str) -> Option<Option<&[usize]>> {
-        self.execution
+        self.execution()
             .deliveries()
             .iter()
             .find(|delivery| delivery.name().as_str() == name)
@@ -144,8 +145,12 @@ impl ValidatedFixtureSpec {
         &self.bundle
     }
 
+    #[cfg(test)]
     pub(super) fn format(&self) -> FixtureFormatVersion {
-        self.format
+        match self.policy {
+            ValidatedFixturePolicy::V1Compatibility(_) => FixtureFormatVersion::V1,
+            ValidatedFixturePolicy::V2Parity(_) => FixtureFormatVersion::V2,
+        }
     }
 
     pub(super) fn input(&self) -> &ExactInput {
@@ -153,7 +158,11 @@ impl ValidatedFixtureSpec {
     }
 
     pub(super) fn execution(&self) -> &ValidatedExecution {
-        &self.execution
+        self.policy.execution()
+    }
+
+    pub(super) fn policy(&self) -> &ValidatedFixturePolicy {
+        &self.policy
     }
 
     pub(super) fn expectations(&self) -> &EnabledExpectations {
@@ -190,7 +199,7 @@ pub(super) fn validate_fixture_v1(
     validate_sha256(&bundle, &declaration.input.sha256, &input_bytes)?;
     let input = validate_input(&bundle, declaration.input, input_bytes)?;
 
-    let execution = validate_execution(&bundle, &input, declaration.execution)?;
+    let execution = validate_execution_v1(&bundle, &input, declaration.execution)?;
     let expectations = validate_expectations(
         &bundle,
         &execution,
@@ -215,12 +224,11 @@ pub(super) fn validate_fixture_v1(
     validate_source_disposition_policy(&bundle, repository_policy, &source, &disposition)?;
 
     Ok(ValidatedFixtureSpec {
-        format: FixtureFormatVersion::V1,
         id,
         bundle,
         source,
         input,
-        execution,
+        policy: ValidatedFixturePolicy::V1Compatibility(ValidatedV1Execution::validated(execution)),
         expectations,
         disposition,
         description: declaration.metadata.description,
@@ -270,7 +278,7 @@ pub(super) fn validate_fixture_v2(
     validate_sha256(&bundle, &declaration.input.sha256, &input_bytes)?;
     let input = validate_input(&bundle, declaration.input, input_bytes)?;
 
-    let execution = validate_execution(&bundle, &input, declaration.execution)?;
+    let execution = validate_execution_v2(&bundle, &input, declaration.execution)?;
     let expectations = validate_expectations(
         &bundle,
         &execution,
@@ -295,13 +303,15 @@ pub(super) fn validate_fixture_v2(
     )?;
     validate_source_disposition_policy(&bundle, repository_policy, &source, &disposition)?;
 
+    let strategies = plan_v2_strategies(&bundle, &input, &execution)?;
     Ok(ValidatedFixtureSpec {
-        format: FixtureFormatVersion::V2,
         id,
         bundle,
         source,
         input,
-        execution,
+        policy: ValidatedFixturePolicy::V2Parity(ValidatedV2Execution::validated(
+            execution, strategies,
+        )),
         expectations,
         disposition,
         description: declaration.metadata.description,
@@ -721,10 +731,296 @@ fn validate_input(
     }
 }
 
+fn validate_execution_v1(
+    bundle: &FixtureBundle,
+    input: &ExactInput,
+    declaration: ExecutionDeclaration,
+) -> Result<ValidatedExecution, FixtureLoadError> {
+    validate_execution(
+        bundle,
+        input,
+        declaration,
+        ExecutionValidationPolicy::V1Compatibility,
+    )
+}
+
+fn validate_execution_v2(
+    bundle: &FixtureBundle,
+    input: &ExactInput,
+    declaration: ExecutionDeclaration,
+) -> Result<ValidatedExecution, FixtureLoadError> {
+    validate_execution(
+        bundle,
+        input,
+        declaration,
+        ExecutionValidationPolicy::V2Parity,
+    )
+}
+
+#[derive(Clone, Copy)]
+enum ExecutionValidationPolicy {
+    V1Compatibility,
+    V2Parity,
+}
+
+const MAX_DECLARED_DELIVERIES_V2: usize = 32;
+const MAX_BOUNDARIES_PER_DELIVERY_V2: usize = 4096;
+const MAX_UNIQUE_PLANNED_STRATEGIES_V2: usize = 24;
+
+fn plan_v2_strategies(
+    bundle: &FixtureBundle,
+    input: &ExactInput,
+    execution: &ValidatedExecution,
+) -> Result<Vec<ScheduledDeliveryStrategy>, FixtureLoadError> {
+    let scalar_extent = input.text().map(|text| text.chars().count());
+    let byte_extent = input.bytes().len();
+    let baseline = match input {
+        ExactInput::Utf8Text { .. } => ResolvedDeliveryStrategy {
+            transport: DeliveryTransport::UnicodeScalars,
+            coordinate_space: DeliveryCoordinateSpace::UnicodeScalarOrdinals,
+            input_extent: scalar_extent.unwrap_or(0),
+            boundaries: CanonicalBoundarySequence::Whole,
+        },
+        ExactInput::RawBytes { .. } => ResolvedDeliveryStrategy {
+            transport: DeliveryTransport::Bytes,
+            coordinate_space: DeliveryCoordinateSpace::ByteOffsets,
+            input_extent: byte_extent,
+            boundaries: CanonicalBoundarySequence::Whole,
+        },
+    };
+    let mut planned = Vec::new();
+    push_or_alias_strategy(
+        bundle,
+        &mut planned,
+        baseline,
+        DeliveryStrategyOrigin::Baseline,
+    )?;
+
+    for declaration in execution.deliveries() {
+        let strategy = resolved_declared_strategy(declaration, scalar_extent, byte_extent);
+        push_or_alias_strategy(
+            bundle,
+            &mut planned,
+            strategy,
+            DeliveryStrategyOrigin::Declared(declaration.name().clone()),
+        )?;
+    }
+
+    let fixed_seven = NonZeroUsize::new(7).ok_or_else(|| {
+        bundle_error(
+            bundle,
+            FixtureLoadErrorKind::InvalidCombination(
+                "representative fixed extent is zero".to_string(),
+            ),
+        )
+    })?;
+    let mut representatives = Vec::new();
+    match input {
+        ExactInput::Utf8Text { .. } => {
+            representatives.push((
+                "whole-bytes",
+                ResolvedDeliveryStrategy {
+                    transport: DeliveryTransport::Bytes,
+                    coordinate_space: DeliveryCoordinateSpace::ByteOffsets,
+                    input_extent: byte_extent,
+                    boundaries: CanonicalBoundarySequence::Whole,
+                },
+            ));
+            representatives.extend([
+                (
+                    "scalar-fixed-one",
+                    ResolvedDeliveryStrategy {
+                        transport: DeliveryTransport::UnicodeScalars,
+                        coordinate_space: DeliveryCoordinateSpace::UnicodeScalarOrdinals,
+                        input_extent: scalar_extent.unwrap_or(0),
+                        boundaries: CanonicalBoundarySequence::Fixed {
+                            units_per_chunk: NonZeroUsize::MIN,
+                        },
+                    },
+                ),
+                (
+                    "scalar-fixed-seven",
+                    ResolvedDeliveryStrategy {
+                        transport: DeliveryTransport::UnicodeScalars,
+                        coordinate_space: DeliveryCoordinateSpace::UnicodeScalarOrdinals,
+                        input_extent: scalar_extent.unwrap_or(0),
+                        boundaries: CanonicalBoundarySequence::Fixed {
+                            units_per_chunk: fixed_seven,
+                        },
+                    },
+                ),
+                (
+                    "scalar-edge-triplet",
+                    ResolvedDeliveryStrategy {
+                        transport: DeliveryTransport::UnicodeScalars,
+                        coordinate_space: DeliveryCoordinateSpace::UnicodeScalarOrdinals,
+                        input_extent: scalar_extent.unwrap_or(0),
+                        boundaries: CanonicalBoundarySequence::Explicit(edge_triplet(
+                            scalar_extent.unwrap_or(0),
+                        )),
+                    },
+                ),
+                (
+                    "byte-fixed-one",
+                    ResolvedDeliveryStrategy {
+                        transport: DeliveryTransport::Bytes,
+                        coordinate_space: DeliveryCoordinateSpace::ByteOffsets,
+                        input_extent: byte_extent,
+                        boundaries: CanonicalBoundarySequence::Fixed {
+                            units_per_chunk: NonZeroUsize::MIN,
+                        },
+                    },
+                ),
+                (
+                    "byte-fixed-seven",
+                    ResolvedDeliveryStrategy {
+                        transport: DeliveryTransport::Bytes,
+                        coordinate_space: DeliveryCoordinateSpace::ByteOffsets,
+                        input_extent: byte_extent,
+                        boundaries: CanonicalBoundarySequence::Fixed {
+                            units_per_chunk: fixed_seven,
+                        },
+                    },
+                ),
+                (
+                    "byte-edge-triplet",
+                    ResolvedDeliveryStrategy {
+                        transport: DeliveryTransport::Bytes,
+                        coordinate_space: DeliveryCoordinateSpace::ByteOffsets,
+                        input_extent: byte_extent,
+                        boundaries: CanonicalBoundarySequence::Explicit(edge_triplet(byte_extent)),
+                    },
+                ),
+            ]);
+        }
+        ExactInput::RawBytes { .. } => representatives.extend([
+            (
+                "byte-fixed-one",
+                ResolvedDeliveryStrategy {
+                    transport: DeliveryTransport::Bytes,
+                    coordinate_space: DeliveryCoordinateSpace::ByteOffsets,
+                    input_extent: byte_extent,
+                    boundaries: CanonicalBoundarySequence::Fixed {
+                        units_per_chunk: NonZeroUsize::MIN,
+                    },
+                },
+            ),
+            (
+                "byte-fixed-seven",
+                ResolvedDeliveryStrategy {
+                    transport: DeliveryTransport::Bytes,
+                    coordinate_space: DeliveryCoordinateSpace::ByteOffsets,
+                    input_extent: byte_extent,
+                    boundaries: CanonicalBoundarySequence::Fixed {
+                        units_per_chunk: fixed_seven,
+                    },
+                },
+            ),
+            (
+                "byte-edge-triplet",
+                ResolvedDeliveryStrategy {
+                    transport: DeliveryTransport::Bytes,
+                    coordinate_space: DeliveryCoordinateSpace::ByteOffsets,
+                    input_extent: byte_extent,
+                    boundaries: CanonicalBoundarySequence::Explicit(edge_triplet(byte_extent)),
+                },
+            ),
+        ]),
+    }
+    for (name, strategy) in representatives {
+        push_or_alias_strategy(
+            bundle,
+            &mut planned,
+            strategy,
+            DeliveryStrategyOrigin::Representative(name),
+        )?;
+    }
+    Ok(planned)
+}
+
+fn resolved_declared_strategy(
+    delivery: &ValidatedDelivery,
+    scalar_extent: Option<usize>,
+    byte_extent: usize,
+) -> ResolvedDeliveryStrategy {
+    let boundaries = match delivery.boundaries() {
+        Some(boundaries) => CanonicalBoundarySequence::Explicit(boundaries.into()),
+        None => CanonicalBoundarySequence::Whole,
+    };
+    match delivery.transport() {
+        DeliveryTransport::UnicodeScalars => ResolvedDeliveryStrategy {
+            transport: DeliveryTransport::UnicodeScalars,
+            coordinate_space: delivery.coordinate_space(),
+            input_extent: scalar_extent.unwrap_or(0),
+            boundaries,
+        },
+        DeliveryTransport::Bytes => ResolvedDeliveryStrategy {
+            transport: DeliveryTransport::Bytes,
+            coordinate_space: delivery.coordinate_space(),
+            input_extent: byte_extent,
+            boundaries,
+        },
+    }
+}
+
+fn push_or_alias_strategy(
+    bundle: &FixtureBundle,
+    planned: &mut Vec<ScheduledDeliveryStrategy>,
+    strategy: ResolvedDeliveryStrategy,
+    origin: DeliveryStrategyOrigin,
+) -> Result<(), FixtureLoadError> {
+    if let Some(existing) = planned
+        .iter_mut()
+        .find(|existing| existing.strategy.semantically_equals(&strategy))
+    {
+        existing.origins.push(origin);
+        return Ok(());
+    }
+    if planned.len() >= MAX_UNIQUE_PLANNED_STRATEGIES_V2 {
+        return invalid_delivery(
+            bundle,
+            DeliveryValidationError::TooManyUniqueStrategies {
+                planned: planned.len() + 1,
+                maximum: MAX_UNIQUE_PLANNED_STRATEGIES_V2,
+            },
+        );
+    }
+    let ordinal = StrategyOrdinal::checked_from_index(planned.len()).ok_or_else(|| {
+        bundle_error(
+            bundle,
+            FixtureLoadErrorKind::InternalPlanningInvariant(
+                FixturePlanningInvariant::StrategyOrdinalOverflow,
+            ),
+        )
+    })?;
+    planned.push(ScheduledDeliveryStrategy {
+        ordinal,
+        strategy,
+        origins: vec![origin],
+    });
+    Ok(())
+}
+
+fn edge_triplet(extent: usize) -> Box<[usize]> {
+    if extent <= 1 {
+        return Box::new([]);
+    }
+    let mut boundaries = Vec::with_capacity(3);
+    for candidate in [1, extent / 2, extent - 1] {
+        if candidate > 0 && candidate < extent && boundaries.last() != Some(&candidate) {
+            boundaries.push(candidate);
+        }
+    }
+    boundaries.sort_unstable();
+    boundaries.dedup();
+    boundaries.into_boxed_slice()
+}
+
 fn validate_execution(
     bundle: &FixtureBundle,
     input: &ExactInput,
     declaration: ExecutionDeclaration,
+    policy: ExecutionValidationPolicy,
 ) -> Result<ValidatedExecution, FixtureLoadError> {
     let target = match declaration.target.kind {
         ParserTargetKindDeclaration::StandaloneTokenizer => {
@@ -786,28 +1082,75 @@ fn validate_execution(
     if declaration.deliveries.is_empty() {
         return invalid_combination(bundle, "execution must declare at least one delivery");
     }
-    if !is_kebab_identifier(&declaration.reference_delivery) {
-        return invalid_combination(
+    if matches!(policy, ExecutionValidationPolicy::V2Parity)
+        && declaration.deliveries.len() > MAX_DECLARED_DELIVERIES_V2
+    {
+        return invalid_delivery(
             bundle,
-            "reference delivery must be a lowercase kebab identifier",
+            DeliveryValidationError::TooManyDeclaredDeliveries {
+                declared: declaration.deliveries.len(),
+                maximum: MAX_DECLARED_DELIVERIES_V2,
+            },
         );
     }
-    let reference_delivery = DeliveryName::validated(declaration.reference_delivery);
+    let reference_delivery_name = declaration.reference_delivery;
     let mut names = BTreeSet::new();
     let mut deliveries = Vec::with_capacity(declaration.deliveries.len());
-    let extent = match input {
-        ExactInput::Utf8Text { text, .. } => text.chars().count(),
-        ExactInput::RawBytes { bytes, .. } => bytes.len(),
-    };
-    for delivery in declaration.deliveries {
-        if !is_kebab_identifier(&delivery.name) || !names.insert(delivery.name.clone()) {
-            return invalid_combination(
+    let byte_extent = input.bytes().len();
+    let scalar_extent = input.text().map(|text| text.chars().count());
+    for (delivery_index, delivery) in declaration.deliveries.into_iter().enumerate() {
+        if matches!(policy, ExecutionValidationPolicy::V2Parity)
+            && delivery
+                .boundaries
+                .as_ref()
+                .is_some_and(|boundaries| boundaries.len() > MAX_BOUNDARIES_PER_DELIVERY_V2)
+        {
+            return invalid_delivery(
                 bundle,
-                "delivery names must be unique lowercase kebab identifiers",
+                DeliveryValidationError::TooManyBoundaries {
+                    delivery_index,
+                    declared_name: delivery.name.clone(),
+                    declared: delivery.boundaries.as_ref().map_or(0, Vec::len),
+                    maximum: MAX_BOUNDARIES_PER_DELIVERY_V2,
+                },
+            );
+        }
+        if !is_kebab_identifier(&delivery.name) {
+            return invalid_delivery(
+                bundle,
+                DeliveryValidationError::InvalidDeliveryName {
+                    delivery_index,
+                    declared_name: delivery.name,
+                },
+            );
+        }
+        if !names.insert(delivery.name.clone()) {
+            return invalid_delivery(
+                bundle,
+                DeliveryValidationError::DuplicateDeliveryName {
+                    delivery_index,
+                    declared_name: delivery.name,
+                },
             );
         }
         let name = DeliveryName::validated(delivery.name);
         let validated = match (input, delivery.unit, delivery.strategy, delivery.boundaries) {
+            (_, _, DeliveryStrategyDeclaration::Whole, Some(_))
+                if matches!(policy, ExecutionValidationPolicy::V2Parity) =>
+            {
+                return invalid_delivery(
+                    bundle,
+                    DeliveryValidationError::BoundariesUnexpected { delivery: name },
+                );
+            }
+            (_, _, DeliveryStrategyDeclaration::Boundaries, None)
+                if matches!(policy, ExecutionValidationPolicy::V2Parity) =>
+            {
+                return invalid_delivery(
+                    bundle,
+                    DeliveryValidationError::BoundariesMissing { delivery: name },
+                );
+            }
             (
                 ExactInput::RawBytes { .. },
                 DeliveryUnitDeclaration::Bytes,
@@ -820,8 +1163,8 @@ fn validate_execution(
                 DeliveryStrategyDeclaration::Boundaries,
                 Some(boundaries),
             ) => ValidatedDelivery::ByteBoundaries {
-                name,
-                boundaries: validate_boundaries(bundle, boundaries, extent)?,
+                name: name.clone(),
+                boundaries: validate_boundaries(bundle, &name, boundaries, byte_extent, policy)?,
             },
             (
                 ExactInput::Utf8Text { .. },
@@ -835,24 +1178,106 @@ fn validate_execution(
                 DeliveryStrategyDeclaration::Boundaries,
                 Some(boundaries),
             ) => ValidatedDelivery::UnicodeScalarBoundaries {
-                name,
-                boundaries: validate_boundaries(bundle, boundaries, extent)?,
+                name: name.clone(),
+                boundaries: validate_boundaries(
+                    bundle,
+                    &name,
+                    boundaries,
+                    scalar_extent.ok_or_else(|| {
+                        bundle_error(
+                            bundle,
+                            FixtureLoadErrorKind::InvalidDelivery(
+                                DeliveryValidationError::UnitNotSupportedForInputDomain {
+                                    delivery: name.clone(),
+                                },
+                            ),
+                        )
+                    })?,
+                    policy,
+                )?,
             },
+            (
+                ExactInput::Utf8Text { .. },
+                DeliveryUnitDeclaration::Bytes,
+                DeliveryStrategyDeclaration::Whole,
+                None,
+            ) if matches!(policy, ExecutionValidationPolicy::V2Parity) => {
+                ValidatedDelivery::WholeBytes { name }
+            }
+            (
+                ExactInput::Utf8Text { .. },
+                DeliveryUnitDeclaration::Bytes,
+                DeliveryStrategyDeclaration::Boundaries,
+                Some(boundaries),
+            ) if matches!(policy, ExecutionValidationPolicy::V2Parity) => {
+                ValidatedDelivery::ByteBoundaries {
+                    name: name.clone(),
+                    boundaries: validate_boundaries(
+                        bundle,
+                        &name,
+                        boundaries,
+                        byte_extent,
+                        policy,
+                    )?,
+                }
+            }
             _ => {
-                return invalid_combination(
+                return invalid_delivery(
                     bundle,
-                    "input kind, delivery unit, strategy, and boundaries are inconsistent",
+                    DeliveryValidationError::UnitNotSupportedForInputDomain { delivery: name },
                 );
             }
         };
         deliveries.push(validated);
     }
+    if matches!(policy, ExecutionValidationPolicy::V2Parity) {
+        let is_domain_baseline = |delivery: &ValidatedDelivery| match input {
+            ExactInput::Utf8Text { .. } => {
+                matches!(delivery, ValidatedDelivery::WholeUnicodeScalars { .. })
+            }
+            ExactInput::RawBytes { .. } => matches!(delivery, ValidatedDelivery::WholeBytes { .. }),
+        };
+        if !deliveries.iter().any(is_domain_baseline) {
+            return invalid_delivery(bundle, DeliveryValidationError::MissingDomainBaseline);
+        }
+    }
+    if !is_kebab_identifier(&reference_delivery_name) {
+        return invalid_delivery(
+            bundle,
+            DeliveryValidationError::InvalidReferenceDeliveryName {
+                declared_name: reference_delivery_name,
+            },
+        );
+    }
+    let reference_delivery = DeliveryName::validated(reference_delivery_name);
     if !names.contains(reference_delivery.as_str()) {
-        return invalid_combination(
+        return invalid_delivery(
             bundle,
-            "reference delivery does not name a declared delivery",
+            DeliveryValidationError::ReferenceDeliveryMissing {
+                delivery: reference_delivery.clone(),
+            },
         );
     }
+    if matches!(policy, ExecutionValidationPolicy::V2Parity) {
+        let is_domain_baseline = |delivery: &ValidatedDelivery| match input {
+            ExactInput::Utf8Text { .. } => {
+                matches!(delivery, ValidatedDelivery::WholeUnicodeScalars { .. })
+            }
+            ExactInput::RawBytes { .. } => matches!(delivery, ValidatedDelivery::WholeBytes { .. }),
+        };
+        let reference_is_domain_baseline = deliveries
+            .iter()
+            .find(|delivery| delivery.name() == &reference_delivery)
+            .is_some_and(is_domain_baseline);
+        if !reference_is_domain_baseline {
+            return invalid_delivery(
+                bundle,
+                DeliveryValidationError::ReferenceIsNotDomainBaseline {
+                    delivery: reference_delivery.clone(),
+                },
+            );
+        }
+    }
     Ok(ValidatedExecution::validated(
         target,
         reference_delivery,
@@ -1151,19 +1576,63 @@ fn validate_sha256(
 
 fn validate_boundaries(
     bundle: &FixtureBundle,
+    delivery: &DeliveryName,
     boundaries: Vec<usize>,
     extent: usize,
+    policy: ExecutionValidationPolicy,
 ) -> Result<Vec<usize>, FixtureLoadError> {
-    if boundaries.is_empty()
-        || boundaries.windows(2).any(|pair| pair[0] >= pair[1])
-        || boundaries
-            .iter()
-            .any(|boundary| *boundary == 0 || *boundary >= extent)
-    {
-        return invalid_combination(
-            bundle,
-            "chunk boundaries must be strictly increasing interior offsets",
-        );
+    if boundaries.is_empty() && matches!(policy, ExecutionValidationPolicy::V1Compatibility) {
+        return invalid_combination(bundle, "delivery boundaries must not be empty");
+    }
+    for (index, boundary) in boundaries.iter().copied().enumerate() {
+        if boundary == 0 {
+            return invalid_delivery(
+                bundle,
+                DeliveryValidationError::BoundaryAtStart {
+                    delivery: delivery.clone(),
+                    boundary_index: index,
+                },
+            );
+        }
+        if boundary == extent {
+            return invalid_delivery(
+                bundle,
+                DeliveryValidationError::BoundaryAtEnd {
+                    delivery: delivery.clone(),
+                    boundary_index: index,
+                },
+            );
+        }
+        if boundary > extent {
+            return invalid_delivery(
+                bundle,
+                DeliveryValidationError::BoundaryOutOfRange {
+                    delivery: delivery.clone(),
+                    boundary_index: index,
+                },
+            );
+        }
+        if index > 0 {
+            let previous = boundaries[index - 1];
+            if boundary == previous {
+                return invalid_delivery(
+                    bundle,
+                    DeliveryValidationError::DuplicateBoundary {
+                        delivery: delivery.clone(),
+                        boundary_index: index,
+                    },
+                );
+            }
+            if boundary < previous {
+                return invalid_delivery(
+                    bundle,
+                    DeliveryValidationError::UnsortedBoundary {
+                        delivery: delivery.clone(),
+                        boundary_index: index,
+                    },
+                );
+            }
+        }
     }
     Ok(boundaries)
 }
@@ -1631,6 +2100,16 @@ fn invalid_combination<T>(bundle: &FixtureBundle, message: &str) -> Result<T, Fi
     ))
 }
 
+fn invalid_delivery<T>(
+    bundle: &FixtureBundle,
+    error: DeliveryValidationError,
+) -> Result<T, FixtureLoadError> {
+    Err(bundle_error(
+        bundle,
+        FixtureLoadErrorKind::InvalidDelivery(error),
+    ))
+}
+
 fn bundle_error(bundle: &FixtureBundle, kind: FixtureLoadErrorKind) -> FixtureLoadError {
     FixtureLoadError {
         path: bundle.repository_relative_path().to_string(),
diff --git a/crates/html_test_support/src/parser_snapshot/final_invariants.rs b/crates/html_test_support/src/parser_snapshot/final_invariants.rs
new file mode 100644
index 00000000..6c63832f
--- /dev/null
+++ b/crates/html_test_support/src/parser_snapshot/final_invariants.rs
@@ -0,0 +1,155 @@
+use super::SnapshotData;
+use super::lexical::{SnapshotReadError, SnapshotRecord, fixed_fields, strict_record_lines};
+use html::conformance::{
+    FinalInvariantField, InvariantNotApplicableReason, InvariantOutcome, ObservationState,
+    ParserFinalizationReport,
+};
+
+const HEADER: &str = "# format: html5-final-invariants-v1";
+
+define_snapshot_types!(
+    ParsedFinalInvariantsSnapshot,
+    CanonicalFinalInvariantsSnapshot
+);
+
+pub(super) fn write(
+    state: &ObservationState<ParserFinalizationReport>,
+) -> Result<CanonicalFinalInvariantsSnapshot, ()> {
+    let ObservationState::Captured(report) = state else {
+        return Err(());
+    };
+    let mut bytes = String::from(HEADER);
+    bytes.push('\n');
+    let mut records = Vec::with_capacity(16);
+    for (index, (field, outcome)) in report.fields().enumerate() {
+        let ordinal = index.checked_add(1).ok_or(())?;
+        let line = format!(
+            "INVARIANT ordinal={ordinal} field={} outcome={}",
+            field_name(field),
+            outcome_name(outcome)
+        );
+        bytes.push_str(&line);
+        bytes.push('\n');
+        records.push(SnapshotRecord {
+            location: field_name(field).to_string(),
+            line,
+        });
+    }
+    Ok(CanonicalFinalInvariantsSnapshot::new(SnapshotData::new(
+        bytes, records,
+    )))
+}
+
+pub(super) fn read(bytes: &[u8]) -> Result<ParsedFinalInvariantsSnapshot, SnapshotReadError> {
+    let lines = strict_record_lines(bytes, HEADER, false)?;
+    if lines.len() != 16 {
+        return Err(SnapshotReadError::TrailingContent {
+            line: lines.get(16).map_or(lines.len() + 2, |line| line.0),
+        });
+    }
+    let fields = canonical_fields();
+    let mut records = Vec::with_capacity(16);
+    for (index, (line_number, line)) in lines.iter().copied().enumerate() {
+        let Some(values) = fixed_fields(line, "INVARIANT", &["ordinal", "field", "outcome"]) else {
+            return malformed(line_number);
+        };
+        let expected_ordinal = index
+            .checked_add(1)
+            .ok_or(SnapshotReadError::MalformedRecord {
+                line: line_number,
+                reason: "final-invariant ordinal overflow",
+            })?;
+        if values[0] != expected_ordinal.to_string()
+            || values[1] != field_name(fields[index])
+            || !valid_outcome(values[2])
+        {
+            return malformed(line_number);
+        }
+        records.push(SnapshotRecord {
+            location: field_name(fields[index]).to_string(),
+            line: line.to_string(),
+        });
+    }
+    Ok(ParsedFinalInvariantsSnapshot::new(SnapshotData::new(
+        std::str::from_utf8(bytes)
+            .map_err(|_| SnapshotReadError::InvalidUtf8)?
+            .to_string(),
+        records,
+    )))
+}
+
+fn canonical_fields() -> [FinalInvariantField; 16] {
+    [
+        FinalInvariantField::DecoderCarryEmpty,
+        FinalInvariantField::PreprocessingFlushed,
+        FinalInvariantField::EofEmittedOnce,
+        FinalInvariantField::PendingConstructsFlushed,
+        FinalInvariantField::OutputAccountedFor,
+        FinalInvariantField::PendingTableTextEmpty,
+        FinalInvariantField::InsertionModeValid,
+        FinalInvariantField::OpenElementsConsistent,
+        FinalInvariantField::ActiveFormattingConsistent,
+        FinalInvariantField::TemplateModesConsistent,
+        FinalInvariantField::FormPointerValid,
+        FinalInvariantField::ParentChildLinksValid,
+        FinalInvariantField::NamespacesValid,
+        FinalInvariantField::TemplateAssociationsValid,
+        FinalInvariantField::AllPatchesMaterialized,
+        FinalInvariantField::LiveTreeMatchesMaterializedDom,
+    ]
+}
+
+pub(crate) const fn field_name(field: FinalInvariantField) -> &'static str {
+    match field {
+        FinalInvariantField::DecoderCarryEmpty => "decoder-carry-empty",
+        FinalInvariantField::PreprocessingFlushed => "preprocessing-flushed",
+        FinalInvariantField::EofEmittedOnce => "eof-emitted-once",
+        FinalInvariantField::PendingConstructsFlushed => "pending-constructs-flushed",
+        FinalInvariantField::OutputAccountedFor => "output-accounted-for",
+        FinalInvariantField::PendingTableTextEmpty => "pending-table-text-empty",
+        FinalInvariantField::InsertionModeValid => "insertion-mode-valid",
+        FinalInvariantField::OpenElementsConsistent => "open-elements-consistent",
+        FinalInvariantField::ActiveFormattingConsistent => "active-formatting-consistent",
+        FinalInvariantField::TemplateModesConsistent => "template-modes-consistent",
+        FinalInvariantField::FormPointerValid => "form-pointer-valid",
+        FinalInvariantField::ParentChildLinksValid => "parent-child-links-valid",
+        FinalInvariantField::NamespacesValid => "namespaces-valid",
+        FinalInvariantField::TemplateAssociationsValid => "template-associations-valid",
+        FinalInvariantField::AllPatchesMaterialized => "all-patches-materialized",
+        FinalInvariantField::LiveTreeMatchesMaterializedDom => "live-tree-matches-materialized-dom",
+    }
+}
+
+fn outcome_name(outcome: &InvariantOutcome) -> &'static str {
+    match outcome {
+        InvariantOutcome::Satisfied => "satisfied",
+        InvariantOutcome::Failed => "failed",
+        InvariantOutcome::NotApplicable(InvariantNotApplicableReason::StandaloneTokenizerRun) => {
+            "not-applicable:standalone-tokenizer-run"
+        }
+        InvariantOutcome::NotApplicable(InvariantNotApplicableReason::DocumentParserRun) => {
+            "not-applicable:document-parser-run"
+        }
+        InvariantOutcome::NotApplicable(InvariantNotApplicableReason::FragmentParserRun) => {
+            "not-applicable:fragment-parser-run"
+        }
+    }
+}
+
+fn valid_outcome(value: &str) -> bool {
+    matches!(
+        value,
+        "satisfied"
+            | "failed"
+            | "not-applicable:standalone-tokenizer-run"
+            | "not-applicable:document-parser-run"
+            | "not-applicable:fragment-parser-run"
+    )
+}
+
+fn malformed<T>(line: usize) -> Result<T, SnapshotReadError> {
+    Err(SnapshotReadError::MalformedRecord {
+        line,
+        reason: "invalid final-invariant record",
+    })
+}
diff --git a/crates/html_test_support/src/parser_snapshot/mod.rs b/crates/html_test_support/src/parser_snapshot/mod.rs
index ec1c07c9..0de3ab63 100644
--- a/crates/html_test_support/src/parser_snapshot/mod.rs
+++ b/crates/html_test_support/src/parser_snapshot/mod.rs
@@ -29,6 +29,7 @@ macro_rules! define_snapshot_types {
 }
 
 mod document_mode;
+mod final_invariants;
 mod implementation_diagnostics;
 mod lexical;
 mod parse_errors;
@@ -53,6 +54,7 @@ pub(crate) enum SnapshotFormat {
     DomPatchV3,
     TreeTransitionsV1,
     UnsupportedFeaturesV1,
+    FinalInvariantsV1,
 }
 
 impl SnapshotFormat {
@@ -66,6 +68,7 @@ impl SnapshotFormat {
             Self::DomPatchV3 => "html5-dompatch-v3",
             Self::TreeTransitionsV1 => "html5-tree-transitions-v1",
             Self::UnsupportedFeaturesV1 => "html5-unsupported-features-v1",
+            Self::FinalInvariantsV1 => "html5-final-invariants-v1",
         }
     }
 }
@@ -137,6 +140,7 @@ pub(crate) enum ParsedSnapshot {
     Patches(patches::ParsedPatchesSnapshot),
     Transitions(transitions::ParsedTransitionsSnapshot),
     UnsupportedFeatures(unsupported_features::ParsedUnsupportedFeaturesSnapshot),
+    FinalInvariants(final_invariants::ParsedFinalInvariantsSnapshot),
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -151,6 +155,7 @@ pub(crate) enum CanonicalSnapshot {
     Patches(patches::CanonicalPatchesSnapshot),
     Transitions(transitions::CanonicalTransitionsSnapshot),
     UnsupportedFeatures(unsupported_features::CanonicalUnsupportedFeaturesSnapshot),
+    FinalInvariants(final_invariants::CanonicalFinalInvariantsSnapshot),
 }
 
 macro_rules! snapshot_accessors {
@@ -168,6 +173,7 @@ macro_rules! snapshot_accessors {
                     Self::Patches(_) => ExpectationSurface::Patches,
                     Self::Transitions(_) => ExpectationSurface::Transitions,
                     Self::UnsupportedFeatures(_) => ExpectationSurface::UnsupportedFeatures,
+                    Self::FinalInvariants(_) => ExpectationSurface::FinalInvariants,
                 }
             }
 
@@ -183,6 +189,7 @@ macro_rules! snapshot_accessors {
                     Self::Patches(_) => SnapshotFormat::DomPatchV3,
                     Self::Transitions(_) => SnapshotFormat::TreeTransitionsV1,
                     Self::UnsupportedFeatures(_) => SnapshotFormat::UnsupportedFeaturesV1,
+                    Self::FinalInvariants(_) => SnapshotFormat::FinalInvariantsV1,
                 }
             }
 
@@ -196,6 +203,7 @@ macro_rules! snapshot_accessors {
                     Self::Patches(value) => value.data(),
                     Self::Transitions(value) => value.data(),
                     Self::UnsupportedFeatures(value) => value.data(),
+                    Self::FinalInvariants(value) => value.data(),
                 }
             }
         }
@@ -228,7 +236,9 @@ pub(crate) fn read_snapshot(
         ExpectationSurface::UnsupportedFeatures => {
             unsupported_features::read(bytes).map(ParsedSnapshot::UnsupportedFeatures)
         }
-        ExpectationSurface::FinalInvariants => Err(SnapshotReadError::InvalidHeader),
+        ExpectationSurface::FinalInvariants => {
+            final_invariants::read(bytes).map(ParsedSnapshot::FinalInvariants)
+        }
     }
 }
 
@@ -261,7 +271,8 @@ pub(crate) fn serialize_snapshot(
             unsupported_features::write(&result.unsupported_features)
                 .map(CanonicalSnapshot::UnsupportedFeatures)
         }
-        ExpectationSurface::FinalInvariants => Err(()),
+        ExpectationSurface::FinalInvariants => final_invariants::write(&result.final_invariants)
+            .map(CanonicalSnapshot::FinalInvariants),
     }
 }
 
diff --git a/crates/html_test_support/src/parser_snapshot/tests.rs b/crates/html_test_support/src/parser_snapshot/tests.rs
index 643105c2..123388aa 100644
--- a/crates/html_test_support/src/parser_snapshot/tests.rs
+++ b/crates/html_test_support/src/parser_snapshot/tests.rs
@@ -55,6 +55,62 @@ fn empty_collection_and_required_singleton_rules_are_surface_specific() {
     assert!(token_v2::read(b"# format: html5-token-v2\n").is_err());
 }
 
+#[test]
+fn final_invariants_v1_is_strict_complete_and_canonically_ordered() {
+    use html::conformance::{
+        DomFinalizationChecks, InputFinalizationChecks, InvariantOutcome, ParserFinalizationReport,
+        PatchFinalizationChecks, TokenizerFinalizationChecks, TreeBuilderFinalizationChecks,
+    };
+    let satisfied = InvariantOutcome::Satisfied;
+    let report = ParserFinalizationReport {
+        input: InputFinalizationChecks {
+            decoder_carry_empty: satisfied.clone(),
+            preprocessing_flushed: satisfied.clone(),
+        },
+        tokenizer: TokenizerFinalizationChecks {
+            eof_emitted_once: satisfied.clone(),
+            pending_constructs_flushed: satisfied.clone(),
+            output_accounted_for: satisfied.clone(),
+        },
+        tree_builder: TreeBuilderFinalizationChecks {
+            pending_table_text_empty: satisfied.clone(),
+            insertion_mode_valid: satisfied.clone(),
+            open_elements_consistent: satisfied.clone(),
+            active_formatting_consistent: satisfied.clone(),
+            template_modes_consistent: satisfied.clone(),
+            form_pointer_valid: satisfied.clone(),
+        },
+        dom: DomFinalizationChecks {
+            parent_child_links_valid: satisfied.clone(),
+            namespaces_valid: satisfied.clone(),
+            template_associations_valid: satisfied.clone(),
+        },
+        patches: PatchFinalizationChecks {
+            all_patches_materialized: satisfied.clone(),
+            live_tree_matches_materialized_dom: satisfied,
+        },
+    };
+    let written = final_invariants::write(&ObservationState::Captured(report))
+        .expect("captured final report");
+    let text = written.data().bytes();
+    assert_eq!(text.lines().count(), 17);
+    assert!(text.lines().nth(1).is_some_and(|line| {
+        line == "INVARIANT ordinal=1 field=decoder-carry-empty outcome=satisfied"
+    }));
+    assert!(text.lines().nth(16).is_some_and(|line| {
+        line == "INVARIANT ordinal=16 field=live-tree-matches-materialized-dom outcome=satisfied"
+    }));
+    final_invariants::read(text.as_bytes()).expect("writer output parses");
+
+    let reordered = text.replace(
+        "ordinal=1 field=decoder-carry-empty",
+        "ordinal=1 field=preprocessing-flushed",
+    );
+    assert!(final_invariants::read(reordered.as_bytes()).is_err());
+    let truncated = text.lines().take(16).collect::<Vec<_>>().join("\n") + "\n";
+    assert!(final_invariants::read(truncated.as_bytes()).is_err());
+}
+
 #[test]
 fn readers_validate_framing_without_reimplementing_parser_semantics() {
     let implausible_tree = b"# format: html5-dom-v3\nNODE path=/root[0] kind=element namespace=svg local-name=\"html\"\n";
@@ -127,6 +183,7 @@ fn every_requested_canonical_writer_is_repeatable_and_strictly_readable() {
         document_mode: ScalarObservationRequest::Capture,
         tree: capture,
         patches: capture,
+        final_invariants: html::conformance::FinalInvariantRequest::NotRequested,
     })
     .expect("production canonical observation");
 
diff --git a/crates/html_test_support/src/wpt_tokenizer.rs b/crates/html_test_support/src/wpt_tokenizer.rs
index f9a5cdf8..805d93c9 100644
--- a/crates/html_test_support/src/wpt_tokenizer.rs
+++ b/crates/html_test_support/src/wpt_tokenizer.rs
@@ -203,6 +203,7 @@ pub fn run_tokenizer_whole_observed(
         document_mode: html::conformance::ScalarObservationRequest::NotRequested,
         tree: ObservationRequest::NotRequested,
         patches: ObservationRequest::NotRequested,
+        final_invariants: html::conformance::FinalInvariantRequest::NotRequested,
     })
     .map_err(|error| format!("canonical tokenizer observation failed for '{case_id}': {error}"))?;
     let observed_tokens = match result.tokens {
diff --git a/docs/engine-feature-gap-tracker.md b/docs/engine-feature-gap-tracker.md
index f9ed8fbe..afcbcfd1 100644
--- a/docs/engine-feature-gap-tracker.md
+++ b/docs/engine-feature-gap-tracker.md
@@ -472,9 +472,9 @@ Current supported subset:
   and scalar failure identities remain unchanged. The focused native corpus
   covers absent versus literal `null` doctype names, template contents, foreign
   namespaces, empty requested diagnostics, canonical patch order,
-  delivery-specific transitions, and unsupported-feature identity. AE13c final
-  invariants and parity, broad corpus migration, external adapters, blessing,
-  fragments, scripting, rendering, and public APIs remain deferred. See
+  delivery-specific transitions, and unsupported-feature identity. Broad corpus
+  migration, external adapters, blessing, fragments, scripting, rendering, and
+  public APIs remain deferred; AE13c parity and final audits are tracked below. See
   `docs/html5/parser-fixture-format-v2.md` and
   `docs/html5/ae13b5-parser-snapshot-formats.md`. Architecture-review hardening
   now uses iterative stack-safe tree writing, strict preorder/template framing,
@@ -489,6 +489,38 @@ Current supported subset:
   validation-time full read and execution-time token-sidecar reread.
   Implementation remains pending formal review and AE13b5 is not yet recorded
   as closed.
+- AE13c whole/chunk parser parity and mandatory final audits: supported
+  fixture-v2 executions now use one authoritative whole-input baseline and a
+  bounded deterministic schedule of declared and representative scalar/byte
+  strategies. UTF-8 scalar coordinates remain scalar ordinals; byte delivery
+  preserves exact stored bytes and may split code points. Semantic aliases
+  execute once with ordered origins and fixture-local ordinals; fixed strategies
+  stream incrementally without boundary vectors. Every applicable canonical
+  surface—tokens, parse errors, implementation diagnostics, document mode,
+  tree, patches, transitions, unsupported features, and final invariants—is
+  compared in fixed order, one candidate at a time. Fixture-v1 remains on its
+  unchanged compatibility path. Production-owned read-only audits cover the
+  decoder/preprocessor, tokenizer EOF lifecycle, insertion modes, SOE, AFE,
+  template modes/diagnostic markers, form pointer, namespaces, template
+  associations, complete patch drain/application, and both live/arena
+  structural and arena/materialized semantic equivalence. Final-audit
+  allocations are fallible typed observation-resource failures at each real
+  reservation, with deterministic occurrence injection; the semantic
+  traversal is iterative with one frame per active ancestor. Typed canonical
+  parity runs before candidate serialization, retains one baseline without a
+  deep clone, and computes boundary digests lazily through streaming SHA-256.
+  AFE/live attributes use exact ordered typed equality distinct from Noah's Ark
+  duplicate equality; marker ownership is marker-kind-specific, residual closed
+  template markers are handled separately, and terminal tokenizer/tree-builder
+  text-mode coordination is audited by the session. Explicit scalar offset
+  resolution reports the fixture-harness resource site
+  `scalar-boundary-execution-offsets`. The private
+  trusted patch arena remains deliberately non-transactional and is discarded
+  immediately on failure. Focused native fixtures cover decoder/preprocessing,
+  tags/attributes, references, EOF, text modes, tables, formatting, forms,
+  templates, foreign integration, and processing instructions. Fragment and
+  scripting execution, external adapters, broad corpus migration, snapshot
+  blessing, rendering, and public parser/DOM APIs remain outside AE13c.
 - AE1 HTML parser ownership architecture: HTML/parser owns tokenizer input
   preprocessing, tokenizer states, typed tokens, parse errors,
   tree-construction state, insertion modes, stack of open elements, active
diff --git a/docs/html5/ae13-parser-conformance-regression-harness.md b/docs/html5/ae13-parser-conformance-regression-harness.md
index 0fed3709..6fccb41a 100644
--- a/docs/html5/ae13-parser-conformance-regression-harness.md
+++ b/docs/html5/ae13-parser-conformance-regression-harness.md
@@ -12,7 +12,8 @@ same production recorder to tree construction and captures the scalar
 parser-owned central tree-dispatch transitions and exact observations for six
 encountered, deliberately unimplemented tree-construction behaviors. It does
 not claim completion of overarching AE13 or implementation of those six
-algorithms.
+algorithms. AE13c adds bounded semantic whole/chunk parity and mandatory
+production-owned terminal audits for every supported fixture-v2 execution.
 
 ## Ownership
 
@@ -42,6 +43,22 @@ expectation, source, and disposition state behind an opaque
 external adapter must enter through the same declaration and validation path.
 It must not construct validated values directly.
 
+AE13c parity compares borrowed typed canonical observations before any snapshot
+serialization. A serializer is invoked only for the selected parity surface
+after typed inequality, or for an expectation surface that actually applies to
+that delivery. The runner retains one owned baseline, borrows it while
+comparing candidates, and moves it into the completed report only after the
+candidate schedule succeeds; it does not deep-clone canonical baselines.
+
+Final-audit allocation injection is attached immediately before each real
+fallible reservation. A reservation site occurrence is counted only when that
+collection, projection, or traversal stack actually attempts to reserve. The
+injected and natural failures use the same observation-resource identity and
+never produce a partial report. Boundary diagnostics use the streaming,
+platform-independent `borrowser-html-delivery-boundaries-v1` SHA-256 encoding;
+the digest is lazy diagnostic metadata and never participates in strategy
+equality or scheduling.
+
 There is one canonical parser-fixture runner. Existing golden, WPT-style, and
 internal corpus infrastructure will be adapted to it in later slices rather
 than being joined by another independent harness.
@@ -762,7 +779,8 @@ Final-invariant fields carry only `Satisfied`, typed `NotApplicable`, or
 `Failed`. A failed field cannot select its own error code. Exhaustive
 field-by-field collection assigns the stable `InvariantFailureCode`, so adding a
 mandatory field requires updating collection and preserves deterministic field
-order. Production execution of these checks remains AE13c work.
+order. AE13c supplies the production-owned execution and aggregation described
+below.
 
 ### Normalized parser positions
 
@@ -946,14 +964,15 @@ See `parser-fixture-format-v2.md` and
 `ae13b5-parser-snapshot-formats.md` for normative grammar, precedence, and
 diagnostics.
 
-## Later slices
+## Slice status
 
 - AE13b1: parser-owned token and tokenizer-diagnostic observation foundation.
 - AE13b2: tree-construction diagnostics and production document-mode capture.
 - AE13b3 and AE13b4: canonical tree/patch/transition/unsupported observations
   are complete. AE13b5 strict serializers and fixture diagnostics are
   implemented; issue closure remains pending formal architecture review.
-- AE13c: semantic whole/chunked parity and production final-invariant execution.
+- AE13c: semantic whole/chunked parity and production final-invariant execution
+  are implemented in the current slice.
 - AE13d: existing corpus consolidation and migration.
 - AE13e: external html5lib/WPT adapter, intentional snapshot updates, final
   documentation, and CI coverage expansion.
@@ -961,3 +980,114 @@ diagnostics.
 Fragment execution, scripting-dependent parsing, original source-byte
 provenance, Layout, Paint, JavaScript execution, navigation, and resource
 loading are not implemented by AE13b5.
+
+## AE13c whole/chunk parity and final audits
+
+AE13c keeps one parser observation boundary. `html` owns compact delivery,
+decoder/tokenizer/tree execution, terminal audits, patch draining and trusted
+application, materialization, and structural/semantic DOM comparison.
+`html-test-support` owns fixture-v2 validation policy, strategy planning,
+scheduling, canonical serialization, comparison, disposition, and diagnostics.
+Test support never reads tokenizer/tree-builder internals and never replays
+patches or reconstructs HTML scope, namespace, template, or recovery rules.
+
+Fixture-v1 and fixture-v2 select a closed validation policy once. V1 retains
+its legacy whole-tokenizer path: it generates no representative strategies,
+does not request final invariants, and performs no AE13c parity. V2 requires an
+authoritative domain baseline and requests final invariants for every supported
+execution, whether or not a `final_invariants` sidecar is declared.
+
+### Strategy semantics and order
+
+UTF-8 text uses whole Unicode input as its baseline. Unicode deliveries use
+Unicode-scalar ordinals; byte deliveries use exact UTF-8 byte offsets and may
+split a code point. Whole bytes are an additional decoder-entry candidate.
+Raw-byte input uses untouched whole bytes as its baseline and never passes
+through a test-support string decoder or sanitizer.
+
+`Whole`, `Fixed`, and `Explicit` are compact storage/execution shapes, not
+semantic identities. Equality compares transport, coordinate space, exact
+input extent, and the exact yielded interior semantic boundaries. Fixed plans
+compare arithmetically and never expand to an offset vector. Whole,
+fixed-with-no-boundary, and explicit-empty plans alias. Scalar ordinals resolve
+to execution-only UTF-8 byte offsets by one checked forward traversal; derived
+offsets do not participate in identity or diagnostics.
+
+Execution order is fixed:
+
+1. the authoritative baseline, ordinal 1;
+2. unique declared non-baseline strategies by first semantic appearance in
+   declaration order; and
+3. representative-only strategies in generator order: whole bytes where
+   applicable, then fixed-one, fixed-seven, and edge-triplet scalar/byte forms.
+
+Later aliases add ordered origins without moving a strategy. Baseline,
+declared names, and representative names are roles, not mutually exclusive
+identities. Empty and one-unit inputs produce no zero-length push; collapsed
+representatives become aliases. Completed reports retain one result per
+required semantic strategy and expose ordered declared aliases and the checked
+contiguous fixture-local ordinal.
+
+Fixture-v2 privately limits declared deliveries to 32, boundaries per declared
+delivery to 4,096, and unique planned strategies to 24. These are validation
+policy, not parser or input-size limits. Excess is rejected before execution;
+no required strategy is truncated. Runtime is
+`O(input length * bounded unique strategy count)`. Fixed delivery has `O(1)`
+strategy memory independent of chunk count. Explicit and edge strategies keep
+only bounded offsets. Peak retention is one typed baseline, one current
+candidate, bounded failure summaries, applicable expectation snapshots, and
+only the selected baseline/candidate snapshots for a parity diagnostic;
+successful parity-only candidates are dropped.
+
+### Parity surfaces and precedence
+
+Every applicable surface is compared in this order: tokens, parse errors,
+implementation diagnostics, document mode, tree, patches, transitions,
+unsupported features, and final invariants. Canonical values and codecs own
+comparison. Raw parser IDs, allocation identity, patch transport batches,
+source chunk shapes, hash iteration, and Rust `Debug` are transport or
+implementation metadata and are not semantic parity surfaces.
+
+The baseline executes first. A parser/fatal/resource/delivery failure,
+incomplete observation, or failed final invariant stops immediately, before
+sidecar content parsing or candidate execution. After a valid baseline, the
+first strategy-ordered parser execution failure returns immediately. The
+runner retains at most the first incomplete observation, first final-audit
+failure, first parity mismatch, and first expectation mismatch, then selects
+in that order. Incomplete or final-audit-failing candidates are never compared.
+No failure exposes a partial completed report.
+
+A parity diagnostic contains fixture ID, repository-relative path, strategy
+ordinal, transport, semantic coordinates, exact extent and boundaries, ordered
+origins, canonical surface, and the first meaningful record difference.
+Equality never depends on a digest. A production `InvalidDelivery` after v2
+validation maps by typed identity to
+`validated-boundary-rejected-by-executor`; messages are not classified.
+
+### Finalization lifecycle
+
+`FinalInvariantRequest` is independent of bounded collection requests.
+Standalone tokenizer runs report five input/tokenizer fields and mark eleven
+document/tree/DOM/patch fields
+`NotApplicable(StandaloneTokenizerRun)`. Document runs aggregate a
+production-owned pre-materialization session/tree audit with a post-drain,
+post-materialization parser-session audit. Parser fatal errors, audit allocation
+failure, checked overflow, patch failure, and materialization failure are
+execution failures with no partial report.
+
+The patch witness exists only for final-audit capture. It records builder
+pending patches after finish, checked counts for each exact drained batch,
+successful trusted application of that same complete batch, terminal `None`,
+builder/emitter pending counts after terminal drain, and materialization after
+that drain. Trusted application is deliberately in-place and
+non-transactional: on failure the private partially updated arena is discarded
+immediately and is never inspected, materialized, audited, or exposed.
+
+`live_tree_matches_materialized_dom` is a compound semantic end-state check. A
+fallible `LiveTree` structural projection must equal the fully applied patch
+arena projection, and a complete semantic patch-arena traversal must equal the
+materialized DOM. Semantic comparison covers document legacy doctype data,
+doctype fields, expanded element names, ordered qualified attributes, text,
+comments, processing instructions, ordinary children, and template contents.
+It is iterative with one frame per active ancestor, so temporary storage is
+`O(tree depth)`, not `O(sibling count)`.
diff --git a/docs/html5/ae13b5-parser-snapshot-formats.md b/docs/html5/ae13b5-parser-snapshot-formats.md
index 844c288d..80e7c567 100644
--- a/docs/html5/ae13b5-parser-snapshot-formats.md
+++ b/docs/html5/ae13b5-parser-snapshot-formats.md
@@ -279,3 +279,48 @@ codec cannot construct a patch snapshot. Accessors derive surface and format
 exhaustively from the variant. Snapshot storage retains one UTF-8 backing
 string plus semantic locations and byte ranges for records; it does not retain
 another owned copy of every record line.
+
+## AE13c final invariants: `html5-final-invariants-v1`
+
+The header is exact:
+
+```text
+# format: html5-final-invariants-v1
+```
+
+Exactly 16 records follow. They use contiguous one-based ordinals and this
+fixed field order:
+
+```text
+INVARIANT ordinal=1 field=decoder-carry-empty outcome=<outcome>
+INVARIANT ordinal=2 field=preprocessing-flushed outcome=<outcome>
+INVARIANT ordinal=3 field=eof-emitted-once outcome=<outcome>
+INVARIANT ordinal=4 field=pending-constructs-flushed outcome=<outcome>
+INVARIANT ordinal=5 field=output-accounted-for outcome=<outcome>
+INVARIANT ordinal=6 field=pending-table-text-empty outcome=<outcome>
+INVARIANT ordinal=7 field=insertion-mode-valid outcome=<outcome>
+INVARIANT ordinal=8 field=open-elements-consistent outcome=<outcome>
+INVARIANT ordinal=9 field=active-formatting-consistent outcome=<outcome>
+INVARIANT ordinal=10 field=template-modes-consistent outcome=<outcome>
+INVARIANT ordinal=11 field=form-pointer-valid outcome=<outcome>
+INVARIANT ordinal=12 field=parent-child-links-valid outcome=<outcome>
+INVARIANT ordinal=13 field=namespaces-valid outcome=<outcome>
+INVARIANT ordinal=14 field=template-associations-valid outcome=<outcome>
+INVARIANT ordinal=15 field=all-patches-materialized outcome=<outcome>
+INVARIANT ordinal=16 field=live-tree-matches-materialized-dom outcome=<outcome>
+```
+
+Closed outcome spellings are `satisfied`, `failed`,
+`not-applicable:standalone-tokenizer-run`, `not-applicable:document-parser-run`, and
+`not-applicable:fragment-parser-run`. The reader rejects a missing, extra,
+reordered, duplicated, unknown, or noncanonical record. It validates report
+framing and stable spellings; it does not inspect parser state or infer whether
+an outcome should be satisfied.
+
+AE13c compares typed final-invariant values before writing this representation;
+the codec is an external snapshot format, not a parity-equality mechanism.
+
+The writer consumes the fixed `ParserFinalizationReport::fields()` iterator.
+Failure inspection uses the report's allocation-free ordered iterator and does
+not allocate a temporary vector of failed codes for disposition or snapshot
+selection. Rust `Debug` is never serialized.
diff --git a/docs/html5/dompatch-contract.md b/docs/html5/dompatch-contract.md
index 5ac43a43..0165526f 100644
--- a/docs/html5/dompatch-contract.md
+++ b/docs/html5/dompatch-contract.md
@@ -164,6 +164,21 @@ Strict runtime rule (Core v0):
 - A batch starting with `Clear` must produce a rooted document state by the end
   of the batch (`CreateDocument` required in practice).
 
+The private `PatchValidationArena::apply_batch_trusted` engine path is a narrow
+exception to the rollback mechanism, not to batch ordering or validation. It
+applies in place because the owning parser session treats any failure as
+terminal. A failed trusted application may leave its private arena partially
+updated; the caller must return immediately and must never inspect,
+materialize, audit, expose, or reuse that arena. Public `apply_batch` and
+runtime-facing appliers retain the staged transactional rule above.
+
+AE13c conformance finalization checked-adds the exact drained batch operation
+count, passes that same batch once to `apply_batch_trusted`, and increments the
+successfully applied count only after the complete batch succeeds. Its final
+witness proves complete successful application through equal drained/applied
+counts, terminal empty drain/buffers, and materialization after terminal drain;
+it does not claim that trusted application is transactional.
+
 ## Version Rules
 
 `DomPatchBatch` carries `{ from, to, patches }` and requires:
diff --git a/docs/html5/invariants.md b/docs/html5/invariants.md
index 33e44d93..a707aeed 100644
--- a/docs/html5/invariants.md
+++ b/docs/html5/invariants.md
@@ -318,6 +318,78 @@ Table cell and AFE interaction:
 - Layout inability cannot alter DOM/style truth; unsupported SVG/MathML roots
   suppress complete box subtrees at the centralized Layout decision boundary.
 
+## AE13c final-audit ownership matrix
+
+All final-audit entry points are read-only, deterministic, checked-arithmetic
+based, non-recursive where traversal is required, and safe to continue after an
+independent field has failed. They do not use assertion-based `LiveTree`
+mutation helpers. Allocation failure aborts observation with
+`ParserObservationExecutionError::ResourceExhaustion`; it is not reclassified
+as an ordinary parser fatal error and no partial report is returned.
+
+`Satisfied` means the stated production-owned predicate holds. `Failed` means
+the predicate is representably false while execution otherwise completed.
+`NotApplicable` is used only as stated below. Tests exercise production parsing
+or narrow production-owned corruption/failure hooks and compare typed reports;
+test support does not reproduce the algorithm.
+
+| Field | Owner and production state | Production helper and phase | Outcomes and test boundary |
+|---|---|---|---|
+| `decoder_carry_empty` | session input; `ByteStreamDecoder` pending bytes | `Html5ParseSession::final_audit_for_conformance`, pre-materialization | satisfied iff no decoder carry; tokenizer and document runs apply; direct whole/fixed/explicit byte tests cover invalid/incomplete UTF-8 EOF |
+| `preprocessing_flushed` | session input; `Input` preprocessing carry | same session audit, pre | satisfied iff no pending preprocessing state; CRLF, lone/trailing CR tests; never N/A for supported runs |
+| `eof_emitted_once` | tokenizer; authoritative `end_of_stream`, `eof_emitted`, and guarded EOF transition | `Html5Tokenizer::final_audit_for_conformance`, pre | satisfied iff terminal lifecycle agrees with configured EOF emission; no second counter; never N/A |
+| `pending_constructs_flushed` | tokenizer pending text/tag/comment/doctype/PI construction fields | tokenizer final audit, pre | satisfied iff every supported pending construct is terminally cleared; EOF recovery/text-mode/PI fixtures |
+| `output_accounted_for` | tokenizer output queue | tokenizer final audit plus session drain ownership, pre | satisfied iff tokenizer output queue is empty after authoritative draining; token/EOF tests |
+| `pending_table_text_empty` | tree builder pending table-text state | `Html5TreeBuilder::final_audit_for_conformance`, pre | satisfied iff no table-text buffer remains; standalone tokenizer is N/A; table and template-EOF fixtures |
+| `insertion_mode_valid` | session tokenizer active text mode plus tree-builder active/original text-mode state, insertion mode, and pending tokenizer control | session/tree-builder final audit, pre | satisfied iff tokenizer and tree-builder active text modes are absent, original insertion mode and pending tokenizer control are absent, and terminal insertion mode is neither Text nor InTableText; standalone N/A |
+| `open_elements_consistent` | SOE entries, expanded-name cache, atoms, and `LiveTree` expanded names | fallible SOE key set and expanded-name count map, pre | satisfied iff keys are unique/valid and cached namespace/name counts and live expanded names agree; standalone N/A; tree-builder production tests |
+| `active_formatting_consistent` | AFE element references, exact typed AFE attributes, and live expanded names/attributes | fallible AFE owner key set, pre | satisfied iff every element key is unique/live, the live HTML name agrees, and ordered typed attribute slices match in length, namespace, prefix, local name, and value; marker ownership is checked by marker kind and coordinated by the template field; standalone N/A |
+| `template_modes_consistent` | open template SOE entries, template-mode owner stack, typed AFE template markers, live host/content associations | fallible template owner/index structures, pre | satisfied iff open modes/owners/associations align and each open template has its marker; retained EOF diagnostic markers are valid when their owner still names a live template association; standalone N/A |
+| `form_pointer_valid` | tree-builder form pointer and live expanded name | tree-builder final audit, pre | satisfied when absent or naming a live HTML `form`; it is not required to be empty; standalone N/A |
+| `parent_child_links_valid` | `LiveTree` node/parent/ordinary-child graph | fallible read-only live-model traversal, pre | satisfied iff every reachable ordinary/association node has coherent typed endpoints and all live nodes are reached; standalone N/A |
+| `namespaces_valid` | `LiveTree` typed expanded names and typed qualified attributes | same live-model audit, pre | satisfied iff element/name/template-host namespace relationships hold and non-elements have no expanded name; qualified attribute namespace/prefix shapes are consumed as typed values, never reparsed; standalone N/A |
+| `template_associations_valid` | `LiveTree` host/content kind and reciprocal endpoints | same live-model audit, pre | satisfied iff every template host/content association is one-to-one, typed, reciprocal, non-parented, and host ordinary children remain empty; standalone N/A |
+| `all_patches_materialized` | parser-session `PatchMaterializationWitness`, builder patch buffer, emitter buffer, checked drained/applied operation counts, terminal drain and materialization ordering | `HtmlParser::into_output_with_final_audit`, post-drain/post-materialization | satisfied only after terminal `None`, empty terminal buffers, equal successfully applied complete-batch counts, and materialization after drain; patch/drain/apply/materialize errors abort without a report; standalone N/A |
+| `live_tree_matches_materialized_dom` | session live structural projection, fully applied patch-arena structural projection, complete patch-arena semantics, materialized DOM | fallible structural projections plus `semantic_equals_materialized_dom_for_final_audit`, post | satisfied only when live structure equals arena structure and arena semantics equal DOM semantics; covers document/doctype, names/namespaces, ordered qualified attributes, text/comment/PI, children, and template contents; standalone N/A |
+
+Cross-owner coordination fields intentionally require their referenced live
+node or template association to exist. A corrupted live expanded name may
+therefore fail both its intrinsic `namespaces_valid` check and an SOE/AFE
+reference check; a corrupted template host/content association may fail both
+`template_modes_consistent` and `template_associations_valid`. This overlap is
+deliberate: the former outcome records the broken tree-builder reference and
+the latter records the independently broken live-model object. No other audit
+field is derived from those failures or made false merely because an earlier
+field failed. Likewise, incomplete patch drain may fail
+`all_patches_materialized` and also leave an independently observable
+live/arena structural mismatch; the two outcomes distinguish lifecycle proof
+from end-state equivalence.
+
+The AFE final check deliberately does not use Noah's Ark duplicate equality.
+`same_attributes_for_html_parser` remains order- and prefix-insensitive for
+duplicate matching. Final AFE/live consistency uses exact ordered typed
+attribute equality, including namespace, prefix, local name, and value.
+
+SOE and AFE audits are effectively linear in their entry counts. Template
+coordination is linear in SOE plus AFE plus template-mode counts. Their hash
+indexes are used only for membership, lookup, and exact count reconstruction;
+hash iteration order never selects a failure or report order. Reservation sites
+are `FinalAuditOpenElementsIndex`, `FinalAuditActiveFormattingIndex`, and
+`FinalAuditTemplateCoordinationIndex`.
+
+Structural projections allocate fallibly at
+`FinalAuditLiveTreeStructuralProjection` and
+`FinalAuditPatchArenaStructuralProjection`; live structural traversal uses
+`FinalAuditDomStructuralTraversal`. The arena/materialized semantic comparator
+uses `FinalAuditSemanticTraversal`, one frame per active ancestor, and never
+pushes all siblings. Thus its temporary storage is `O(tree depth)`. Wide and
+deep regression tests prove the depth witness and iterative execution.
+
+Final reports always expose exactly 16 fields in the table order. Independent
+false predicates are all collected. Allocation, representational overflow,
+patch application, patch-history, adapter, drain, or materialization errors
+remain higher-priority execution failures with no partial report.
+
 ## AE13b4 Parser Observation Invariants
 
 - One tree transition is one central-driver invocation of one selected
diff --git a/docs/html5/parser-fixture-format-v2.md b/docs/html5/parser-fixture-format-v2.md
index e4567b49..43277cf7 100644
--- a/docs/html5/parser-fixture-format-v2.md
+++ b/docs/html5/parser-fixture-format-v2.md
@@ -83,9 +83,19 @@ Unused supported deliveries do not execute. Planned deliveries execute in
 validated declaration order and at most once. Each production request contains
 the union of the surfaces required from that delivery.
 
-AE13b5 supports whole Unicode-scalar delivery. Raw bytes, byte delivery,
-Unicode-scalar boundaries, fragment parsing, and scripting-enabled parsing are
-typed unsupported semantics. This is not whole/chunked parity.
+AE13c supports one authoritative whole-input baseline per exact input domain,
+compact fixed-size delivery, and validated explicit boundaries. Unicode
+boundaries are scalar ordinals; byte deliveries use byte offsets. Fixture-v2
+validation applies deterministic guardrails before planning and reports
+delivery defects through `InvalidDelivery(DeliveryValidationError)` in this
+order: declaration count; per-delivery boundary count in declaration order;
+delivery-name/declaration shape; input-domain, unit, and strategy compatibility;
+boundary presence; each boundary's start/end/range/duplicate/ordering checks
+in boundary-index order; authoritative domain-baseline existence; reference
+identifier and baseline identity; representative construction; semantic
+deduplication and the unique-strategy limit; and sealed v2 planning. The
+validated-name type is constructed only after name validation. Fixture-v1
+retains its legacy compatibility policy.
 
 ## Skipped disposition
 
@@ -129,7 +139,9 @@ For non-skipped v2 fixtures:
 8. Validate every requested `ObservationState` after every execution succeeds.
 9. Reject `Incomplete`, requested `NotRequested`, unexpected `NotApplicable`,
    and prohibited unrequested capture before serialization.
-10. Serialize all requested typed canonical surfaces.
+10. Serialize requested canonical surfaces for expectations. Whole/chunk
+    parity compares the borrowed typed canonical values first and serializes
+    only the selected unequal surface for a diagnostic difference.
 11. Compare in the order below.
 12. Return a completed report only after every delivery and expectation passes.
 
@@ -165,7 +177,14 @@ The first mismatch is returned in this exact order:
 5. canonical tree;
 6. canonical patches;
 7. transitions in transition-expectation declaration order;
-8. unsupported features.
+8. unsupported features;
+9. final invariants.
+
+Final invariants are mandatory for every supported v2 execution, independent
+of whether a final-invariant expectation sidecar is present. Their sixteen
+fields are evaluated independently in fixed order. The strict v1 codec uses
+the only accepted not-applicable spellings: `not-applicable:standalone-tokenizer-run`,
+`not-applicable:document-parser-run`, and `not-applicable:fragment-parser-run`.
 
 Transitions precede unsupported features because they describe the dispatch
 attempt leading to an unsupported-feature fallback.
@@ -282,3 +301,91 @@ snapshot, incomplete capture, or mismatch.
 Final-invariant execution, parity, fragment parsing, external adapters,
 snapshot blessing, scripting, rendering, and public parser/DOM APIs are outside
 fixture v2 AE13b5.
+
+## AE13c execution policy
+
+AE13c activates whole/chunk parity and mandatory final audits for supported v2
+fixtures. The earlier AE13b5 planned-delivery text above is historical: v2 now
+validates and schedules semantic strategies, while v1 retains the old policy.
+
+For `utf8-text`, `reference_delivery` must name a declared whole
+`unicode-scalars` delivery. Its boundary numbers are Unicode-scalar ordinals,
+not UTF-8 byte offsets. V2 may additionally declare whole or boundary `bytes`
+delivery over the exact stored UTF-8 bytes. For `raw-bytes`, the reference must
+name whole bytes and all deliveries use byte offsets. Boundaries must be
+strictly increasing interior values; start, terminal, duplicate, decreasing,
+and out-of-range values are validation errors. An empty v2 explicit-boundary
+list is valid and aliases whole delivery when it yields no interior boundary;
+fixture-v1 retains its earlier non-empty-list rule. A scalar ordinal in range
+is inherently a valid Unicode-scalar boundary and is not tested as a byte offset.
+
+Duplicate semantic declarations are aliases, not errors. Semantic equality is
+transport plus coordinate space plus exact input extent plus exact yielded
+interior coordinates. Representation (`whole`, fixed representative, or
+explicit boundaries) and any derived scalar-to-byte execution offsets do not
+affect equality. Ordered origins are baseline, declared delivery names in
+declaration order, then representative names in generator order.
+
+Private validation limits are:
+
+- 32 declared deliveries;
+- 4,096 boundaries in one declared delivery; and
+- 24 unique planned semantic strategies.
+
+Excess fails validation before execution. Values are never truncated and no
+fixture input-byte limit is introduced. Fixed representatives are compact and
+derive the next chunk incrementally; a fixed-one plan never allocates one
+boundary per input unit.
+
+The exact schedule is baseline ordinal 1, unique declared non-baselines by
+first semantic appearance, then representative-only strategies in fixed
+generator order. Aliases never move or re-execute a strategy. Strategy ordinals
+are contiguous one-based fixture-local identities used by diagnostics and
+completed reports.
+
+V2 requests all applicable canonical surfaces plus final invariants once per
+unique strategy. Final invariants are mandatory even without a sidecar. The
+baseline must successfully execute, produce complete observations, and satisfy
+all final invariants before sidecar content is parsed or candidates run. After
+that gate, parser execution failure returns immediately. The retained
+cross-candidate precedence is incomplete observation, final-invariant failure,
+parity mismatch, then expectation mismatch. Successful parity-only candidate
+results are discarded.
+
+The parity surface order is:
+
+1. tokens;
+2. parse errors;
+3. implementation diagnostics;
+4. document mode when applicable;
+5. tree when applicable;
+6. patches when applicable;
+7. transitions when applicable;
+8. unsupported features; and
+9. final invariants.
+
+Before comparison, the runner retains only one canonical baseline and one
+current candidate. Typed values are compared directly; candidate snapshots are
+serialized only for the first unequal parity surface and for expectation
+surfaces that apply to that strategy. A successful parity-only candidate is
+disposed immediately. Explicit Unicode-scalar offset resolution is a bounded,
+fallible fixture-harness allocation at
+`scalar-boundary-execution-offsets`; fixed scalar strategies never allocate an
+offset array.
+
+The boundary digest is computed only while constructing a diagnostic (or in a
+dedicated digest test). Its input is streamed into SHA-256 using the exact
+magic, transport, coordinate-space, big-endian count, and big-endian semantic
+boundaries. Fixed strategies remain compact even when their boundary count is
+large.
+
+`final-invariant` expected-failure classification matches only when the report
+has exactly one failed field and its stable `InvariantFailureCode` equals the
+declaration. Multiple failures retain canonical report order and do not match a
+singleton declaration.
+
+V2 stable post-validation runner contradictions additionally include
+`validated-boundary-rejected-by-executor` and
+`strategy-schedule-contradiction`. The former is selected directly from the
+production typed delivery-error identity. Malformed declarations remain
+fixture validation failures, never runner contradictions.
diff --git a/docs/html5/parser-parity-matrix.md b/docs/html5/parser-parity-matrix.md
index 24ee2e23..877782ff 100644
--- a/docs/html5/parser-parity-matrix.md
+++ b/docs/html5/parser-parity-matrix.md
@@ -69,6 +69,41 @@ Guarantee:
 - chunked parsing matches whole-input parsing for the supported subset
 - runtime materialization remains equivalent across delivery modes
 
+### AE13c canonical whole/chunk equivalence
+
+The fixture-v2 AE13c runner is the reusable canonical parser parity boundary.
+
+Its comparison is typed-first: whole and chunked results are compared as
+borrowed canonical values in the fixed nine-surface order, and snapshot text is
+diagnostic output only after a typed mismatch. One owned baseline is borrowed
+for all candidates, so successful candidate execution does not clone the full
+canonical observation model. Reservation-site failure injection surrounds each
+actual fallible audit allocation, including later traversal-stack growth.
+For UTF-8 text it compares whole Unicode input with declared and representative
+Unicode-scalar delivery and with applicable exact-byte decoder delivery. For
+raw-byte input it compares untouched whole bytes with byte delivery. Fixed
+strategies are incremental and generic; generation does not scan HTML syntax.
+
+The semantic comparison order is tokens, parse errors, implementation
+diagnostics, document mode, tree, patches, transitions, unsupported features,
+and final invariants. This expands the earlier DOM-only parity statement:
+same-token reprocessing, patch materialization, unsupported-feature identity,
+decoder/preprocessing terminal state, parser stacks/pointers, namespaces, and
+template associations are now part of the canonical fixture contract wherever
+the target supports them.
+
+Chunk shapes, raw parser/node allocation IDs, patch transport batch boundaries,
+and hash-map order are not parser semantics and are deliberately excluded.
+Stable canonical serializers, rather than Rust equality over internal storage
+or `Debug`, identify the first meaningful mismatch.
+
+The focused native AE13c fixtures cover decoder/preprocessing boundaries, tags
+and attributes, character references, tokenizer EOF recovery, RCDATA/RAWTEXT/
+supported script data, table buffering/foster parenting, active formatting,
+form pointers, template state/EOF, SVG/MathML integration points, and processing
+instructions. Unit coverage separately pins CRLF/lone/trailing CR and invalid or
+incomplete UTF-8 split behavior.
+
 ## May Differ (Intentional)
 
 ### Malformed markup recovery