compose_lens/syntax/

mod.rs

//! Loss-aware YAML syntax documents.

use crate::diagnostic::{Diagnostic, DiagnosticCode, DiagnosticLabel, Severity};
use crate::source::{LineColumn, SourceId, SourceSpan, line_column};
use std::collections::{BTreeMap, BTreeSet};
use std::error::Error;
use std::fmt;
use std::sync::Arc;
use yaml_edit::{
    AnchorRegistry, AsYaml, Mapping, Parse, ParseErrorKind, Scalar, ScalarStyle, ScalarType, ScalarValue, YamlFile,
    YamlNode,
};

/// A generic YAML syntax error not covered by a more specific code.
pub const YAML_SYNTAX_ERROR: DiagnosticCode = DiagnosticCode::new("compose.yaml.syntax");

/// The private YAML backend did not include the complete source in the YAML document root.
pub const YAML_UNPARSED_INPUT: DiagnosticCode = DiagnosticCode::new("compose.yaml.unparsed-input");

/// A flow sequence is missing its closing bracket.
pub const YAML_UNCLOSED_FLOW_SEQUENCE: DiagnosticCode = DiagnosticCode::new("compose.yaml.unclosed-flow-sequence");

/// A flow mapping is missing its closing brace.
pub const YAML_UNCLOSED_FLOW_MAPPING: DiagnosticCode = DiagnosticCode::new("compose.yaml.unclosed-flow-mapping");

/// A quoted scalar is missing its closing quote.
pub const YAML_UNTERMINATED_STRING: DiagnosticCode = DiagnosticCode::new("compose.yaml.unterminated-string");

/// Authored YAML scalar presentation, independently of its semantic category.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum ScalarPresentation {
    /// An unquoted scalar.
    Plain,
    /// A single-quoted scalar.
    SingleQuoted,
    /// A double-quoted scalar.
    DoubleQuoted,
    /// A literal block scalar (`|`).
    Literal,
    /// A folded block scalar (`>`).
    Folded,
}

/// A loss-aware YAML document and its original source text.
///
/// The underlying concrete syntax tree is intentionally private so `ComposeLens` can maintain a
/// stable API independently of its parser dependency. Preservation rendering emits the original
/// source without normalization, interpolation, or environment access.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SyntaxDocument {
    source_id: SourceId,
    source: Arc<str>,
    parse: Parse<YamlFile>,
}

impl SyntaxDocument {
    /// Parses YAML into a loss-aware document and structured diagnostics.
    ///
    /// Recoverable YAML errors are returned in [`SyntaxParse::diagnostics`] while the syntax
    /// document remains available. Only sources too large for the concrete syntax tree produce a
    /// fatal error.
    ///
    /// # Errors
    ///
    /// Returns [`SyntaxParseError`] when the source exceeds the concrete syntax tree's byte-offset
    /// capacity. Malformed YAML is recoverable and is reported through structured diagnostics.
    pub fn parse(source_id: SourceId, source: impl Into<Arc<str>>) -> Result<SyntaxParse, SyntaxParseError> {
        let source = source.into();
        if u32::try_from(source.len()).is_err() {
            return Err(SyntaxParseError {
                source_id,
                byte_len: source.len(),
            });
        }

        let (parser_source, block_scalars) = parser_compatible_source(&source);
        let parse = YamlFile::parse(parser_source.as_deref().unwrap_or(&source));
        let mut diagnostics: Vec<_> = parse
            .positioned_errors()
            .iter()
            .map(|error| syntax_diagnostic(source_id, source.len(), error))
            .collect();
        for block in &block_scalars {
            if !block.valid {
                diagnostics.push(block_scalar_diagnostic(
                    source_id,
                    source.len(),
                    block.start,
                    YAML_SYNTAX_ERROR,
                ));
            } else if !block_scalar_is_complete(&parse, &source, block) {
                diagnostics.push(block_scalar_diagnostic(
                    source_id,
                    source.len(),
                    block.start,
                    YAML_UNPARSED_INPUT,
                ));
            }
        }
        if diagnostics.is_empty()
            && let Some(document_end) = unparsed_input_offset(&parse, &source)
        {
            diagnostics.push(unparsed_input_diagnostic(source_id, source.len(), document_end));
        }

        let document = Self {
            source_id,
            source,
            parse,
        };
        for scalar in document.editable_value_scalars() {
            if let Some(offset) = anchored_mapping_in_plain_scalar(&scalar.raw) {
                diagnostics.push(unparsed_input_diagnostic(
                    source_id,
                    document.source.len(),
                    scalar.span.start() + offset,
                ));
            }
        }
        Ok(SyntaxParse { document, diagnostics })
    }

    /// Returns the source identifier supplied by the caller.
    #[must_use]
    pub const fn source_id(&self) -> SourceId {
        self.source_id
    }

    /// Returns the original source text.
    #[must_use]
    pub fn source_text(&self) -> &str {
        &self.source
    }

    /// Returns the span covering the complete source text.
    #[must_use]
    pub fn source_span(&self) -> SourceSpan {
        SourceSpan::from_valid_offsets(self.source_id, 0, self.source.len())
    }

    /// Returns the source text covered by a span from this document.
    #[must_use]
    pub fn text(&self, span: SourceSpan) -> Option<&str> {
        if span.source_id() != self.source_id || span.end() > self.source.len() {
            return None;
        }

        self.source.get(span.range())
    }

    /// Converts a byte offset in this document to a one-based line and column.
    #[must_use]
    pub fn line_column(&self, byte_offset: usize) -> Option<LineColumn> {
        line_column(&self.source, byte_offset)
    }

    /// Returns the number of YAML documents in the stream.
    #[must_use]
    pub fn document_count(&self) -> usize {
        self.parse.tree().documents().count()
    }

    /// Returns the number of comment tokens retained by the concrete syntax tree.
    #[must_use]
    pub fn comment_count(&self) -> usize {
        self.parse.tree().comments().count()
    }

    /// Returns the original source as preservation-oriented output.
    #[must_use]
    pub fn render_preserved(&self) -> String {
        self.source.to_string()
    }

    pub(crate) fn yaml_file(&self) -> YamlFile {
        self.parse.tree()
    }

