diff --git a/crates/html/src/conformance/execution.rs b/crates/html/src/conformance/execution.rs
index 4d080acf..fa7cc3ba 100644
--- a/crates/html/src/conformance/execution.rs
+++ b/crates/html/src/conformance/execution.rs
@@ -10,8 +10,9 @@ use super::{CanonicalParserResult, IncompleteObservationReason, ObservationState
 use crate::html5::PatchHistoryObservationConfig;
 use crate::html5::shared::{
     CapturedSurface, DocumentParseContext, ErrorPolicy, ObservationOccurrenceSequence,
-    ObservationSurface, ParserObservationCapture, ParserObservationConfig,
-    ParserObservationInvariant, SurfaceCaptureRequest,
+    ObservationSurface, ParserObservationCapture, ParserObservationCaptureFailure,
+    ParserObservationConfig, ParserObservationFailure, ParserObservationInvariant,
+    SurfaceCaptureRequest, UnsupportedFeatureObservationFailure,
 };
 use crate::html5::{ByteStreamDecoder, Html5Tokenizer, Input, TokenizeResult, TokenizerConfig};
 use crate::{HtmlParseOptions, HtmlParser};
@@ -53,6 +54,10 @@ pub struct ParserObservationRequest<'a> {
     pub tokens: ObservationRequest,
     pub parse_errors: ObservationRequest,
     pub implementation_diagnostics: ObservationRequest,
+    /// Maximum retained central tree-builder dispatch attempts. This is an
+    /// event-count capacity, not a retained-string byte budget.
+    pub transitions: ObservationRequest,
+    pub unsupported_features: ObservationRequest,
     pub document_mode: ScalarObservationRequest,
     /// Maximum canonical structural units: document, document type, element or
     /// HTML template host, text, comment, processing instruction, and typed
@@ -69,6 +74,8 @@ pub enum ParserObservationExecutionError {
     ParserInvariant,
     TokenizerInvariant(ParserTokenizerInvariantError),
     TokenCanonicalizationInvariant,
+    TreeTransitionTokenCanonicalizationInvariant,
+    UnsupportedFeatureObservationInvariant(UnsupportedFeatureObservationInvariantError),
     ObservationRecorderMissing,
     PatchHistoryCaptureMissing,
     ObservationInvariant(ParserObservationInvariantError),
@@ -148,9 +155,13 @@ pub enum ParserTokenizerInvariantError {
 pub enum ParserObservationInvariantError {
     ParseErrorOccurrenceOverflow,
     ImplementationDiagnosticOccurrenceOverflow,
+    TreeTransitionOccurrenceOverflow,
+    UnsupportedFeatureOccurrenceOverflow,
     TokenDroppedCountOverflow,
     ParseErrorDroppedCountOverflow,
     ImplementationDiagnosticDroppedCountOverflow,
+    TreeTransitionDroppedCountOverflow,
+    UnsupportedFeatureDroppedCountOverflow,
     NormalizedPositionOverflow,
     NormalizedPositionIndexDiscontinuity,
     NormalizedPositionIndexMissing,
@@ -169,6 +180,14 @@ pub enum ParserObservationInvariantError {
     SnapshotLabelSequenceOverflow,
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum UnsupportedFeatureObservationInvariantError {
+    TokenAttributeNameUnavailable,
+    ExistingHtmlElementSemanticsUnavailable,
+    ExistingBodyElementSemanticsUnavailable,
+    ExistingElementIdentityContradiction,
+}
+
 impl std::fmt::Display for ParserObservationExecutionError {
     fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
@@ -183,6 +202,13 @@ impl std::fmt::Display for ParserObservationExecutionError {
             Self::TokenCanonicalizationInvariant => {
                 formatter.write_str("production token could not be resolved at its drain boundary")
             }
+            Self::TreeTransitionTokenCanonicalizationInvariant => formatter.write_str(
+                "tree transition token summary could not be resolved at its dispatch boundary",
+            ),
+            Self::UnsupportedFeatureObservationInvariant(invariant) => write!(
+                formatter,
+                "unsupported-feature observation invariant failed: {invariant:?}"
+            ),
             Self::ObservationRecorderMissing => formatter.write_str(
                 "parser observation was requested but the production recorder was missing",
             ),
@@ -217,6 +243,11 @@ pub fn execute_parser_observation(
         tokens: internal_request(request.tokens),
         parse_errors: internal_request(request.parse_errors),
         implementation_diagnostics: internal_request(request.implementation_diagnostics),
+        tree_transitions: match request.target {
+            ParserObservationTarget::StandaloneTokenizer => SurfaceCaptureRequest::NotRequested,
+            ParserObservationTarget::DocumentParser => internal_request(request.transitions),
+        },
+        unsupported_features: internal_request(request.unsupported_features),
     };
     let patch_config = match request.patches {
         ObservationRequest::NotRequested => PatchHistoryObservationConfig::default(),
@@ -252,7 +283,14 @@ pub fn execute_parser_observation(
             (capture, mode, tree, patches)
         }
     };
-    canonical_result(capture, document_mode, tree, patches)
+    canonical_result(
+        capture,
+        document_mode,
+        tree,
+        patches,
+        request.target,
+        request.transitions,
+    )
 }
 
 fn not_applicable_or_not_requested<T>(request: ObservationRequest) -> ObservationState<T> {
@@ -689,8 +727,17 @@ fn empty_capture() -> ParserObservationCapture {
             items: Vec::new(),
             dropped: 0,
         },
-        token_capture_failed: false,
-        invariant: None,
+        tree_transitions: CapturedSurface {
+            requested: false,
+            items: Vec::new(),
+            dropped: 0,
+        },
+        unsupported_features: CapturedSurface {
+            requested: false,
+            items: Vec::new(),
+            dropped: 0,
+        },
+        failure: None,
     }
 }
 
@@ -728,8 +775,16 @@ fn canonical_result(
     document_mode: ObservationState<crate::DocumentMode>,
     tree: ObservationState<super::ObservedTree>,
     patches: ObservationState<super::ObservedPatchStream>,
+    target: ParserObservationTarget,
+    transitions_request: ObservationRequest,
 ) -> Result<CanonicalParserResult, ParserObservationExecutionError> {
     validate_capture(&capture)?;
+    let transitions = match target {
+        ParserObservationTarget::StandaloneTokenizer => {
+            not_applicable_or_not_requested(transitions_request)
+        }
+        ParserObservationTarget::DocumentParser => finish_surface(capture.tree_transitions),
+    };
     Ok(CanonicalParserResult {
         tokens: finish_surface(capture.tokens),
         parse_errors: finish_surface(capture.parse_errors),
@@ -737,8 +792,8 @@ fn canonical_result(
         document_mode,
         tree,
         patches,
-        transitions: ObservationState::NotRequested,
-        unsupported_features: ObservationState::NotRequested,
+        transitions,
+        unsupported_features: finish_surface(capture.unsupported_features),
         final_invariants: ObservationState::NotRequested,
     })
 }
@@ -746,17 +801,54 @@ fn canonical_result(
 fn validate_capture(
     capture: &ParserObservationCapture,
 ) -> Result<(), ParserObservationExecutionError> {
-    if capture.token_capture_failed {
-        return Err(ParserObservationExecutionError::TokenCanonicalizationInvariant);
-    }
-    if let Some(invariant) = capture.invariant {
-        return Err(ParserObservationExecutionError::ObservationInvariant(
-            public_observation_invariant(invariant),
-        ));
+    if let Some(failure) = capture.failure {
+        return Err(public_observation_failure(failure));
     }
     Ok(())
 }
 
+fn public_observation_failure(
+    failure: ParserObservationFailure,
+) -> ParserObservationExecutionError {
+    match failure {
+        ParserObservationFailure::Capture(
+            ParserObservationCaptureFailure::TokenCanonicalization,
+        ) => ParserObservationExecutionError::TokenCanonicalizationInvariant,
+        ParserObservationFailure::Capture(
+            ParserObservationCaptureFailure::TreeTransitionTokenCanonicalization,
+        ) => ParserObservationExecutionError::TreeTransitionTokenCanonicalizationInvariant,
+        ParserObservationFailure::Capture(
+            ParserObservationCaptureFailure::UnsupportedFeatureEligibility(failure),
+        ) => ParserObservationExecutionError::UnsupportedFeatureObservationInvariant(
+            public_unsupported_feature_observation_failure(failure),
+        ),
+        ParserObservationFailure::Invariant(invariant) => {
+            ParserObservationExecutionError::ObservationInvariant(public_observation_invariant(
+                invariant,
+            ))
+        }
+    }
+}
+
+fn public_unsupported_feature_observation_failure(
+    failure: UnsupportedFeatureObservationFailure,
+) -> UnsupportedFeatureObservationInvariantError {
+    match failure {
+        UnsupportedFeatureObservationFailure::TokenAttributeNameUnavailable => {
+            UnsupportedFeatureObservationInvariantError::TokenAttributeNameUnavailable
+        }
+        UnsupportedFeatureObservationFailure::ExistingHtmlElementSemanticsUnavailable => {
+            UnsupportedFeatureObservationInvariantError::ExistingHtmlElementSemanticsUnavailable
+        }
+        UnsupportedFeatureObservationFailure::ExistingBodyElementSemanticsUnavailable => {
+            UnsupportedFeatureObservationInvariantError::ExistingBodyElementSemanticsUnavailable
+        }
+        UnsupportedFeatureObservationFailure::ExistingElementIdentityContradiction => {
+            UnsupportedFeatureObservationInvariantError::ExistingElementIdentityContradiction
+        }
+    }
+}
+
 fn public_observation_invariant(
     invariant: ParserObservationInvariant,
 ) -> ParserObservationInvariantError {
@@ -767,6 +859,12 @@ fn public_observation_invariant(
         ParserObservationInvariant::OccurrenceSequenceOverflow(
             ObservationOccurrenceSequence::ImplementationDiagnostics,
         ) => ParserObservationInvariantError::ImplementationDiagnosticOccurrenceOverflow,
+        ParserObservationInvariant::OccurrenceSequenceOverflow(
+            ObservationOccurrenceSequence::TreeTransitions,
+        ) => ParserObservationInvariantError::TreeTransitionOccurrenceOverflow,
+        ParserObservationInvariant::OccurrenceSequenceOverflow(
+            ObservationOccurrenceSequence::UnsupportedFeatures,
+        ) => ParserObservationInvariantError::UnsupportedFeatureOccurrenceOverflow,
         ParserObservationInvariant::DroppedCountOverflow(ObservationSurface::Tokens) => {
             ParserObservationInvariantError::TokenDroppedCountOverflow
         }
@@ -776,6 +874,12 @@ fn public_observation_invariant(
         ParserObservationInvariant::DroppedCountOverflow(
             ObservationSurface::ImplementationDiagnostics,
         ) => ParserObservationInvariantError::ImplementationDiagnosticDroppedCountOverflow,
+        ParserObservationInvariant::DroppedCountOverflow(ObservationSurface::TreeTransitions) => {
+            ParserObservationInvariantError::TreeTransitionDroppedCountOverflow
+        }
+        ParserObservationInvariant::DroppedCountOverflow(
+            ObservationSurface::UnsupportedFeatures,
+        ) => ParserObservationInvariantError::UnsupportedFeatureDroppedCountOverflow,
         ParserObservationInvariant::NormalizedPositionOverflow => {
             ParserObservationInvariantError::NormalizedPositionOverflow
         }
@@ -856,6 +960,8 @@ mod tests {
             implementation_diagnostics: ObservationRequest::Capture {
                 capacity: DIAGNOSTIC_CAPACITY,
             },
+            transitions: ObservationRequest::NotRequested,
+            unsupported_features: ObservationRequest::NotRequested,
             document_mode: ScalarObservationRequest::NotRequested,
             tree: ObservationRequest::NotRequested,
             patches: ObservationRequest::NotRequested,
@@ -870,6 +976,66 @@ mod tests {
         }
     }
 
+    fn observe_ae13b4(
+        source: &str,
+        transitions: ObservationRequest,
+        unsupported_features: ObservationRequest,
+    ) -> CanonicalParserResult {
+        observe_ae13b4_input(
+            ParserObservationInput::Utf8(source),
+            transitions,
+            unsupported_features,
+            ObservationRequest::NotRequested,
+        )
+    }
+
+    fn observe_ae13b4_input(
+        input: ParserObservationInput<'_>,
+        transitions: ObservationRequest,
+        unsupported_features: ObservationRequest,
+        tree: ObservationRequest,
+    ) -> CanonicalParserResult {
+        execute_parser_observation(ParserObservationRequest {
+            target: ParserObservationTarget::DocumentParser,
+            input,
+            tokens: ObservationRequest::NotRequested,
+            parse_errors: ObservationRequest::Capture { capacity: 256 },
+            implementation_diagnostics: ObservationRequest::Capture { capacity: 256 },
+            transitions,
+            unsupported_features,
+            document_mode: ScalarObservationRequest::NotRequested,
+            tree,
+            patches: ObservationRequest::NotRequested,
+        })
+        .expect("AE13b4 production observation")
+    }
+
+    fn unsupported_identities(
+        result: &CanonicalParserResult,
+    ) -> Vec<crate::html5::shared::TreeConstructionUnsupportedFeature> {
+        captured(&result.unsupported_features)
+            .iter()
+            .map(|event| match event {
+                crate::html5::shared::UnsupportedFeatureEvent::TreeConstruction {
+                    feature, ..
+                } => *feature,
+            })
+            .collect()
+    }
+
+    fn canonical_result_with_unrequested_projections(
+        capture: ParserObservationCapture,
+    ) -> Result<CanonicalParserResult, ParserObservationExecutionError> {
+        canonical_result(
+            capture,
+            ObservationState::NotRequested,
+            ObservationState::NotRequested,
+            ObservationState::NotRequested,
+            ParserObservationTarget::DocumentParser,
+            ObservationRequest::NotRequested,
+        )
+    }
+
     fn observed_scalars(result: &CanonicalParserResult) -> String {
         captured(&result.tokens)
             .iter()
@@ -960,6 +1126,8 @@ mod tests {
             tokens: ObservationRequest::NotRequested,
             parse_errors: ObservationRequest::NotRequested,
             implementation_diagnostics: ObservationRequest::NotRequested,
+            transitions: ObservationRequest::NotRequested,
+            unsupported_features: ObservationRequest::NotRequested,
             document_mode: ScalarObservationRequest::NotRequested,
             tree: ObservationRequest::NotRequested,
             patches: ObservationRequest::NotRequested,
@@ -976,6 +1144,662 @@ mod tests {
         ));
     }
 
+    #[test]
+    fn ae13b4_target_applicability_is_explicit_and_surface_local() {
+        let standalone = execute_parser_observation(ParserObservationRequest {
+            target: ParserObservationTarget::StandaloneTokenizer,
+            input: ParserObservationInput::Utf8("<p>x"),
+            tokens: ObservationRequest::NotRequested,
+            parse_errors: ObservationRequest::NotRequested,
+            implementation_diagnostics: ObservationRequest::NotRequested,
+            transitions: ObservationRequest::Capture { capacity: 8 },
+            unsupported_features: ObservationRequest::Capture { capacity: 8 },
+            document_mode: ScalarObservationRequest::NotRequested,
+            tree: ObservationRequest::NotRequested,
+            patches: ObservationRequest::NotRequested,
+        })
+        .unwrap();
+        assert_eq!(
+            standalone.transitions,
+            ObservationState::NotApplicable {
+                reason: NotApplicableReason::StandaloneTokenizerRun
+            }
+        );
+        assert_eq!(
+            standalone.unsupported_features,
+            ObservationState::Captured(Vec::new())
+        );
+
+        let document = observe_ae13b4(
+            "<p>x",
+            ObservationRequest::Capture { capacity: 32 },
+            ObservationRequest::NotRequested,
+        );
+        assert!(matches!(
+            document.transitions,
+            ObservationState::Captured(_)
+        ));
+        assert!(matches!(
+            document.unsupported_features,
+            ObservationState::NotRequested
+        ));
+    }
+
+    #[test]
+    fn eof_reprocessing_records_each_central_attempt_with_committed_modes() {
+        use crate::html5::shared::{ObservedInsertionMode as Mode, TreeDispatchPath};
+
+        let result = observe_ae13b4(
+            "",
+            ObservationRequest::Capture { capacity: 16 },
+            ObservationRequest::NotRequested,
+        );
+        let transitions = captured(&result.transitions);
+        let modes = [
+            (Mode::Initial, Mode::BeforeHtml),
+            (Mode::BeforeHtml, Mode::BeforeHead),
+            (Mode::BeforeHead, Mode::InHead),
+            (Mode::InHead, Mode::AfterHead),
+            (Mode::AfterHead, Mode::InBody),
+            (Mode::InBody, Mode::InBody),
+        ];
+        assert_eq!(transitions.len(), modes.len());
+        for (index, (event, (before, after))) in transitions.iter().zip(modes).enumerate() {
+            assert_eq!(event.occurrence, index as u64 + 1);
+            assert_eq!(event.insertion_mode_before, before);
+            assert_eq!(event.insertion_mode_after, after);
+            assert_eq!(
+                event.dispatch_path,
+                TreeDispatchPath::HtmlInsertionMode(before)
+            );
+            assert_eq!(event.reprocessed, index != 0);
+            assert!(matches!(
+                event.token.as_ref(),
+                crate::html5::shared::TransitionTokenSummary::Eof
+            ));
+        }
+    }
+
+    #[test]
+    fn dispatch_paths_distinguish_template_text_foreign_and_internal_delegation() {
+        use crate::html5::shared::{
+            ObservedInsertionMode as Mode, TransitionTokenSummary, TreeDispatchPath,
+        };
+
+        let result = observe_ae13b4(
+            "<template><title>x</title></template><svg><g></g></svg>",
+            ObservationRequest::Capture { capacity: 128 },
+            ObservationRequest::NotRequested,
+        );
+        let transitions = captured(&result.transitions);
+        assert!(transitions.iter().any(|event| {
+            event.dispatch_path == TreeDispatchPath::SharedTemplateRules
+                && matches!(
+                    event.token.as_ref(),
+                    TransitionTokenSummary::StartTag { name, .. } if name == "template"
+                )
+        }));
+        assert!(transitions.iter().any(|event| {
+            event.dispatch_path == TreeDispatchPath::TextMode
+                && event.insertion_mode_before == Mode::Text
+                && matches!(
+                    event.token.as_ref(),
+                    TransitionTokenSummary::Character { data } if data == "x"
+                )
+        }));
+        assert!(transitions.iter().any(|event| {
+            event.insertion_mode_before == Mode::InTemplate
+                && event.insertion_mode_after == Mode::Text
+                && !event.reprocessed
+                && matches!(
+                    event.token.as_ref(),
+                    TransitionTokenSummary::StartTag { name, .. } if name == "title"
+                )
+        }));
+        assert!(transitions.iter().any(|event| {
+            event.dispatch_path == TreeDispatchPath::ForeignContent
+                && matches!(
+                    event.token.as_ref(),
+                    TransitionTokenSummary::StartTag { name, .. } if name == "g"
+                )
+        }));
+
+        let delegated = observe_ae13b4(
+            "<table><tr><td><html data-x=1>",
+            ObservationRequest::Capture { capacity: 64 },
+            ObservationRequest::NotRequested,
+        );
+        let html_attempts = captured(&delegated.transitions)
+            .iter()
+            .filter(|event| {
+                matches!(
+                    event.token.as_ref(),
+                    TransitionTokenSummary::StartTag { name, .. } if name == "html"
+                )
+            })
+            .collect::<Vec<_>>();
+        assert_eq!(html_attempts.len(), 1);
+        assert_eq!(
+            html_attempts[0].dispatch_path,
+            TreeDispatchPath::HtmlInsertionMode(Mode::InCell)
+        );
+    }
+
+    #[test]
+    fn template_and_table_mode_changes_redispatch_only_through_the_driver() {
+        use crate::html5::shared::{
+            ObservedInsertionMode as Mode, TransitionTokenSummary, TreeDispatchPath,
+        };
+
+        for (source, name, expected_paths) in [
+            (
+                "<template><col>",
+                "col",
+                [
+                    TreeDispatchPath::HtmlInsertionMode(Mode::InTemplate),
+                    TreeDispatchPath::HtmlInsertionMode(Mode::InColumnGroup),
+                ],
+            ),
+            (
+                "<table><tr>",
+                "tr",
+                [
+                    TreeDispatchPath::HtmlInsertionMode(Mode::InTable),
+                    TreeDispatchPath::HtmlInsertionMode(Mode::InTableBody),
+                ],
+            ),
+        ] {
+            let result = observe_ae13b4(
+                source,
+                ObservationRequest::Capture { capacity: 128 },
+                ObservationRequest::NotRequested,
+            );
+            let attempts = captured(&result.transitions)
+                .iter()
+                .filter(|event| {
+                    matches!(
+                        event.token.as_ref(),
+                        TransitionTokenSummary::StartTag { name: actual, .. } if actual == name
+                    )
+                })
+                .collect::<Vec<_>>();
+            assert_eq!(attempts.len(), 2, "source={source}");
+            assert_eq!(attempts[0].dispatch_path, expected_paths[0]);
+            assert!(!attempts[0].reprocessed);
+            assert_eq!(attempts[1].dispatch_path, expected_paths[1]);
+            assert!(attempts[1].reprocessed);
+        }
+    }
+
+    #[test]
+    fn foreign_breakout_and_end_fallback_are_two_observable_attempts() {
+        use crate::html5::shared::{TransitionTokenSummary, TreeDispatchPath};
+
+        for (source, token_name, start_tag) in [
+            ("<svg><g><p>x", "p", true),
+            ("<svg><g></span>", "span", false),
+        ] {
+            let result = observe_ae13b4(
+                source,
+                ObservationRequest::Capture { capacity: 128 },
+                ObservationRequest::NotRequested,
+            );
+            let attempts = captured(&result.transitions)
+                .iter()
+                .filter(|event| match event.token.as_ref() {
+                    TransitionTokenSummary::StartTag { name, .. } => {
+                        start_tag && name == token_name
+                    }
+                    TransitionTokenSummary::EndTag { name } => !start_tag && name == token_name,
+                    _ => false,
+                })
+                .collect::<Vec<_>>();
+            assert_eq!(attempts.len(), 2, "source={source}");
+            assert_eq!(attempts[0].dispatch_path, TreeDispatchPath::ForeignContent);
+            assert!(!attempts[0].reprocessed);
+            assert!(matches!(
+                attempts[1].dispatch_path,
+                TreeDispatchPath::HtmlInsertionMode(_)
+            ));
+            assert!(attempts[1].reprocessed);
+            assert_eq!(attempts[0].token, attempts[1].token);
+        }
+    }
+
+    #[test]
+    fn integration_points_and_foreign_eof_select_html_rules_centrally() {
+        use crate::html5::shared::{TransitionTokenSummary, TreeDispatchPath};
+
+        let integration = observe_ae13b4(
+            "<svg><foreignObject><p>x</p></foreignObject></svg>",
+            ObservationRequest::Capture { capacity: 128 },
+            ObservationRequest::NotRequested,
+        );
+        let paragraph = captured(&integration.transitions)
+            .iter()
+            .find(|event| {
+                matches!(
+                    event.token.as_ref(),
+                    TransitionTokenSummary::StartTag { name, .. } if name == "p"
+                )
+            })
+            .unwrap();
+        assert!(matches!(
+            paragraph.dispatch_path,
+            TreeDispatchPath::HtmlInsertionMode(_)
+        ));
+
+        let eof = observe_ae13b4(
+            "<svg><g>",
+            ObservationRequest::Capture { capacity: 128 },
+            ObservationRequest::NotRequested,
+        );
+        let eof_attempts = captured(&eof.transitions)
+            .iter()
+            .filter(|event| matches!(event.token.as_ref(), TransitionTokenSummary::Eof))
+            .collect::<Vec<_>>();
+        assert_eq!(eof_attempts.len(), 1);
+        assert!(matches!(
+            eof_attempts[0].dispatch_path,
+            TreeDispatchPath::HtmlInsertionMode(_)
+        ));
+    }
+
+    #[test]
+    fn transition_and_unsupported_capacities_are_independent_prefixes() {
+        let zero = observe_ae13b4(
+            "",
+            ObservationRequest::Capture { capacity: 0 },
+            ObservationRequest::NotRequested,
+        );
+        assert_eq!(
+            zero.transitions,
+            ObservationState::Incomplete {
+                partial: Vec::new(),
+                reason: IncompleteObservationReason::StorageLimitExceeded {
+                    retained: 0,
+                    dropped: 6,
+                },
+            }
+        );
+
+        let bounded = observe_ae13b4(
+            "<body><body data-missing=1>",
+            ObservationRequest::Capture { capacity: 1 },
+            ObservationRequest::Capture { capacity: 1 },
+        );
+        let ObservationState::Incomplete {
+            partial: transition_prefix,
+            reason: transition_reason,
+        } = &bounded.transitions
+        else {
+            panic!("transition prefix must be incomplete");
+        };
+        assert_eq!(transition_prefix.len(), 1);
+        assert_eq!(transition_prefix[0].occurrence, 1);
+        assert!(matches!(
+            transition_reason,
+            IncompleteObservationReason::StorageLimitExceeded { dropped, .. } if *dropped > 0
+        ));
+        let ObservationState::Incomplete {
+            partial: unsupported_prefix,
+            reason: unsupported_reason,
+        } = &bounded.unsupported_features
+        else {
+            panic!("unsupported prefix must be incomplete");
+        };
+        assert_eq!(unsupported_prefix.len(), 1);
+        let crate::html5::shared::UnsupportedFeatureEvent::TreeConstruction { occurrence, .. } =
+            &unsupported_prefix[0];
+        assert_eq!(*occurrence, 1);
+        assert_eq!(
+            *unsupported_reason,
+            IncompleteObservationReason::StorageLimitExceeded {
+                retained: 1,
+                dropped: 1,
+            }
+        );
+    }
+
+    #[test]
+    fn html_and_body_attribute_eligibility_uses_missing_expanded_names() {
+        use crate::html5::shared::TreeConstructionUnsupportedFeature as Feature;
+
+        for source in [
+            "<html a=one><head></head><body><html>",
+            "<html a=one><head></head><body><html a=two>",
+            "<html a=one><head></head><body><html a=two a=three>",
+        ] {
+            let result = observe_ae13b4(
+                source,
+                ObservationRequest::NotRequested,
+                ObservationRequest::Capture { capacity: 16 },
+            );
+            assert!(
+                !unsupported_identities(&result)
+                    .contains(&Feature::MergeAttributesIntoExistingHtmlElement),
+                "source={source}"
+            );
+        }
+
+        for source in [
+            "<html a=one><head><html b=two></head>",
+            "<html a=one><head></head><html b=two><body>",
+            "<html a=one><head></head><body><html b=two>",
+            "<html a=one><head></head><body></body><html b=two>",
+            "<html a=one><head></head><body></body></html><html b=two>",
+        ] {
+            let result = observe_ae13b4(
+                source,
+                ObservationRequest::NotRequested,
+                ObservationRequest::Capture { capacity: 16 },
+            );
+            assert_eq!(
+                unsupported_identities(&result)
+                    .into_iter()
+                    .filter(|feature| {
+                        *feature == Feature::MergeAttributesIntoExistingHtmlElement
+                    })
+                    .count(),
+                1,
+                "source={source}"
+            );
+        }
+
+        let mixed = observe_ae13b4(
+            "<html><head></head><body a=one><body a=two b=three c=four>",
+            ObservationRequest::NotRequested,
+            ObservationRequest::Capture { capacity: 16 },
+        );
+        let mixed_features = unsupported_identities(&mixed);
+        assert_eq!(
+            mixed_features,
+            vec![
+                Feature::MarkFramesetNotOkForRepeatedBodyStartTag,
+                Feature::MergeAttributesIntoExistingBodyElement,
+            ]
+        );
+
+        let existing_only = observe_ae13b4(
+            "<html><head></head><body a=one><body a=two>",
+            ObservationRequest::NotRequested,
+            ObservationRequest::Capture { capacity: 16 },
+        );
+        assert!(
+            !unsupported_identities(&existing_only)
+                .contains(&Feature::MergeAttributesIntoExistingBodyElement)
+        );
+
+        for source in [
+            "<html><head></head><body><template><html missing=one></template>",
+            "<html><head></head><body><template><body missing=one></template>",
+        ] {
+            let result = observe_ae13b4(
+                source,
+                ObservationRequest::NotRequested,
+                ObservationRequest::Capture { capacity: 16 },
+            );
+            let features = unsupported_identities(&result);
+            assert!(!features.contains(&Feature::MergeAttributesIntoExistingHtmlElement));
+            assert!(!features.contains(&Feature::MergeAttributesIntoExistingBodyElement));
+            assert!(!features.contains(&Feature::MarkFramesetNotOkForRepeatedBodyStartTag));
+        }
+    }
+
+    #[test]
+    fn explicit_cell_end_tags_follow_the_non_cascading_decision_table() {
+        use crate::html5::shared::TreeConstructionUnsupportedFeature as Feature;
+
+        for source in [
+            "<table><tr><th></td>",
+            "<table><tr><td></th>",
+            "<table><tr><th><p></td>",
+            "<table><tr><td><p></th>",
+            "<table><tr><th><div></td>",
+            "<table><tr><td><div></th>",
+        ] {
+            let result = observe_ae13b4(
+                source,
+                ObservationRequest::NotRequested,
+                ObservationRequest::Capture { capacity: 16 },
+            );
+            let features = unsupported_identities(&result);
+            assert_eq!(
+                features,
+                vec![Feature::RequireSameNamedTableCellInScopeForEndTag],
+                "source={source}"
+            );
+        }
+
+        for source in ["<table><tr><td></td>", "<table><tr><th></th>"] {
+            let result = observe_ae13b4(
+                source,
+                ObservationRequest::NotRequested,
+                ObservationRequest::Capture { capacity: 16 },
+            );
+            assert!(
+                unsupported_identities(&result).is_empty(),
+                "source={source}"
+            );
+        }
+
+        for source in [
+            "<table><tr><td><p></td>",
+            "<table><tr><th><p></th>",
+            "<table><tr><td><div></td>",
+            "<table><tr><th><b></th>",
+        ] {
+            let result = observe_ae13b4(
+                source,
+                ObservationRequest::NotRequested,
+                ObservationRequest::Capture { capacity: 16 },
+            );
+            assert_eq!(
+                unsupported_identities(&result),
+                vec![Feature::GenerateImpliedEndTagsAndCheckCurrentNodeBeforeClosingTableCell],
+                "source={source}"
+            );
+        }
+    }
+
+    #[test]
+    fn table_structure_cell_closures_remain_independently_eligible() {
+        use crate::html5::shared::TreeConstructionUnsupportedFeature as Feature;
+
+        for source in [
+            "<table><tbody><tr><td><p><caption>",
+            "<table><tbody><tr><td><p><col>",
+            "<table><tbody><tr><td><p><colgroup>",
+            "<table><tbody><tr><td><p><tbody>",
+            "<table><tbody><tr><td><p><td>",
+            "<table><tbody><tr><td><p><tfoot>",
+            "<table><tbody><tr><td><p><th>",
+            "<table><tbody><tr><td><p><thead>",
+            "<table><tbody><tr><td><p><tr>",
+            "<table><tbody><tr><td><p></table>",
+            "<table><tbody><tr><td><p></tbody>",
+            "<table><tfoot><tr><td><p></tfoot>",
+            "<table><thead><tr><td><p></thead>",
+            "<table><tbody><tr><td><p></tr>",
+        ] {
+            let result = observe_ae13b4(
+                source,
+                ObservationRequest::NotRequested,
+                ObservationRequest::Capture { capacity: 32 },
+            );
+            assert!(
+                unsupported_identities(&result).contains(
+                    &Feature::GenerateImpliedEndTagsAndCheckCurrentNodeBeforeClosingTableCell
+                ),
+                "source={source}"
+            );
+        }
+    }
+
+    #[test]
+    fn every_caption_close_caller_observes_exact_identity_and_reprocessing() {
+        use crate::html5::shared::{
+            ObservedInsertionMode as Mode, TransitionTokenSummary,
+            TreeConstructionUnsupportedFeature as Feature, TreeDispatchPath,
+            UnsupportedFeatureEvent,
+        };
+
+        for (token, token_name, start_tag, reprocesses) in [
+            ("</caption>", "caption", false, false),
+            ("<colgroup>", "colgroup", true, true),
+            ("</table>", "table", false, true),
+        ] {
+            for nested in [false, true] {
+                let source = if nested {
+                    format!("<table><caption><p>x{token}")
+                } else {
+                    format!("<table><caption>{token}")
+                };
+                let observed = observe_ae13b4_input(
+                    ParserObservationInput::Utf8(&source),
+                    ObservationRequest::Capture { capacity: 128 },
+                    ObservationRequest::Capture { capacity: 8 },
+                    ObservationRequest::Capture { capacity: 256 },
+                );
+                let baseline = observe_ae13b4_input(
+                    ParserObservationInput::Utf8(&source),
+                    ObservationRequest::Capture { capacity: 128 },
+                    ObservationRequest::NotRequested,
+                    ObservationRequest::Capture { capacity: 256 },
+                );
+
+                assert_eq!(observed.tree, baseline.tree, "source={source}");
+                assert_eq!(
+                    observed.transitions, baseline.transitions,
+                    "source={source}"
+                );
+                assert_eq!(
+                    observed.parse_errors, baseline.parse_errors,
+                    "source={source}"
+                );
+
+                let events = captured(&observed.unsupported_features);
+                if nested {
+                    assert_eq!(events.len(), 1, "source={source}");
+                    let UnsupportedFeatureEvent::TreeConstruction {
+                        occurrence,
+                        feature,
+                        ..
+                    } = &events[0];
+                    assert_eq!(*occurrence, 1, "source={source}");
+                    assert_eq!(
+                        *feature,
+                        Feature::GenerateImpliedEndTagsAndCheckCurrentNodeBeforeClosingCaption,
+                        "source={source}"
+                    );
+                } else {
+                    assert!(events.is_empty(), "source={source}");
+                }
+
+                let attempts = captured(&observed.transitions)
+                    .iter()
+                    .filter(|event| match event.token.as_ref() {
+                        TransitionTokenSummary::StartTag { name, .. } => {
+                            start_tag && name == token_name
+                        }
+                        TransitionTokenSummary::EndTag { name } => !start_tag && name == token_name,
+                        _ => false,
+                    })
+                    .collect::<Vec<_>>();
+                let expected_attempts = if reprocesses { 2 } else { 1 };
+                assert_eq!(attempts.len(), expected_attempts, "source={source}");
+                assert_eq!(
+                    attempts[0].dispatch_path,
+                    TreeDispatchPath::HtmlInsertionMode(Mode::InCaption),
+                    "source={source}"
+                );
+                assert!(!attempts[0].reprocessed, "source={source}");
+                if reprocesses {
+                    assert_eq!(
+                        attempts[1].dispatch_path,
+                        TreeDispatchPath::HtmlInsertionMode(Mode::InTable),
+                        "source={source}"
+                    );
+                    assert!(attempts[1].reprocessed, "source={source}");
+                }
+            }
+        }
+
+        let whole_source = "<table><caption><p>x</table>";
+        let chunks = ["<table><caption><p>x", "</table>"];
+        let whole = observe_ae13b4_input(
+            ParserObservationInput::Utf8(whole_source),
+            ObservationRequest::Capture { capacity: 128 },
+            ObservationRequest::Capture { capacity: 8 },
+            ObservationRequest::Capture { capacity: 256 },
+        );
+        let chunked = observe_ae13b4_input(
+            ParserObservationInput::Utf8Chunks(&chunks),
+            ObservationRequest::Capture { capacity: 128 },
+            ObservationRequest::Capture { capacity: 8 },
+            ObservationRequest::Capture { capacity: 256 },
+        );
+        assert_eq!(whole.unsupported_features, chunked.unsupported_features);
+        assert_eq!(whole.transitions, chunked.transitions);
+        assert_eq!(whole.parse_errors, chunked.parse_errors);
+        assert_eq!(whole.tree, chunked.tree);
+    }
+
+    #[test]
+    fn ae13b4_observations_are_whole_chunked_equal_and_do_not_change_tree_output() {
+        let chunks = ["<table><tr><th><p>", "</td><svg><g><p>", "x"];
+        let source = chunks.concat();
+        let whole = observe_ae13b4(
+            &source,
+            ObservationRequest::Capture { capacity: 256 },
+            ObservationRequest::Capture { capacity: 64 },
+        );
+        let chunked = execute_parser_observation(ParserObservationRequest {
+            target: ParserObservationTarget::DocumentParser,
+            input: ParserObservationInput::Utf8Chunks(&chunks),
+            tokens: ObservationRequest::NotRequested,
+            parse_errors: ObservationRequest::Capture { capacity: 256 },
+            implementation_diagnostics: ObservationRequest::Capture { capacity: 256 },
+            transitions: ObservationRequest::Capture { capacity: 256 },
+            unsupported_features: ObservationRequest::Capture { capacity: 64 },
+            document_mode: ScalarObservationRequest::NotRequested,
+            tree: ObservationRequest::NotRequested,
+            patches: ObservationRequest::NotRequested,
+        })
+        .unwrap();
+        assert_eq!(whole.transitions, chunked.transitions);
+        assert_eq!(whole.unsupported_features, chunked.unsupported_features);
+        assert_eq!(whole.parse_errors, chunked.parse_errors);
+
+        let observed_tree = execute_parser_observation(ParserObservationRequest {
+            target: ParserObservationTarget::DocumentParser,
+            input: ParserObservationInput::Utf8(&source),
+            tokens: ObservationRequest::NotRequested,
+            parse_errors: ObservationRequest::NotRequested,
+            implementation_diagnostics: ObservationRequest::NotRequested,
+            transitions: ObservationRequest::Capture { capacity: 256 },
+            unsupported_features: ObservationRequest::Capture { capacity: 64 },
+            document_mode: ScalarObservationRequest::NotRequested,
+            tree: ObservationRequest::Capture { capacity: 256 },
+            patches: ObservationRequest::NotRequested,
+        })
+        .unwrap();
+        let unobserved_tree = execute_parser_observation(ParserObservationRequest {
+            target: ParserObservationTarget::DocumentParser,
+            input: ParserObservationInput::Utf8(&source),
+            tokens: ObservationRequest::NotRequested,
+            parse_errors: ObservationRequest::NotRequested,
+            implementation_diagnostics: ObservationRequest::NotRequested,
+            transitions: ObservationRequest::NotRequested,
+            unsupported_features: ObservationRequest::NotRequested,
+            document_mode: ScalarObservationRequest::NotRequested,
+            tree: ObservationRequest::Capture { capacity: 256 },
+            patches: ObservationRequest::NotRequested,
+        })
+        .unwrap();
+        assert_eq!(observed_tree.tree, unobserved_tree.tree);
+    }
+
     #[test]
     fn requested_capture_cannot_silently_disappear_for_either_execution_target() {
         let config = ParserObservationConfig {
@@ -1011,6 +1835,7 @@ mod tests {
             tokens: SurfaceCaptureRequest::Capture { capacity: 8 },
             parse_errors: SurfaceCaptureRequest::Capture { capacity: 8 },
             implementation_diagnostics: SurfaceCaptureRequest::Capture { capacity: 8 },
+            ..ParserObservationConfig::default()
         };
         let mut parser = HtmlParser::new_with_observations_and_failure_injection(
             HtmlParseOptions::default(),
@@ -1258,44 +2083,35 @@ mod tests {
     #[test]
     fn observation_invariants_are_typed_execution_failures() {
         let mut capture = empty_capture();
-        capture.invariant = Some(ParserObservationInvariant::OccurrenceSequenceOverflow(
-            ObservationOccurrenceSequence::ParseErrors,
+        capture.failure = Some(ParserObservationFailure::Invariant(
+            ParserObservationInvariant::OccurrenceSequenceOverflow(
+                ObservationOccurrenceSequence::ParseErrors,
+            ),
         ));
         assert_eq!(
-            canonical_result(
-                capture,
-                ObservationState::NotRequested,
-                ObservationState::NotRequested,
-                ObservationState::NotRequested,
-            ),
+            canonical_result_with_unrequested_projections(capture),
             Err(ParserObservationExecutionError::ObservationInvariant(
                 ParserObservationInvariantError::ParseErrorOccurrenceOverflow
             ))
         );
 
         let mut capture = empty_capture();
-        capture.invariant = Some(ParserObservationInvariant::InvalidNormalizedPositionOffset);
+        capture.failure = Some(ParserObservationFailure::Invariant(
+            ParserObservationInvariant::InvalidNormalizedPositionOffset,
+        ));
         assert_eq!(
-            canonical_result(
-                capture,
-                ObservationState::NotRequested,
-                ObservationState::NotRequested,
-                ObservationState::NotRequested,
-            ),
+            canonical_result_with_unrequested_projections(capture),
             Err(ParserObservationExecutionError::ObservationInvariant(
                 ParserObservationInvariantError::InvalidNormalizedPositionOffset
             ))
         );
 
         let mut capture = empty_capture();
-        capture.invariant = Some(ParserObservationInvariant::NormalizedPositionIndexMissing);
+        capture.failure = Some(ParserObservationFailure::Invariant(
+            ParserObservationInvariant::NormalizedPositionIndexMissing,
+        ));
         assert_eq!(
-            canonical_result(
-                capture,
-                ObservationState::NotRequested,
-                ObservationState::NotRequested,
-                ObservationState::NotRequested,
-            ),
+            canonical_result_with_unrequested_projections(capture),
             Err(ParserObservationExecutionError::ObservationInvariant(
                 ParserObservationInvariantError::NormalizedPositionIndexMissing
             ))
@@ -1326,12 +2142,7 @@ mod tests {
             "an invalid normalized offset must not retain a false unavailable-position event"
         );
         assert_eq!(
-            canonical_result(
-                capture,
-                ObservationState::NotRequested,
-                ObservationState::NotRequested,
-                ObservationState::NotRequested,
-            ),
+            canonical_result_with_unrequested_projections(capture),
             Err(ParserObservationExecutionError::ObservationInvariant(
                 ParserObservationInvariantError::InvalidNormalizedPositionOffset
             ))
@@ -1363,18 +2174,39 @@ mod tests {
             "missing-index corruption must not retain a false unavailable event"
         );
         assert_eq!(
-            canonical_result(
-                capture,
-                ObservationState::NotRequested,
-                ObservationState::NotRequested,
-                ObservationState::NotRequested,
-            ),
+            canonical_result_with_unrequested_projections(capture),
             Err(ParserObservationExecutionError::ObservationInvariant(
                 ParserObservationInvariantError::NormalizedPositionIndexMissing
             ))
         );
     }
 
+    #[test]
+    fn observation_capture_failures_have_one_deterministic_public_mapping() {
+        let cases = [
+            (
+                ParserObservationCaptureFailure::TreeTransitionTokenCanonicalization,
+                ParserObservationExecutionError::TreeTransitionTokenCanonicalizationInvariant,
+            ),
+            (
+                ParserObservationCaptureFailure::UnsupportedFeatureEligibility(
+                    UnsupportedFeatureObservationFailure::TokenAttributeNameUnavailable,
+                ),
+                ParserObservationExecutionError::UnsupportedFeatureObservationInvariant(
+                    UnsupportedFeatureObservationInvariantError::TokenAttributeNameUnavailable,
+                ),
+            ),
+        ];
+        for (failure, expected) in cases {
+            let mut capture = empty_capture();
+            capture.failure = Some(ParserObservationFailure::Capture(failure));
+            assert_eq!(
+                canonical_result_with_unrequested_projections(capture),
+                Err(expected)
+            );
+        }
+    }
+
     #[test]
     fn literal_replacement_scalar_is_not_a_decoder_diagnostic() {
         let literal = observe_bytes(ParserObservationInput::Utf8("\u{FFFD}"));
@@ -1480,6 +2312,8 @@ mod tests {
             tokens: ObservationRequest::NotRequested,
             parse_errors: ObservationRequest::NotRequested,
             implementation_diagnostics: ObservationRequest::Capture { capacity: 1 },
+            transitions: ObservationRequest::NotRequested,
+            unsupported_features: ObservationRequest::NotRequested,
             document_mode: ScalarObservationRequest::NotRequested,
             tree: ObservationRequest::NotRequested,
             patches: ObservationRequest::NotRequested,
@@ -1888,6 +2722,8 @@ mod tests {
             tokens: ObservationRequest::NotRequested,
             parse_errors: ObservationRequest::Capture { capacity: 8 },
             implementation_diagnostics: ObservationRequest::NotRequested,
+            transitions: ObservationRequest::NotRequested,
+            unsupported_features: ObservationRequest::NotRequested,
             document_mode: ScalarObservationRequest::NotRequested,
             tree: ObservationRequest::NotRequested,
             patches: ObservationRequest::NotRequested,
@@ -2613,6 +3449,7 @@ mod tests {
                 tokens: SurfaceCaptureRequest::Capture { capacity: 8 },
                 parse_errors: SurfaceCaptureRequest::Capture { capacity: 8 },
                 implementation_diagnostics: SurfaceCaptureRequest::Capture { capacity: 8 },
+                ..ParserObservationConfig::default()
             },
         )
         .expect("observed parser");
@@ -2655,6 +3492,7 @@ mod tests {
                     tokens: SurfaceCaptureRequest::Capture { capacity: 8 },
                     parse_errors: SurfaceCaptureRequest::Capture { capacity: 8 },
                     implementation_diagnostics: SurfaceCaptureRequest::Capture { capacity: 8 },
+                    ..ParserObservationConfig::default()
                 },
             )
             .expect("observed parser");
@@ -2691,6 +3529,7 @@ mod tests {
                     tokens: SurfaceCaptureRequest::Capture { capacity: 8 },
                     parse_errors: SurfaceCaptureRequest::Capture { capacity: 8 },
                     implementation_diagnostics: SurfaceCaptureRequest::Capture { capacity: 8 },
+                    ..ParserObservationConfig::default()
                 },
             )
             .expect("observed parser");
@@ -2722,6 +3561,7 @@ mod tests {
                 tokens: SurfaceCaptureRequest::Capture { capacity: 8 },
                 parse_errors: SurfaceCaptureRequest::Capture { capacity: 8 },
                 implementation_diagnostics: SurfaceCaptureRequest::Capture { capacity: 8 },
+                ..ParserObservationConfig::default()
             },
         )
         .expect("observed parser");
@@ -2753,6 +3593,7 @@ mod tests {
                 tokens: SurfaceCaptureRequest::Capture { capacity: 8 },
                 parse_errors: SurfaceCaptureRequest::Capture { capacity: 8 },
                 implementation_diagnostics: SurfaceCaptureRequest::Capture { capacity: 8 },
+                ..ParserObservationConfig::default()
             },
         )
         .expect("observed parser");
@@ -2791,6 +3632,7 @@ mod tests {
                     tokens: SurfaceCaptureRequest::Capture { capacity: 8 },
                     parse_errors: SurfaceCaptureRequest::Capture { capacity: 8 },
                     implementation_diagnostics: SurfaceCaptureRequest::Capture { capacity: 8 },
+                    ..ParserObservationConfig::default()
                 },
             )
             .expect("observed parser");
@@ -2824,6 +3666,7 @@ mod tests {
                     tokens: SurfaceCaptureRequest::Capture { capacity: 8 },
                     parse_errors: SurfaceCaptureRequest::Capture { capacity: 8 },
                     implementation_diagnostics: SurfaceCaptureRequest::Capture { capacity: 8 },
+                    ..ParserObservationConfig::default()
                 },
             )
             .expect("observed parser")
@@ -3301,6 +4144,8 @@ mod tests {
             implementation_diagnostics: ObservationRequest::Capture {
                 capacity: diagnostic_capacity,
             },
+            transitions: ObservationRequest::NotRequested,
+            unsupported_features: ObservationRequest::NotRequested,
             document_mode,
             tree: ObservationRequest::NotRequested,
             patches: ObservationRequest::NotRequested,
@@ -3596,6 +4441,8 @@ mod tests {
                 tokens: ObservationRequest::NotRequested,
                 parse_errors: ObservationRequest::NotRequested,
                 implementation_diagnostics: ObservationRequest::NotRequested,
+                transitions: ObservationRequest::NotRequested,
+                unsupported_features: ObservationRequest::NotRequested,
                 document_mode: ScalarObservationRequest::Capture,
                 tree: ObservationRequest::NotRequested,
                 patches: ObservationRequest::NotRequested,
@@ -3613,6 +4460,8 @@ mod tests {
             tokens: ObservationRequest::NotRequested,
             parse_errors: ObservationRequest::NotRequested,
             implementation_diagnostics: ObservationRequest::NotRequested,
+            transitions: ObservationRequest::NotRequested,
+            unsupported_features: ObservationRequest::NotRequested,
             document_mode: ScalarObservationRequest::Capture,
             tree: ObservationRequest::NotRequested,
             patches: ObservationRequest::NotRequested,
@@ -3639,6 +4488,8 @@ mod tests {
             tokens: ObservationRequest::NotRequested,
             parse_errors: ObservationRequest::NotRequested,
             implementation_diagnostics: ObservationRequest::NotRequested,
+            transitions: ObservationRequest::NotRequested,
+            unsupported_features: ObservationRequest::NotRequested,
             document_mode: ScalarObservationRequest::NotRequested,
             tree: ObservationRequest::Capture { capacity: 256 },
             patches: ObservationRequest::Capture { capacity: 512 },
@@ -3848,6 +4699,8 @@ mod tests {
             tokens: ObservationRequest::NotRequested,
             parse_errors: ObservationRequest::NotRequested,
             implementation_diagnostics: ObservationRequest::NotRequested,
+            transitions: ObservationRequest::NotRequested,
+            unsupported_features: ObservationRequest::NotRequested,
             document_mode: ScalarObservationRequest::NotRequested,
             tree: ObservationRequest::NotRequested,
             patches: ObservationRequest::Capture { capacity },
@@ -3902,6 +4755,8 @@ mod tests {
             tokens: ObservationRequest::NotRequested,
             parse_errors: ObservationRequest::NotRequested,
             implementation_diagnostics: ObservationRequest::NotRequested,
+            transitions: ObservationRequest::Capture { capacity: 32 },
+            unsupported_features: ObservationRequest::NotRequested,
             document_mode: ScalarObservationRequest::NotRequested,
             tree: ObservationRequest::Capture { capacity: 32 },
             patches: ObservationRequest::Capture { capacity: 32 },
@@ -3940,6 +4795,8 @@ mod tests {
             tokens: ObservationRequest::NotRequested,
             parse_errors: ObservationRequest::NotRequested,
             implementation_diagnostics: ObservationRequest::NotRequested,
+            transitions: ObservationRequest::NotRequested,
+            unsupported_features: ObservationRequest::NotRequested,
             document_mode: ScalarObservationRequest::NotRequested,
             tree: ObservationRequest::Capture {
                 capacity: depth + 5,
diff --git a/crates/html/src/conformance/mod.rs b/crates/html/src/conformance/mod.rs
index a8b782ec..537fb184 100644
--- a/crates/html/src/conformance/mod.rs
+++ b/crates/html/src/conformance/mod.rs
@@ -17,13 +17,16 @@ pub use crate::html5::shared::{
     ParserGuardrail, ParserGuardrailPayload, ParserRecoveryAction, ParserResourceLimit,
     ParserResourceLimitPayload, ParserStage, ParserTokenKind, PositionUnavailableReason,
     SourceBytePosition, SourcePositionUnavailableReason, TokenizerExtensionParseErrorCode,
-    TreeConstructionImplementationDiagnosticCode, TreeConstructionParseErrorCode,
-    Utf8ReplacementPayload, Utf8ReplacementReason, WhatwgParseErrorCode,
+    TransitionTokenSummary, TreeConstructionImplementationDiagnosticCode,
+    TreeConstructionParseErrorCode, TreeConstructionUnsupportedFeature, TreeDispatchPath,
+    TreeTransitionEvent, UnsupportedFeatureEvent, Utf8ReplacementPayload, Utf8ReplacementReason,
+    WhatwgParseErrorCode,
 };
 pub use execution::{
     ObservationRequest, ObservationReservationSite, ObservationResourceExhaustion,
     ParserObservationExecutionError, ParserObservationInput, ParserObservationInvariantError,
     ParserObservationRequest, ParserObservationTarget, ParserTokenizerInvariantError,
-    ScalarObservationRequest, execute_parser_observation,
+    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 717acf3f..e305ca60 100644
--- a/crates/html/src/conformance/model.rs
+++ b/crates/html/src/conformance/model.rs
@@ -4,8 +4,8 @@
 //! public web-platform API and are available only with `parser-conformance`.
 
 use crate::html5::shared::{
-    ImplementationDiagnosticEvent, ObservedInsertionMode, ObservedToken, ParseErrorEvent,
-    ParserContextSummary,
+    ImplementationDiagnosticEvent, ObservedToken, ParseErrorEvent, TreeTransitionEvent,
+    UnsupportedFeatureEvent,
 };
 use crate::{AttributeNamespace, DocumentMode, ElementNamespace};
 
@@ -199,52 +199,6 @@ pub enum ObservedPatchOperation {
     },
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum TreeDispatchPath {
-    HtmlInsertionMode(ObservedInsertionMode),
-    SharedTemplateRules,
-    ForeignContent,
-    TextMode,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum TransitionTokenSummary {
-    Doctype,
-    StartTag { name: String, self_closing: bool },
-    EndTag { name: String },
-    Character { data: String },
-    Comment,
-    ProcessingInstruction { target: String },
-    Eof,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct TreeTransitionEvent {
-    pub occurrence: u64,
-    pub token: TransitionTokenSummary,
-    pub insertion_mode_before: ObservedInsertionMode,
-    pub dispatch_path: TreeDispatchPath,
-    pub insertion_mode_after: ObservedInsertionMode,
-    pub reprocessed: bool,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct UnsupportedFeatureEvent {
-    pub occurrence: u64,
-    pub classification: UnsupportedFeatureClassification,
-    pub context: Option<ParserContextSummary>,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum UnsupportedFeatureClassification {
-    UnsupportedInputPreprocessingBranch,
-    UnsupportedTokenizerBranch,
-    UnsupportedTreeConstructionRule,
-    DeferredFragmentParsing,
-    DeferredScriptingDependentParsing,
-    PartialForeignContentBranch,
-}
-
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct ParserFinalizationReport {
     pub input: InputFinalizationChecks,
diff --git a/crates/html/src/html5/session/tests/text_mode.rs b/crates/html/src/html5/session/tests/text_mode.rs
index 3460bb6f..53a24e32 100644
--- a/crates/html/src/html5/session/tests/text_mode.rs
+++ b/crates/html/src/html5/session/tests/text_mode.rs
@@ -102,6 +102,7 @@ fn parser_observations_do_not_change_text_mode_tokenizer_controls() {
                     tokens: SurfaceCaptureRequest::Capture { capacity: 64 },
                     parse_errors: SurfaceCaptureRequest::Capture { capacity: 64 },
                     implementation_diagnostics: SurfaceCaptureRequest::Capture { capacity: 64 },
+                    ..ParserObservationConfig::default()
                 },
             )
         } else {
@@ -212,8 +213,7 @@ fn parser_observations_do_not_change_text_mode_tokenizer_controls() {
     assert_eq!(observed.document_mode, unobserved.document_mode);
 
     let capture = observed.capture.expect("explicit observation capture");
-    assert_eq!(capture.invariant, None);
-    assert!(!capture.token_capture_failed);
+    assert_eq!(capture.failure, None);
     assert_eq!(capture.tokens.dropped, 0);
     assert_eq!(capture.parse_errors.dropped, 0);
     assert_eq!(capture.implementation_diagnostics.dropped, 0);
diff --git a/crates/html/src/html5/shared/context.rs b/crates/html/src/html5/shared/context.rs
index 3c6ec1ff..3a4218e0 100644
--- a/crates/html/src/html5/shared/context.rs
+++ b/crates/html/src/html5/shared/context.rs
@@ -9,7 +9,7 @@ use super::ParserFailureInjection;
 use super::ParserObservationCapture;
 use super::{
     AtomTable, Counters, ErrorOrigin, ErrorPolicy, Input, LegacyParseErrorCode,
-    NormalizedPositionIndex, ParseError, ParseErrorCode, ParserDiagnosticSink, ParserGuardrail,
+    NormalizedPositionIndex, ParseError, ParseErrorCode, ParserEventSink, ParserGuardrail,
     ParserObservationConfig, ParserObservationRecorder, ParserRecoveryAction, ParserResourceLimit,
     ParserStage, Utf8ReplacementPayload, Utf8ReplacementReason, WhatwgParseErrorCode,
 };
@@ -174,7 +174,7 @@ impl DocumentParseContext {
         legacy_aux: Option<u32>,
         legacy_code_override: Option<LegacyParseErrorCode>,
     ) {
-        let mut sink = ParserDiagnosticSink::new(
+        let mut sink = ParserEventSink::new(
             &mut self.counters,
             self.error_policy,
             &mut self.errors,
@@ -206,7 +206,7 @@ impl DocumentParseContext {
         position: usize,
         description: Option<&'static str>,
     ) {
-        let mut sink = ParserDiagnosticSink::new(
+        let mut sink = ParserEventSink::new(
             &mut self.counters,
             self.error_policy,
             &mut self.errors,
@@ -236,7 +236,7 @@ impl DocumentParseContext {
         position: usize,
         description: Option<&'static str>,
     ) {
-        let mut sink = ParserDiagnosticSink::new(
+        let mut sink = ParserEventSink::new(
             &mut self.counters,
             self.error_policy,
             &mut self.errors,
@@ -265,7 +265,7 @@ impl DocumentParseContext {
         reason: Utf8ReplacementReason,
         payload: Utf8ReplacementPayload,
     ) {
-        let mut sink = ParserDiagnosticSink::new(
+        let mut sink = ParserEventSink::new(
             &mut self.counters,
             self.error_policy,
             &mut self.errors,
@@ -309,6 +309,7 @@ impl DocumentParseContext {
                 implementation_diagnostics: super::SurfaceCaptureRequest::Capture {
                     capacity: 4_096,
                 },
+                ..ParserObservationConfig::default()
             });
         }
     }
@@ -517,8 +518,10 @@ mod tests {
         let parse_capture = parse_ctx.take_observations().expect("parse capture");
         assert!(parse_capture.parse_errors.items.is_empty());
         assert_eq!(
-            parse_capture.invariant,
-            Some(crate::html5::shared::ParserObservationInvariant::NormalizedPositionIndexMissing)
+            parse_capture.failure,
+            Some(crate::html5::shared::ParserObservationFailure::Invariant(
+                crate::html5::shared::ParserObservationInvariant::NormalizedPositionIndexMissing
+            ))
         );
 
         let mut diagnostic_ctx = observed_context(0, 1);
@@ -540,8 +543,10 @@ mod tests {
                 .is_empty()
         );
         assert_eq!(
-            diagnostic_capture.invariant,
-            Some(crate::html5::shared::ParserObservationInvariant::NormalizedPositionIndexMissing)
+            diagnostic_capture.failure,
+            Some(crate::html5::shared::ParserObservationFailure::Invariant(
+                crate::html5::shared::ParserObservationInvariant::NormalizedPositionIndexMissing
+            ))
         );
     }
 
@@ -802,8 +807,10 @@ mod tests {
         assert!(capture.parse_errors.items.is_empty());
         assert!(capture.implementation_diagnostics.items.is_empty());
         assert_eq!(
-            capture.invariant,
-            Some(super::super::ParserObservationInvariant::InvalidNormalizedPositionOffset)
+            capture.failure,
+            Some(super::super::ParserObservationFailure::Invariant(
+                super::super::ParserObservationInvariant::InvalidNormalizedPositionOffset
+            ))
         );
     }
 }
diff --git a/crates/html/src/html5/shared/diagnostics.rs b/crates/html/src/html5/shared/event_sink.rs
similarity index 87%
rename from crates/html/src/html5/shared/diagnostics.rs
rename to crates/html/src/html5/shared/event_sink.rs
index 6997cbb1..11d2ddb6 100644
--- a/crates/html/src/html5/shared/diagnostics.rs
+++ b/crates/html/src/html5/shared/event_sink.rs
@@ -1,4 +1,4 @@
-//! Shared parser-owned diagnostic fanout.
+//! Shared parser-owned diagnostic and semantic-observation fanout.
 
 use super::{
     Counters, DiagnosticEventMetadata, ErrorOrigin, ErrorPolicy, EventPosition,
@@ -7,7 +7,8 @@ use super::{
     ParseErrorEvent, ParserContextSummary, ParserGuardrail, ParserGuardrailPayload,
     ParserObservationRecorder, ParserRecoveryAction, ParserResourceLimit,
     ParserResourceLimitPayload, ParserStage, PositionUnavailableReason,
-    TreeConstructionImplementationDiagnosticCode, Utf8ReplacementPayload, Utf8ReplacementReason,
+    TreeConstructionImplementationDiagnosticCode, TreeTransitionEvent, UnsupportedFeatureEvent,
+    UnsupportedFeatureObservationFailure, Utf8ReplacementPayload, Utf8ReplacementReason,
 };
 use std::collections::VecDeque;
 
@@ -20,14 +21,14 @@ pub(crate) struct LegacyDiagnosticProjection {
     pub(crate) aux: Option<u32>,
 }
 
-pub(crate) struct ParserDiagnosticSink<'a> {
+pub(crate) struct ParserEventSink<'a> {
     counters: &'a mut Counters,
     error_policy: ErrorPolicy,
     errors: &'a mut Option<VecDeque<ParseError>>,
     observations: &'a mut Option<ParserObservationRecorder>,
 }
 
-impl<'a> ParserDiagnosticSink<'a> {
+impl<'a> ParserEventSink<'a> {
     pub(crate) fn new(
         counters: &'a mut Counters,
         error_policy: ErrorPolicy,
@@ -307,6 +308,51 @@ impl<'a> ParserDiagnosticSink<'a> {
         );
     }
 
+    pub(crate) fn reserve_tree_transition(&mut self) -> Option<u64> {
+        self.observations
+            .as_mut()
+            .and_then(ParserObservationRecorder::reserve_tree_transition)
+    }
+
+    pub(crate) fn retain_tree_transition(&mut self, event: TreeTransitionEvent) {
+        if let Some(recorder) = self.observations.as_mut() {
+            recorder.retain_tree_transition(event);
+        }
+    }
+
+    pub(crate) fn record_tree_transition_capture_failure(&mut self) {
+        if let Some(recorder) = self.observations.as_mut() {
+            recorder.record_tree_transition_capture_failure();
+        }
+    }
+
+    pub(crate) fn unsupported_features_requested(&self) -> bool {
+        self.observations
+            .as_ref()
+            .is_some_and(ParserObservationRecorder::unsupported_features_requested)
+    }
+
+    pub(crate) fn reserve_unsupported_feature(&mut self) -> Option<u64> {
+        self.observations
+            .as_mut()
+            .and_then(ParserObservationRecorder::reserve_unsupported_feature)
+    }
+
+    pub(crate) fn retain_unsupported_feature(&mut self, event: UnsupportedFeatureEvent) {
+        if let Some(recorder) = self.observations.as_mut() {
+            recorder.retain_unsupported_feature(event);
+        }
+    }
+
+    pub(crate) fn record_unsupported_feature_observation_failure(
+        &mut self,
+        failure: UnsupportedFeatureObservationFailure,
+    ) {
+        if let Some(recorder) = self.observations.as_mut() {
+            recorder.record_unsupported_feature_observation_failure(failure);
+        }
+    }
+
     fn record_implementation_diagnostic_known(
         &mut self,
         input: &Input,
diff --git a/crates/html/src/html5/shared/mod.rs b/crates/html/src/html5/shared/mod.rs
index 0961b44e..fef337b1 100644
--- a/crates/html/src/html5/shared/mod.rs
+++ b/crates/html/src/html5/shared/mod.rs
@@ -6,8 +6,8 @@
 mod atom;
 mod context;
 mod counters;
-mod diagnostics;
 mod error;
+mod event_sink;
 mod input;
 mod observation;
 mod observation_model;
@@ -18,22 +18,23 @@ mod token;
 pub use atom::{AtomError, AtomId, AtomTable};
 pub use context::DocumentParseContext;
 pub use counters::Counters;
-pub(crate) use diagnostics::{LegacyDiagnosticProjection, ParserDiagnosticSink};
 #[allow(unused_imports)]
 pub use error::{
     EngineInvariantError, ErrorOrigin, ErrorPolicy, Html5SessionError, LegacyParseErrorCode,
     ParseError, ParserFatalError, ParserReservationSite, ParserResourceExhaustion,
 };
+pub(crate) use event_sink::{LegacyDiagnosticProjection, ParserEventSink};
 #[allow(unused_imports)]
 pub use input::{ByteStreamDecoder, DecodeResult, Input};
 #[cfg(any(test, feature = "parser-conformance"))]
 pub(crate) use observation::{
     CapturedSurface, ObservationOccurrenceSequence, ObservationSurface, ParserObservationCapture,
-    ParserObservationInvariant, SurfaceCaptureRequest,
+    ParserObservationCaptureFailure, ParserObservationFailure, ParserObservationInvariant,
+    SurfaceCaptureRequest,
 };
 pub(crate) use observation::{
     NormalizedPositionIndex, ObservationPositionResolution, ObservationPositionSource,
-    ParserObservationConfig, ParserObservationRecorder,
+    ParserObservationConfig, ParserObservationRecorder, UnsupportedFeatureObservationFailure,
 };
 pub use observation_model::*;
 #[cfg(all(
diff --git a/crates/html/src/html5/shared/observation.rs b/crates/html/src/html5/shared/observation.rs
index 0050d472..cb46c03f 100644
--- a/crates/html/src/html5/shared/observation.rs
+++ b/crates/html/src/html5/shared/observation.rs
@@ -1,9 +1,12 @@
 //! Passive, bounded observation storage owned by the production parser.
 
+#[cfg(test)]
+use super::TransitionTokenSummary;
 use super::{
     ImplementationDiagnosticEvent, InputCoordinateSpace, InputPosition, NormalizedInputPosition,
     NormalizedLineNumber, NormalizedScalarColumn, ObservedToken, ParseErrorEvent,
     PositionUnavailableReason, SourceBytePosition, SourcePositionUnavailableReason,
+    TreeTransitionEvent, UnsupportedFeatureEvent,
 };
 
 const POSITION_CHECKPOINT_STRIDE: u64 = 256;
@@ -12,6 +15,8 @@ const POSITION_CHECKPOINT_STRIDE: u64 = 256;
 pub(crate) enum ObservationOccurrenceSequence {
     ParseErrors,
     ImplementationDiagnostics,
+    TreeTransitions,
+    UnsupportedFeatures,
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -19,6 +24,8 @@ pub(crate) enum ObservationSurface {
     Tokens,
     ParseErrors,
     ImplementationDiagnostics,
+    TreeTransitions,
+    UnsupportedFeatures,
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -35,6 +42,27 @@ pub(crate) enum ParserObservationInvariant {
     PatchDroppedCountOverflow,
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum UnsupportedFeatureObservationFailure {
+    TokenAttributeNameUnavailable,
+    ExistingHtmlElementSemanticsUnavailable,
+    ExistingBodyElementSemanticsUnavailable,
+    ExistingElementIdentityContradiction,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum ParserObservationCaptureFailure {
+    TokenCanonicalization,
+    TreeTransitionTokenCanonicalization,
+    UnsupportedFeatureEligibility(UnsupportedFeatureObservationFailure),
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum ParserObservationFailure {
+    Capture(ParserObservationCaptureFailure),
+    Invariant(ParserObservationInvariant),
+}
+
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub(crate) enum ObservationPositionSource {
     NormalizedOffset(usize),
@@ -73,6 +101,8 @@ pub(crate) struct ParserObservationConfig {
     pub(crate) tokens: SurfaceCaptureRequest,
     pub(crate) parse_errors: SurfaceCaptureRequest,
     pub(crate) implementation_diagnostics: SurfaceCaptureRequest,
+    pub(crate) tree_transitions: SurfaceCaptureRequest,
+    pub(crate) unsupported_features: SurfaceCaptureRequest,
 }
 
 impl ParserObservationConfig {
@@ -83,6 +113,11 @@ impl ParserObservationConfig {
                 self.implementation_diagnostics,
                 SurfaceCaptureRequest::NotRequested
             )
+            || !matches!(self.tree_transitions, SurfaceCaptureRequest::NotRequested)
+            || !matches!(
+                self.unsupported_features,
+                SurfaceCaptureRequest::NotRequested
+            )
     }
 }
 
@@ -147,12 +182,15 @@ impl<T> BoundedCapture<T> {
 pub(crate) struct ParserObservationRecorder {
     next_parse_error_occurrence: Option<u64>,
     next_implementation_diagnostic_occurrence: Option<u64>,
+    next_tree_transition_occurrence: Option<u64>,
+    next_unsupported_feature_occurrence: Option<u64>,
     tokens: BoundedCapture<ObservedToken>,
     parse_errors: BoundedCapture<ParseErrorEvent>,
     implementation_diagnostics: BoundedCapture<ImplementationDiagnosticEvent>,
+    tree_transitions: BoundedCapture<TreeTransitionEvent>,
+    unsupported_features: BoundedCapture<UnsupportedFeatureEvent>,
     position_index: Option<NormalizedPositionIndex>,
-    token_capture_failed: bool,
-    invariant: Option<ParserObservationInvariant>,
+    failure: Option<ParserObservationFailure>,
 }
 
 impl ParserObservationRecorder {
@@ -171,12 +209,15 @@ impl ParserObservationRecorder {
         Some(Self {
             next_parse_error_occurrence: Some(1),
             next_implementation_diagnostic_occurrence: Some(1),
+            next_tree_transition_occurrence: Some(1),
+            next_unsupported_feature_occurrence: Some(1),
             tokens: BoundedCapture::new(config.tokens),
             parse_errors: BoundedCapture::new(config.parse_errors),
             implementation_diagnostics: BoundedCapture::new(config.implementation_diagnostics),
+            tree_transitions: BoundedCapture::new(config.tree_transitions),
+            unsupported_features: BoundedCapture::new(config.unsupported_features),
             position_index: position_requested.then(NormalizedPositionIndex::new),
-            token_capture_failed: false,
-            invariant: None,
+            failure: None,
         })
     }
 
@@ -201,7 +242,7 @@ impl ParserObservationRecorder {
     }
 
     pub(crate) fn record_token_capture_failure(&mut self) {
-        self.token_capture_failed = true;
+        self.record_capture_failure(ParserObservationCaptureFailure::TokenCanonicalization);
     }
 
     /// Assign the next parse-error occurrence before applying capacity.
@@ -277,6 +318,91 @@ impl ParserObservationRecorder {
         self.disable_position_index_if_exhausted();
     }
 
+    /// Assign the next tree-transition occurrence before applying capacity.
+    pub(crate) fn reserve_tree_transition(&mut self) -> Option<u64> {
+        if !self.tree_transitions.is_requested() {
+            return None;
+        }
+        let Some(occurrence) = self.next_tree_transition_occurrence else {
+            self.record_invariant(ParserObservationInvariant::OccurrenceSequenceOverflow(
+                ObservationOccurrenceSequence::TreeTransitions,
+            ));
+            return None;
+        };
+        self.next_tree_transition_occurrence = occurrence.checked_add(1);
+        if self.next_tree_transition_occurrence.is_none() {
+            self.record_invariant(ParserObservationInvariant::OccurrenceSequenceOverflow(
+                ObservationOccurrenceSequence::TreeTransitions,
+            ));
+        }
+        if self.tree_transitions.can_retain() {
+            Some(occurrence)
+        } else {
+            if !self.tree_transitions.record_drop() {
+                self.record_invariant(ParserObservationInvariant::DroppedCountOverflow(
+                    ObservationSurface::TreeTransitions,
+                ));
+            }
+            None
+        }
+    }
+
+    pub(crate) fn retain_tree_transition(&mut self, event: TreeTransitionEvent) {
+        self.tree_transitions.push_reserved(event);
+    }
+
+    pub(crate) fn unsupported_features_requested(&self) -> bool {
+        self.unsupported_features.is_requested()
+    }
+
+    /// Assign the next unsupported-feature occurrence before applying capacity.
+    pub(crate) fn reserve_unsupported_feature(&mut self) -> Option<u64> {
+        if !self.unsupported_features.is_requested() {
+            return None;
+        }
+        let Some(occurrence) = self.next_unsupported_feature_occurrence else {
+            self.record_invariant(ParserObservationInvariant::OccurrenceSequenceOverflow(
+                ObservationOccurrenceSequence::UnsupportedFeatures,
+            ));
+            return None;
+        };
+        self.next_unsupported_feature_occurrence = occurrence.checked_add(1);
+        if self.next_unsupported_feature_occurrence.is_none() {
+            self.record_invariant(ParserObservationInvariant::OccurrenceSequenceOverflow(
+                ObservationOccurrenceSequence::UnsupportedFeatures,
+            ));
+        }
+        if self.unsupported_features.can_retain() {
+            Some(occurrence)
+        } else {
+            if !self.unsupported_features.record_drop() {
+                self.record_invariant(ParserObservationInvariant::DroppedCountOverflow(
+                    ObservationSurface::UnsupportedFeatures,
+                ));
+            }
+            None
+        }
+    }
+
+    pub(crate) fn retain_unsupported_feature(&mut self, event: UnsupportedFeatureEvent) {
+        self.unsupported_features.push_reserved(event);
+    }
+
+    pub(crate) fn record_tree_transition_capture_failure(&mut self) {
+        self.record_capture_failure(
+            ParserObservationCaptureFailure::TreeTransitionTokenCanonicalization,
+        );
+    }
+
+    pub(crate) fn record_unsupported_feature_observation_failure(
+        &mut self,
+        failure: UnsupportedFeatureObservationFailure,
+    ) {
+        self.record_capture_failure(
+            ParserObservationCaptureFailure::UnsupportedFeatureEligibility(failure),
+        );
+    }
+
     pub(crate) fn position_index_mut(&mut self) -> Option<&mut NormalizedPositionIndex> {
         self.position_index.as_mut()
     }
@@ -322,8 +448,16 @@ impl ParserObservationRecorder {
     }
 
     fn record_invariant(&mut self, invariant: ParserObservationInvariant) {
-        if self.invariant.is_none() {
-            self.invariant = Some(invariant);
+        self.record_failure(ParserObservationFailure::Invariant(invariant));
+    }
+
+    fn record_capture_failure(&mut self, failure: ParserObservationCaptureFailure) {
+        self.record_failure(ParserObservationFailure::Capture(failure));
+    }
+
+    fn record_failure(&mut self, failure: ParserObservationFailure) {
+        if self.failure.is_none() {
+            self.failure = Some(failure);
         }
     }
 
@@ -338,8 +472,9 @@ impl ParserObservationRecorder {
             tokens: self.tokens.finish(),
             parse_errors: self.parse_errors.finish(),
             implementation_diagnostics: self.implementation_diagnostics.finish(),
-            token_capture_failed: self.token_capture_failed,
-            invariant: self.invariant,
+            tree_transitions: self.tree_transitions.finish(),
+            unsupported_features: self.unsupported_features.finish(),
+            failure: self.failure,
         }
     }
 
@@ -372,8 +507,9 @@ pub(crate) struct ParserObservationCapture {
     pub(crate) tokens: CapturedSurface<ObservedToken>,
     pub(crate) parse_errors: CapturedSurface<ParseErrorEvent>,
     pub(crate) implementation_diagnostics: CapturedSurface<ImplementationDiagnosticEvent>,
-    pub(crate) token_capture_failed: bool,
-    pub(crate) invariant: Option<ParserObservationInvariant>,
+    pub(crate) tree_transitions: CapturedSurface<TreeTransitionEvent>,
+    pub(crate) unsupported_features: CapturedSurface<UnsupportedFeatureEvent>,
+    pub(crate) failure: Option<ParserObservationFailure>,
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -629,7 +765,7 @@ mod tests {
         assert_eq!(recorder.position_checkpoint_count(), 0);
         assert_eq!(recorder.reserve_parse_error(), None);
         assert_eq!(
-            recorder.finish().invariant,
+            recorder.finish().failure,
             None,
             "intentional bounded-work index retirement is not corruption"
         );
@@ -656,9 +792,11 @@ mod tests {
             vec![u64::MAX]
         );
         assert_eq!(
-            capture.invariant,
-            Some(ParserObservationInvariant::OccurrenceSequenceOverflow(
-                ObservationOccurrenceSequence::ParseErrors
+            capture.failure,
+            Some(ParserObservationFailure::Invariant(
+                ParserObservationInvariant::OccurrenceSequenceOverflow(
+                    ObservationOccurrenceSequence::ParseErrors
+                )
             ))
         );
     }
@@ -684,9 +822,11 @@ mod tests {
             vec![u64::MAX]
         );
         assert_eq!(
-            capture.invariant,
-            Some(ParserObservationInvariant::OccurrenceSequenceOverflow(
-                ObservationOccurrenceSequence::ImplementationDiagnostics
+            capture.failure,
+            Some(ParserObservationFailure::Invariant(
+                ParserObservationInvariant::OccurrenceSequenceOverflow(
+                    ObservationOccurrenceSequence::ImplementationDiagnostics
+                )
             ))
         );
     }
@@ -703,9 +843,11 @@ mod tests {
         let parse_capture = parse_recorder.finish();
         assert_eq!(parse_capture.parse_errors.dropped, 1);
         assert_eq!(
-            parse_capture.invariant,
-            Some(ParserObservationInvariant::OccurrenceSequenceOverflow(
-                ObservationOccurrenceSequence::ParseErrors
+            parse_capture.failure,
+            Some(ParserObservationFailure::Invariant(
+                ParserObservationInvariant::OccurrenceSequenceOverflow(
+                    ObservationOccurrenceSequence::ParseErrors
+                )
             ))
         );
 
@@ -722,9 +864,11 @@ mod tests {
         let diagnostic_capture = diagnostic_recorder.finish();
         assert_eq!(diagnostic_capture.implementation_diagnostics.dropped, 1);
         assert_eq!(
-            diagnostic_capture.invariant,
-            Some(ParserObservationInvariant::OccurrenceSequenceOverflow(
-                ObservationOccurrenceSequence::ImplementationDiagnostics
+            diagnostic_capture.failure,
+            Some(ParserObservationFailure::Invariant(
+                ParserObservationInvariant::OccurrenceSequenceOverflow(
+                    ObservationOccurrenceSequence::ImplementationDiagnostics
+                )
             ))
         );
     }
@@ -748,9 +892,11 @@ mod tests {
         assert_eq!(capture.parse_errors.items.len(), 0);
         assert_eq!(capture.parse_errors.dropped, u64::MAX);
         assert_eq!(
-            capture.invariant,
-            Some(ParserObservationInvariant::OccurrenceSequenceOverflow(
-                ObservationOccurrenceSequence::ParseErrors
+            capture.failure,
+            Some(ParserObservationFailure::Invariant(
+                ParserObservationInvariant::OccurrenceSequenceOverflow(
+                    ObservationOccurrenceSequence::ParseErrors
+                )
             ))
         );
     }
@@ -778,8 +924,10 @@ mod tests {
             vec![u64::MAX]
         );
         assert_eq!(
-            capture.invariant,
-            Some(ParserObservationInvariant::NormalizedPositionOverflow)
+            capture.failure,
+            Some(ParserObservationFailure::Invariant(
+                ParserObservationInvariant::NormalizedPositionOverflow
+            ))
         );
     }
 
@@ -793,9 +941,9 @@ mod tests {
         recorder.parse_errors.dropped = u64::MAX;
         assert_eq!(recorder.reserve_parse_error(), None);
         assert_eq!(
-            recorder.finish().invariant,
-            Some(ParserObservationInvariant::DroppedCountOverflow(
-                ObservationSurface::ParseErrors
+            recorder.finish().failure,
+            Some(ParserObservationFailure::Invariant(
+                ParserObservationInvariant::DroppedCountOverflow(ObservationSurface::ParseErrors)
             ))
         );
     }
@@ -857,8 +1005,10 @@ mod tests {
             )
         );
         assert_eq!(
-            recorder.finish().invariant,
-            Some(ParserObservationInvariant::InvalidNormalizedPositionOffset)
+            recorder.finish().failure,
+            Some(ParserObservationFailure::Invariant(
+                ParserObservationInvariant::InvalidNormalizedPositionOffset
+            ))
         );
     }
 
@@ -883,8 +1033,10 @@ mod tests {
         let capture = recorder.finish();
         assert!(capture.parse_errors.items.is_empty());
         assert_eq!(
-            capture.invariant,
-            Some(ParserObservationInvariant::NormalizedPositionIndexMissing)
+            capture.failure,
+            Some(ParserObservationFailure::Invariant(
+                ParserObservationInvariant::NormalizedPositionIndexMissing
+            ))
         );
     }
 
@@ -913,7 +1065,160 @@ mod tests {
 
         let capture = recorder.finish();
         assert_eq!(capture.parse_errors.items.len(), 1);
-        assert_eq!(capture.invariant, None);
+        assert_eq!(capture.failure, None);
+    }
+
+    #[test]
+    fn transition_and_unsupported_surfaces_have_independent_prefix_capacity() {
+        let mut recorder = ParserObservationRecorder::new(ParserObservationConfig {
+            tree_transitions: SurfaceCaptureRequest::Capture { capacity: 1 },
+            unsupported_features: SurfaceCaptureRequest::Capture { capacity: 0 },
+            ..ParserObservationConfig::default()
+        })
+        .unwrap();
+
+        let transition_occurrence = recorder.reserve_tree_transition().unwrap();
+        recorder.retain_tree_transition(TreeTransitionEvent {
+            occurrence: transition_occurrence,
+            token: std::sync::Arc::new(TransitionTokenSummary::Eof),
+            insertion_mode_before: super::super::ObservedInsertionMode::InBody,
+            dispatch_path: super::super::TreeDispatchPath::HtmlInsertionMode(
+                super::super::ObservedInsertionMode::InBody,
+            ),
+            insertion_mode_after: super::super::ObservedInsertionMode::InBody,
+            reprocessed: false,
+        });
+        assert_eq!(recorder.reserve_unsupported_feature(), None);
+        assert_eq!(recorder.reserve_tree_transition(), None);
+        assert_eq!(recorder.reserve_unsupported_feature(), None);
+
+        let capture = recorder.finish();
+        assert_eq!(capture.tree_transitions.items.len(), 1);
+        assert_eq!(capture.tree_transitions.items[0].occurrence, 1);
+        assert_eq!(capture.tree_transitions.dropped, 1);
+        assert!(capture.unsupported_features.items.is_empty());
+        assert_eq!(capture.unsupported_features.dropped, 2);
+        assert_eq!(capture.failure, None);
+    }
+
+    #[test]
+    fn one_failure_slot_preserves_cross_category_detection_order() {
+        let mut capture_first = ParserObservationRecorder::new(ParserObservationConfig {
+            tree_transitions: SurfaceCaptureRequest::Capture { capacity: 0 },
+            ..ParserObservationConfig::default()
+        })
+        .unwrap();
+        capture_first.record_tree_transition_capture_failure();
+        capture_first.next_tree_transition_occurrence = Some(u64::MAX);
+        assert_eq!(capture_first.reserve_tree_transition(), None);
+        assert_eq!(
+            capture_first.finish().failure,
+            Some(ParserObservationFailure::Capture(
+                ParserObservationCaptureFailure::TreeTransitionTokenCanonicalization
+            ))
+        );
+
+        let mut invariant_first = ParserObservationRecorder::new(ParserObservationConfig {
+            tree_transitions: SurfaceCaptureRequest::Capture { capacity: 0 },
+            ..ParserObservationConfig::default()
+        })
+        .unwrap();
+        invariant_first.next_tree_transition_occurrence = Some(u64::MAX);
+        assert_eq!(invariant_first.reserve_tree_transition(), None);
+        invariant_first.record_tree_transition_capture_failure();
+        assert_eq!(
+            invariant_first.finish().failure,
+            Some(ParserObservationFailure::Invariant(
+                ParserObservationInvariant::OccurrenceSequenceOverflow(
+                    ObservationOccurrenceSequence::TreeTransitions
+                )
+            ))
+        );
+    }
+
+    #[test]
+    fn capture_failure_precedes_later_dropped_count_overflow() {
+        let mut recorder = ParserObservationRecorder::new(ParserObservationConfig {
+            tree_transitions: SurfaceCaptureRequest::Capture { capacity: 0 },
+            ..ParserObservationConfig::default()
+        })
+        .unwrap();
+        recorder.record_tree_transition_capture_failure();
+        recorder.tree_transitions.dropped = u64::MAX;
+        assert_eq!(recorder.reserve_tree_transition(), None);
+        assert_eq!(
+            recorder.finish().failure,
+            Some(ParserObservationFailure::Capture(
+                ParserObservationCaptureFailure::TreeTransitionTokenCanonicalization
+            ))
+        );
+    }
+
+    #[test]
+    fn transition_and_unsupported_overflows_use_exact_surface_identities() {
+        let mut transition = ParserObservationRecorder::new(ParserObservationConfig {
+            tree_transitions: SurfaceCaptureRequest::Capture { capacity: 0 },
+            ..ParserObservationConfig::default()
+        })
+        .unwrap();
+        transition.next_tree_transition_occurrence = Some(u64::MAX);
+        assert_eq!(transition.reserve_tree_transition(), None);
+        assert_eq!(
+            transition.finish().failure,
+            Some(ParserObservationFailure::Invariant(
+                ParserObservationInvariant::OccurrenceSequenceOverflow(
+                    ObservationOccurrenceSequence::TreeTransitions
+                )
+            ))
+        );
+
+        let mut transition_drop = ParserObservationRecorder::new(ParserObservationConfig {
+            tree_transitions: SurfaceCaptureRequest::Capture { capacity: 0 },
+            ..ParserObservationConfig::default()
+        })
+        .unwrap();
+        transition_drop.tree_transitions.dropped = u64::MAX;
+        assert_eq!(transition_drop.reserve_tree_transition(), None);
+        assert_eq!(
+            transition_drop.finish().failure,
+            Some(ParserObservationFailure::Invariant(
+                ParserObservationInvariant::DroppedCountOverflow(
+                    ObservationSurface::TreeTransitions
+                )
+            ))
+        );
+
+        let mut unsupported_occurrence = ParserObservationRecorder::new(ParserObservationConfig {
+            unsupported_features: SurfaceCaptureRequest::Capture { capacity: 0 },
+            ..ParserObservationConfig::default()
+        })
+        .unwrap();
+        unsupported_occurrence.next_unsupported_feature_occurrence = Some(u64::MAX);
+        assert_eq!(unsupported_occurrence.reserve_unsupported_feature(), None);
+        assert_eq!(
+            unsupported_occurrence.finish().failure,
+            Some(ParserObservationFailure::Invariant(
+                ParserObservationInvariant::OccurrenceSequenceOverflow(
+                    ObservationOccurrenceSequence::UnsupportedFeatures
+                )
+            ))
+        );
+
+        let mut unsupported_drop = ParserObservationRecorder::new(ParserObservationConfig {
+            unsupported_features: SurfaceCaptureRequest::Capture { capacity: 0 },
+            ..ParserObservationConfig::default()
+        })
+        .unwrap();
+        unsupported_drop.unsupported_features.dropped = u64::MAX;
+        assert_eq!(unsupported_drop.reserve_unsupported_feature(), None);
+        assert_eq!(
+            unsupported_drop.finish().failure,
+            Some(ParserObservationFailure::Invariant(
+                ParserObservationInvariant::DroppedCountOverflow(
+                    ObservationSurface::UnsupportedFeatures
+                )
+            ))
+        );
     }
 
     #[test]
diff --git a/crates/html/src/html5/shared/observation_model.rs b/crates/html/src/html5/shared/observation_model.rs
index 0845584e..1cfcfd7d 100644
--- a/crates/html/src/html5/shared/observation_model.rs
+++ b/crates/html/src/html5/shared/observation_model.rs
@@ -6,6 +6,7 @@
 
 use crate::ElementNamespace;
 use std::num::NonZeroU64;
+use std::sync::Arc;
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct ObservedTokenAttribute {
@@ -236,16 +237,12 @@ pub enum ParserResourceLimit {
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 #[cfg_attr(not(any(test, feature = "parser-conformance")), allow(dead_code))]
 pub enum TreeConstructionImplementationDiagnosticCode {
-    HtmlElementAttributesNotMerged,
-    BodyElementAttributesNotMerged,
     UnsupportedTableInsertionModeFallback,
     UnexpectedStartTagTokenInTextMode,
     TextModeStartTagAttributeValuesDiscarded,
     TextModeStartTagAttributeNamesCanonicalized,
     UnexpectedDoctypeTokenInTextMode,
     UnexpectedEndTagTokenInTextMode,
-    MismatchedCellEndTagClosedOpenCell,
-    CaptionCloseImpliedEndTagsNotImplemented,
     NonVoidHtmlSelfClosingFlagAlteredStackDisposition,
 }
 
@@ -492,3 +489,51 @@ pub enum ObservedInsertionMode {
     InTemplate,
     Text,
 }
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum TreeDispatchPath {
+    HtmlInsertionMode(ObservedInsertionMode),
+    SharedTemplateRules,
+    ForeignContent,
+    TextMode,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum TransitionTokenSummary {
+    Doctype,
+    StartTag { name: String, self_closing: bool },
+    EndTag { name: String },
+    Character { data: String },
+    Comment,
+    ProcessingInstruction { target: String },
+    Eof,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct TreeTransitionEvent {
+    pub occurrence: u64,
+    pub token: Arc<TransitionTokenSummary>,
+    pub insertion_mode_before: ObservedInsertionMode,
+    pub dispatch_path: TreeDispatchPath,
+    pub insertion_mode_after: ObservedInsertionMode,
+    pub reprocessed: bool,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum TreeConstructionUnsupportedFeature {
+    MergeAttributesIntoExistingHtmlElement,
+    MergeAttributesIntoExistingBodyElement,
+    MarkFramesetNotOkForRepeatedBodyStartTag,
+    RequireSameNamedTableCellInScopeForEndTag,
+    GenerateImpliedEndTagsAndCheckCurrentNodeBeforeClosingTableCell,
+    GenerateImpliedEndTagsAndCheckCurrentNodeBeforeClosingCaption,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum UnsupportedFeatureEvent {
+    TreeConstruction {
+        occurrence: u64,
+        feature: TreeConstructionUnsupportedFeature,
+        context: ParserContextSummary,
+    },
+}
diff --git a/crates/html/src/html5/tree_builder/api.rs b/crates/html/src/html5/tree_builder/api.rs
index 945e69b5..c8d9bc4f 100644
--- a/crates/html/src/html5/tree_builder/api.rs
+++ b/crates/html/src/html5/tree_builder/api.rs
@@ -728,6 +728,22 @@ impl Html5TreeBuilder {
         );
     }
 
+    pub(in crate::html5::tree_builder) fn record_tree_unsupported_feature(
+        &self,
+        context: &mut TreeBuilderProcessContext<'_>,
+        feature: crate::html5::shared::TreeConstructionUnsupportedFeature,
+    ) {
+        let Some(occurrence) = context.reserve_unsupported_feature() else {
+            return;
+        };
+        context.retain_unsupported_feature(
+            occurrence,
+            feature,
+            self.insertion_mode,
+            self.adjusted_current_node_namespace(),
+        );
+    }
+
     pub(in crate::html5::tree_builder) fn record_tree_resource_limit(
         &self,
         context: &mut TreeBuilderProcessContext<'_>,
diff --git a/crates/html/src/html5/tree_builder/attributes.rs b/crates/html/src/html5/tree_builder/attributes.rs
index 63995a25..14c20dfd 100644
--- a/crates/html/src/html5/tree_builder/attributes.rs
+++ b/crates/html/src/html5/tree_builder/attributes.rs
@@ -1,5 +1,5 @@
 use crate::attributes::ParserCreatedAttribute;
-use crate::html5::shared::{AtomTable, Attribute};
+use crate::html5::shared::{AtomTable, Attribute, UnsupportedFeatureObservationFailure};
 use crate::html5::tokenizer::TextResolver;
 use crate::html5::tree_builder::TreeBuilderError;
 use crate::html5::tree_builder::resolve::resolve_attribute_value;
@@ -43,6 +43,38 @@ pub(in crate::html5::tree_builder) fn resolve_afe_attributes_first_wins(
     attrs.to_vec()
 }
 
+/// Returns whether the applicable repeated-html/body rule would need to add
+/// at least one unqualified token attribute to the authoritative live element.
+///
+/// This is observation-only: it neither resolves values nor mutates the
+/// parser-created element. The quadratic first-wins scan avoids observer-owned
+/// allocation and matches the canonical token attribute semantics.
+pub(in crate::html5::tree_builder) fn has_missing_unqualified_token_attribute_first_wins(
+    attrs: &[Attribute],
+    existing: &[ParserCreatedAttribute],
+    atoms: &AtomTable,
+) -> Result<bool, UnsupportedFeatureObservationFailure> {
+    for (index, attr) in attrs.iter().enumerate() {
+        if attrs[..index]
+            .iter()
+            .any(|earlier| earlier.name == attr.name)
+        {
+            continue;
+        }
+        let local_name = atoms
+            .resolve(attr.name)
+            .ok_or(UnsupportedFeatureObservationFailure::TokenAttributeNameUnavailable)?;
+        let already_present = existing.iter().any(|existing| {
+            existing.namespace() == crate::attributes::AttributeNamespace::None
+                && existing.local_name() == local_name
+        });
+        if !already_present {
+            return Ok(true);
+        }
+    }
+    Ok(false)
+}
+
 /// HTML tree-construction "same attributes" comparison.
 ///
 /// Encounter order and prefix do not participate. Parser-created lists contain
@@ -64,8 +96,11 @@ pub(in crate::html5::tree_builder) fn same_attributes_for_html_parser(
 
 #[cfg(test)]
 mod tests {
-    use super::same_attributes_for_html_parser;
+    use super::{
+        has_missing_unqualified_token_attribute_first_wins, same_attributes_for_html_parser,
+    };
     use crate::attributes::{ParserCreatedAttribute, QualifiedAttributeName};
+    use crate::html5::shared::{AtomTable, Attribute, AttributeValue};
     use crate::names::NameInterner;
 
     #[test]
@@ -117,4 +152,64 @@ mod tests {
         );
         assert!(!same_attributes_for_html_parser(&first, &changed_value));
     }
+
+    #[test]
+    fn repeated_element_merge_eligibility_is_first_wins_and_expanded_name_only() {
+        let mut atoms = AtomTable::default();
+        let a = atoms.intern_ascii_folded("a").unwrap();
+        let b = atoms.intern_ascii_folded("b").unwrap();
+        let a_local = atoms.resolve_local_name(a).unwrap();
+        let existing = vec![ParserCreatedAttribute::new(
+            QualifiedAttributeName::unqualified(a_local.clone()),
+            "old".to_string(),
+        )];
+        let token_attribute = |name, value: &str| Attribute {
+            name,
+            value: AttributeValue::Owned(value.to_string()),
+        };
+
+        assert!(
+            !has_missing_unqualified_token_attribute_first_wins(&[], &existing, &atoms).unwrap()
+        );
+        assert!(
+            !has_missing_unqualified_token_attribute_first_wins(
+                &[token_attribute(a, "different")],
+                &existing,
+                &atoms
+            )
+            .unwrap()
+        );
+        assert!(
+            !has_missing_unqualified_token_attribute_first_wins(
+                &[token_attribute(a, "first"), token_attribute(a, "duplicate")],
+                &existing,
+                &atoms
+            )
+            .unwrap()
+        );
+        assert!(
+            has_missing_unqualified_token_attribute_first_wins(
+                &[
+                    token_attribute(a, "existing"),
+                    token_attribute(b, "missing")
+                ],
+                &existing,
+                &atoms
+            )
+            .unwrap()
+        );
+
+        let namespaced_only = vec![ParserCreatedAttribute::new(
+            QualifiedAttributeName::xlink(a_local),
+            "old".to_string(),
+        )];
+        assert!(
+            has_missing_unqualified_token_attribute_first_wins(
+                &[token_attribute(a, "unqualified")],
+                &namespaced_only,
+                &atoms
+            )
+            .unwrap()
+        );
+    }
 }
diff --git a/crates/html/src/html5/tree_builder/dispatch/drive.rs b/crates/html/src/html5/tree_builder/dispatch/drive.rs
index 8cf5441a..8b536332 100644
--- a/crates/html/src/html5/tree_builder/dispatch/drive.rs
+++ b/crates/html/src/html5/tree_builder/dispatch/drive.rs
@@ -1,14 +1,31 @@
 use crate::dom_patch::PatchKey;
-use crate::html5::shared::{EngineInvariantError, Token};
+use crate::html5::shared::{EngineInvariantError, Token, TreeDispatchPath};
 use crate::html5::tokenizer::TextResolver;
 use crate::html5::tree_builder::formatting::AfeDiagnosticEntry;
 use crate::html5::tree_builder::modes::InsertionMode;
+use crate::html5::tree_builder::observation::{
+    LogicalTokenSummaryCache, PendingTreeTransition, prepare_tree_transition,
+};
 use crate::html5::tree_builder::process_context::TreeBuilderProcessContext;
 use crate::html5::tree_builder::template_state::TemplateInsertionMode;
 use crate::html5::tree_builder::{Html5TreeBuilder, TreeBuilderError, TreeBuilderStepResult};
 use crate::{ExpandedElementName, ParserCreatedAttribute};
 use std::collections::HashMap;
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+enum DispatchSelectionScope {
+    Normal,
+    HtmlRulesOnly,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum SelectedDispatchPath {
+    HtmlInsertionMode(InsertionMode),
+    SharedTemplateRules,
+    ForeignContent,
+    TextMode,
+}
+
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 struct SemanticFingerprint {
     first: u64,
@@ -37,6 +54,7 @@ impl SemanticFingerprint {
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 struct ReprocessFingerprint {
     mode: InsertionMode,
+    selection_scope: DispatchSelectionScope,
     original_mode: Option<InsertionMode>,
     pending_table_mode: Option<InsertionMode>,
     open_elements: SemanticFingerprint,
@@ -71,6 +89,7 @@ struct ExactAdjustedCurrentNode {
 #[derive(Clone, Debug, PartialEq, Eq)]
 struct ExactReprocessState {
     mode: InsertionMode,
+    selection_scope: DispatchSelectionScope,
     original_mode: Option<InsertionMode>,
     pending_table_mode: Option<InsertionMode>,
     open_elements: Vec<PatchKey>,
@@ -113,6 +132,7 @@ impl ExactReprocessState {
         );
         ReprocessFingerprint {
             mode: self.mode,
+            selection_scope: self.selection_scope,
             original_mode: self.original_mode,
             pending_table_mode: self.pending_table_mode,
             open_elements,
@@ -205,6 +225,7 @@ impl ReprocessStateTracker {
 fn forced_collision_fingerprint() -> ReprocessFingerprint {
     ReprocessFingerprint {
         mode: InsertionMode::Initial,
+        selection_scope: DispatchSelectionScope::Normal,
         original_mode: None,
         pending_table_mode: None,
         open_elements: SemanticFingerprint::from_values([]),
@@ -237,6 +258,33 @@ pub(in crate::html5::tree_builder) enum DispatchOutcome {
     Reprocess(InsertionMode),
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(in crate::html5::tree_builder) enum ForeignDispatchOutcome {
+    Done,
+    RedispatchUsingHtmlRules,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum CentralDispatchOutcome {
+    HtmlRules(DispatchOutcome),
+    Foreign(ForeignDispatchOutcome),
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum DispatchContinuation {
+    Finish,
+    Redispatch {
+        mode: InsertionMode,
+        selection_scope: DispatchSelectionScope,
+    },
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+struct AppliedDispatchOutcome {
+    insertion_mode_after: InsertionMode,
+    continuation: DispatchContinuation,
+}
+
 impl Html5TreeBuilder {
     pub(in crate::html5::tree_builder) fn dispatch_token_in_html_mode(
         &mut self,
@@ -246,11 +294,6 @@ impl Html5TreeBuilder {
         text: &dyn TextResolver,
     ) -> Result<DispatchOutcome, TreeBuilderError> {
         let atoms = context.atoms();
-        if let Some(outcome) =
-            self.handle_shared_template_token(mode, token, atoms, context, text)?
-        {
-            return Ok(outcome);
-        }
         match mode {
             InsertionMode::Initial => self.handle_initial(token, atoms, context, text),
             InsertionMode::BeforeHtml => self.handle_before_html(token, atoms, context, text),
@@ -272,7 +315,127 @@ impl Html5TreeBuilder {
             InsertionMode::InRow => self.handle_in_row(token, atoms, context, text),
             InsertionMode::InCell => self.handle_in_cell(token, atoms, context, text),
             InsertionMode::InTemplate => self.handle_in_template(token, atoms, context, text),
-            InsertionMode::Text => self.handle_text_mode(token, atoms, context, text),
+            InsertionMode::Text => Err(crate::html5::shared::ParserFatalError::EngineInvariant),
+        }
+    }
+
+    fn select_dispatch_path(
+        &self,
+        scope: DispatchSelectionScope,
+        mode: InsertionMode,
+        token: &Token,
+        atoms: &crate::html5::shared::AtomTable,
+    ) -> Result<SelectedDispatchPath, TreeBuilderError> {
+        if scope == DispatchSelectionScope::Normal
+            && self.foreign_dispatch_decision(token, atoms)?
+                == crate::html5::tree_builder::foreign::ForeignDispatchDecision::Foreign
+        {
+            return Ok(SelectedDispatchPath::ForeignContent);
+        }
+        if self.shared_template_rules_apply(mode, token) {
+            return Ok(SelectedDispatchPath::SharedTemplateRules);
+        }
+        if mode == InsertionMode::Text {
+            return Ok(SelectedDispatchPath::TextMode);
+        }
+        Ok(SelectedDispatchPath::HtmlInsertionMode(mode))
+    }
+
+    fn dispatch_selected_path(
+        &mut self,
+        selected: SelectedDispatchPath,
+        token: &Token,
+        context: &mut TreeBuilderProcessContext<'_>,
+        text: &dyn TextResolver,
+    ) -> Result<CentralDispatchOutcome, TreeBuilderError> {
+        let atoms = context.atoms();
+        match selected {
+            SelectedDispatchPath::HtmlInsertionMode(mode) => self
+                .dispatch_token_in_html_mode(mode, token, context, text)
+                .map(CentralDispatchOutcome::HtmlRules),
+            SelectedDispatchPath::SharedTemplateRules => self
+                .dispatch_shared_template_token(self.insertion_mode, token, atoms, context, text)
+                .map(CentralDispatchOutcome::HtmlRules),
+            SelectedDispatchPath::ForeignContent => self
+                .process_foreign_token(token, atoms, context, text)
+                .map(CentralDispatchOutcome::Foreign),
+            SelectedDispatchPath::TextMode => self
+                .handle_text_mode(token, atoms, context, text)
+                .map(CentralDispatchOutcome::HtmlRules),
+        }
+    }
+
+    fn apply_dispatch_outcome(
+        &mut self,
+        selected: SelectedDispatchPath,
+        selection_scope: DispatchSelectionScope,
+        mode_before: InsertionMode,
+        before_progress: BoundedProgressMeasure,
+        outcome: CentralDispatchOutcome,
+    ) -> Result<AppliedDispatchOutcome, TreeBuilderError> {
+        match (selected, outcome) {
+            (SelectedDispatchPath::ForeignContent, CentralDispatchOutcome::Foreign(outcome)) => {
+                if selection_scope != DispatchSelectionScope::Normal
+                    || self.insertion_mode != mode_before
+                {
+                    return Err(crate::html5::shared::ParserFatalError::EngineInvariant);
+                }
+                let continuation = match outcome {
+                    ForeignDispatchOutcome::Done => DispatchContinuation::Finish,
+                    ForeignDispatchOutcome::RedispatchUsingHtmlRules => {
+                        DispatchContinuation::Redispatch {
+                            mode: mode_before,
+                            selection_scope: DispatchSelectionScope::HtmlRulesOnly,
+                        }
+                    }
+                };
+                Ok(AppliedDispatchOutcome {
+                    insertion_mode_after: mode_before,
+                    continuation,
+                })
+            }
+            (
+                SelectedDispatchPath::HtmlInsertionMode(_)
+                | SelectedDispatchPath::SharedTemplateRules
+                | SelectedDispatchPath::TextMode,
+                CentralDispatchOutcome::HtmlRules(outcome),
+            ) => match outcome {
+                DispatchOutcome::Done => Ok(AppliedDispatchOutcome {
+                    insertion_mode_after: self.insertion_mode,
+                    continuation: DispatchContinuation::Finish,
+                }),
+                DispatchOutcome::Reprocess(next_mode) => {
+                    if self.insertion_mode != mode_before && self.insertion_mode != next_mode {
+                        return Err(crate::html5::shared::ParserFatalError::EngineInvariant);
+                    }
+                    self.insertion_mode = next_mode;
+                    let after_progress = self.bounded_progress_measure(next_mode);
+                    require_bounded_reprocess_progress(
+                        before_progress,
+                        after_progress,
+                        self.config.limits,
+                    )?;
+                    Ok(AppliedDispatchOutcome {
+                        insertion_mode_after: next_mode,
+                        continuation: DispatchContinuation::Redispatch {
+                            mode: next_mode,
+                            selection_scope: DispatchSelectionScope::Normal,
+                        },
+                    })
+                }
+            },
+            _ => Err(crate::html5::shared::ParserFatalError::EngineInvariant),
+        }
+    }
+
+    fn observed_dispatch_path(selected: SelectedDispatchPath) -> TreeDispatchPath {
+        match selected {
+            SelectedDispatchPath::HtmlInsertionMode(mode) => TreeDispatchPath::HtmlInsertionMode(
+                crate::html5::tree_builder::process_context::observed_insertion_mode(mode),
+            ),
+            SelectedDispatchPath::SharedTemplateRules => TreeDispatchPath::SharedTemplateRules,
+            SelectedDispatchPath::ForeignContent => TreeDispatchPath::ForeignContent,
+            SelectedDispatchPath::TextMode => TreeDispatchPath::TextMode,
         }
     }
 
@@ -293,6 +456,9 @@ impl Html5TreeBuilder {
         debug_assert!(self.pending_tokenizer_control.is_none());
         let validation_checkpoint = self.template_validation_checkpoint();
         let mut mode = self.insertion_mode;
+        let mut selection_scope = DispatchSelectionScope::Normal;
+        let mut reprocessed = false;
+        let mut token_summary_cache = LogicalTokenSummaryCache::default();
         let mut seen_states = ReprocessStateTracker::default();
         loop {
             self.insertion_mode = mode;
@@ -309,27 +475,47 @@ impl Html5TreeBuilder {
                 mode = self.insertion_mode;
             }
 
-            let exact_state = self.exact_reprocess_state(mode);
+            let exact_state = self.exact_reprocess_state(mode, selection_scope);
             if seen_states.observe(exact_state) {
                 return Err(crate::html5::shared::ParserFatalError::EngineInvariant);
             }
             self.perf_max_same_token_cycle_states = self
                 .perf_max_same_token_cycle_states
                 .max(seen_states.retained_states() as u64);
-            let before = self.bounded_progress_measure(mode);
-            let outcome = if self.foreign_dispatch_decision(token, atoms)?
-                == crate::html5::tree_builder::foreign::ForeignDispatchDecision::Foreign
-            {
-                self.process_foreign_token(mode, token, atoms, context, text)?
-            } else {
-                self.dispatch_token_in_html_mode(mode, token, context, text)?
-            };
-            match outcome {
-                DispatchOutcome::Done => break,
-                DispatchOutcome::Reprocess(next_mode) => {
-                    let after = self.bounded_progress_measure(next_mode);
-                    require_bounded_reprocess_progress(before, after, self.config.limits)?;
+            let selected = self.select_dispatch_path(selection_scope, mode, token, atoms)?;
+            let pending_transition =
+                prepare_tree_transition(context, &mut token_summary_cache, token, text);
+            let before_progress = self.bounded_progress_measure(mode);
+            let outcome = self.dispatch_selected_path(selected, token, context, text)?;
+            let applied = self.apply_dispatch_outcome(
+                selected,
+                selection_scope,
+                mode,
+                before_progress,
+                outcome,
+            )?;
+            if let Some(PendingTreeTransition { occurrence, token }) = pending_transition {
+                context.retain_tree_transition(
+                    occurrence,
+                    token,
+                    mode,
+                    Self::observed_dispatch_path(selected),
+                    applied.insertion_mode_after,
+                    reprocessed,
+                );
+            }
+            match applied.continuation {
+                DispatchContinuation::Finish => {
+                    mode = applied.insertion_mode_after;
+                    break;
+                }
+                DispatchContinuation::Redispatch {
+                    mode: next_mode,
+                    selection_scope: next_scope,
+                } => {
                     mode = next_mode;
+                    selection_scope = next_scope;
+                    reprocessed = true;
                 }
             }
         }
@@ -367,9 +553,14 @@ impl Html5TreeBuilder {
         ))
     }
 
-    fn exact_reprocess_state(&self, mode: InsertionMode) -> ExactReprocessState {
+    fn exact_reprocess_state(
+        &self,
+        mode: InsertionMode,
+        selection_scope: DispatchSelectionScope,
+    ) -> ExactReprocessState {
         ExactReprocessState {
             mode,
+            selection_scope,
             original_mode: self.original_insertion_mode,
             pending_table_mode: self.pending_table_text.as_ref().map(
                 crate::html5::tree_builder::table::PendingTableTextState::original_insertion_mode,
@@ -469,6 +660,7 @@ mod tests {
     fn exact_state(mode: InsertionMode) -> ExactReprocessState {
         ExactReprocessState {
             mode,
+            selection_scope: DispatchSelectionScope::Normal,
             original_mode: None,
             pending_table_mode: None,
             open_elements: vec![PatchKey(1), PatchKey(2)],
@@ -607,4 +799,96 @@ mod tests {
         assert!(!seen.observe(different_mode));
         assert_eq!(seen.retained_states(), 3);
     }
+
+    #[test]
+    fn selection_scope_participates_in_exact_cycle_identity() {
+        let normal = exact_state(InsertionMode::InBody);
+        let mut html_rules_only = normal.clone();
+        html_rules_only.selection_scope = DispatchSelectionScope::HtmlRulesOnly;
+        assert_ne!(normal.fingerprint(), html_rules_only.fingerprint());
+
+        let mut seen = ReprocessStateTracker::default();
+        assert!(!seen.observe(normal.clone()));
+        assert!(!seen.observe(html_rules_only));
+        assert!(seen.observe(normal));
+    }
+
+    #[test]
+    fn dispatcher_applies_and_validates_outcomes_before_observation() {
+        let mut context = crate::html5::shared::DocumentParseContext::new();
+        let mut builder = Html5TreeBuilder::new(
+            crate::html5::tree_builder::TreeBuilderConfig::default(),
+            &mut context,
+        )
+        .unwrap();
+        builder.insertion_mode = InsertionMode::InBody;
+        let before = builder.bounded_progress_measure(InsertionMode::InBody);
+
+        let forced = builder
+            .apply_dispatch_outcome(
+                SelectedDispatchPath::ForeignContent,
+                DispatchSelectionScope::Normal,
+                InsertionMode::InBody,
+                before,
+                CentralDispatchOutcome::Foreign(ForeignDispatchOutcome::RedispatchUsingHtmlRules),
+            )
+            .unwrap();
+        assert_eq!(forced.insertion_mode_after, InsertionMode::InBody);
+        assert_eq!(
+            forced.continuation,
+            DispatchContinuation::Redispatch {
+                mode: InsertionMode::InBody,
+                selection_scope: DispatchSelectionScope::HtmlRulesOnly,
+            }
+        );
+
+        assert!(
+            builder
+                .apply_dispatch_outcome(
+                    SelectedDispatchPath::ForeignContent,
+                    DispatchSelectionScope::HtmlRulesOnly,
+                    InsertionMode::InBody,
+                    before,
+                    CentralDispatchOutcome::Foreign(ForeignDispatchOutcome::Done),
+                )
+                .is_err(),
+            "a forced HTML-rules attempt cannot select foreign content again"
+        );
+
+        builder.insertion_mode = InsertionMode::InBody;
+        let ordinary_after_forced = builder
+            .apply_dispatch_outcome(
+                SelectedDispatchPath::HtmlInsertionMode(InsertionMode::InBody),
+                DispatchSelectionScope::HtmlRulesOnly,
+                InsertionMode::InBody,
+                before,
+                CentralDispatchOutcome::HtmlRules(DispatchOutcome::Reprocess(
+                    InsertionMode::InTable,
+                )),
+            )
+            .unwrap();
+        assert_eq!(
+            ordinary_after_forced.continuation,
+            DispatchContinuation::Redispatch {
+                mode: InsertionMode::InTable,
+                selection_scope: DispatchSelectionScope::Normal,
+            }
+        );
+
+        builder.insertion_mode = InsertionMode::InTable;
+        assert!(
+            builder
+                .apply_dispatch_outcome(
+                    SelectedDispatchPath::HtmlInsertionMode(InsertionMode::InBody),
+                    DispatchSelectionScope::Normal,
+                    InsertionMode::InBody,
+                    before,
+                    CentralDispatchOutcome::HtmlRules(DispatchOutcome::Reprocess(
+                        InsertionMode::InRow,
+                    )),
+                )
+                .is_err(),
+            "a third handler-owned mode is an engine invariant"
+        );
+    }
 }
diff --git a/crates/html/src/html5/tree_builder/dispatch/early_modes.rs b/crates/html/src/html5/tree_builder/dispatch/early_modes.rs
index 8fc998f1..670d1331 100644
--- a/crates/html/src/html5/tree_builder/dispatch/early_modes.rs
+++ b/crates/html/src/html5/tree_builder/dispatch/early_modes.rs
@@ -1,7 +1,6 @@
 use super::DispatchOutcome;
 use crate::html5::shared::{
-    AtomTable, ParserRecoveryAction, Token, TreeConstructionImplementationDiagnosticCode,
-    TreeConstructionParseErrorCode,
+    AtomTable, ParserRecoveryAction, Token, TreeConstructionParseErrorCode,
 };
 use crate::html5::tokenizer::TextResolver;
 use crate::html5::tree_builder::modes::InsertionMode;
@@ -254,13 +253,7 @@ impl Html5TreeBuilder {
                     Some(ParserRecoveryAction::IgnoreToken),
                     Some("in-head-unexpected-html-start-tag"),
                 );
-                if !attrs.is_empty() {
-                    self.record_tree_implementation_diagnostic(
-                        context,
-                        TreeConstructionImplementationDiagnosticCode::HtmlElementAttributesNotMerged,
-                        Some("html-start-tag-attributes-ignored"),
-                    );
-                }
+                self.observe_repeated_html_start_rule(attrs, atoms, context);
                 Ok(DispatchOutcome::Done)
             }
             Token::StartTag {
@@ -369,13 +362,7 @@ impl Html5TreeBuilder {
                     Some(ParserRecoveryAction::IgnoreToken),
                     Some("after-head-unexpected-html-start-tag"),
                 );
-                if !attrs.is_empty() {
-                    self.record_tree_implementation_diagnostic(
-                        context,
-                        TreeConstructionImplementationDiagnosticCode::HtmlElementAttributesNotMerged,
-                        Some("html-start-tag-attributes-ignored"),
-                    );
-                }
+                self.observe_repeated_html_start_rule(attrs, atoms, context);
                 Ok(DispatchOutcome::Done)
             }
             Token::StartTag { name, .. } if *name == self.known_tags.head => {
@@ -470,7 +457,7 @@ impl Html5TreeBuilder {
     pub(in crate::html5::tree_builder) fn handle_after_body(
         &mut self,
         token: &Token,
-        _atoms: &AtomTable,
+        atoms: &AtomTable,
         context: &mut crate::html5::tree_builder::TreeBuilderProcessContext<'_>,
         text: &dyn TextResolver,
     ) -> Result<DispatchOutcome, TreeBuilderError> {
@@ -517,13 +504,7 @@ impl Html5TreeBuilder {
                     Some(ParserRecoveryAction::IgnoreToken),
                     Some("after-body-unexpected-html-start-tag"),
                 );
-                if !attrs.is_empty() {
-                    self.record_tree_implementation_diagnostic(
-                        context,
-                        TreeConstructionImplementationDiagnosticCode::HtmlElementAttributesNotMerged,
-                        Some("html-start-tag-attributes-ignored"),
-                    );
-                }
+                self.observe_repeated_html_start_rule(attrs, atoms, context);
                 Ok(DispatchOutcome::Done)
             }
             Token::EndTag { name } if *name == self.known_tags.html => {
@@ -547,7 +528,7 @@ impl Html5TreeBuilder {
     pub(in crate::html5::tree_builder) fn handle_after_after_body(
         &mut self,
         token: &Token,
-        _atoms: &AtomTable,
+        atoms: &AtomTable,
         context: &mut crate::html5::tree_builder::TreeBuilderProcessContext<'_>,
         text: &dyn TextResolver,
     ) -> Result<DispatchOutcome, TreeBuilderError> {
@@ -579,13 +560,14 @@ impl Html5TreeBuilder {
                 );
                 Ok(DispatchOutcome::Done)
             }
-            Token::StartTag { name, .. } if *name == self.known_tags.html => {
+            Token::StartTag { name, attrs, .. } if *name == self.known_tags.html => {
                 self.record_tree_parse_error(
                     context,
                     TreeConstructionParseErrorCode::HtmlStartTagAfterHtmlElement,
                     Some(ParserRecoveryAction::IgnoreToken),
                     Some("after-after-body-unexpected-html-start-tag"),
                 );
+                self.observe_repeated_html_start_rule(attrs, atoms, context);
                 Ok(DispatchOutcome::Done)
             }
             Token::Eof => Ok(DispatchOutcome::Done),
diff --git a/crates/html/src/html5/tree_builder/dispatch/in_body.rs b/crates/html/src/html5/tree_builder/dispatch/in_body.rs
index c3b5df05..308292a1 100644
--- a/crates/html/src/html5/tree_builder/dispatch/in_body.rs
+++ b/crates/html/src/html5/tree_builder/dispatch/in_body.rs
@@ -213,9 +213,7 @@ impl Html5TreeBuilder {
                 self_closing,
             } if *name == self.known_tags.html => {
                 self.record_tree_parse_error(context, crate::html5::shared::TreeConstructionParseErrorCode::HtmlStartTagAfterHtmlElement, Some(crate::html5::shared::ParserRecoveryAction::IgnoreToken), Some("unexpected-html-start-tag-after-html-created"));
-                if !attrs.is_empty() {
-                    self.record_tree_implementation_diagnostic(context, crate::html5::shared::TreeConstructionImplementationDiagnosticCode::HtmlElementAttributesNotMerged, Some("html-start-tag-attributes-ignored"));
-                }
+                self.observe_repeated_html_start_rule(attrs, atoms, context);
             }
             Token::StartTag {
                 name,
@@ -223,9 +221,7 @@ impl Html5TreeBuilder {
                 self_closing,
             } if *name == self.known_tags.body => {
                 self.record_tree_parse_error(context, crate::html5::shared::TreeConstructionParseErrorCode::BodyStartTagAfterBodyElement, Some(crate::html5::shared::ParserRecoveryAction::IgnoreToken), Some("unexpected-body-start-tag-after-body-created"));
-                if !attrs.is_empty() {
-                    self.record_tree_implementation_diagnostic(context, crate::html5::shared::TreeConstructionImplementationDiagnosticCode::BodyElementAttributesNotMerged, Some("body-start-tag-attributes-ignored"));
-                }
+                self.observe_repeated_body_start_rule(attrs, atoms, context);
             }
             Token::StartTag { name, .. } if *name == self.known_tags.head => {
                 self.record_tree_parse_error(context, crate::html5::shared::TreeConstructionParseErrorCode::StartTagForbiddenByActiveInsertionMode, Some(crate::html5::shared::ParserRecoveryAction::IgnoreToken), Some("in-body-unexpected-head-start-tag"));
diff --git a/crates/html/src/html5/tree_builder/dispatch/mod.rs b/crates/html/src/html5/tree_builder/dispatch/mod.rs
index afbf7060..58a4364c 100644
--- a/crates/html/src/html5/tree_builder/dispatch/mod.rs
+++ b/crates/html/src/html5/tree_builder/dispatch/mod.rs
@@ -6,5 +6,5 @@ mod select;
 mod start_tag;
 mod template;
 
-pub(in crate::html5::tree_builder) use drive::DispatchOutcome;
+pub(in crate::html5::tree_builder) use drive::{DispatchOutcome, ForeignDispatchOutcome};
 pub(in crate::html5::tree_builder) use start_tag::SelfClosingFlagDisposition;
diff --git a/crates/html/src/html5/tree_builder/dispatch/template.rs b/crates/html/src/html5/tree_builder/dispatch/template.rs
index 2251cf10..02815205 100644
--- a/crates/html/src/html5/tree_builder/dispatch/template.rs
+++ b/crates/html/src/html5/tree_builder/dispatch/template.rs
@@ -26,15 +26,12 @@ struct TemplateStartPreflight {
 }
 
 impl Html5TreeBuilder {
-    pub(in crate::html5::tree_builder) fn handle_shared_template_token(
-        &mut self,
+    pub(in crate::html5::tree_builder) fn shared_template_rules_apply(
+        &self,
         mode: InsertionMode,
         token: &Token,
-        atoms: &AtomTable,
-        context: &mut crate::html5::tree_builder::TreeBuilderProcessContext<'_>,
-        text: &dyn TextResolver,
-    ) -> Result<Option<DispatchOutcome>, TreeBuilderError> {
-        if !matches!(
+    ) -> bool {
+        matches!(
             mode,
             InsertionMode::InHead
                 | InsertionMode::AfterHead
@@ -46,10 +43,21 @@ impl Html5TreeBuilder {
                 | InsertionMode::InRow
                 | InsertionMode::InCell
                 | InsertionMode::InTemplate
-        ) {
-            return Ok(None);
-        }
+        ) && matches!(
+            token,
+            Token::StartTag { name, .. } | Token::EndTag { name }
+                if *name == self.known_tags.template
+        )
+    }
 
+    pub(in crate::html5::tree_builder) fn dispatch_shared_template_token(
+        &mut self,
+        mode: InsertionMode,
+        token: &Token,
+        atoms: &AtomTable,
+        context: &mut crate::html5::tree_builder::TreeBuilderProcessContext<'_>,
+        text: &dyn TextResolver,
+    ) -> Result<DispatchOutcome, TreeBuilderError> {
         match token {
             Token::StartTag {
                 name,
@@ -64,13 +72,13 @@ impl Html5TreeBuilder {
                     let _ =
                         self.handle_template_start_tag(attrs, *self_closing, atoms, context, text)?;
                 }
-                Ok(Some(DispatchOutcome::Done))
+                Ok(DispatchOutcome::Done)
             }
             Token::EndTag { name } if *name == self.known_tags.template => {
                 self.handle_template_end_tag(context)?;
-                Ok(Some(DispatchOutcome::Done))
+                Ok(DispatchOutcome::Done)
             }
-            _ => Ok(None),
+            _ => Err(crate::html5::shared::ParserFatalError::EngineInvariant),
         }
     }
 
diff --git a/crates/html/src/html5/tree_builder/foreign/dispatch.rs b/crates/html/src/html5/tree_builder/foreign/dispatch.rs
index 78c4ba3b..3b3dd1fa 100644
--- a/crates/html/src/html5/tree_builder/foreign/dispatch.rs
+++ b/crates/html/src/html5/tree_builder/foreign/dispatch.rs
@@ -3,8 +3,7 @@ use crate::html5::shared::{
     AtomTable, Attribute, ParserRecoveryAction, TextValue, Token, TreeConstructionParseErrorCode,
 };
 use crate::html5::tokenizer::TextResolver;
-use crate::html5::tree_builder::dispatch::DispatchOutcome;
-use crate::html5::tree_builder::modes::InsertionMode;
+use crate::html5::tree_builder::dispatch::ForeignDispatchOutcome;
 use crate::html5::tree_builder::resolve::{resolve_atom, resolve_text_value};
 use crate::html5::tree_builder::{Html5TreeBuilder, TreeBuilderError};
 use crate::names::ElementNamespace;
@@ -103,11 +102,8 @@ impl Html5TreeBuilder {
 
     fn breakout_to_html(
         &mut self,
-        mode: InsertionMode,
-        token: &Token,
         context: &mut crate::html5::tree_builder::TreeBuilderProcessContext<'_>,
-        text: &dyn TextResolver,
-    ) -> Result<DispatchOutcome, TreeBuilderError> {
+    ) -> Result<ForeignDispatchOutcome, TreeBuilderError> {
         self.record_tree_parse_error(
             context,
             TreeConstructionParseErrorCode::HtmlTokenNotAllowedInForeignContent,
@@ -119,17 +115,16 @@ impl Html5TreeBuilder {
                 .pop()
                 .ok_or(crate::html5::shared::ParserFatalError::EngineInvariant)?;
         }
-        self.dispatch_token_in_html_mode(mode, token, context, text)
+        Ok(ForeignDispatchOutcome::RedispatchUsingHtmlRules)
     }
 
     pub(in crate::html5::tree_builder) fn process_foreign_token(
         &mut self,
-        mode: InsertionMode,
         token: &Token,
         atoms: &AtomTable,
         context: &mut crate::html5::tree_builder::TreeBuilderProcessContext<'_>,
         text: &dyn TextResolver,
-    ) -> Result<DispatchOutcome, TreeBuilderError> {
+    ) -> Result<ForeignDispatchOutcome, TreeBuilderError> {
         match token {
             Token::Text { text: token_text } => {
                 let resolved = resolve_text_value(token_text, text)?;
@@ -161,15 +156,15 @@ impl Html5TreeBuilder {
                     self.document_state.frameset_ok = false;
                 }
                 self.insert_text(&TextValue::Owned(normalized), context, text)?;
-                Ok(DispatchOutcome::Done)
+                Ok(ForeignDispatchOutcome::Done)
             }
             Token::Comment { text: token_text } => {
                 self.insert_comment(token_text, context, text)?;
-                Ok(DispatchOutcome::Done)
+                Ok(ForeignDispatchOutcome::Done)
             }
             Token::ProcessingInstruction(processing_instruction) => {
                 self.insert_processing_instruction(processing_instruction, context, text, None)?;
-                Ok(DispatchOutcome::Done)
+                Ok(ForeignDispatchOutcome::Done)
             }
             Token::Doctype { .. } => {
                 self.record_tree_parse_error(
@@ -178,7 +173,7 @@ impl Html5TreeBuilder {
                     Some(ParserRecoveryAction::IgnoreToken),
                     Some("doctype-in-foreign-content"),
                 );
-                Ok(DispatchOutcome::Done)
+                Ok(ForeignDispatchOutcome::Done)
             }
             Token::StartTag {
                 name,
@@ -190,7 +185,7 @@ impl Html5TreeBuilder {
                     || (token_name == "font"
                         && Self::token_has_html_font_breakout_attribute(attrs, atoms)?)
                 {
-                    return self.breakout_to_html(mode, token, context, text);
+                    return self.breakout_to_html(context);
                 }
                 let namespace = self
                     .adjusted_current_node_namespace()
@@ -218,12 +213,12 @@ impl Html5TreeBuilder {
                 if *self_closing {
                     context.acknowledge_self_closing_flag()?;
                 }
-                Ok(DispatchOutcome::Done)
+                Ok(ForeignDispatchOutcome::Done)
             }
             Token::EndTag { name } => {
                 let token_name = resolve_atom(atoms, *name)?;
                 if matches!(token_name, "br" | "p") {
-                    return self.breakout_to_html(mode, token, context, text);
+                    return self.breakout_to_html(context);
                 }
                 let current = self
                     .open_elements
@@ -244,7 +239,7 @@ impl Html5TreeBuilder {
                         .get(index)
                         .ok_or(crate::html5::shared::ParserFatalError::EngineInvariant)?;
                     if candidate.namespace() == ElementNamespace::Html {
-                        return self.dispatch_token_in_html_mode(mode, token, context, text);
+                        return Ok(ForeignDispatchOutcome::RedispatchUsingHtmlRules);
                     }
                     if resolve_atom(atoms, candidate.name())?.eq_ignore_ascii_case(token_name) {
                         while self.open_elements.len() > index {
@@ -252,12 +247,12 @@ impl Html5TreeBuilder {
                                 .pop()
                                 .ok_or(crate::html5::shared::ParserFatalError::EngineInvariant)?;
                         }
-                        return Ok(DispatchOutcome::Done);
+                        return Ok(ForeignDispatchOutcome::Done);
                     }
                 }
-                Ok(DispatchOutcome::Done)
+                Ok(ForeignDispatchOutcome::Done)
             }
-            Token::Eof => self.dispatch_token_in_html_mode(mode, token, context, text),
+            Token::Eof => Ok(ForeignDispatchOutcome::RedispatchUsingHtmlRules),
         }
     }
 }
diff --git a/crates/html/src/html5/tree_builder/mod.rs b/crates/html/src/html5/tree_builder/mod.rs
index fd0f0654..3f6f2574 100644
--- a/crates/html/src/html5/tree_builder/mod.rs
+++ b/crates/html/src/html5/tree_builder/mod.rs
@@ -24,6 +24,7 @@ mod known_tags;
 mod limits;
 mod live_tree;
 pub(crate) mod modes;
+mod observation;
 mod parser_validation;
 mod patch_sink;
 mod process_context;
@@ -33,6 +34,7 @@ mod stack;
 mod table;
 mod template_state;
 mod text_mode;
+mod unsupported;
 
 #[cfg(any(test, feature = "html5-fuzzing"))]
 pub(crate) use api::TreeBuilderProgressWitness;
diff --git a/crates/html/src/html5/tree_builder/observation.rs b/crates/html/src/html5/tree_builder/observation.rs
new file mode 100644
index 00000000..47af50ee
--- /dev/null
+++ b/crates/html/src/html5/tree_builder/observation.rs
@@ -0,0 +1,314 @@
+use crate::html5::shared::{TextValue, Token, TransitionTokenSummary};
+use crate::html5::tokenizer::TextResolver;
+use crate::html5::tree_builder::TreeBuilderProcessContext;
+use std::sync::Arc;
+
+#[derive(Debug, Default)]
+pub(in crate::html5::tree_builder) enum LogicalTokenSummaryCache {
+    #[default]
+    Uninitialized,
+    Ready(Arc<TransitionTokenSummary>),
+    Failed,
+}
+
+#[derive(Debug)]
+pub(in crate::html5::tree_builder) struct PendingTreeTransition {
+    pub(in crate::html5::tree_builder) occurrence: u64,
+    pub(in crate::html5::tree_builder) token: Arc<TransitionTokenSummary>,
+}
+
+pub(in crate::html5::tree_builder) fn prepare_tree_transition(
+    context: &mut TreeBuilderProcessContext<'_>,
+    cache: &mut LogicalTokenSummaryCache,
+    token: &Token,
+    text: &dyn TextResolver,
+) -> Option<PendingTreeTransition> {
+    let occurrence = context.reserve_tree_transition()?;
+    let summary = match cache {
+        LogicalTokenSummaryCache::Ready(summary) => Arc::clone(summary),
+        LogicalTokenSummaryCache::Failed => return None,
+        LogicalTokenSummaryCache::Uninitialized => {
+            let Some(summary) = canonicalize_transition_token(token, context.atoms(), text) else {
+                *cache = LogicalTokenSummaryCache::Failed;
+                context.record_tree_transition_capture_failure();
+                return None;
+            };
+            let summary = Arc::new(summary);
+            *cache = LogicalTokenSummaryCache::Ready(Arc::clone(&summary));
+            summary
+        }
+    };
+    Some(PendingTreeTransition {
+        occurrence,
+        token: summary,
+    })
+}
+
+fn canonicalize_transition_token(
+    token: &Token,
+    atoms: &crate::html5::shared::AtomTable,
+    text: &dyn TextResolver,
+) -> Option<TransitionTokenSummary> {
+    Some(match token {
+        Token::Doctype { .. } => TransitionTokenSummary::Doctype,
+        Token::StartTag {
+            name, self_closing, ..
+        } => TransitionTokenSummary::StartTag {
+            name: atoms.resolve(*name)?.to_string(),
+            self_closing: *self_closing,
+        },
+        Token::EndTag { name } => TransitionTokenSummary::EndTag {
+            name: atoms.resolve(*name)?.to_string(),
+        },
+        Token::Text { text: value } => TransitionTokenSummary::Character {
+            data: resolve_text(value, text)?,
+        },
+        Token::Comment { .. } => TransitionTokenSummary::Comment,
+        Token::ProcessingInstruction(processing_instruction) => {
+            TransitionTokenSummary::ProcessingInstruction {
+                target: processing_instruction.target.clone(),
+            }
+        }
+        Token::Eof => TransitionTokenSummary::Eof,
+    })
+}
+
+fn resolve_text(value: &TextValue, text: &dyn TextResolver) -> Option<String> {
+    match value {
+        TextValue::Owned(value) | TextValue::NullNormalized { text: value, .. } => {
+            Some(value.clone())
+        }
+        TextValue::Span(span) => text.resolve_span(*span).ok().map(str::to_string),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::html5::shared::{
+        DocumentParseContext, ErrorPolicy, ParserObservationCaptureFailure,
+        ParserObservationConfig, ParserObservationFailure, SurfaceCaptureRequest, TextSpan,
+    };
+    use crate::html5::tokenizer::TextResolveError;
+    use crate::html5::tree_builder::TreeBuilderProcessContext;
+    use std::cell::Cell;
+
+    struct NoSpans;
+
+    impl TextResolver for NoSpans {
+        fn resolve_span(&self, span: TextSpan) -> Result<&str, TextResolveError> {
+            Err(TextResolveError::InvalidSpan { span })
+        }
+    }
+
+    struct CountingFailureResolver {
+        calls: Cell<usize>,
+    }
+
+    impl TextResolver for CountingFailureResolver {
+        fn resolve_span(&self, span: TextSpan) -> Result<&str, TextResolveError> {
+            self.calls.set(self.calls.get() + 1);
+            Err(TextResolveError::InvalidSpan { span })
+        }
+    }
+
+    fn start_tag(context: &mut DocumentParseContext) -> Token {
+        let name = context
+            .atoms
+            .intern_ascii_folded("redispatched")
+            .expect("test atom");
+        Token::StartTag {
+            name,
+            attrs: Vec::new(),
+            self_closing: false,
+        }
+    }
+
+    #[test]
+    fn logical_token_summary_is_shared_across_retainable_attempts() {
+        let mut owner = DocumentParseContext::with_observations(
+            ErrorPolicy::default(),
+            ParserObservationConfig {
+                tree_transitions: SurfaceCaptureRequest::Capture { capacity: 2 },
+                ..ParserObservationConfig::default()
+            },
+        );
+        let token = start_tag(&mut owner);
+        let mut context = TreeBuilderProcessContext::new(&mut owner);
+        let mut cache = LogicalTokenSummaryCache::default();
+        let first = prepare_tree_transition(&mut context, &mut cache, &token, &NoSpans).unwrap();
+        let second = prepare_tree_transition(&mut context, &mut cache, &token, &NoSpans).unwrap();
+        assert!(Arc::ptr_eq(&first.token, &second.token));
+    }
+
+    #[test]
+    fn failed_logical_token_summary_is_latched_and_never_retried() {
+        let mut owner = DocumentParseContext::with_observations(
+            ErrorPolicy::default(),
+            ParserObservationConfig {
+                tree_transitions: SurfaceCaptureRequest::Capture { capacity: 3 },
+                ..ParserObservationConfig::default()
+            },
+        );
+        let token = Token::Text {
+            text: TextValue::Span(TextSpan::new(0, 1)),
+        };
+        let resolver = CountingFailureResolver {
+            calls: Cell::new(0),
+        };
+        {
+            let mut context = TreeBuilderProcessContext::new(&mut owner);
+            let mut cache = LogicalTokenSummaryCache::default();
+
+            assert!(prepare_tree_transition(&mut context, &mut cache, &token, &resolver).is_none());
+            assert!(matches!(cache, LogicalTokenSummaryCache::Failed));
+            assert_eq!(resolver.calls.get(), 1);
+
+            assert!(prepare_tree_transition(&mut context, &mut cache, &token, &resolver).is_none());
+            assert!(matches!(cache, LogicalTokenSummaryCache::Failed));
+            assert_eq!(
+                resolver.calls.get(),
+                1,
+                "failed summaries must not be retried"
+            );
+
+            let mut next_token_cache = LogicalTokenSummaryCache::default();
+            let next = prepare_tree_transition(
+                &mut context,
+                &mut next_token_cache,
+                &Token::Eof,
+                &resolver,
+            )
+            .expect("a later logical token remains observable");
+            assert_eq!(next.occurrence, 3);
+            context.retain_tree_transition(
+                next.occurrence,
+                next.token,
+                crate::html5::tree_builder::modes::InsertionMode::InBody,
+                crate::html5::shared::TreeDispatchPath::HtmlInsertionMode(
+                    crate::html5::shared::ObservedInsertionMode::InBody,
+                ),
+                crate::html5::tree_builder::modes::InsertionMode::InBody,
+                false,
+            );
+        }
+
+        let capture = owner.take_observations().unwrap();
+        assert_eq!(capture.tree_transitions.items.len(), 1);
+        assert_eq!(capture.tree_transitions.items[0].occurrence, 3);
+        assert_eq!(capture.tree_transitions.dropped, 0);
+        assert_eq!(
+            capture.failure,
+            Some(ParserObservationFailure::Capture(
+                ParserObservationCaptureFailure::TreeTransitionTokenCanonicalization
+            ))
+        );
+    }
+
+    #[test]
+    fn unrequested_zero_and_exhausted_capture_do_not_construct_a_summary() {
+        let token_for = |context: &mut DocumentParseContext| start_tag(context);
+
+        let mut unrequested_owner = DocumentParseContext::new();
+        let unrequested_token = token_for(&mut unrequested_owner);
+        let mut unrequested_context = TreeBuilderProcessContext::new(&mut unrequested_owner);
+        let mut unrequested_cache = LogicalTokenSummaryCache::default();
+        assert!(
+            prepare_tree_transition(
+                &mut unrequested_context,
+                &mut unrequested_cache,
+                &unrequested_token,
+                &NoSpans,
+            )
+            .is_none()
+        );
+        assert!(matches!(
+            unrequested_cache,
+            LogicalTokenSummaryCache::Uninitialized
+        ));
+
+        let mut zero_owner = DocumentParseContext::with_observations(
+            ErrorPolicy::default(),
+            ParserObservationConfig {
+                tree_transitions: SurfaceCaptureRequest::Capture { capacity: 0 },
+                ..ParserObservationConfig::default()
+            },
+        );
+        let zero_token = token_for(&mut zero_owner);
+        let mut zero_context = TreeBuilderProcessContext::new(&mut zero_owner);
+        let mut zero_cache = LogicalTokenSummaryCache::default();
+        assert!(
+            prepare_tree_transition(&mut zero_context, &mut zero_cache, &zero_token, &NoSpans)
+                .is_none()
+        );
+        assert!(matches!(
+            zero_cache,
+            LogicalTokenSummaryCache::Uninitialized
+        ));
+
+        let mut one_owner = DocumentParseContext::with_observations(
+            ErrorPolicy::default(),
+            ParserObservationConfig {
+                tree_transitions: SurfaceCaptureRequest::Capture { capacity: 1 },
+                ..ParserObservationConfig::default()
+            },
+        );
+        let one_token = token_for(&mut one_owner);
+        let mut one_context = TreeBuilderProcessContext::new(&mut one_owner);
+        let mut one_cache = LogicalTokenSummaryCache::default();
+        let retained =
+            prepare_tree_transition(&mut one_context, &mut one_cache, &one_token, &NoSpans)
+                .expect("first reservation");
+        one_context.retain_tree_transition(
+            retained.occurrence,
+            retained.token,
+            crate::html5::tree_builder::modes::InsertionMode::InBody,
+            crate::html5::shared::TreeDispatchPath::HtmlInsertionMode(
+                crate::html5::shared::ObservedInsertionMode::InBody,
+            ),
+            crate::html5::tree_builder::modes::InsertionMode::InBody,
+            false,
+        );
+        assert!(
+            prepare_tree_transition(&mut one_context, &mut one_cache, &one_token, &NoSpans)
+                .is_none()
+        );
+        assert!(matches!(one_cache, LogicalTokenSummaryCache::Ready(_)));
+    }
+
+    #[test]
+    fn independent_parser_fatal_is_not_replaced_by_summary_capture_failure() {
+        let mut owner = DocumentParseContext::with_observations(
+            ErrorPolicy::default(),
+            ParserObservationConfig {
+                tree_transitions: SurfaceCaptureRequest::Capture { capacity: 1 },
+                ..ParserObservationConfig::default()
+            },
+        );
+        let mut builder = crate::html5::tree_builder::Html5TreeBuilder::new(
+            crate::html5::tree_builder::TreeBuilderConfig::default(),
+            &mut owner,
+        )
+        .unwrap();
+        let token = Token::Text {
+            text: TextValue::Span(TextSpan::new(0, 1)),
+        };
+        assert_eq!(
+            builder.process(
+                &token,
+                &mut TreeBuilderProcessContext::new(&mut owner),
+                &NoSpans,
+            ),
+            Err(crate::html5::shared::ParserFatalError::EngineInvariant)
+        );
+        let capture = owner.take_observations().unwrap();
+        assert_eq!(
+            capture.failure,
+            Some(crate::html5::shared::ParserObservationFailure::Capture(
+                crate::html5::shared::ParserObservationCaptureFailure::
+                    TreeTransitionTokenCanonicalization
+            ))
+        );
+        assert!(capture.tree_transitions.items.is_empty());
+    }
+}
diff --git a/crates/html/src/html5/tree_builder/process_context.rs b/crates/html/src/html5/tree_builder/process_context.rs
index 11f465ad..66179756 100644
--- a/crates/html/src/html5/tree_builder/process_context.rs
+++ b/crates/html/src/html5/tree_builder/process_context.rs
@@ -1,14 +1,17 @@
 use crate::html5::shared::ObservedInsertionMode;
 use crate::html5::shared::Token;
 use crate::html5::shared::{
-    AtomTable, DocumentParseContext, ParseErrorCode, ParserContextSummary, ParserDiagnosticSink,
+    AtomTable, DocumentParseContext, ParseErrorCode, ParserContextSummary, ParserEventSink,
     ParserRecoveryAction, ParserReservationController, ParserReservationSite,
-    ParserResourceExhaustion, ParserResourceLimit, ParserTokenKind,
+    ParserResourceExhaustion, ParserResourceLimit, ParserTokenKind, TransitionTokenSummary,
     TreeConstructionImplementationDiagnosticCode, TreeConstructionParseErrorCode,
+    TreeConstructionUnsupportedFeature, TreeDispatchPath, TreeTransitionEvent,
+    UnsupportedFeatureEvent, UnsupportedFeatureObservationFailure,
 };
 use crate::html5::tree_builder::TreeBuilderError;
 use crate::html5::tree_builder::modes::InsertionMode;
 use crate::names::ElementNamespace;
+use std::sync::Arc;
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 enum TreeBuilderTokenSource {
@@ -24,11 +27,11 @@ pub(in crate::html5::tree_builder) enum SelfClosingFlagEffect {
     AlteredHtmlStackDisposition,
 }
 
-pub(crate) struct TreeConstructionDiagnosticSink<'a> {
-    shared: ParserDiagnosticSink<'a>,
+pub(crate) struct TreeConstructionEventSink<'a> {
+    shared: ParserEventSink<'a>,
 }
 
-impl TreeConstructionDiagnosticSink<'_> {
+impl TreeConstructionEventSink<'_> {
     fn record_parse_error(
         &mut self,
         code: TreeConstructionParseErrorCode,
@@ -64,12 +67,54 @@ impl TreeConstructionDiagnosticSink<'_> {
         self.shared
             .record_tree_resource_limit(limit, configured_limit, context, description);
     }
+
+    fn reserve_tree_transition(&mut self) -> Option<u64> {
+        self.shared.reserve_tree_transition()
+    }
+
+    fn retain_tree_transition(&mut self, event: TreeTransitionEvent) {
+        self.shared.retain_tree_transition(event);
+    }
+
+    fn record_tree_transition_capture_failure(&mut self) {
+        self.shared.record_tree_transition_capture_failure();
+    }
+
+    fn unsupported_features_requested(&self) -> bool {
+        self.shared.unsupported_features_requested()
+    }
+
+    fn reserve_unsupported_feature(&mut self) -> Option<u64> {
+        self.shared.reserve_unsupported_feature()
+    }
+
+    fn retain_unsupported_feature(
+        &mut self,
+        occurrence: u64,
+        feature: TreeConstructionUnsupportedFeature,
+        context: ParserContextSummary,
+    ) {
+        self.shared
+            .retain_unsupported_feature(UnsupportedFeatureEvent::TreeConstruction {
+                occurrence,
+                feature,
+                context,
+            });
+    }
+
+    fn record_unsupported_feature_observation_failure(
+        &mut self,
+        failure: UnsupportedFeatureObservationFailure,
+    ) {
+        self.shared
+            .record_unsupported_feature_observation_failure(failure);
+    }
 }
 
 /// Per-token tree-construction dependencies borrowed from the parser owner.
 pub struct TreeBuilderProcessContext<'a> {
     atoms: &'a AtomTable,
-    diagnostics: TreeConstructionDiagnosticSink<'a>,
+    events: TreeConstructionEventSink<'a>,
     token_kind: ParserTokenKind,
     token_source: TreeBuilderTokenSource,
     self_closing_flag: SelfClosingFlagEffect,
@@ -100,8 +145,8 @@ impl<'a> TreeBuilderProcessContext<'a> {
         } = parse_context;
         Self {
             atoms,
-            diagnostics: TreeConstructionDiagnosticSink {
-                shared: ParserDiagnosticSink::new(counters, *error_policy, errors, observations),
+            events: TreeConstructionEventSink {
+                shared: ParserEventSink::new(counters, *error_policy, errors, observations),
             },
             token_kind: ParserTokenKind::Eof,
             token_source,
@@ -136,6 +181,61 @@ impl<'a> TreeBuilderProcessContext<'a> {
         self.token_source == TreeBuilderTokenSource::IntegratedTokenizer
     }
 
+    pub(in crate::html5::tree_builder) fn reserve_tree_transition(&mut self) -> Option<u64> {
+        self.events.reserve_tree_transition()
+    }
+
+    pub(in crate::html5::tree_builder) fn retain_tree_transition(
+        &mut self,
+        occurrence: u64,
+        token: Arc<TransitionTokenSummary>,
+        insertion_mode_before: InsertionMode,
+        dispatch_path: TreeDispatchPath,
+        insertion_mode_after: InsertionMode,
+        reprocessed: bool,
+    ) {
+        self.events.retain_tree_transition(TreeTransitionEvent {
+            occurrence,
+            token,
+            insertion_mode_before: observed_insertion_mode(insertion_mode_before),
+            dispatch_path,
+            insertion_mode_after: observed_insertion_mode(insertion_mode_after),
+            reprocessed,
+        });
+    }
+
+    pub(in crate::html5::tree_builder) fn record_tree_transition_capture_failure(&mut self) {
+        self.events.record_tree_transition_capture_failure();
+    }
+
+    pub(in crate::html5::tree_builder) fn unsupported_features_requested(&self) -> bool {
+        self.events.unsupported_features_requested()
+    }
+
+    pub(in crate::html5::tree_builder) fn reserve_unsupported_feature(&mut self) -> Option<u64> {
+        self.events.reserve_unsupported_feature()
+    }
+
+    pub(in crate::html5::tree_builder) fn retain_unsupported_feature(
+        &mut self,
+        occurrence: u64,
+        feature: TreeConstructionUnsupportedFeature,
+        insertion_mode: InsertionMode,
+        adjusted_current_node_namespace: Option<ElementNamespace>,
+    ) {
+        let parser_context = self.parser_context(insertion_mode, adjusted_current_node_namespace);
+        self.events
+            .retain_unsupported_feature(occurrence, feature, parser_context);
+    }
+
+    pub(in crate::html5::tree_builder) fn record_unsupported_feature_observation_failure(
+        &mut self,
+        failure: UnsupportedFeatureObservationFailure,
+    ) {
+        self.events
+            .record_unsupported_feature_observation_failure(failure);
+    }
+
     pub(in crate::html5::tree_builder) fn record_parse_error(
         &mut self,
         code: TreeConstructionParseErrorCode,
@@ -144,7 +244,7 @@ impl<'a> TreeBuilderProcessContext<'a> {
         adjusted_current_node_namespace: Option<ElementNamespace>,
         description: Option<&'static str>,
     ) {
-        self.diagnostics.record_parse_error(
+        self.events.record_parse_error(
             code,
             recovery,
             self.parser_context(insertion_mode, adjusted_current_node_namespace),
@@ -159,7 +259,7 @@ impl<'a> TreeBuilderProcessContext<'a> {
         adjusted_current_node_namespace: Option<ElementNamespace>,
         description: Option<&'static str>,
     ) {
-        self.diagnostics.record_implementation_diagnostic(
+        self.events.record_implementation_diagnostic(
             code,
             self.parser_context(insertion_mode, adjusted_current_node_namespace),
             description,
@@ -174,7 +274,7 @@ impl<'a> TreeBuilderProcessContext<'a> {
         adjusted_current_node_namespace: Option<ElementNamespace>,
         description: Option<&'static str>,
     ) {
-        self.diagnostics.record_resource_limit(
+        self.events.record_resource_limit(
             limit,
             configured_limit,
             self.parser_context(insertion_mode, adjusted_current_node_namespace),
@@ -254,7 +354,9 @@ fn parser_token_kind(token: &Token) -> ParserTokenKind {
     }
 }
 
-fn observed_insertion_mode(mode: InsertionMode) -> ObservedInsertionMode {
+pub(in crate::html5::tree_builder) fn observed_insertion_mode(
+    mode: InsertionMode,
+) -> ObservedInsertionMode {
     match mode {
         InsertionMode::Initial => ObservedInsertionMode::Initial,
         InsertionMode::BeforeHtml => ObservedInsertionMode::BeforeHtml,
diff --git a/crates/html/src/html5/tree_builder/stack/scope.rs b/crates/html/src/html5/tree_builder/stack/scope.rs
index 281b2e45..b9f7ef30 100644
--- a/crates/html/src/html5/tree_builder/stack/scope.rs
+++ b/crates/html/src/html5/tree_builder/stack/scope.rs
@@ -41,12 +41,24 @@ impl OpenElementsStack {
         kind: ScopeKind,
         tags: &ScopeTagSet,
     ) -> bool {
+        self.find_in_scope(target, kind, tags).is_some()
+    }
+
+    /// Returns the exact parser-owned element identity visible in the
+    /// requested scope without mutating the stack.
+    pub(crate) fn find_in_scope(
+        &mut self,
+        target: AtomId,
+        kind: ScopeKind,
+        tags: &ScopeTagSet,
+    ) -> Option<OpenElement> {
         // Probe-only check: no stack mutation, but contributes to scan counters.
         self.scope_scan_calls = self.scope_scan_calls.saturating_add(1);
         if !self.has_name_count(ElementNamespace::Html, target) {
-            return false;
+            return None;
         }
-        self.find_in_scope_match_index(target, kind, tags).is_some()
+        let index = self.find_in_scope_match_index(target, kind, tags)?;
+        self.items.get(index).copied()
     }
 
     /// Removes elements from the top down to and including `target` when it is
diff --git a/crates/html/src/html5/tree_builder/table/close.rs b/crates/html/src/html5/tree_builder/table/close.rs
index 3f0d4e92..82843f9e 100644
--- a/crates/html/src/html5/tree_builder/table/close.rs
+++ b/crates/html/src/html5/tree_builder/table/close.rs
@@ -1,16 +1,33 @@
-use crate::html5::shared::AtomId;
+use crate::html5::shared::{AtomId, TreeConstructionUnsupportedFeature};
 use crate::html5::tree_builder::Html5TreeBuilder;
 use crate::html5::tree_builder::modes::InsertionMode;
 use crate::html5::tree_builder::stack::ScopeKind;
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(in crate::html5::tree_builder) enum CellCloseCause {
+    SameNamedEndTag,
+    MismatchedEndTagSubstitute,
+    TableStructureRecovery,
+}
+
 impl Html5TreeBuilder {
     pub(in crate::html5::tree_builder) fn close_cell(
         &mut self,
-        _context: &mut crate::html5::tree_builder::TreeBuilderProcessContext<'_>,
+        context: &mut crate::html5::tree_builder::TreeBuilderProcessContext<'_>,
+        cause: CellCloseCause,
     ) -> bool {
         let Some(cell) = self.current_table_cell_in_scope() else {
             return false;
         };
+        if cause != CellCloseCause::MismatchedEndTagSubstitute
+            && self.open_elements.current().map(|entry| entry.key()) != Some(cell.key())
+        {
+            self.record_tree_unsupported_feature(
+                context,
+                TreeConstructionUnsupportedFeature::
+                    GenerateImpliedEndTagsAndCheckCurrentNodeBeforeClosingTableCell,
+            );
+        }
         let closed = self.close_element_in_scope(cell.name(), ScopeKind::Table);
         if !closed {
             return false;
@@ -93,12 +110,16 @@ impl Html5TreeBuilder {
         &mut self,
         context: &mut crate::html5::tree_builder::TreeBuilderProcessContext<'_>,
     ) -> bool {
-        if !self.has_in_table_scope(self.known_tags.caption) {
+        let Some(caption) = self.element_in_table_scope(self.known_tags.caption) else {
             self.record_tree_parse_error(context, crate::html5::shared::TreeConstructionParseErrorCode::TableContextElementNotInRequiredScope, Some(crate::html5::shared::ParserRecoveryAction::IgnoreToken), Some("caption-end-tag-not-in-table-scope"));
             return false;
-        }
-        if self.current_node_name() != Some(self.known_tags.caption) {
-            self.record_tree_implementation_diagnostic(context, crate::html5::shared::TreeConstructionImplementationDiagnosticCode::CaptionCloseImpliedEndTagsNotImplemented, Some("caption-close-current-node-mismatch"));
+        };
+        if self.open_elements.current().map(|entry| entry.key()) != Some(caption.key()) {
+            self.record_tree_unsupported_feature(
+                context,
+                TreeConstructionUnsupportedFeature::
+                    GenerateImpliedEndTagsAndCheckCurrentNodeBeforeClosingCaption,
+            );
         }
         let closed = self.close_element_in_scope(self.known_tags.caption, ScopeKind::Table);
         if !closed {
diff --git a/crates/html/src/html5/tree_builder/table/in_cell.rs b/crates/html/src/html5/tree_builder/table/in_cell.rs
index aaa84f8f..e8fedacc 100644
--- a/crates/html/src/html5/tree_builder/table/in_cell.rs
+++ b/crates/html/src/html5/tree_builder/table/in_cell.rs
@@ -1,3 +1,4 @@
+use super::close::CellCloseCause;
 use crate::html5::shared::{AtomTable, Token};
 use crate::html5::tokenizer::TextResolver;
 use crate::html5::tree_builder::dispatch::DispatchOutcome;
@@ -37,13 +38,20 @@ impl Html5TreeBuilder {
                     self.record_tree_parse_error(context, crate::html5::shared::TreeConstructionParseErrorCode::TableContextElementNotInRequiredScope, Some(crate::html5::shared::ParserRecoveryAction::IgnoreToken), Some("in-cell-cell-end-tag-not-in-table-scope"));
                     return Ok(DispatchOutcome::Done);
                 };
-                if open_cell.name() != *name {
-                    self.record_tree_implementation_diagnostic(context, crate::html5::shared::TreeConstructionImplementationDiagnosticCode::MismatchedCellEndTagClosedOpenCell, Some("in-cell-cell-end-tag-open-cell-mismatch"));
-                }
+                let close_cause = if open_cell.name() == *name {
+                    CellCloseCause::SameNamedEndTag
+                } else {
+                    self.record_tree_unsupported_feature(
+                        context,
+                        crate::html5::shared::TreeConstructionUnsupportedFeature::
+                            RequireSameNamedTableCellInScopeForEndTag,
+                    );
+                    CellCloseCause::MismatchedEndTagSubstitute
+                };
                 if self.current_node_name() != Some(*name) {
                     self.record_tree_parse_error(context, crate::html5::shared::TreeConstructionParseErrorCode::CurrentNodeMismatchAfterImpliedEndTags, Some(crate::html5::shared::ParserRecoveryAction::PopOpenElements), Some("in-cell-cell-end-tag-current-node-mismatch"));
                 }
-                let _ = self.close_cell(context);
+                let _ = self.close_cell(context, close_cause);
                 Ok(DispatchOutcome::Done)
             }
             Token::StartTag { name, .. }
@@ -67,7 +75,7 @@ impl Html5TreeBuilder {
                     );
                     return Ok(DispatchOutcome::Done);
                 }
-                if !self.close_cell(context) {
+                if !self.close_cell(context, CellCloseCause::TableStructureRecovery) {
                     return Ok(DispatchOutcome::Done);
                 }
                 Ok(DispatchOutcome::Reprocess(InsertionMode::InRow))
@@ -83,7 +91,7 @@ impl Html5TreeBuilder {
                     self.record_tree_parse_error(context, crate::html5::shared::TreeConstructionParseErrorCode::TableContextElementNotInRequiredScope, Some(crate::html5::shared::ParserRecoveryAction::IgnoreToken), Some("in-cell-table-structure-end-tag-not-in-table-scope"));
                     return Ok(DispatchOutcome::Done);
                 }
-                if !self.close_cell(context) {
+                if !self.close_cell(context, CellCloseCause::TableStructureRecovery) {
                     return Ok(DispatchOutcome::Done);
                 }
                 Ok(DispatchOutcome::Reprocess(InsertionMode::InRow))
diff --git a/crates/html/src/html5/tree_builder/table/mod.rs b/crates/html/src/html5/tree_builder/table/mod.rs
index 3dfca717..f6dd7697 100644
--- a/crates/html/src/html5/tree_builder/table/mod.rs
+++ b/crates/html/src/html5/tree_builder/table/mod.rs
@@ -15,4 +15,6 @@ mod in_table_text;
 mod scope;
 mod state;
 
+#[cfg(test)]
+pub(in crate::html5::tree_builder) use close::CellCloseCause;
 pub(in crate::html5::tree_builder) use state::PendingTableTextState;
diff --git a/crates/html/src/html5/tree_builder/table/scope.rs b/crates/html/src/html5/tree_builder/table/scope.rs
index 43ccf582..30a52747 100644
--- a/crates/html/src/html5/tree_builder/table/scope.rs
+++ b/crates/html/src/html5/tree_builder/table/scope.rs
@@ -25,6 +25,11 @@ impl Html5TreeBuilder {
             .has_in_scope(name, ScopeKind::Table, &self.scope_tags)
     }
 
+    pub(super) fn element_in_table_scope(&mut self, name: AtomId) -> Option<OpenElement> {
+        self.open_elements
+            .find_in_scope(name, ScopeKind::Table, &self.scope_tags)
+    }
+
     pub(super) fn current_table_cell_in_scope(&mut self) -> Option<OpenElement> {
         self.open_elements.find_last_table_cell_in_scope(
             self.known_tags.td,
diff --git a/crates/html/src/html5/tree_builder/tests/api.rs b/crates/html/src/html5/tree_builder/tests/api.rs
index 521cdd8f..242e9625 100644
--- a/crates/html/src/html5/tree_builder/tests/api.rs
+++ b/crates/html/src/html5/tree_builder/tests/api.rs
@@ -130,9 +130,11 @@ fn direct_tree_error_occurrence_overflow_is_a_recorder_invariant() {
     assert_eq!(capture.parse_errors.items.len(), 1);
     assert_eq!(capture.parse_errors.items[0].occurrence, u64::MAX);
     assert_eq!(
-        capture.invariant,
-        Some(ParserObservationInvariant::OccurrenceSequenceOverflow(
-            ObservationOccurrenceSequence::ParseErrors,
+        capture.failure,
+        Some(crate::html5::shared::ParserObservationFailure::Invariant(
+            ParserObservationInvariant::OccurrenceSequenceOverflow(
+                ObservationOccurrenceSequence::ParseErrors,
+            )
         ))
     );
 }
diff --git a/crates/html/src/html5/tree_builder/tests/helpers.rs b/crates/html/src/html5/tree_builder/tests/helpers.rs
index b4486085..63caf2e3 100644
--- a/crates/html/src/html5/tree_builder/tests/helpers.rs
+++ b/crates/html/src/html5/tree_builder/tests/helpers.rs
@@ -60,7 +60,10 @@ impl crate::html5::tree_builder::Html5TreeBuilder {
         ctx: &mut crate::html5::shared::DocumentParseContext,
     ) -> bool {
         let mut context = crate::html5::tree_builder::TreeBuilderProcessContext::new(ctx);
-        self.close_cell(&mut context)
+        self.close_cell(
+            &mut context,
+            crate::html5::tree_builder::table::CellCloseCause::TableStructureRecovery,
+        )
     }
 
     pub(in crate::html5::tree_builder) fn run_adoption_agency_algorithm_for_test(
diff --git a/crates/html/src/html5/tree_builder/tests/table_caption_colgroup.rs b/crates/html/src/html5/tree_builder/tests/table_caption_colgroup.rs
index eac8153f..844b7c17 100644
--- a/crates/html/src/html5/tree_builder/tests/table_caption_colgroup.rs
+++ b/crates/html/src/html5/tree_builder/tests/table_caption_colgroup.rs
@@ -79,6 +79,108 @@ fn in_caption_conflicting_colgroup_start_closes_caption_and_reprocesses() {
     );
 }
 
+#[test]
+fn every_caption_close_caller_preserves_stack_and_afe_close_contract() {
+    use crate::html5::shared::Token;
+    use crate::html5::tree_builder::modes::InsertionMode;
+
+    for (caller, nested) in [
+        ("explicit", false),
+        ("explicit", true),
+        ("conflicting-start", false),
+        ("conflicting-start", true),
+        ("table-end", false),
+        ("table-end", true),
+    ] {
+        let resolver = EmptyResolver;
+        let mut ctx = crate::html5::shared::DocumentParseContext::new();
+        let mut builder = crate::html5::tree_builder::Html5TreeBuilder::new(
+            crate::html5::tree_builder::TreeBuilderConfig::default(),
+            &mut ctx,
+        )
+        .unwrap();
+        let _ = enter_in_body(&mut builder, &mut ctx, &resolver);
+        let table = ctx.atoms.intern_ascii_folded("table").unwrap();
+        let caption = ctx.atoms.intern_ascii_folded("caption").unwrap();
+        let paragraph = ctx.atoms.intern_ascii_folded("p").unwrap();
+        let colgroup = ctx.atoms.intern_ascii_folded("colgroup").unwrap();
+        let body = ctx.atoms.intern_ascii_folded("body").unwrap();
+
+        for token in [
+            Token::StartTag {
+                name: table,
+                attrs: Vec::new(),
+                self_closing: false,
+            },
+            Token::StartTag {
+                name: caption,
+                attrs: Vec::new(),
+                self_closing: false,
+            },
+        ] {
+            let _ = builder
+                .process(
+                    &token,
+                    &mut crate::html5::tree_builder::TreeBuilderProcessContext::new(&mut ctx),
+                    &resolver,
+                )
+                .unwrap();
+        }
+        if nested {
+            let _ = builder
+                .process(
+                    &Token::StartTag {
+                        name: paragraph,
+                        attrs: Vec::new(),
+                        self_closing: false,
+                    },
+                    &mut crate::html5::tree_builder::TreeBuilderProcessContext::new(&mut ctx),
+                    &resolver,
+                )
+                .unwrap();
+        }
+
+        let close_token = match caller {
+            "explicit" => Token::EndTag { name: caption },
+            "conflicting-start" => Token::StartTag {
+                name: colgroup,
+                attrs: Vec::new(),
+                self_closing: false,
+            },
+            "table-end" => Token::EndTag { name: table },
+            _ => unreachable!(),
+        };
+        let _ = builder
+            .process(
+                &close_token,
+                &mut crate::html5::tree_builder::TreeBuilderProcessContext::new(&mut ctx),
+                &resolver,
+            )
+            .unwrap();
+
+        let state = builder.state_snapshot();
+        let (expected_mode, expected_current) = match caller {
+            "explicit" => (InsertionMode::InTable, table),
+            "conflicting-start" => (InsertionMode::InColumnGroup, colgroup),
+            "table-end" => (InsertionMode::InBody, body),
+            _ => unreachable!(),
+        };
+        assert_eq!(
+            state.insertion_mode, expected_mode,
+            "caller={caller} nested={nested}"
+        );
+        assert_eq!(
+            state.open_element_names.last().copied(),
+            Some(expected_current),
+            "caller={caller} nested={nested}"
+        );
+        assert!(
+            builder.active_formatting.entries().is_empty(),
+            "caller={caller} nested={nested}"
+        );
+    }
+}
+
 #[test]
 fn in_caption_stray_end_tag_is_ignored_without_popping_caption() {
     use crate::html5::shared::Token;
diff --git a/crates/html/src/html5/tree_builder/tests/table_cell.rs b/crates/html/src/html5/tree_builder/tests/table_cell.rs
index 1f159830..cbc36266 100644
--- a/crates/html/src/html5/tree_builder/tests/table_cell.rs
+++ b/crates/html/src/html5/tree_builder/tests/table_cell.rs
@@ -5,11 +5,21 @@ use crate::dom_patch::DomPatch;
 
 #[test]
 fn mismatched_cell_end_tag_closes_current_cell_and_returns_to_in_row() {
-    use crate::html5::shared::{TextValue, Token};
+    use crate::html5::shared::{
+        ErrorPolicy, ParserObservationConfig, SurfaceCaptureRequest, TextValue, Token,
+        TreeConstructionUnsupportedFeature, UnsupportedFeatureEvent,
+    };
     use crate::html5::tree_builder::modes::InsertionMode;
 
     let resolver = EmptyResolver;
-    let mut ctx = crate::html5::shared::DocumentParseContext::with_tree_observations_for_test();
+    let mut ctx = crate::html5::shared::DocumentParseContext::with_observations(
+        ErrorPolicy::default(),
+        ParserObservationConfig {
+            parse_errors: SurfaceCaptureRequest::Capture { capacity: 16 },
+            unsupported_features: SurfaceCaptureRequest::Capture { capacity: 4 },
+            ..ParserObservationConfig::default()
+        },
+    );
     let mut builder = crate::html5::tree_builder::Html5TreeBuilder::new(
         crate::html5::tree_builder::TreeBuilderConfig::default(),
         &mut ctx,
@@ -53,7 +63,7 @@ fn mismatched_cell_end_tag_closes_current_cell_and_returns_to_in_row() {
 
     let tr = ctx.atoms.intern_ascii_folded("tr").expect("atom interning");
     let state = builder.state_snapshot();
-    let diagnostics = ctx.take_tree_implementation_diagnostic_descriptions_for_test();
+    let capture = ctx.take_observations().expect("requested observations");
 
     assert_eq!(state.insertion_mode, InsertionMode::InRow);
     assert_eq!(
@@ -65,10 +75,24 @@ fn mismatched_cell_end_tag_closes_current_cell_and_returns_to_in_row() {
         builder.active_formatting.entries().is_empty(),
         "closing a mismatched cell must clear AFE back to the cell marker"
     );
-    assert!(
-        diagnostics.contains(&"in-cell-cell-end-tag-open-cell-mismatch"),
-        "mismatched cell end tags should record the cell-name mismatch"
+    assert_eq!(capture.unsupported_features.items.len(), 1);
+    let UnsupportedFeatureEvent::TreeConstruction {
+        occurrence,
+        feature,
+        ..
+    } = &capture.unsupported_features.items[0];
+    assert_eq!(*occurrence, 1);
+    assert_eq!(
+        *feature,
+        TreeConstructionUnsupportedFeature::RequireSameNamedTableCellInScopeForEndTag
     );
+    assert!(capture.parse_errors.items.iter().any(|event| {
+        event.code
+            == crate::html5::shared::ParseErrorCode::TreeConstruction(
+                crate::html5::shared::TreeConstructionParseErrorCode::
+                    CurrentNodeMismatchAfterImpliedEndTags,
+            )
+    }));
 }
 
 #[test]
diff --git a/crates/html/src/html5/tree_builder/tests/table_state.rs b/crates/html/src/html5/tree_builder/tests/table_state.rs
index f8cbc1b0..2bca029a 100644
--- a/crates/html/src/html5/tree_builder/tests/table_state.rs
+++ b/crates/html/src/html5/tree_builder/tests/table_state.rs
@@ -121,6 +121,49 @@ fn in_table_text_without_pending_state_is_internal_invariant_error() {
     );
 }
 
+#[test]
+fn in_cell_without_a_scoped_cell_reports_only_the_existing_parse_error() {
+    use crate::html5::shared::{
+        ErrorPolicy, ParserObservationConfig, SurfaceCaptureRequest, Token,
+        TreeConstructionParseErrorCode,
+    };
+
+    let resolver = EmptyResolver;
+    let mut ctx = crate::html5::shared::DocumentParseContext::with_observations(
+        ErrorPolicy::default(),
+        ParserObservationConfig {
+            parse_errors: SurfaceCaptureRequest::Capture { capacity: 4 },
+            unsupported_features: SurfaceCaptureRequest::Capture { capacity: 4 },
+            ..ParserObservationConfig::default()
+        },
+    );
+    let td = ctx.atoms.intern_ascii_folded("td").expect("td atom");
+    let mut builder = crate::html5::tree_builder::Html5TreeBuilder::new(
+        crate::html5::tree_builder::TreeBuilderConfig::default(),
+        &mut ctx,
+    )
+    .expect("tree builder init");
+    builder.insertion_mode = InsertionMode::InCell;
+
+    let _ = builder
+        .process(
+            &Token::EndTag { name: td },
+            &mut crate::html5::tree_builder::TreeBuilderProcessContext::new(&mut ctx),
+            &resolver,
+        )
+        .expect("the authored token is ignored recoverably");
+
+    let capture = ctx.take_observations().expect("requested capture");
+    assert!(capture.unsupported_features.items.is_empty());
+    assert_eq!(capture.parse_errors.items.len(), 1);
+    assert_eq!(
+        capture.parse_errors.items[0].code,
+        crate::html5::shared::ParseErrorCode::TreeConstruction(
+            TreeConstructionParseErrorCode::TableContextElementNotInRequiredScope
+        )
+    );
+}
+
 #[test]
 fn entering_in_table_text_twice_is_non_destructive_internal_invariant_error() {
     let mut ctx = crate::html5::shared::DocumentParseContext::with_tree_observations_for_test();
diff --git a/crates/html/src/html5/tree_builder/unsupported.rs b/crates/html/src/html5/tree_builder/unsupported.rs
new file mode 100644
index 00000000..30dbdc16
--- /dev/null
+++ b/crates/html/src/html5/tree_builder/unsupported.rs
@@ -0,0 +1,456 @@
+use crate::html5::shared::{
+    AtomTable, Attribute, TreeConstructionUnsupportedFeature, UnsupportedFeatureObservationFailure,
+};
+use crate::html5::tree_builder::attributes::has_missing_unqualified_token_attribute_first_wins;
+use crate::html5::tree_builder::{Html5TreeBuilder, TreeBuilderProcessContext};
+use crate::names::ElementNamespace;
+
+impl Html5TreeBuilder {
+    pub(in crate::html5::tree_builder) fn observe_repeated_html_start_rule(
+        &mut self,
+        attrs: &[Attribute],
+        atoms: &AtomTable,
+        context: &mut TreeBuilderProcessContext<'_>,
+    ) {
+        if !context.unsupported_features_requested()
+            || self
+                .open_elements
+                .contains_html_name(self.known_tags.template)
+        {
+            return;
+        }
+        let Some(root) = self.open_elements.get(0) else {
+            return;
+        };
+        if root.namespace() != ElementNamespace::Html || root.name() != self.known_tags.html {
+            return;
+        }
+        let Some((expanded_name, existing_attributes)) =
+            self.live_tree.element_semantics(root.key())
+        else {
+            context.record_unsupported_feature_observation_failure(
+                UnsupportedFeatureObservationFailure::ExistingHtmlElementSemanticsUnavailable,
+            );
+            return;
+        };
+        if expanded_name.namespace() != ElementNamespace::Html
+            || expanded_name.local_name_str() != "html"
+        {
+            context.record_unsupported_feature_observation_failure(
+                UnsupportedFeatureObservationFailure::ExistingElementIdentityContradiction,
+            );
+            return;
+        }
+        let missing = match has_missing_unqualified_token_attribute_first_wins(
+            attrs,
+            existing_attributes,
+            atoms,
+        ) {
+            Ok(missing) => missing,
+            Err(failure) => {
+                context.record_unsupported_feature_observation_failure(failure);
+                return;
+            }
+        };
+        if missing {
+            self.record_tree_unsupported_feature(
+                context,
+                TreeConstructionUnsupportedFeature::MergeAttributesIntoExistingHtmlElement,
+            );
+        }
+    }
+
+    pub(in crate::html5::tree_builder) fn observe_repeated_body_start_rule(
+        &mut self,
+        attrs: &[Attribute],
+        atoms: &AtomTable,
+        context: &mut TreeBuilderProcessContext<'_>,
+    ) {
+        if !context.unsupported_features_requested()
+            || self
+                .open_elements
+                .contains_html_name(self.known_tags.template)
+        {
+            return;
+        }
+        let Some(body) = self.open_elements.get(1) else {
+            return;
+        };
+        if body.namespace() != ElementNamespace::Html || body.name() != self.known_tags.body {
+            return;
+        }
+        if self.document_state.frameset_ok {
+            self.record_tree_unsupported_feature(
+                context,
+                TreeConstructionUnsupportedFeature::MarkFramesetNotOkForRepeatedBodyStartTag,
+            );
+        }
+        let Some((expanded_name, existing_attributes)) =
+            self.live_tree.element_semantics(body.key())
+        else {
+            context.record_unsupported_feature_observation_failure(
+                UnsupportedFeatureObservationFailure::ExistingBodyElementSemanticsUnavailable,
+            );
+            return;
+        };
+        if expanded_name.namespace() != ElementNamespace::Html
+            || expanded_name.local_name_str() != "body"
+        {
+            context.record_unsupported_feature_observation_failure(
+                UnsupportedFeatureObservationFailure::ExistingElementIdentityContradiction,
+            );
+            return;
+        }
+
+        let missing = match has_missing_unqualified_token_attribute_first_wins(
+            attrs,
+            existing_attributes,
+            atoms,
+        ) {
+            Ok(missing) => missing,
+            Err(failure) => {
+                context.record_unsupported_feature_observation_failure(failure);
+                return;
+            }
+        };
+        if missing {
+            self.record_tree_unsupported_feature(
+                context,
+                TreeConstructionUnsupportedFeature::MergeAttributesIntoExistingBodyElement,
+            );
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::html5::shared::{
+        AttributeValue, DocumentParseContext, ErrorPolicy, ParserObservationCapture,
+        ParserObservationCaptureFailure, ParserObservationConfig, ParserObservationFailure,
+        SurfaceCaptureRequest, TextSpan, Token, UnsupportedFeatureEvent,
+    };
+    use crate::html5::tokenizer::{TextResolveError, TextResolver};
+    use crate::html5::tree_builder::stack::OpenElement;
+    use crate::html5::tree_builder::{TreeBuilderConfig, TreeBuilderProcessContext};
+
+    struct NoSpans;
+
+    impl TextResolver for NoSpans {
+        fn resolve_span(&self, span: TextSpan) -> Result<&str, TextResolveError> {
+            Err(TextResolveError::InvalidSpan { span })
+        }
+    }
+
+    fn finish_implied_document(builder: &mut Html5TreeBuilder, context: &mut DocumentParseContext) {
+        let _ = builder
+            .process(
+                &Token::Eof,
+                &mut TreeBuilderProcessContext::new(context),
+                &NoSpans,
+            )
+            .unwrap();
+    }
+
+    fn repeated_body_builder(capacity: usize) -> (DocumentParseContext, Html5TreeBuilder) {
+        let mut owner = DocumentParseContext::with_observations(
+            ErrorPolicy::default(),
+            ParserObservationConfig {
+                unsupported_features: SurfaceCaptureRequest::Capture { capacity },
+                ..ParserObservationConfig::default()
+            },
+        );
+        let mut builder = Html5TreeBuilder::new(TreeBuilderConfig::default(), &mut owner).unwrap();
+        finish_implied_document(&mut builder, &mut owner);
+        let _ = builder.drain_patches();
+        (owner, builder)
+    }
+
+    fn missing_attribute(owner: &mut DocumentParseContext) -> Attribute {
+        Attribute {
+            name: owner.atoms.intern_ascii_folded("missing").unwrap(),
+            value: AttributeValue::Owned("value".to_string()),
+        }
+    }
+
+    fn record_repeated_body(
+        builder: &mut Html5TreeBuilder,
+        owner: &mut DocumentParseContext,
+        attrs: &[Attribute],
+    ) {
+        let mut process = TreeBuilderProcessContext::new(owner);
+        let atoms = process.atoms();
+        builder.observe_repeated_body_start_rule(attrs, atoms, &mut process);
+    }
+
+    fn feature_occurrences(
+        capture: &ParserObservationCapture,
+    ) -> Vec<(u64, TreeConstructionUnsupportedFeature)> {
+        capture
+            .unsupported_features
+            .items
+            .iter()
+            .map(|event| match event {
+                UnsupportedFeatureEvent::TreeConstruction {
+                    occurrence,
+                    feature,
+                    ..
+                } => (*occurrence, *feature),
+            })
+            .collect()
+    }
+
+    #[test]
+    fn unrequested_attribute_eligibility_does_not_resolve_token_names() {
+        let mut owner = DocumentParseContext::new();
+        let mut builder = Html5TreeBuilder::new(TreeBuilderConfig::default(), &mut owner).unwrap();
+        finish_implied_document(&mut builder, &mut owner);
+        let mut foreign_atoms = crate::html5::shared::AtomTable::default();
+        let invalid_here = foreign_atoms.intern_ascii_folded("missing").unwrap();
+        let mut process = TreeBuilderProcessContext::new(&mut owner);
+        let atoms = process.atoms();
+        builder.observe_repeated_html_start_rule(
+            &[Attribute {
+                name: invalid_here,
+                value: AttributeValue::Owned("x".to_string()),
+            }],
+            atoms,
+            &mut process,
+        );
+        assert!(owner.take_observations().is_none());
+    }
+
+    #[test]
+    fn requested_attribute_eligibility_failure_is_passively_latched() {
+        let mut owner = DocumentParseContext::with_observations(
+            ErrorPolicy::default(),
+            ParserObservationConfig {
+                unsupported_features: SurfaceCaptureRequest::Capture { capacity: 4 },
+                ..ParserObservationConfig::default()
+            },
+        );
+        let mut builder = Html5TreeBuilder::new(TreeBuilderConfig::default(), &mut owner).unwrap();
+        finish_implied_document(&mut builder, &mut owner);
+        let mut foreign_atoms = crate::html5::shared::AtomTable::default();
+        let invalid_here = foreign_atoms.intern_ascii_folded("missing").unwrap();
+        let mut process = TreeBuilderProcessContext::new(&mut owner);
+        let atoms = process.atoms();
+        builder.observe_repeated_html_start_rule(
+            &[Attribute {
+                name: invalid_here,
+                value: AttributeValue::Owned("x".to_string()),
+            }],
+            atoms,
+            &mut process,
+        );
+        let capture = owner.take_observations().unwrap();
+        assert!(capture.unsupported_features.items.is_empty());
+        assert_eq!(
+            capture.failure,
+            Some(ParserObservationFailure::Capture(
+                ParserObservationCaptureFailure::UnsupportedFeatureEligibility(
+                    UnsupportedFeatureObservationFailure::TokenAttributeNameUnavailable
+                )
+            ))
+        );
+    }
+
+    #[test]
+    fn repeated_body_rule_requires_the_authoritative_second_stack_entry() {
+        let mut owner = DocumentParseContext::with_observations(
+            ErrorPolicy::default(),
+            ParserObservationConfig {
+                unsupported_features: SurfaceCaptureRequest::Capture { capacity: 4 },
+                ..ParserObservationConfig::default()
+            },
+        );
+        let mut builder = Html5TreeBuilder::new(TreeBuilderConfig::default(), &mut owner).unwrap();
+        finish_implied_document(&mut builder, &mut owner);
+        let body = builder.open_elements.pop().expect("implied body");
+        let div = owner.atoms.intern_ascii_folded("div").unwrap();
+        builder
+            .open_elements
+            .try_reserve_push(ElementNamespace::Html, div)
+            .unwrap();
+        builder
+            .open_elements
+            .push(OpenElement::new_html(body.key(), div));
+        let missing = owner.atoms.intern_ascii_folded("missing").unwrap();
+        let mut process = TreeBuilderProcessContext::new(&mut owner);
+        let atoms = process.atoms();
+        builder.observe_repeated_body_start_rule(
+            &[Attribute {
+                name: missing,
+                value: AttributeValue::Owned("x".to_string()),
+            }],
+            atoms,
+            &mut process,
+        );
+        let capture = owner.take_observations().unwrap();
+        assert!(capture.unsupported_features.items.is_empty());
+        assert_eq!(capture.failure, None);
+    }
+
+    #[test]
+    fn repeated_body_frameset_and_merge_observations_are_independent_and_ordered() {
+        let frameset = TreeConstructionUnsupportedFeature::MarkFramesetNotOkForRepeatedBodyStartTag;
+        let merge = TreeConstructionUnsupportedFeature::MergeAttributesIntoExistingBodyElement;
+
+        let (mut empty_owner, mut empty_builder) = repeated_body_builder(4);
+        assert!(empty_builder.document_state.frameset_ok);
+        record_repeated_body(&mut empty_builder, &mut empty_owner, &[]);
+        let empty_capture = empty_owner.take_observations().unwrap();
+        assert_eq!(feature_occurrences(&empty_capture), vec![(1, frameset)]);
+        assert!(empty_builder.document_state.frameset_ok);
+        assert!(empty_builder.drain_patches().is_empty());
+
+        let (mut merge_owner, mut merge_builder) = repeated_body_builder(4);
+        merge_builder.document_state.frameset_ok = false;
+        let missing = missing_attribute(&mut merge_owner);
+        record_repeated_body(&mut merge_builder, &mut merge_owner, &[missing]);
+        let merge_capture = merge_owner.take_observations().unwrap();
+        assert_eq!(feature_occurrences(&merge_capture), vec![(1, merge)]);
+        assert!(!merge_builder.document_state.frameset_ok);
+        assert!(merge_builder.drain_patches().is_empty());
+
+        let (mut both_owner, mut both_builder) = repeated_body_builder(4);
+        let missing = missing_attribute(&mut both_owner);
+        record_repeated_body(&mut both_builder, &mut both_owner, &[missing]);
+        let both_capture = both_owner.take_observations().unwrap();
+        assert_eq!(
+            feature_occurrences(&both_capture),
+            vec![(1, frameset), (2, merge)]
+        );
+        assert_eq!(both_capture.failure, None);
+        assert!(both_builder.document_state.frameset_ok);
+        assert!(both_builder.drain_patches().is_empty());
+    }
+
+    #[test]
+    fn repeated_body_frameset_occurrence_precedes_passive_merge_eligibility_failure() {
+        let (mut owner, mut builder) = repeated_body_builder(4);
+        let state_before = builder.state_snapshot();
+        let mut foreign_atoms = AtomTable::default();
+        let unavailable_name = foreign_atoms.intern_ascii_folded("missing").unwrap();
+        record_repeated_body(
+            &mut builder,
+            &mut owner,
+            &[Attribute {
+                name: unavailable_name,
+                value: AttributeValue::Owned("value".to_string()),
+            }],
+        );
+
+        let capture = owner.take_observations().unwrap();
+        assert_eq!(
+            feature_occurrences(&capture),
+            vec![(
+                1,
+                TreeConstructionUnsupportedFeature::MarkFramesetNotOkForRepeatedBodyStartTag
+            )]
+        );
+        assert_eq!(
+            capture.failure,
+            Some(ParserObservationFailure::Capture(
+                ParserObservationCaptureFailure::UnsupportedFeatureEligibility(
+                    UnsupportedFeatureObservationFailure::TokenAttributeNameUnavailable
+                )
+            ))
+        );
+        assert_eq!(builder.state_snapshot(), state_before);
+        assert!(builder.drain_patches().is_empty());
+    }
+
+    #[test]
+    fn repeated_body_applicability_suppresses_both_events_before_observer_lookup() {
+        for stack_case in ["template", "missing-body", "non-body"] {
+            let (mut owner, mut builder) = repeated_body_builder(4);
+            match stack_case {
+                "template" => {
+                    let template = builder.known_tags.template;
+                    builder
+                        .open_elements
+                        .try_reserve_push(ElementNamespace::Html, template)
+                        .unwrap();
+                    builder.open_elements.push(OpenElement::new_html(
+                        crate::dom_patch::PatchKey(u32::MAX),
+                        template,
+                    ));
+                }
+                "missing-body" => {
+                    let _ = builder.open_elements.pop().expect("implied body");
+                }
+                "non-body" => {
+                    let body = builder.open_elements.pop().expect("implied body");
+                    let div = owner.atoms.intern_ascii_folded("div").unwrap();
+                    builder
+                        .open_elements
+                        .try_reserve_push(ElementNamespace::Html, div)
+                        .unwrap();
+                    builder
+                        .open_elements
+                        .push(OpenElement::new_html(body.key(), div));
+                }
+                _ => unreachable!(),
+            }
+            let mut foreign_atoms = AtomTable::default();
+            let unavailable_name = foreign_atoms.intern_ascii_folded("missing").unwrap();
+            record_repeated_body(
+                &mut builder,
+                &mut owner,
+                &[Attribute {
+                    name: unavailable_name,
+                    value: AttributeValue::Owned("value".to_string()),
+                }],
+            );
+            let capture = owner.take_observations().unwrap();
+            assert!(
+                capture.unsupported_features.items.is_empty(),
+                "{stack_case}"
+            );
+            assert_eq!(capture.failure, None, "{stack_case}");
+        }
+    }
+
+    #[test]
+    fn repeated_body_zero_and_exhausted_capacity_drop_both_events_passively() {
+        let (mut zero_owner, mut zero_builder) = repeated_body_builder(0);
+        let missing = missing_attribute(&mut zero_owner);
+        let zero_state = zero_builder.state_snapshot();
+        record_repeated_body(&mut zero_builder, &mut zero_owner, &[missing]);
+        let zero_capture = zero_owner.take_observations().unwrap();
+        assert!(zero_capture.unsupported_features.items.is_empty());
+        assert_eq!(zero_capture.unsupported_features.dropped, 2);
+        assert_eq!(zero_capture.failure, None);
+        assert_eq!(zero_builder.state_snapshot(), zero_state);
+        assert!(zero_builder.drain_patches().is_empty());
+
+        let (mut full_owner, mut full_builder) = repeated_body_builder(2);
+        let missing = missing_attribute(&mut full_owner);
+        record_repeated_body(
+            &mut full_builder,
+            &mut full_owner,
+            std::slice::from_ref(&missing),
+        );
+        let full_state = full_builder.state_snapshot();
+        record_repeated_body(&mut full_builder, &mut full_owner, &[missing]);
+        let full_capture = full_owner.take_observations().unwrap();
+        assert_eq!(
+            feature_occurrences(&full_capture),
+            vec![
+                (
+                    1,
+                    TreeConstructionUnsupportedFeature::MarkFramesetNotOkForRepeatedBodyStartTag
+                ),
+                (
+                    2,
+                    TreeConstructionUnsupportedFeature::MergeAttributesIntoExistingBodyElement
+                )
+            ]
+        );
+        assert_eq!(full_capture.unsupported_features.dropped, 2);
+        assert_eq!(full_capture.failure, None);
+        assert_eq!(full_builder.state_snapshot(), full_state);
+        assert!(full_builder.drain_patches().is_empty());
+    }
+}
diff --git a/crates/html/src/parser/tests.rs b/crates/html/src/parser/tests.rs
index ec415a3a..988cd2b6 100644
--- a/crates/html/src/parser/tests.rs
+++ b/crates/html/src/parser/tests.rs
@@ -455,6 +455,7 @@ fn passive_observation_preserves_complete_parser_output_whole_and_chunked() {
                 tokens: SurfaceCaptureRequest::Capture { capacity: 256 },
                 parse_errors: SurfaceCaptureRequest::Capture { capacity: 256 },
                 implementation_diagnostics: SurfaceCaptureRequest::Capture { capacity: 256 },
+                ..ParserObservationConfig::default()
             },
         )
         .expect("observed parser init");
@@ -531,6 +532,7 @@ fn document_mode_capture_is_whole_and_chunk_delivery_invariant() {
                 tokens: SurfaceCaptureRequest::Capture { capacity: 256 },
                 parse_errors: SurfaceCaptureRequest::Capture { capacity: 256 },
                 implementation_diagnostics: SurfaceCaptureRequest::Capture { capacity: 256 },
+                ..ParserObservationConfig::default()
             },
         )
         .expect("observed parser init");
@@ -544,8 +546,7 @@ fn document_mode_capture_is_whole_and_chunk_delivery_invariant() {
             .take_observations_for_conformance()
             .expect("observation drain")
             .expect("document-mode observation capture");
-        assert!(!capture.token_capture_failed);
-        assert_eq!(capture.invariant, None);
+        assert_eq!(capture.failure, None);
         assert_eq!(capture.tokens.dropped, 0);
         assert_eq!(capture.parse_errors.dropped, 0);
         assert_eq!(capture.implementation_diagnostics.dropped, 0);
@@ -642,6 +643,7 @@ fn comment_observation_is_neutral_and_legacy_projection_stays_lossy_at_every_spl
                     tokens: SurfaceCaptureRequest::Capture { capacity: 32 },
                     parse_errors: SurfaceCaptureRequest::Capture { capacity: 32 },
                     implementation_diagnostics: SurfaceCaptureRequest::Capture { capacity: 32 },
+                    ..ParserObservationConfig::default()
                 },
             )
             .expect("observed parser")
@@ -806,6 +808,7 @@ fn start_tag_solidus_semantics_preserve_tokens_diagnostics_dom_and_patches_at_ev
                     tokens: SurfaceCaptureRequest::Capture { capacity: 32 },
                     parse_errors: SurfaceCaptureRequest::Capture { capacity: 32 },
                     implementation_diagnostics: SurfaceCaptureRequest::Capture { capacity: 32 },
+                    ..ParserObservationConfig::default()
                 },
             )
             .expect("observed parser")
@@ -1018,6 +1021,7 @@ fn supported_void_rule_groups_acknowledge_self_closing_at_every_split() {
                     tokens: SurfaceCaptureRequest::NotRequested,
                     parse_errors: SurfaceCaptureRequest::Capture { capacity: 256 },
                     implementation_diagnostics: SurfaceCaptureRequest::Capture { capacity: 256 },
+                    ..ParserObservationConfig::default()
                 },
             )
             .expect("observed parser")
@@ -1153,6 +1157,7 @@ fn configured_insertion_suppression_never_claims_legacy_stack_alteration() {
                     tokens: SurfaceCaptureRequest::NotRequested,
                     parse_errors: SurfaceCaptureRequest::Capture { capacity: 16 },
                     implementation_diagnostics: SurfaceCaptureRequest::Capture { capacity: 16 },
+                    ..ParserObservationConfig::default()
                 },
             )
             .expect("observed parser")
@@ -1296,6 +1301,7 @@ fn text_mode_end_tag_position_observation_preserves_dom_patches_and_legacy_outpu
                     tokens: SurfaceCaptureRequest::Capture { capacity: 64 },
                     parse_errors: SurfaceCaptureRequest::Capture { capacity: 64 },
                     implementation_diagnostics: SurfaceCaptureRequest::Capture { capacity: 64 },
+                    ..ParserObservationConfig::default()
                 },
             )
             .expect("observed parser")
@@ -1416,6 +1422,7 @@ fn tokenizer_recovery_metadata_matches_literal_references_and_duplicate_attribut
                     tokens: SurfaceCaptureRequest::Capture { capacity: 32 },
                     parse_errors: SurfaceCaptureRequest::Capture { capacity: 32 },
                     implementation_diagnostics: SurfaceCaptureRequest::Capture { capacity: 32 },
+                    ..ParserObservationConfig::default()
                 },
             )
             .expect("observed parser")
@@ -1650,6 +1657,7 @@ fn malformed_byte_observation_is_counter_and_output_neutral_at_every_split() {
                     tokens: SurfaceCaptureRequest::Capture { capacity: 256 },
                     parse_errors: SurfaceCaptureRequest::Capture { capacity: 256 },
                     implementation_diagnostics: SurfaceCaptureRequest::Capture { capacity },
+                    ..ParserObservationConfig::default()
                 },
             )
             .expect("observed parser init"),
@@ -1799,6 +1807,7 @@ fn tree_errors_count_without_becoming_fabricated_legacy_position_events() {
             tokens: SurfaceCaptureRequest::NotRequested,
             parse_errors: SurfaceCaptureRequest::Capture { capacity: 8 },
             implementation_diagnostics: SurfaceCaptureRequest::NotRequested,
+            ..ParserObservationConfig::default()
         },
     )
     .expect("observed parser");
diff --git a/crates/html/src/test_harness/tree_diagnostics.rs b/crates/html/src/test_harness/tree_diagnostics.rs
index 43d051a6..74e377e0 100644
--- a/crates/html/src/test_harness/tree_diagnostics.rs
+++ b/crates/html/src/test_harness/tree_diagnostics.rs
@@ -22,6 +22,8 @@ impl TreeDiagnosticProjection {
                     capacity: GOLDEN_TREE_PARSE_ERROR_CAPACITY,
                 },
                 implementation_diagnostics: SurfaceCaptureRequest::NotRequested,
+                tree_transitions: SurfaceCaptureRequest::NotRequested,
+                unsupported_features: SurfaceCaptureRequest::NotRequested,
             },
         )
     }
@@ -38,13 +40,8 @@ impl TreeDiagnosticProjection {
         let capture = context
             .take_observations()
             .ok_or_else(|| "tree diagnostic observation recorder was not installed".to_string())?;
-        if let Some(invariant) = capture.invariant {
-            return Err(format!(
-                "tree diagnostic observation invariant failed: {invariant:?}"
-            ));
-        }
-        if capture.token_capture_failed {
-            return Err("unexpected token-capture failure in tree diagnostic adapter".to_string());
+        if let Some(failure) = capture.failure {
+            return Err(format!("tree diagnostic observation failed: {failure:?}"));
         }
         if !capture.parse_errors.requested {
             return Err("tree parse-error capture was not requested".to_string());
diff --git a/crates/html_test_support/src/wpt_tokenizer.rs b/crates/html_test_support/src/wpt_tokenizer.rs
index 23857912..f9a5cdf8 100644
--- a/crates/html_test_support/src/wpt_tokenizer.rs
+++ b/crates/html_test_support/src/wpt_tokenizer.rs
@@ -198,6 +198,8 @@ pub fn run_tokenizer_whole_observed(
         tokens: ObservationRequest::Capture { capacity },
         parse_errors: ObservationRequest::NotRequested,
         implementation_diagnostics: ObservationRequest::NotRequested,
+        transitions: ObservationRequest::NotRequested,
+        unsupported_features: ObservationRequest::NotRequested,
         document_mode: html::conformance::ScalarObservationRequest::NotRequested,
         tree: ObservationRequest::NotRequested,
         patches: ObservationRequest::NotRequested,
diff --git a/docs/engine-feature-gap-tracker.md b/docs/engine-feature-gap-tracker.md
index 2ac283db..00ad3247 100644
--- a/docs/engine-feature-gap-tracker.md
+++ b/docs/engine-feature-gap-tracker.md
@@ -445,8 +445,18 @@ Current supported subset:
   assigns first-appearance labels, and validates retained creation history.
   These capacities are not byte budgets, and the existing parser-owned
   materializer is not claimed to be stack-independent. Canonical serializers,
-  fixture sidecars/corpus migration, transitions, unsupported features, and
-  AE13c final invariants remain deferred. Full doctype classification
+  fixture sidecars/corpus migration, and AE13c final invariants remain
+  deferred. AE13b4 adds always-compiled parser-owned tree dispatch transitions
+  and exact unsupported-feature observations. One central event records each
+  ordinary HTML, shared-template, Text-mode, or foreign attempt; foreign
+  breakout/end fallback uses a visible one-shot HTML-rules-only redispatch.
+  Both surfaces independently own bounded retained prefixes, occurrences,
+  drops, and passive first-observed failure. Transition capacity bounds event
+  count, not retained string bytes. The exact unsupported set records six
+  production omissions: repeated html/body attribute merge, repeated-body
+  `frameset_ok`, same-named table-cell end-tag validation, cell close
+  preparation, and caption close preparation. None of those algorithms is
+  implemented by AE13b4. Full doctype classification
   conformance is not claimed. See
   `docs/html5/ae13-parser-conformance-regression-harness.md`.
 - AE1 HTML parser ownership architecture: HTML/parser owns tokenizer input
@@ -558,6 +568,9 @@ Current supported subset:
   construction; table-specific scope and stack-clearing helpers; table-cell
   AFE markers; pending table-character-token buffering and EOF flushing; and
   foster parenting as adjusted insertion-location selection before insertion.
+  Its deterministic mismatched-cell substitute does not implement the
+  same-named `td`/`th` end-tag guard, and cell/caption closure omits the required
+  implied-end-tag/current-node preparation; AE13b4 reports those exact gaps.
   See `docs/html5/ae8-specialized-table-tree-construction-contract.md`.
   AE8 does not claim full WHATWG table conformance, table layout, CSS table
   formatting, select/template table branches, foreign-content table behavior,
@@ -609,6 +622,9 @@ Missing or incomplete:
   subsets, including
   advanced insertion modes and malformed-markup recovery outside the documented
   Core-v0 scope
+- repeated html/body attribute merging and repeated-body `frameset_ok`;
+  same-named table-cell end-tag recovery and complete cell/caption close
+  preparation (observed exactly by AE13b4, not implemented)
 - full DOM API surface
 - public DOM `DocumentType` API exposure
 - script integration
diff --git a/docs/html5/ae10-template-tree-construction-contract.md b/docs/html5/ae10-template-tree-construction-contract.md
index 38433dbc..86ead68d 100644
--- a/docs/html5/ae10-template-tree-construction-contract.md
+++ b/docs/html5/ae10-template-tree-construction-contract.md
@@ -233,6 +233,14 @@ table/column/body/row starts replace the template mode and reprocess; other
 starts replace with `InBody`; template end tags use shared close; EOF uses
 template recovery.
 
+AE13b4 makes that interception visible as exactly one central
+`SharedTemplateRules` dispatch attempt. Calls from the shared algorithm into
+InHead or InBody rules remain internal delegation and do not create another
+transition. A template/table mode replacement that returns `Reprocess` creates
+a later central attempt for the same logical token. The dedicated template EOF
+unwind happens before the next traced attempt and is not itself a dispatch
+attempt.
+
 Adjusted insertion-location calculation redirects insertions whose target is a
 template host to its contents root. That applies to elements, text, comments,
 reconstructed formatting elements, foster-parented nodes, and supported AAA
diff --git a/docs/html5/ae11-foreign-content-tree-construction-contract.md b/docs/html5/ae11-foreign-content-tree-construction-contract.md
index f9706756..fe28703f 100644
--- a/docs/html5/ae11-foreign-content-tree-construction-contract.md
+++ b/docs/html5/ae11-foreign-content-tree-construction-contract.md
@@ -222,8 +222,9 @@ replacement/error path.
 
 ## Per-token dispatch and namespace selection
 
-The active HTML insertion mode never becomes a foreign or XML mode. Before
-ordinary insertion-mode dispatch, each supported token is classified:
+The active HTML insertion mode never becomes a foreign or XML mode. The
+central tree-builder driver classifies each supported token before selecting
+an HTML-rules-family attempt:
 
 - empty stack, HTML adjusted current node, or EOF: ordinary HTML dispatch;
 - MathML `mi`, `mo`, `mn`, `ms`, or `mtext`: character tokens and start tags
@@ -283,15 +284,19 @@ For a foreign end tag, the current foreign local name is compared ASCII-
 insensitively with the token and one mismatch error is emitted only when they
 differ. The stack is walked backward deterministically. A matching foreign
 local name pops through the match. Reaching the root guard returns safely.
-Reaching an HTML element reprocesses the same token through the active HTML
-mode without a synthetic boundary error; that handler may independently emit
-its own specified error.
+Reaching an HTML element returns a one-shot central `HtmlRulesOnly` directive.
+That route skips foreign selection exactly once and selects shared-template,
+Text-mode, or ordinary active insertion-mode rules centrally, even when the
+adjusted current node remains foreign. It cannot request itself again; any
+ordinary reprocessing afterward returns to normal selection.
 
 Breakout emits `unexpected-html-token-in-foreign-content`, pops to HTML or a
-supported integration point, then reprocesses the identical token through the
-still-active HTML insertion mode. Exact-state fingerprints and bounded
-reprocessing guards require every retry to change state or terminate, including
-template and table delegation.
+supported integration point, then uses the same one-shot route for the
+identical token. AE13b4 therefore observes a foreign attempt followed by an
+HTML-rules-family attempt. Dispatch-selection scope is part of exact cycle
+identity, although that route-only move is not generic semantic progress.
+Normal HTML/MathML integration-point selection and EOF select HTML rules
+directly and produce no preceding foreign attempt.
 
 ## CSS, rendering, and runtime consumers
 
diff --git a/docs/html5/ae13-parser-conformance-regression-harness.md b/docs/html5/ae13-parser-conformance-regression-harness.md
index 43b5d903..ca6dc010 100644
--- a/docs/html5/ae13-parser-conformance-regression-harness.md
+++ b/docs/html5/ae13-parser-conformance-regression-harness.md
@@ -8,16 +8,20 @@ document-mode ownership, disposition policy, and one standalone-tokenizer
 fixture. AE13b1 adds the parser-owned observation foundation for tokens,
 tokenizer parse errors, and implementation diagnostics. AE13b2 extends that
 same production recorder to tree construction and captures the scalar
-`DocumentMode` selected by the production tree builder. It does not claim
-completion of overarching AE13.
+`DocumentMode` selected by the production tree builder. AE13b4 adds
+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.
 
 ## Ownership
 
 The `html` crate owns parser semantics and typed canonical observation values.
 `html::DocumentMode` is the one document-mode type used by tree construction
-and future parser observations. The exact token, position, parse-error, and
-implementation-diagnostic semantic identities live in always-compiled
-HTML/parser ownership. `html::conformance` re-exports those same types and owns
+and future parser observations. The exact token, position, parse-error,
+implementation-diagnostic, transition, and unsupported-feature semantic
+identities live in always-compiled HTML/parser ownership.
+`html::conformance` re-exports those same types and owns
 the passive request/result execution boundary behind the non-default
 `parser-conformance` feature. These are versioned engine-test contracts rather
 than stable DOM or general-purpose parser APIs. `HtmlParseOptions`,
@@ -118,13 +122,16 @@ result. An absent recorder is normal only when every surface was unrequested.
 
 ## AE13b2 tree-construction observation boundary
 
-`DocumentParseContext` owns one diagnostic fanout for preprocessing,
+`DocumentParseContext` owns one neutral `ParserEventSink` fanout for
+diagnostics and non-diagnostic semantic observations across preprocessing,
 tokenization, and tree construction. A short-lived
 `TreeBuilderProcessContext` borrows only the atom table and that fanout for one
-token, including every reprocessing iteration. Tree modules emit typed events
-through this boundary but cannot reserve occurrences, retain canonical events,
-update counters, or project legacy events directly. Unobserved parsing uses
-the same path and installs no tree-owned recorder, queue, or string store.
+logical token, including every reprocessing iteration. The authoritative
+central dispatch boundary reserves and retains transitions through this
+context; exact production fallback branches reserve unsupported events.
+Individual insertion-mode modules cannot own counters, a second recorder, or
+legacy projection. Unobserved parsing uses the same production path and
+installs no tree-owned recorder, queue, or string store.
 
 Genuine HTML tree-construction parse errors increment
 `Counters::parse_errors` whenever counter tracking is enabled, regardless of
@@ -226,6 +233,164 @@ events one way to non-canonical description lines. It neither captures nor
 merges implementation/resource diagnostics, and patch goldens do not use this
 adapter.
 
+## AE13b4 dispatch and unsupported-feature observations
+
+One `TreeTransitionEvent` is one invocation by the central iterative
+tree-builder driver of exactly one selected top-level algorithm family for the
+current logical token. The typed paths are `HtmlInsertionMode(mode)`,
+`SharedTemplateRules`, `ForeignContent`, and `TextMode`.
+
+The event captures its surface-local occurrence, an immutable canonical token
+summary, the committed insertion mode immediately before selection, the
+selected path, the committed mode after central outcome validation and
+application, and whether this is a later central attempt for the same logical
+token. `reprocessed` means attempt index greater than zero; it does not predict
+the current attempt's outcome.
+
+Internal delegation is not another attempt. Table-family calls to InBody,
+InTemplate calls to supported InHead behavior, temporary-head delegation, and
+other direct calls between rule sets remain inside the selected attempt.
+Changing insertion mode for the next tokenizer token likewise does not make
+that next token reprocessed. Shared-template selection precedes Text-mode
+selection, which precedes ordinary active insertion-mode handling.
+
+Foreign processing never calls an HTML insertion-mode handler directly. A
+foreign breakout or foreign end-tag fallback returns a central directive that
+redispatches the same token once under `HtmlRulesOnly` selection. That scope
+skips foreign selection exactly once and still selects shared-template,
+Text-mode, or ordinary HTML rules centrally. It participates in exact cycle
+identity, but the route-only move is not generic semantic progress. A forced
+HTML attempt cannot request the same forced route; ordinary reprocessing after
+it returns to normal selection. EOF and integration-point conditions selected
+as HTML rules by the normal foreign decision produce one HTML-family attempt.
+Template EOF depth unwind remains recovery before the next traced dispatch
+attempt.
+
+Handler outcomes are applied centrally before the event is retained. For
+`Reprocess(next_mode)`, handler-owned mode may remain at the committed before
+mode or already equal `next_mode`; any third mode is an engine invariant. The
+driver commits `next_mode` before capturing `after`. Foreign `Done` and
+`HtmlRulesOnly` directives cannot change insertion mode. Self-closing
+finalization still occurs exactly once after the logical token reaches its
+terminal outcome.
+
+Transition and unsupported-feature surfaces are independent. Each has its own
+request state, capacity, occurrence sequence beginning at one, retained
+prefix, dropped count, and exact occurrence/dropped-overflow invariant. There
+is no fabricated cross-surface sequence. Occurrence is reserved at the
+production boundary before capacity filtering, including at zero capacity.
+One logical token lazily creates at most one
+`Arc<TransitionTokenSummary>` when an attempt can retain it; later retained
+attempts share it. Unrequested, zero-capacity, and already-exhausted attempts
+do not resolve or clone token strings.
+
+Transition capacity bounds event count only. It does not bound bytes retained
+by token names, character data, or processing-instruction targets. AE13b4
+therefore does not describe this surface as byte-memory-bounded.
+
+Unsupported events are structurally phase-correct:
+`UnsupportedFeatureEvent::TreeConstruction` always carries a
+`ParserContextSummary`. The exact closed tree-construction identities are:
+
+- `MergeAttributesIntoExistingHtmlElement`;
+- `MergeAttributesIntoExistingBodyElement`;
+- `MarkFramesetNotOkForRepeatedBodyStartTag`;
+- `RequireSameNamedTableCellInScopeForEndTag`;
+- `GenerateImpliedEndTagsAndCheckCurrentNodeBeforeClosingTableCell`;
+- `GenerateImpliedEndTagsAndCheckCurrentNodeBeforeClosingCaption`.
+
+Repeated-html/body merge events occur only when the applicable production rule
+is reached, no HTML template is on the stack, the authoritative root/second
+stack entry has the required HTML identity, and at least one first-wins
+unqualified token attribute is absent by expanded name from the corresponding
+`LiveTree` element. Values, prefixes, encounter order, and already-present
+different values do not create a missing attribute. The check reads the stack
+entry's `PatchKey` and `LiveTree::element_semantics`, resolves no values,
+mutates no element, and is skipped entirely when unsupported observation is
+unrequested.
+
+For explicit `</td>`/`</th>`, no cell in table scope preserves the existing
+parse-error-and-ignore behavior and emits no unsupported event. An opposite
+scoped cell emits only `RequireSameNamedTableCellInScopeForEndTag`; it does not
+also claim downstream close preparation, because the Standard algorithm would
+stop at the failed same-name guard. A matching current cell emits no event. A
+matching non-current cell emits the compound preparation identity.
+Table-structure-driven closure has no failed same-name guard and emits the
+compound identity when the exact scoped cell `PatchKey` is not current.
+Caption closure uses the same exact-key rule for its compound preparation
+identity.
+
+General causality rule: an unsupported event is not emitted for a downstream
+algorithm step that would be unreachable if an earlier missing guard for the
+same token were implemented correctly.
+
+These events replace the four former attribute-merge, caption-close, and
+mismatched-cell implementation-diagnostic identities. Independent
+authored-input parse errors remain. Ordinary implementation diagnostics,
+configured limits, parser guardrails, operating-resource exhaustion, engine
+invariants, fixture limitations, unsupported execution targets, and deliberate
+fully implemented Borrowser deviations remain separate categories.
+
+All recorder failures share one first-observed
+`ParserObservationFailure::{Capture, Invariant}` slot. Observer-only token
+canonicalization, attribute comparison, or live-element lookup failure is
+latched without changing parser control flow. A separately occurring parser
+fatal remains authoritative and suppresses canonical observation output.
+Standalone-tokenizer transition requests are
+`NotApplicable(StandaloneTokenizerRun)`; unsupported-feature requests remain
+applicable because future exact preprocessing/tokenizer variants may use that
+surface. Tree-construction unsupported events can occur only when document
+tree construction actually runs. Unrequested surfaces remain `NotRequested`.
+
+AE13b4 adds no serializer, fixture sidecar, adapter, corpus migration, final
+invariant execution, or implementation of the observed missing algorithms.
+
+### Approved follow-up backlog
+
+Milestone: **AE follow-up — Remaining observed tree-construction conformance**
+
+Description: implement the exact tree-construction semantics exposed by
+AE13b4 while preserving parser ownership, production dispatch, patch/stack/AFE
+invariants, and whole-versus-chunked parity. The milestone does not add
+scripting, frameset insertion modes, fragment parsing, public DOM APIs, or
+runtime behavior.
+
+- **Implement attribute merging for repeated html start tags.** Implement the
+  applicable first-wins expanded-name merge into the authoritative existing
+  parser-created root element, preserving template suppression, patch/live-tree
+  consistency, source attribute order, and deterministic chunk parity.
+- **Implement attribute merging for repeated body start tags.** Implement the
+  applicable first-wins expanded-name merge into the authoritative second-stack
+  HTML body element, preserving template and stack-state exceptions,
+  patch/live-tree consistency, source order, and chunk parity.
+- **Mark frameset not ok for repeated body start tags.** Implement the
+  applicable repeated-body `frameset_ok = false` transition independently of
+  attribute merging, respecting template and second-stack-entry body
+  exceptions. Do not add frameset insertion modes or frameset element parsing.
+- **Implement complete table-cell end-tag and close preparation.** Implement
+  same-named `td`/`th` table-scope validation; parse-error-and-ignore behavior
+  for mismatched explicit cell end tags; implied-end-tag generation before
+  valid cell closure; the post-generation current-node check; and all explicit
+  and table-structure-driven `close_cell` paths. Preserve stack, AFE,
+  insertion-mode, patch, transition, and whole/chunk invariants.
+- **Implement complete caption close preparation.** Generate the required
+  implied end tags before caption closure, perform the post-generation
+  current-node check and parse error, and preserve caption scope, stack, AFE,
+  patch, transition, and whole/chunk invariants for explicit and
+  table-structure-driven closure.
+
+Milestone: **AE follow-up — Parser observation resource accounting**
+
+Description: complete parser observation memory accounting without changing
+semantic event identity or production parsing.
+
+- **Add byte-bounded parser observation payload policies.** Add explicit,
+  independently configured retained-string byte capacities for parser
+  observation surfaces while preserving event-count capacity, production-order
+  occurrences, drop accounting, passive failures, lazy logical-token
+  canonicalization, shared immutable summaries, and deterministic conformance
+  projection. Do not add serializers or infer events after parsing.
+
 ## Exact input and path boundary
 
 All inputs are loaded with `fs::read`; the loader never trims or normalizes
diff --git a/docs/html5/ae8-specialized-table-tree-construction-contract.md b/docs/html5/ae8-specialized-table-tree-construction-contract.md
index 69336ab7..210898e5 100644
--- a/docs/html5/ae8-specialized-table-tree-construction-contract.md
+++ b/docs/html5/ae8-specialized-table-tree-construction-contract.md
@@ -143,11 +143,17 @@ Entering `td` or `th`:
 Closing a cell, whether explicit or parser-recovery-driven:
 
 - finds the current table cell in table scope;
-- performs the supported implied-end-tag stack cleanup by closing through the
-  table-scope path;
+- closes through that scoped cell using Borrowser's deterministic substitute
+  stack path;
 - clears active formatting entries back to the last marker;
 - switches to `InRow`.
 
+AE8 does not implement the Standard's same-named `td`/`th` scope guard for
+explicit end tags, implied-end-tag generation before cell closure, or the
+post-generation current-node check. It likewise does not implement caption
+close preparation. AE13b4 observes those exact production omissions without
+changing AE8's substitute tree, stack, AFE, insertion mode, or parse errors.
+
 AE8 does not introduce layout cell concepts into the parser.
 AE10 adds marker kind/owner diagnostics without changing AE8's last-marker
 boundary semantics.
diff --git a/docs/html5/html5-core-v0.md b/docs/html5/html5-core-v0.md
index 7a8a60e1..d2d68f2d 100644
--- a/docs/html5/html5-core-v0.md
+++ b/docs/html5/html5-core-v0.md
@@ -198,7 +198,11 @@ Core v0 tree-builder partial-scope guards:
 - `TB-ALGO-AAA` (`MVP_PARTIAL`) is limited to Borrowser's supported
   formatting-element set and representative deterministic recovery fixtures.
   This does not claim full WHATWG adoption-agency conformance.
-- `TB-ALGO-REPROCESS` guarantees that reprocessing reuses the same token instance and does not emit duplicate patches for a single logical token unless explicitly required by the spec algorithm.
+- `TB-ALGO-REPROCESS` guarantees that reprocessing reuses the same logical
+  token and does not emit duplicate patches for a single semantic action.
+  AE13b4 observes only central-driver attempts. Internal calls between rule
+  sets are delegation, not redispatch; foreign-to-HTML fallback is an explicit
+  one-shot central `HtmlRulesOnly` route.
 
 ### Text Coalescing Policy (Core v0)
 
@@ -331,12 +335,13 @@ Core v0 guarantees:
 
 ### Parse-Error Diagnostics
 
-Core v0 parser diagnostics are deterministic internal regression/debug data:
+Core v0 parser events are deterministic internal regression/debug data:
 
-- one `DocumentParseContext` diagnostic fanout owns counters, the independent
+- one neutral `DocumentParseContext` event sink owns counters, the independent
   parse-error and implementation-diagnostic occurrence sequences, bounded
-  canonical retention, dropped counts, and optional legacy projection for
-  preprocessing, tokenizer, and tree-construction production rules;
+  canonical diagnostic retention, parser observations, dropped counts, and
+  optional legacy diagnostic projection. Transition and unsupported-feature
+  observations are not diagnostics and have independent sequences/capacities;
 - tokenizer-origin malformed input records exact-position legacy `ParseError`
   entries where representable. Tree-construction canonical events currently
   use `Unavailable(ParserDidNotProvidePosition)` and are not projected with a
@@ -517,7 +522,10 @@ Core v0 stance:
   `thead`, `tfoot`, `tr`, `td`, and `th`.
 - supported omitted wrappers, malformed row/cell/body recovery, pending
   table-character-token handling, and foster-parent insertion locations are
-  parser-owned behavior.
+  parser-owned deterministic behavior. This does not claim the same-named
+  `td`/`th` end-tag guard, implied-end-tag preparation/current-node check for
+  table-cell closure, or caption-close preparation; AE13b4 observes those
+  exact omissions without implementing them.
 - unsupported table interactions still require robust fallback:
   - parser MUST remain deterministic,
   - parser MUST preserve core invariants (SOE/patch ordering),
@@ -547,7 +555,19 @@ Core v0 stance:
   wrap, and counter-backed depth-16/depth-256 fixtures prove linear aggregate
   EOF close/owner/reset work with O(1) auxiliary recovery memory. Contents are
   preserved in the centralized full-model traversal and inert to active
-  consumers.
+  consumers. AE13b4 classifies shared-template interception as one central
+  `SharedTemplateRules` attempt; its internal InHead/InBody delegation creates
+  no extra attempt, and template EOF unwind remains outside the attempt trace.
+
+- AE13b4 adds parser-owned dispatch-attempt and exact unsupported-feature
+  observations. The central driver records ordinary HTML, shared-template,
+  Text-mode, and foreign attempts with before/after insertion modes and
+  same-token redispatch identity. Foreign breakout and HTML fallback use a
+  one-shot HTML-rules-only route rather than hidden handler calls. The exact
+  unsupported identities cover repeated html/body attribute merging, repeated
+  body `frameset_ok`, table-cell same-name/close preparation, and caption close
+  preparation. These observations do not implement the six missing algorithms.
+  Event capacity bounds retained event count, not retained token-string bytes.
 
 - AE13b2.2a defines allocation-free parser fatal identities and first-failure
   terminal latching for live `Html5ParseSession` work. Construction failures
@@ -591,6 +611,9 @@ The following are intentionally not part of the Core v0 guarantee:
     CharacterData mutation, cloning, public mutation, and broader DOM PI
     validity
   - `PLAINTEXT`, frameset insertion modes, and fragment parsing for AE12
+  - repeated html/body attribute merging; repeated-body `frameset_ok = false`;
+    same-named table-cell end-tag recovery; cell/caption implied-end-tag and
+    post-generation current-node preparation observed by AE13b4
 
 Policy classification requirements:
 
diff --git a/docs/html5/invariants.md b/docs/html5/invariants.md
index 971b85fa..a1afe2d5 100644
--- a/docs/html5/invariants.md
+++ b/docs/html5/invariants.md
@@ -181,6 +181,10 @@ Table cell and AFE interaction:
 - closing a cell, explicit or implied, clears AFE entries back to the last
   marker;
 - cell close recovery must not expand into unrelated adoption-agency behavior.
+- AE13b4 observes, but does not implement, the same-named explicit cell-end-tag
+  guard and implied-end-tag/current-node preparation. If the missing same-name
+  guard would have ignored a token, no downstream close-preparation omission is
+  reported for that token.
 
 ## AE9a Form And Void-Insertion Invariants
 
@@ -304,11 +308,43 @@ Table cell and AFE interaction:
   foster parenting, and other adjusted insertion locations.
 - Breakout reprocesses the exact token only after a stack change establishes
   progress. Foreign end-tag scanning never corrupts stack caches.
+- Foreign breakout and end-tag HTML fallback return a one-shot central
+  `HtmlRulesOnly` directive; foreign handlers never call HTML handlers
+  directly. Selection scope participates in exact cycle identity but a
+  route-only scope change is not generic semantic progress. A forced HTML
+  attempt cannot force the same route again.
 - Unknown foreign elements retain their inherited foreign namespace. Results,
   patches, errors, and attribute order do not depend on chunk boundaries.
 - Layout inability cannot alter DOM/style truth; unsupported SVG/MathML roots
   suppress complete box subtrees at the centralized Layout decision boundary.
 
+## AE13b4 Parser Observation Invariants
+
+- One tree transition is one central-driver invocation of one selected
+  top-level family: ordinary HTML insertion mode, shared template rules,
+  foreign content, or Text mode. Internal rule-set delegation is not an
+  additional attempt.
+- The central driver captures committed insertion mode before selection and
+  after outcome validation/application. A handler returning
+  `Reprocess(next_mode)` may leave the mode unchanged or already set it to
+  `next_mode`; any third mode is an engine invariant.
+- A logical token is finalized for self-closing semantics exactly once after
+  its terminal attempt. Its retained attempts share one lazily canonicalized
+  immutable token summary.
+- Transition and unsupported-feature surfaces independently own request state,
+  capacity, occurrence sequence, retained prefix, drop count, and overflow
+  identity. No cross-surface timeline exists. Capacity zero and exhausted
+  capacity still reserve occurrences and count drops without constructing
+  owned transition payloads.
+- Transition capacity bounds event count, not retained token-string bytes.
+- All observation failures latch through one first-observed
+  `ParserObservationFailure` slot. Observer-only failure remains passive;
+  independently occurring parser fatal failure remains authoritative and
+  suppresses canonical observation output.
+- Unsupported observations originate only at the exact production fallback.
+  A downstream omission is not reported when a missing earlier guard would
+  have made that downstream step unreachable for the same token.
+
 ## AE12 processing-instruction invariants
 
 - Ordinary PI recognition is entered only through Data/TagOpen. Borrowser's
diff --git a/docs/html5/spec-matrix-treebuilder.md b/docs/html5/spec-matrix-treebuilder.md
index 8636b080..c41178db 100644
--- a/docs/html5/spec-matrix-treebuilder.md
+++ b/docs/html5/spec-matrix-treebuilder.md
@@ -52,12 +52,13 @@ It defines HTML5 Core v0 tree-builder scope and explicitly records deferred and
   - AE13b2 exposes a feature-gated in-memory scalar observation, not a patch,
     DOM API, or serialized fixture sidecar.
 
-## Tree-construction diagnostic contract
+## Tree-construction event contract
 
-- `DocumentParseContext` owns one shared diagnostic fanout and the independent
-  parse-error and implementation-diagnostic occurrence sequences.
+- `DocumentParseContext` owns one neutral parser event sink. It owns diagnostic
+  counters/projection and the parser observation recorder without categorizing
+  transitions or unsupported-feature observations as diagnostics.
 - `TreeBuilderProcessContext` is the one-token borrow boundary for the atom
-  table and tree diagnostic sink; `process`/`push_token` keep borrowed tokens,
+  table and tree event sink; `process`/`push_token` keep borrowed tokens,
   `TextResolver`, `PatchSink`, `TreeBuilderStepResult`, tokenizer controls, and
   `TreeBuilderError`.
 - HTML parse errors, Borrowser implementation diagnostics, configured
@@ -81,6 +82,11 @@ It defines HTML5 Core v0 tree-builder scope and explicitly records deferred and
   finite fail-on-incomplete capture, and projects only typed tree parse errors.
   It does not establish a combined parse/implementation timeline or affect
   patch goldens.
+- AE13b4 transition and unsupported-feature surfaces have independent
+  requested state, capacities, occurrences, retained prefixes, and drop
+  accounting. There is no global event timeline. Parser-owned semantic types
+  are always compiled; `html::conformance` only re-exports and projects them.
+  Transition event capacity is not a retained-string byte budget.
 
 ## Historical Repository Baseline (Before D2 Execution)
 
@@ -109,11 +115,11 @@ It defines HTML5 Core v0 tree-builder scope and explicitly records deferred and
 | `TB-MODE-TEXT` | MVP_PARTIAL | `Text` | `#the-text-insertion-mode` | `mod.rs`, `modes.rs`, `text_mode.rs` | Current coverage: `tree_builder/tests/text_mode.rs`; planned fixture umbrella: `tb-text-mode-core`. | Return-to-original-mode mechanics, mismatched end tags, and EOF in text mode. | `tb-text-mode-core` | Core-v0 text-mode routing for title/textarea/style and the dedicated script tokenizer family; parser execution/pause behavior remains out of scope. |
 | `TB-MODE-IN-TABLE` | MVP_PARTIAL | `In table` | `#parsing-main-intable` | `tree_builder/table/in_table.rs`, `insert/location.rs`, `stack/foster.rs` | Current: `ae8-*`, `i10-table-*`, `i3-in-table-*`; unit: `table_modes.rs`. | caption/colgroup/row-group/row/cell dispatch, implied wrappers, nested table recovery, foster-parented non-table content. | `tb-ae8-in-table` | AE8 supported static table construction routes table tokens through explicit table mode instead of generic in-body nesting. |
 | `TB-MODE-IN-TABLE-TEXT` | MVP_PARTIAL | `In table text` | `#parsing-main-intabletext` | `tree_builder/table/in_table_text.rs`, `table/state.rs`, `table/delegation.rs` | Current: `ae8-pending-table-text-eof`, `ae8-foster-text-and-element`; unit: table-text return-mode tests. | Chunk-safe pending character buffering, return-mode restoration, EOF flush, foster-parenting non-space runs. | `tb-ae8-in-table-text` | Needed so table whitespace and non-space table text are processed through parser-owned pending state. |
-| `TB-MODE-IN-CAPTION` | MVP_PARTIAL | `In caption` | `#parsing-main-incaption` | `tree_builder/table/in_caption.rs`, `table/close.rs` | Current: `i4-caption-colgroup-transition`; unit: `table_caption_colgroup.rs`. | Caption close, conflicting table-structure tokens, AFE marker cleanup. | `tb-ae8-in-caption` | Caption content delegates to body rules until a table-structure token closes and reprocesses. |
+| `TB-MODE-IN-CAPTION` | MVP_PARTIAL | `In caption` | `#parsing-main-incaption` | `tree_builder/table/in_caption.rs`, `table/close.rs` | Current: `i4-caption-colgroup-transition`; unit: `table_caption_colgroup.rs`; AE13b4 exact unsupported observation. | Caption close, conflicting table-structure tokens, AFE marker cleanup; implied-end-tag/current-node close preparation remains unimplemented. | `tb-ae8-in-caption` | Caption content delegates to body rules until a table-structure token closes and reprocesses. |
 | `TB-MODE-IN-COLUMN-GROUP` | MVP_PARTIAL | `In column group` | `#parsing-main-incolgroup` | `tree_builder/table/in_column_group.rs`, `table/close.rs` | Current: `ae8-basic-explicit-table`, `i4-colgroup-*`; unit: `table_caption_colgroup.rs`. | `col` insertion, missing `</colgroup>`, non-space recovery into table foster-parenting. | `tb-ae8-in-column-group` | Required for deterministic parser-created `colgroup`/`col` structure. |
 | `TB-MODE-IN-TABLE-BODY` | MVP_PARTIAL | `In table body` | `#parsing-main-intbody` | `tree_builder/table/in_table_body.rs`, `table/scope.rs`, `table/close.rs` | Current: `ae8-multiple-bodies`, `ae8-implied-row-direct-cell`; unit: `table_body_row.rs`. | row insertion, implied row for cells, row-group transitions, table end recovery. | `tb-ae8-in-table-body` | Owns row-group context instead of encoding row-group behavior in generic element insertion. |
 | `TB-MODE-IN-ROW` | MVP_PARTIAL | `In row` | `#parsing-main-intr` | `tree_builder/table/in_row.rs`, `table/close.rs` | Current: `ae8-malformed-row-and-cell-recovery`, `i5-stray-tr`; unit: `table_body_row.rs`. | cell insertion, conflicting row starts, row closure, row-group/table boundaries. | `tb-ae8-in-row` | Owns row context and cell transition behavior. |
-| `TB-MODE-IN-CELL` | MVP_PARTIAL | `In cell` | `#parsing-main-intd` | `tree_builder/table/in_cell.rs`, `table/close.rs` | Current: `ae8-malformed-row-and-cell-recovery`, `i6-*`; unit: `table_cell.rs`. | explicit/mismatched cell end tags, implied cell close, AFE marker clearing, nested table support. | `tb-ae8-in-cell` | Owns table-cell recovery without introducing layout-cell concepts. |
+| `TB-MODE-IN-CELL` | MVP_PARTIAL | `In cell` | `#parsing-main-intd` | `tree_builder/table/in_cell.rs`, `table/close.rs` | Current: `ae8-malformed-row-and-cell-recovery`, `i6-*`; unit: `table_cell.rs`; AE13b4 exact unsupported observations. | deterministic explicit/mismatched cell substitute recovery and AFE clearing; same-name guard plus implied-end-tag/current-node close preparation remain unimplemented. | `tb-ae8-in-cell` | Owns a partial table-cell recovery boundary without introducing layout-cell concepts. |
 | `TB-MODE-IN-TEMPLATE` | MVP_PARTIAL | `In template` | `#parsing-main-intemplate` | `tree_builder/dispatch/template.rs`, `tree_builder/template_state.rs`, `tree_builder/modes.rs` | Current local `ae10-*`; pinned WPT `template-*`; unit/session template tests. | category delegation, owner-mode replacement, same-token reprocessing, nested close and EOF unwind. | `tb-ae10-template-construction` | AE10 static ordinary-template subset with typed contents; no declarative shadow DOM or public template APIs. |
 
 ## `TB-MODE-IN-HEAD` Core v0 Partial Scope
@@ -136,7 +142,7 @@ Explicitly deferred from Core v0 `In head`:
 
 | ID | Tier | Algorithm / structure | Spec anchor(s) | Implementation mapping | Test mapping (current + planned) | Key edge cases | Acceptance placeholder | Rationale |
 | --- | --- | --- | --- | --- | --- | --- | --- | --- |
-| `TB-ALGO-REPROCESS` | MVP | Token reprocessing semantics | `#tree-construction`, `#parsing-main-inbody` | `tree_builder/mod.rs`, `tree_builder/modes.rs` | Planned fixtures: `tb-reprocess-mode-switch`, `tb-reprocess-no-duplicate-patch`. | Reprocess current token after insertion-mode switch without losing token identity and without duplicate patch emission. | `tb-reprocess-core` | Required for spec-faithful mode transitions and deterministic emission. |
+| `TB-ALGO-REPROCESS` | MVP | Token reprocessing semantics | `#tree-construction`, `#parsing-main-inbody` | `tree_builder/dispatch/drive.rs`, `tree_builder/dispatch/template.rs`, `tree_builder/foreign/dispatch.rs` | AE13b4 dispatch, template/table, foreign-route, cycle, and whole/chunk tests. | Central same-token redispatch after insertion-mode switch; one-shot foreign HTML-rules route; internal delegation creates no attempt. | `tb-reprocess-core` | Required for spec-faithful mode transitions, deterministic emission, and authoritative production tracing. |
 | `TB-ALGO-SOE` | MVP | Stack of open elements (SOE) | `#stack-of-open-elements` | `tree_builder/stack.rs`, `tree_builder/mod.rs` | Current proxy: `tree_builder/simple-element`. Planned fixtures: `tb-soe-nested-pop`, `tb-soe-implied-end-tags`. | Correct push/pop ordering, implied end tags, scope checks for end-tag processing. | `tb-soe-core` | Foundational invariant for all insertion modes. |
 | `TB-ALGO-BODY-RECOVERY` | MVP_PARTIAL | Body-mode malformed-content recovery | `#parsing-main-inbody`, implied end tags | `tree_builder/body_recovery.rs`, `tree_builder/dispatch/in_body.rs`, `tree_builder/known_tags.rs` | Current fixtures: `ae7-*`, `f7-in-body-stray-end-tags`. | Paragraph auto-close, unmatched `</p>` synthesis, list-item sibling recovery, supported implied end tags. | `tb-ae7-body-recovery` | AE7-supported subset only; not full `In body` conformance. |
 | `TB-ALGO-AFE` | MVP_PARTIAL | Active formatting elements (AFE) | `#the-list-of-active-formatting-elements` | `tree_builder/formatting.rs`, `mod.rs` | Current fixtures: `h8-*`, `f13-*`; unit/session reconstruction tests. | Reconstruction triggers, marker boundaries, duplicate formatting entries. | `tb-afe-core` | Needed for supported in-body formatting fidelity; full formatting conformance remains out of scope. |
@@ -161,6 +167,11 @@ Explicitly deferred from Core v0 `In head`:
   - No duplicate patch emission for the same semantic action during mode switches.
   - Reprocessing must be implemented with the iterative dispatch loop above; recursion is not permitted in Core v0.
   - Implementation should include a bounded reprocess-iteration guard in debug builds (for example, max 64 loop iterations per token) to catch infinite mode-flip bugs early.
+- AE13b4 observes one transition for each central attempt. Shared-template and
+  Text-mode handling are distinct paths; internal InBody/InHead/table
+  delegation is not a central attempt. Foreign breakout/end fallback returns
+  one `HtmlRulesOnly` redispatch, whose scope is included in exact cycle
+  identity. Template EOF unwind remains outside this trace boundary.
 
 ## SOE Ownership And Ordering Invariants (`TB-ALGO-SOE`)
 
@@ -206,6 +217,9 @@ Rationale:
   supported static table parsing.
 - The promoted scope remains declared and partial so Borrowser does not claim
   full WHATWG table conformance.
+- AE13b4 exposes exact unsupported events for the missing same-named cell guard,
+  cell close preparation, and caption close preparation. It preserves AE8's
+  substitute tree/stack/AFE behavior and does not implement those algorithms.
 
 ## Core v0 Tree Builder Subset
 
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index e30418bd..fc95cf2d 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,4 +1,4 @@
 [toolchain]
 channel = "1.92.0"
 profile = "minimal"
-components = ["rustfmt", "clippy"]
\ No newline at end of file
+components = ["rustfmt", "clippy", "rust-analyzer"]
\ No newline at end of file