    pub(crate) fn interpolatable_value_scalars(&self) -> Vec<ValueScalar> {
        let mut values = Vec::new();
        if let Some(document) = self.parse.tree().document() {
            if let Some(mapping) = document.as_mapping() {
                collect_value_scalars(self.source_id, &self.source, YamlNode::Mapping(mapping), &mut values);
            } else if let Some(sequence) = document.as_sequence() {
                collect_value_scalars(self.source_id, &self.source, YamlNode::Sequence(sequence), &mut values);
            } else if let Some(scalar) = document.as_scalar() {
                collect_value_scalars(self.source_id, &self.source, YamlNode::Scalar(scalar), &mut values);
            }
        }
        values
    }

    pub(crate) fn editable_value_scalars(&self) -> Vec<EditableValueScalar> {
        let mut values = Vec::new();
        if let Some(document) = self.parse.tree().document() {
            if let Some(mapping) = document.as_mapping() {
                collect_editable_value_scalars(self.source_id, &self.source, YamlNode::Mapping(mapping), &mut values);
            } else if let Some(sequence) = document.as_sequence() {
                collect_editable_value_scalars(self.source_id, &self.source, YamlNode::Sequence(sequence), &mut values);
            } else if let Some(scalar) = document.as_scalar() {
                collect_editable_value_scalars(self.source_id, &self.source, YamlNode::Scalar(scalar), &mut values);
            }
        }
        values
    }

    pub(crate) fn merge_root(&self) -> Option<MergeSyntaxValue> {
        let document = self.parse.tree().document()?;
        let root = if let Some(mapping) = document.as_mapping() {
            YamlNode::Mapping(mapping)
        } else if let Some(sequence) = document.as_sequence() {
            YamlNode::Sequence(sequence)
        } else {
            YamlNode::Scalar(document.as_scalar()?)
        };
        let registry = AnchorRegistry::from_document(&document);
        Some(extract_merge_value(
            self.source_id,
            &self.source,
            root,
            &registry,
            &mut Vec::new(),
        ))
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct ValueScalar {
    pub(crate) value: String,
    pub(crate) span: SourceSpan,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct EditableValueScalar {
    pub(crate) raw: String,
    pub(crate) span: SourceSpan,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum MergeScalarKind {
    String,
    Boolean,
    Number,
    Null,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct MergeSyntaxScalar {
    pub(crate) raw: String,
    pub(crate) value: String,
    pub(crate) kind: MergeScalarKind,
    pub(crate) plain: bool,
    pub(crate) presentation: ScalarPresentation,
    pub(crate) strict_yaml_string: bool,
    pub(crate) span: SourceSpan,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct MergeSyntaxEntry {
    pub(crate) key: MergeSyntaxScalar,
    pub(crate) value: MergeSyntaxValue,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) enum MergeSyntaxValue {
    Empty(SourceSpan),
    Scalar(MergeSyntaxScalar),
    Mapping {
        entries: Vec<MergeSyntaxEntry>,
        span: SourceSpan,
    },
    Sequence {
        values: Vec<MergeSyntaxValue>,
        span: SourceSpan,
    },
    Alias {
        name: String,
        span: SourceSpan,
    },
    Tagged {
        tag: String,
        value: Box<MergeSyntaxValue>,
        span: SourceSpan,
    },
}

/// The recoverable result of parsing one YAML source.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SyntaxParse {
    document: SyntaxDocument,
    diagnostics: Vec<Diagnostic>,
}

impl SyntaxParse {
    /// Returns the loss-aware syntax document.
    #[must_use]
    pub const fn document(&self) -> &SyntaxDocument {
        &self.document
    }

    /// Returns all syntax diagnostics in source order.
    #[must_use]
    pub fn diagnostics(&self) -> &[Diagnostic] {
        &self.diagnostics
    }

    /// Reports whether parsing produced no error diagnostics.
    #[must_use]
    pub fn is_valid(&self) -> bool {
        !self
            .diagnostics
            .iter()
            .any(|diagnostic| diagnostic.severity() == Severity::Error)
    }

    /// Separates the document and diagnostics.
    #[must_use]
    pub fn into_parts(self) -> (SyntaxDocument, Vec<Diagnostic>) {
        (self.document, self.diagnostics)
    }
}

/// A source that exceeds the concrete syntax tree's byte-offset capacity.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct SyntaxParseError {
    source_id: SourceId,
    byte_len: usize,
}

impl SyntaxParseError {
    /// Returns the source identifier supplied to the parser.
    #[must_use]
    pub const fn source_id(self) -> SourceId {
        self.source_id
    }

    /// Returns the rejected source length in bytes.
    #[must_use]
    pub const fn byte_len(self) -> usize {
        self.byte_len
    }
}

impl fmt::Display for SyntaxParseError {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            formatter,
            "{} contains {} bytes, exceeding the YAML syntax tree limit",
            self.source_id, self.byte_len
        )
    }
}

impl Error for SyntaxParseError {}

fn syntax_diagnostic(source_id: SourceId, source_len: usize, error: &yaml_edit::PositionedParseError) -> Diagnostic {
    let (code, message) = match error.kind {
        ParseErrorKind::UnclosedFlowSequence => (YAML_UNCLOSED_FLOW_SEQUENCE, "flow sequence is missing a closing `]`"),
        ParseErrorKind::UnclosedFlowMapping => (YAML_UNCLOSED_FLOW_MAPPING, "flow mapping is missing a closing `}`"),
        ParseErrorKind::UnterminatedString => (YAML_UNTERMINATED_STRING, "quoted scalar is missing its closing quote"),
        ParseErrorKind::Other => (YAML_SYNTAX_ERROR, "invalid YAML syntax"),
    };
    let start = (error.range.start as usize).min(source_len);
    let end = (error.range.end as usize).clamp(start, source_len);
    let span = SourceSpan::from_valid_offsets(source_id, start, end);

    Diagnostic::new(code, Severity::Error, message).with_label(DiagnosticLabel::primary(span, "syntax error"))
}

fn unparsed_input_diagnostic(source_id: SourceId, source_len: usize, document_end: usize) -> Diagnostic {
    let span = SourceSpan::from_valid_offsets(source_id, document_end.min(source_len), source_len);

    Diagnostic::new(
        YAML_UNPARSED_INPUT,
        Severity::Error,
        "YAML parser did not include the complete input in the document root",
    )
    .with_label(DiagnosticLabel::primary(span, "input omitted from YAML document"))
    .with_note("the original source remains available, but typed processing must not continue silently")
}

fn unparsed_input_offset(parse: &Parse<YamlFile>, source: &str) -> Option<usize> {
    let document_end = parse
        .tree()
        .document()
        .and_then(|document| {
            document
                .as_node()
                .map(|node| u32::from(node.text_range().end()) as usize)
        })
        .unwrap_or_default();
    unparsed_input_offset_after_document_end(document_end, source)
}

fn unparsed_input_offset_after_document_end(document_end: usize, source: &str) -> Option<usize> {
    source
        .as_bytes()
        .get(document_end..)
        .is_some_and(|suffix| suffix.iter().any(|byte| !byte.is_ascii_whitespace()))
        .then_some(document_end)
}

/// Produces a same-length input for private YAML backend limitations. It masks safe, non-colliding
/// hyphens in anchor and alias names, leading option dashes, and commas in block-style plain
/// scalars, plus block-body quotes and explicit indentation. Authored block boundaries are checked
/// independently. Original text remains authoritative for scalar meaning and preservation.
fn parser_compatible_source(source: &str) -> (Option<String>, Vec<BlockScalarBoundary>) {
    let mut compatible = source.as_bytes().to_vec();
    let mut changed = mask_blank_lines_after_mapping_keys(source, &mut compatible);
    changed |= mask_non_colliding_anchor_hyphens(source, &mut compatible);
    let mut offset = 0;
    let mut blocks: Vec<BlockScalarBoundary> = Vec::new();
    let mut state = ParserCompatibilityState::default();

    for line in source.split_inclusive('\n') {
        let content = line.trim_end_matches(['\r', '\n']);
        let indent = content.bytes().take_while(|byte| *byte == b' ').count();
        let blank = content[indent..].is_empty();

        if let Some(block) = blocks.last_mut().filter(|block| block.end == offset)
            && (blank || indent > block.parent_indent)
        {
            if blank && block.content_indent.is_none() {
                block.leading_blank_indent = block.leading_blank_indent.max(indent);
            } else if !blank {
                let required = *block.content_indent.get_or_insert(indent);
                block.valid &= indent >= required && block.leading_blank_indent <= required;
                if block.explicit_indent && indent > required {
                    // The implicit private header must infer the explicit minimum even when
                    // the first content line deliberately retains additional leading spaces.
                    compatible[offset + required..offset + indent].fill(b'_');
                    changed = true;
                }
            }
            // Quotes are content in YAML block scalars, but the backend lexer scans them as
            // quoted strings before recognizing the block. Keep byte offsets while preventing
            // that scan from consuming a dedented sibling. Decode the original scalar below.
            for (index, byte) in content.bytes().enumerate() {
                if matches!(byte, b'\'' | b'"') {
                    compatible[offset + index] = b'_';
                    changed = true;
                }
            }
            block.end += line.len();
            offset += line.len();
            continue;
        }

        let (line_changed, starts_block_scalar) = mask_block_plain_commas(content, offset, &mut compatible, &mut state);
        changed |= line_changed;
        if let Some(index) = starts_block_scalar {
            let parent_indent = block_parent_indent(&content[..index]);
            let header = &content[index..];
            let token = header.split_ascii_whitespace().next().unwrap_or_default();
            let mut digit = None;
            let mut chomp = None;
            let mut valid = true;
            for byte in token.bytes().skip(1) {
                match byte {
                    b'1'..=b'9' if digit.is_none() => digit = Some(usize::from(byte - b'0')),
                    b'+' | b'-' if chomp.is_none() => chomp = Some(byte),
                    _ => valid = false,
                }
            }
            valid &=
                header[token.len()..].trim_start().is_empty() || header[token.len()..].trim_start().starts_with('#');
            if digit.is_some() && valid {
                // The backend interprets explicit indentation as an absolute column. Parse an
                // implicit header instead; decode its authored semantics independently below.
                compatible[offset + index + 1..offset + index + token.len()].fill(b' ');
                if token.len() > 2 {
                    compatible[offset + index + 2] = b'#';
                }
                changed = true;
            }
            blocks.push(BlockScalarBoundary {
                start: offset + index,
                end: offset + line.len(),
                parent_indent,
                content_indent: digit.map(|digit| parent_indent + digit),
                explicit_indent: digit.is_some(),
                leading_blank_indent: 0,
                valid,
            });
        }
        offset += line.len();
    }

    if changed {
        (String::from_utf8(compatible).ok(), blocks)
    } else {
        (None, blocks)
    }
}

#[derive(Debug)]
struct BlockScalarBoundary {
    start: usize,
    end: usize,
    parent_indent: usize,
    content_indent: Option<usize>,
    explicit_indent: bool,
    leading_blank_indent: usize,
    valid: bool,
}

fn block_parent_indent(prefix: &str) -> usize {
    let indent = prefix.bytes().take_while(|byte| *byte == b' ').count();
    let bytes = prefix.as_bytes();
    let mut cursor = indent;
    let mut sequence_indent = None;
    while bytes.get(cursor) == Some(&b'-') && bytes.get(cursor + 1).is_some_and(u8::is_ascii_whitespace) {
        sequence_indent = Some(cursor);
        cursor += 1;
        cursor += bytes[cursor..]
            .iter()
            .take_while(|byte| byte.is_ascii_whitespace())
            .count();
    }
    // Anchor/tag properties belong to the scalar; they do not introduce a compact mapping.
    while matches!(bytes.get(cursor), Some(b'&' | b'!')) {
        cursor += bytes[cursor..]
            .iter()
            .take_while(|byte| !byte.is_ascii_whitespace())
            .count();
        cursor += bytes[cursor..]
            .iter()
            .take_while(|byte| byte.is_ascii_whitespace())
            .count();
    }
    sequence_indent.map_or(indent, |base| if cursor == prefix.len() { base } else { cursor })
}

fn block_scalar_is_complete(parse: &Parse<YamlFile>, source: &str, block: &BlockScalarBoundary) -> bool {
    parse.tree().documents().any(|document| {
        document.as_node().is_some_and(|root| {
            root.descendants().any(|node| {
                let Some(YamlNode::Scalar(scalar)) = YamlNode::from_syntax(node) else {
                    return false;
                };
                let range = scalar.byte_range();
                range.start as usize == block.start
                    && range.end as usize <= block.end
                    && source[range.end as usize..block.end]
                        .bytes()
                        .all(|byte| byte.is_ascii_whitespace())
            })
        })
    })
}

fn block_scalar_diagnostic(source_id: SourceId, source_len: usize, start: usize, code: DiagnosticCode) -> Diagnostic {
    Diagnostic::new(
        code,
        Severity::Error,
        "The YAML block scalar could not be interpreted safely.",
    )
    .with_label(DiagnosticLabel::primary(
        SourceSpan::from_valid_offsets(source_id, start, source_len.min(start + 1)),
        "Check the block scalar header and indentation.",
    ))
}

fn mask_blank_lines_after_mapping_keys(source: &str, compatible: &mut [u8]) -> bool {
    let bytes = source.as_bytes();
    let mut line_starts = vec![0];
    line_starts.extend(
        bytes
            .iter()
            .enumerate()
            .filter_map(|(index, byte)| (*byte == b'\n').then_some(index + 1)),
    );
    let mut changed = false;

    for line_index in 0..line_starts.len().saturating_sub(2) {
        let start = line_starts[line_index];
        let end = line_starts.get(line_index + 1).copied().unwrap_or(bytes.len());
        let content_end = line_content_end(bytes, start, end);
        let content = &source[start..content_end];
        let trimmed = content.trim();
        if trimmed.starts_with('#') || !trimmed.ends_with(':') {
            continue;
        }

        let mut next_line = line_index + 1;
        while next_line < line_starts.len() {
            let next_start = line_starts[next_line];
            let next_end = line_starts.get(next_line + 1).copied().unwrap_or(bytes.len());
            let next_content_end = line_content_end(bytes, next_start, next_end);
            if !source[next_start..next_content_end].trim().is_empty() {
                break;
            }
            next_line += 1;
        }
        if next_line == line_index + 1 || next_line >= line_starts.len() {
            continue;
        }

        let key_indent = content.bytes().take_while(|byte| *byte == b' ').count();
        let value_start = line_starts[next_line];
        let value_indent = source[value_start..].bytes().take_while(|byte| *byte == b' ').count();
        if value_indent <= key_indent {
            continue;
        }

        // Keep the final blank line's line ending and turn the preceding separators into trailing
        // spaces. This removes the backend-only blank-line ambiguity without changing byte spans.
        let final_blank_start = line_starts[next_line - 1];
        compatible[content_end..final_blank_start].fill(b' ');
        changed = true;
    }
    changed
}

fn line_content_end(bytes: &[u8], start: usize, end: usize) -> usize {
    let mut content_end = end;
    if content_end > start && bytes[content_end - 1] == b'\n' {
        content_end -= 1;
    }
    if content_end > start && bytes[content_end - 1] == b'\r' {
        content_end -= 1;
    }
    content_end
}

fn mask_non_colliding_anchor_hyphens(source: &str, compatible: &mut [u8]) -> bool {
    let bytes = source.as_bytes();
    let mut occurrences = Vec::new();
    let mut originals_by_normalized = BTreeMap::<Vec<u8>, BTreeSet<Vec<u8>>>::new();
    let mut index = 0;

    while index < bytes.len() {
        if !matches!(bytes[index], b'&' | b'*') {
            index += 1;
            continue;
        }
        let line_start = bytes[..index]
            .iter()
            .rposition(|byte| *byte == b'\n')
            .map_or(0, |position| position + 1);
        let preceding = bytes[line_start..index]
            .iter()
            .rfind(|byte| !byte.is_ascii_whitespace())
            .copied();
        if preceding.is_some_and(|byte| !matches!(byte, b':' | b'-' | b'[' | b'{' | b',' | b'?')) {
            index += 1;
            continue;
        }
        let start = index + 1;
        let mut end = start;
        while bytes.get(end).is_some_and(|byte| !anchor_name_delimiter(*byte)) {
            end += 1;
        }
        if start == end {
            index += 1;
            continue;
        }

        let original = bytes[start..end].to_vec();
        let normalized = original
            .iter()
            .map(|byte| if *byte == b'-' { b'_' } else { *byte })
            .collect::<Vec<_>>();
        originals_by_normalized
            .entry(normalized.clone())
            .or_default()
            .insert(original.clone());
        occurrences.push((start, end, original, normalized));
        index = end;
    }

    let mut changed = false;
    for (start, end, original, normalized) in occurrences {
        if !original.contains(&b'-')
            || originals_by_normalized
                .get(&normalized)
                .is_none_or(|originals| originals.len() != 1)
        {
            continue;
        }
        for byte in &mut compatible[start..end] {
            if *byte == b'-' {
                *byte = b'_';
                changed = true;
            }
        }
    }
    changed
}

const fn anchor_name_delimiter(byte: u8) -> bool {
    byte.is_ascii_whitespace() || matches!(byte, b'[' | b']' | b'{' | b'}' | b',')
}

#[derive(Debug, Default)]
struct ParserCompatibilityState {
    flow_depth: u32,
    quote: Option<u8>,
    escaped: bool,
}

fn block_sequence_indicator(bytes: &[u8], index: usize) -> bool {
    bytes[index] == b'-' && bytes.get(index + 1).is_none_or(u8::is_ascii_whitespace)
}

fn mask_block_plain_commas(
    content: &str,
    offset: usize,
    compatible: &mut [u8],
    state: &mut ParserCompatibilityState,
) -> (bool, Option<usize>) {
    let bytes = content.as_bytes();
    let mut index = 0;
    let mut first_token = true;
    let mut plain_started = false;
    let mut eligible_plain_value = false;
    let mut interpolation_depth = 0u32;
    let mut changed = false;

    while index < bytes.len() {
        let byte = bytes[index];

        if let Some(delimiter) = state.quote {
            if delimiter == b'"' && state.escaped {
                state.escaped = false;
            } else if delimiter == b'"' && byte == b'\\' {
                state.escaped = true;
            } else if byte == delimiter {
                if delimiter == b'\'' && bytes.get(index + 1) == Some(&b'\'') {
                    index += 1;
                } else {
                    state.quote = None;
                }
            }
            index += 1;
            continue;
        }

        if byte == b'#' && (index == 0 || bytes[index - 1].is_ascii_whitespace()) {
            break;
        }

        if eligible_plain_value && !plain_started && matches!(byte, b'!' | b'&') {
            index += 1;
            while bytes.get(index).is_some_and(|byte| !byte.is_ascii_whitespace()) {
                index += 1;
            }
            first_token = false;
            continue;
        }

        if matches!(byte, b'\'' | b'"') && !plain_started {
            state.quote = Some(byte);
            first_token = false;
            index += 1;
            continue;
        }

        if state.flow_depth > 0 {
            match byte {
                b'[' | b'{' => state.flow_depth += 1,
                b']' | b'}' => state.flow_depth -= 1,
                _ => {}
            }
            index += 1;
            continue;
        }

        let token_boundary = index == 0 || bytes[index - 1].is_ascii_whitespace();
        if matches!(byte, b'[' | b'{') && (!plain_started || (eligible_plain_value && token_boundary)) {
            state.flow_depth = 1;
            first_token = false;
            index += 1;
            continue;
        }

        if byte.is_ascii_whitespace() {
            index += 1;
            continue;
        }

        if (first_token || (eligible_plain_value && !plain_started)) && block_sequence_indicator(bytes, index) {
            eligible_plain_value = true;
            plain_started = false;
            first_token = false;
            index += 1;
            continue;
        }

        if byte == b':' && bytes.get(index + 1).is_none_or(u8::is_ascii_whitespace) {
            eligible_plain_value = true;
            plain_started = false;
            first_token = false;
            index += 1;
            continue;
        }

        if eligible_plain_value && !plain_started && matches!(byte, b'|' | b'>') {
            return (changed, Some(index));
        }

        // yaml-edit currently treats the first dash in an unquoted `- --option` item as another
        // block-sequence indicator. Masking one dash in the private, same-length parser input keeps
        // the item scalar while scalar extraction still reads the authored source.
        if eligible_plain_value && !plain_started && byte == b'-' && bytes.get(index + 1) == Some(&b'-') {
            compatible[offset + index] = b'_';
            changed = true;
        }

        if eligible_plain_value && plain_started && byte == b',' {
            compatible[offset + index] = b'_';
            changed = true;
        }

        // yaml-edit treats `}` as a plain-scalar terminator, while Compose permits
        // unquoted `${NAME}` expressions. Mask only balanced interpolation closers
        // in the private same-length parser input; source extraction restores the
        // authored brace and therefore preserves exact diagnostics and rendering.
        if eligible_plain_value && byte == b'$' && bytes.get(index + 1) == Some(&b'{') {
            interpolation_depth = interpolation_depth.saturating_add(1);
        } else if eligible_plain_value && plain_started && byte == b'}' && interpolation_depth > 0 {
            interpolation_depth -= 1;
            compatible[offset + index] = b'_';
            changed = true;
        }

        plain_started = true;
        first_token = false;
        index += 1;
    }

    state.escaped = false;
    (changed, None)
}

pub(crate) fn scalar_raw_from_source(source: &str, scalar: &Scalar) -> String {
    let range = scalar.byte_range();
    source
        .get(range.start as usize..range.end as usize)
        .map_or_else(|| scalar.value(), str::to_owned)
}

pub(crate) fn scalar_string_from_source(source: &str, scalar: &Scalar) -> String {
    let authored = scalar_raw_from_source(source, scalar);
    if authored.starts_with(['|', '>']) {
        let line_start = source[..scalar.byte_range().start as usize]
            .rfind('\n')
            .map_or(0, |index| index + 1);
        let indent = block_parent_indent(&source[line_start..scalar.byte_range().start as usize]);
        decode_block_scalar(&authored, indent)
    } else if authored == scalar.value() {
        scalar.as_string()
    } else {
        // Other compatibility replacements rewrite complete, single-line block plain scalars.
        authored
    }
}

/// Decodes authored block scalar text already bounded and checked by the syntax adapter.
/// YAML 1.2.2 section 8.1 defines relative indentation, folding and chomping independently of
/// the private backend's lexer and scalar decoder.
fn decode_block_scalar(authored: &str, parent_indent: usize) -> String {
    let Some((header, body)) = authored.split_once('\n') else {
        return String::new();
    };
    let token = header.split_ascii_whitespace().next().unwrap_or_default();
    let explicit = token.bytes().skip(1).find(|byte| matches!(byte, b'1'..=b'9'));
    let indent = explicit.map_or_else(
        || {
            body.split_inclusive('\n')
                .find_map(|line| {
                    let content = line.trim_end_matches(['\r', '\n']);
                    let spaces = content.bytes().take_while(|byte| *byte == b' ').count();
                    (spaces < content.len()).then_some(spaces)
                })
                // An implicit block with no non-empty content consists entirely of trailing
                // empty lines. Their indentation spaces are not scalar content.
                .unwrap_or_else(|| body.split_inclusive('\n').map(|line| {
                    line.bytes().take_while(|byte| *byte == b' ').count()
                }).max().unwrap_or(parent_indent + 1))
        },
        |digit| parent_indent + usize::from(digit - b'0'),
    );
    let lines: Vec<_> = body
        .split_inclusive('\n')
        .map(|line| {
            let has_break = line.ends_with('\n');
            let content = line.strip_suffix('\n').unwrap_or(line);
            let content = content.strip_suffix('\r').unwrap_or(content);
            let spaces = content.bytes().take_while(|byte| *byte == b' ').count();
            let text = &content[spaces.min(indent)..];
            (text, has_break, spaces > indent || text.starts_with('\t'))
        })
        .collect();
    let folded = token.starts_with('>');
    let mut decoded = String::new();
    for (index, &(text, has_break, more_indented)) in lines.iter().enumerate() {
        decoded.push_str(text);
        if !has_break {
            continue;
        }
        if !folded || text.is_empty() || more_indented {
            decoded.push('\n');
            continue;
        }
        match lines.get(index + 1) {
            Some((next, _, false)) if !next.is_empty() => decoded.push(' '),
            Some((next, _, _))
                if next.is_empty()
                    && lines[index + 1..]
                        .iter()
                        .find(|(text, _, _)| !text.is_empty())
                        .is_some_and(|(_, _, more)| !more) => {}
            _ => decoded.push('\n'),
        }
    }
    let has_final_break = decoded.ends_with('\n');
    if !token.contains('+') {
        decoded.truncate(decoded.trim_end_matches('\n').len());
        if !token.contains('-') && has_final_break && !decoded.is_empty() {
            decoded.push('\n');
        }
    }
    decoded
}

fn collect_value_scalars(source_id: SourceId, source: &str, node: YamlNode, values: &mut Vec<ValueScalar>) {
    match node {
        YamlNode::Scalar(scalar) => collect_scalar(source_id, source, &scalar, values),
        YamlNode::Mapping(mapping) => {
            for value in mapping.entries().filter_map(|entry| entry.value_node()) {
                collect_value_scalars(source_id, source, value, values);
            }
        }
        YamlNode::Sequence(sequence) => {
            for value in sequence.values() {
                collect_value_scalars(source_id, source, value, values);
            }
        }
        YamlNode::TaggedNode(tagged) => {
            if let Some(node) = tagged
                .as_node()
                .and_then(|node| node.children().find_map(YamlNode::from_syntax))
            {
                collect_value_scalars(source_id, source, node, values);
            }
        }
        YamlNode::Alias(_) => {}
    }
}

fn collect_editable_value_scalars(
    source_id: SourceId,
    source: &str,
    node: YamlNode,
    values: &mut Vec<EditableValueScalar>,
) {
    match node {
        YamlNode::Scalar(scalar) => {
            values.push(EditableValueScalar {
                raw: scalar_raw_from_source(source, &scalar),
                span: position_span(source_id, scalar.byte_range()),
            });
        }
        YamlNode::Mapping(mapping) => {
            for value in mapping.entries().filter_map(|entry| entry.value_node()) {
                collect_editable_value_scalars(source_id, source, value, values);
            }
        }
        YamlNode::Sequence(sequence) => {
            for value in sequence.values() {
                collect_editable_value_scalars(source_id, source, value, values);
            }
        }
        YamlNode::TaggedNode(tagged) => {
            if let Some(node) = tagged
                .as_node()
                .and_then(|node| node.children().find_map(YamlNode::from_syntax))
            {
                collect_editable_value_scalars(source_id, source, node, values);
            }
        }
        YamlNode::Alias(_) => {}
    }
}

fn extract_merge_value(
    source_id: SourceId,
    source: &str,
    node: YamlNode,
    registry: &AnchorRegistry,
    aliases: &mut Vec<String>,
) -> MergeSyntaxValue {
    match node {
        YamlNode::Scalar(scalar) if scalar.byte_range().is_empty() => {
            MergeSyntaxValue::Empty(position_span(source_id, scalar.byte_range()))
        }
        YamlNode::Scalar(scalar) => MergeSyntaxValue::Scalar(extract_merge_scalar(source_id, source, &scalar)),
        YamlNode::Mapping(mapping) => extract_merge_mapping(source_id, source, &mapping, registry, aliases),
        YamlNode::Sequence(sequence) => {
            let span = position_span(source_id, sequence.byte_range());
            let values = sequence
                .values()
                .map(|value| extract_merge_value(source_id, source, value, registry, aliases))
                .collect();
            MergeSyntaxValue::Sequence { values, span }
        }
        YamlNode::Alias(alias) => {
            let name = alias.name();
            let span = yaml_node_span(source_id, &YamlNode::Alias(alias.clone()));
            if aliases.contains(&name) || aliases.len() >= 64 {
                return MergeSyntaxValue::Alias {
                    name: original_alias_name(source, span).unwrap_or(name),
                    span,
                };
            }
            if let Some(target) = registry.resolve(&name).and_then(|node| {
                YamlNode::from_syntax(node.clone()).or_else(|| node.children().find_map(YamlNode::from_syntax))
            }) {
                aliases.push(name);
                let value = extract_merge_value(source_id, source, target, registry, aliases);
                let _ = aliases.pop();
                value
            } else {
                MergeSyntaxValue::Alias {
                    name: original_alias_name(source, span).unwrap_or(name),
                    span,
                }
            }
        }
        YamlNode::TaggedNode(tagged) => {
            let span = yaml_node_span(source_id, &YamlNode::TaggedNode(tagged.clone()));
            let tag = tagged.tag().unwrap_or_default();
            let mut value = tagged
                .as_node()
                .and_then(|node| node.children().find_map(YamlNode::from_syntax))
                .map_or_else(
                    || MergeSyntaxValue::Empty(span),
                    |value| extract_merge_value(source_id, source, value, registry, aliases),
                );
            if matches!(tag.as_str(), "!!timestamp" | "!!regex")
                && let MergeSyntaxValue::Scalar(scalar) = &mut value
            {
                scalar.strict_yaml_string = false;
            }
            MergeSyntaxValue::Tagged {
                tag,
                value: Box::new(value),
                span,
            }
        }
    }
}

fn original_alias_name(source: &str, span: SourceSpan) -> Option<String> {
    source.get(span.range())?.strip_prefix('*').map(ToOwned::to_owned)
}

fn extract_merge_mapping(
    source_id: SourceId,
    source: &str,
    mapping: &Mapping,
    registry: &AnchorRegistry,
    aliases: &mut Vec<String>,
) -> MergeSyntaxValue {
    let span = position_span(source_id, mapping.byte_range());
    let fields = raw_merge_fields(source_id, source, mapping);
    let direct = if is_flow_mapping(source, mapping) {
        fields
    } else {
        flatten_merge_fields(source_id, source, fields)
    };
    let mut entries = Vec::new();
    let mut inherited = Vec::new();
    for mut field in direct {
        let value = field.value.map_or_else(
            || {
                MergeSyntaxValue::Empty(SourceSpan::from_valid_offsets(
                    source_id,
                    field.key.span.end(),
                    field.key.span.end(),
                ))
            },
            |value| extract_merge_value(source_id, source, value, registry, aliases),
        );
        if field.key.plain && field.key.value == "<<" {
            match merge_source_groups(value) {
                Ok(groups) => inherited.extend(groups),
                Err(value) => {
                    // Invalid/unresolved merge sources must remain diagnosable, not disappear.
                    field.key.strict_yaml_string = false;
                    entries.push(MergeSyntaxEntry { key: field.key, value });
                }
            }
        } else {
            entries.push(MergeSyntaxEntry { key: field.key, value });
        }
    }
    // Local keys override inherited keys; earlier merge sources override later sources. Add a
    // group's keys only after filtering it so duplicate entries within that source stay visible.
    let mut previous: BTreeSet<_> = entries
        .iter()
        .map(|entry| (entry.key.value.clone(), entry.key.strict_yaml_string))
        .collect();
    for group in inherited {
        let mut added = BTreeSet::new();
        entries.extend(group.into_iter().filter(|entry| {
            let key = (entry.key.value.clone(), entry.key.strict_yaml_string);
            if previous.contains(&key) {
                false
            } else {
                added.insert(key);
                true
            }
        }));
        previous.extend(added);
    }
    MergeSyntaxValue::Mapping { entries, span }
}

fn merge_source_groups(value: MergeSyntaxValue) -> Result<Vec<Vec<MergeSyntaxEntry>>, MergeSyntaxValue> {
    match value {
        MergeSyntaxValue::Mapping { entries, .. } => Ok(vec![entries]),
        MergeSyntaxValue::Sequence { values, span } => {
            if values
                .iter()
                .any(|value| !matches!(value, MergeSyntaxValue::Mapping { .. }))
            {
                return Err(MergeSyntaxValue::Sequence { values, span });
            }
            Ok(values
                .into_iter()
                .filter_map(|value| match value {
                    MergeSyntaxValue::Mapping { entries, .. } => Some(entries),
                    _ => None,
                })
                .collect())
        }
        value => Err(value),
    }
}

#[derive(Debug)]
struct RawMergeField {
    key: MergeSyntaxScalar,
    value: Option<YamlNode>,
}

fn raw_merge_fields(source_id: SourceId, source: &str, mapping: &Mapping) -> Vec<RawMergeField> {
    let node = YamlNode::Mapping(mapping.clone());
    let Some(syntax) = node.as_node() else {
        return Vec::new();
    };
    // Mapping children are entry nodes. Keep their KEY wrappers available: key_node() omits
    // unsupported properties such as a tag token followed by a scalar inside that wrapper.
    mapping
        .entries()
        .zip(syntax.children())
        .filter_map(|(entry, authored)| {
            let wrapper = authored.children().next()?;
            let range = wrapper.text_range();
            let span = SourceSpan::from_valid_offsets(
                source_id,
                u32::from(authored.text_range().start()) as usize,
                u32::from(range.end()) as usize,
            );
            let key = if source.get(span.range()).is_some_and(|raw| raw.starts_with(['!', '&'])) {
                // key_node() exposes only the scalar body and hides leading property tokens.
                unsupported_merge_key(source, span)
            } else {
                entry.key_node().map_or_else(
                    || unsupported_merge_key(source, span),
                    |node| extract_merge_key(source_id, source, &node),
                )
            };
            Some(RawMergeField {
                key,
                value: entry.value_node(),
            })
        })
        .collect()
}

// The backend can consume an anchored sibling mapping key into a preceding plain scalar.
// Such a declaration cannot be valid plain-scalar content: colon + separation requires structure.
fn anchored_mapping_in_plain_scalar(raw: &str) -> Option<usize> {
    if raw.starts_with(['\'', '"', '|', '>']) {
        return None;
    }
    let mut offset = 0;
    for line in raw.split_inclusive('\n') {
        let content = line.trim_start_matches([' ', '\t']);
        if content.starts_with('&')
            && (content.contains(": ") || content.contains(":\t") || content.trim_end().ends_with(':'))
        {
            return Some(offset + line.len() - content.len());
        }
        offset += line.len();
    }
    None
}

fn extract_merge_key(source_id: SourceId, source: &str, node: &YamlNode) -> MergeSyntaxScalar {
    node.as_scalar().map_or_else(
        || unsupported_merge_key(source, yaml_node_span(source_id, node)),
        |scalar| extract_merge_scalar(source_id, source, scalar),
    )
}

fn unsupported_merge_key(source: &str, span: SourceSpan) -> MergeSyntaxScalar {
    let raw = source.get(span.range()).unwrap_or_default().to_owned();
    MergeSyntaxScalar {
        value: raw.clone(),
        raw,
        kind: MergeScalarKind::String,
        plain: false,
        presentation: ScalarPresentation::Plain,
        strict_yaml_string: false,
        span,
    }
}

fn flatten_merge_fields(source_id: SourceId, source: &str, fields: Vec<RawMergeField>) -> Vec<RawMergeField> {
    let Some(target_column) = fields
        .first()
        .map(|field| source_column(source, field.key.span.start()))
    else {
        return fields;
    };
    recover_merge_fields(source_id, source, fields, target_column)
}

fn recover_merge_fields(
    source_id: SourceId,
    source: &str,
    fields: Vec<RawMergeField>,
    target_column: usize,
) -> Vec<RawMergeField> {
    let mut flattened = Vec::new();
    for mut field in fields {
        let field_column = source_column(source, field.key.span.start());
        let nested_mapping = field.value.as_ref().and_then(YamlNode::as_mapping).cloned();
        let continuation = nested_mapping.as_ref().is_some_and(|mapping| {
            !is_flow_mapping(source, mapping)
                && mapping
                    .entries()
                    .find_map(|entry| entry.key_node()?.as_scalar().map(Scalar::byte_range))
                    .is_some_and(|position| source_column(source, position.start as usize) <= field_column)
        });
        if continuation {
            field.value = None;
        }
        if field_column == target_column {
            flattened.push(field);
        }
        if let Some(mapping) = nested_mapping.filter(|mapping| !is_flow_mapping(source, mapping)) {
            let nested = raw_merge_fields(source_id, source, &mapping);
            flattened.extend(recover_merge_fields(source_id, source, nested, target_column));
        }
    }
    flattened
}

fn is_flow_mapping(source: &str, mapping: &Mapping) -> bool {
    let position = mapping.byte_range();
    source
        .get(position.start as usize..position.end as usize)
        .is_some_and(|text| text.trim_start().starts_with('{'))
}

fn source_column(source: &str, offset: usize) -> usize {
    let prefix = &source[..offset.min(source.len())];
    let line_start = prefix.rfind('\n').map_or(0, |index| index + 1);
    source[line_start..offset.min(source.len())].chars().count()
}

fn extract_merge_scalar(source_id: SourceId, source: &str, scalar: &Scalar) -> MergeSyntaxScalar {
    let scalar_type = ScalarValue::from_scalar(scalar).scalar_type();
    let kind = match scalar_type {
        ScalarType::Boolean => MergeScalarKind::Boolean,
        ScalarType::Integer | ScalarType::Float => MergeScalarKind::Number,
        ScalarType::Null => MergeScalarKind::Null,
        ScalarType::String | ScalarType::Timestamp | ScalarType::Regex => MergeScalarKind::String,
    };
    MergeSyntaxScalar {
        presentation: match scalar_raw_from_source(source, scalar).chars().next() {
            Some('|') => ScalarPresentation::Literal,
            Some('>') => ScalarPresentation::Folded,
            Some('\'') => ScalarPresentation::SingleQuoted,
            Some('"') => ScalarPresentation::DoubleQuoted,
            _ => ScalarPresentation::Plain,
        },
        raw: scalar_raw_from_source(source, scalar),
        value: scalar_string_from_source(source, scalar),
        kind,
        plain: ScalarValue::from_scalar(scalar).style() == ScalarStyle::Plain
            && !scalar_uses_block_style(source, scalar),
        strict_yaml_string: scalar_type == ScalarType::String,
        span: position_span(source_id, scalar.byte_range()),
    }
}

fn scalar_uses_block_style(source: &str, scalar: &Scalar) -> bool {
    let start = scalar.byte_range().start as usize;
    source[start..].trim_start().starts_with(['|', '>'])
        || source[..start]
            .lines()
            .rev()
            .find(|line| !line.trim().is_empty())
            .is_some_and(|header| header.contains(": |") || header.contains(": >"))
}

fn yaml_node_span(source_id: SourceId, node: &YamlNode) -> SourceSpan {
    let Some(syntax) = node.as_node() else {
        return SourceSpan::from_valid_offsets(source_id, 0, 0);
    };
    let range = syntax.text_range();
    SourceSpan::from_valid_offsets(
        source_id,
        u32::from(range.start()) as usize,
        u32::from(range.end()) as usize,
    )
}

fn position_span(source_id: SourceId, position: yaml_edit::TextPosition) -> SourceSpan {
    SourceSpan::from_valid_offsets(source_id, position.start as usize, position.end as usize)
}

fn collect_scalar(source_id: SourceId, source: &str, scalar: &Scalar, values: &mut Vec<ValueScalar>) {
    let raw = scalar_raw_from_source(source, scalar);
    let eligible_style = !raw.starts_with('\'') && !raw.starts_with('|') && !raw.starts_with('>');
    if !eligible_style || !raw.contains('$') {
        return;
    }
    let position = scalar.byte_range();
    values.push(ValueScalar {
        value: scalar_string_from_source(source, scalar),
        span: SourceSpan::from_valid_offsets(source_id, position.start as usize, position.end as usize),
    });
}

#[cfg(test)]
mod tests {
    use super::{
        MergeSyntaxScalar, MergeSyntaxValue, SyntaxDocument, block_scalar_is_complete, parser_compatible_source,
        unparsed_input_offset_after_document_end,
    };
    use crate::source::SourceId;

    fn assert_send_and_sync<T: Send + Sync>() {}

    #[test]
    fn syntax_documents_are_send_and_sync() {
        assert_send_and_sync::<SyntaxDocument>();
    }

    #[test]
    fn parsing_never_reads_the_process_environment() -> Result<(), Box<dyn std::error::Error>> {
        let source = "services:\n  app:\n    image: ${COMPOSE_LENS_SECRET}\n";
        let parsed = SyntaxDocument::parse(SourceId::new(1), source)?;

        assert_eq!(parsed.document().render_preserved(), source);
        assert!(parsed.is_valid());
        Ok(())
    }

    #[test]
    fn complete_root_guard_rejects_non_whitespace_after_the_backend_root() {
        let source = "services:\n  app:\n    image: example.invalid/app\n";
        let document_end = "services:".len();

        assert_eq!(
            unparsed_input_offset_after_document_end(document_end, source),
            Some(document_end)
        );
        assert_eq!(unparsed_input_offset_after_document_end(source.len(), source), None);
    }

    #[test]
    fn block_boundary_guard_rejects_backend_scalars_crossing_siblings() {
        let source = "services:\n  app:\n    command: |2\n      body\n  sibling:\n    image: later\n";
        let (_, blocks) = parser_compatible_source(source);
        let raw = yaml_edit::YamlFile::parse(source);
        assert_eq!(blocks.len(), 1);
        assert!(!block_scalar_is_complete(&raw, source, &blocks[0]));
    }

    #[test]
    fn comma_bearing_short_volumes_are_complete_and_preserved() -> Result<(), Box<dyn std::error::Error>> {
        let source = "services:\n  app:\n    volumes:\n      - ./data:/data:Z,ro\n  later:\n    image: later\n";

        let parsed = SyntaxDocument::parse(SourceId::new(2), source)?;

        assert!(parsed.is_valid());
        assert_eq!(parsed.document().render_preserved(), source);
        Ok(())
    }

    #[test]
    fn anchor_compatibility_does_not_merge_colliding_names() {
        let source = "first: &shared-name one\nsecond: &shared_name two\n";

        assert_eq!(parser_compatible_source(source).0, None);
    }

    #[test]
    fn anchor_compatibility_ignores_scalar_and_comment_content() {
        let source = "quoted: \"*not-an-alias\"\nplain: echo &not-an-anchor\n# *also-not-an-alias\n";

        assert_eq!(parser_compatible_source(source).0, None);
    }

    #[test]
    fn merge_scalars_retain_strict_yaml_string_identity() -> Result<(), Box<dyn std::error::Error>> {
        let parsed = SyntaxDocument::parse(
            SourceId::new(2),
            "plain: gpu\ntimestamp: !!timestamp 2023-12-25\nregex: !!regex 'gpu.*'\nquoted-timestamp: \"2023-12-25\"\nquoted-regex: \"gpu.*\"\n",
        )?;
        let root = parsed.document().merge_root().ok_or("merge root")?;
        let scalar = |name| -> Option<&MergeSyntaxScalar> {
            let MergeSyntaxValue::Mapping { entries, .. } = &root else {
                return None;
            };
            let value = &entries.iter().find(|entry| entry.key.value == name)?.value;
            match value {
                MergeSyntaxValue::Scalar(scalar) => Some(scalar),
                MergeSyntaxValue::Tagged { value, .. } => match value.as_ref() {
                    MergeSyntaxValue::Scalar(scalar) => Some(scalar),
                    _ => None,
                },
                _ => None,
            }
        };
        assert!(scalar("plain").is_some_and(|value| value.strict_yaml_string));
        for name in ["timestamp", "regex"] {
            assert!(
                scalar(name).is_some_and(|value| !value.strict_yaml_string),
                "{name}: {:?}",
                scalar(name)
            );
        }
        for name in ["quoted-timestamp", "quoted-regex"] {
            assert!(scalar(name).is_some_and(|value| value.strict_yaml_string));
        }
        Ok(())
    }
}