crates/biome_yaml_parser/tests/yaml_test_suite/err/block/extra_characters_in_header.yaml (1)

1-1: Good negative case; consider folded counterpart too.

Add a matching folded-scalar example (e.g., > bb a) to ensure both styles report the same diagnostic.

crates/biome_yaml_parser/tests/yaml_test_suite/err/block/invalid_headers.yaml (1)

1-5: Solid coverage; add folded and multi-digit edge cases.

To mirror literal tests and stress recovery, add:

• - >+1-2 (folded + multiple indicators)
• - >123 (invalid multi-digit indent)

 - |0
+
+- >+1-2
+
+- >123

xtask/codegen/src/yaml_kinds_src.rs (1)

13-15: Confirm PLUS is scoped to block-header lexing.

If emitted in general contexts, a+b risks fragmenting into PLAIN_LITERAL("a") PLUS PLAIN_LITERAL("b"). Please ensure the lexer keeps + inside PLAIN_LITERAL outside block headers, and add a test to lock this in.

Example test to add (in lexer tests):

#[test]
fn lex_plus_in_plain_scalar() {
    assert_lex!(
        "a+b: 1",
        MAPPING_START:0,
        PLAIN_LITERAL:3,
        COLON:1,
        WHITESPACE:1,
        FLOW_START:0,
        PLAIN_LITERAL:1,
        FLOW_END:0,
        MAPPING_END:0,
    );
}

crates/biome_yaml_parser/src/lexer/tests/block.rs (5)

462-469: Great sanity check; add folded twin for symmetry.

 #[test]
 fn lex_basic_block_scalar() {
     assert_lex!(
         r"|
     hello",
         PIPE:1,
         BLOCK_CONTENT_LITERAL:10,
     );
 }
+
+#[test]
+fn lex_basic_folded_block_scalar() {
+    assert_lex!(
+        r">
+    hello",
+        R_ANGLE:1,
+        BLOCK_CONTENT_LITERAL:10,
+    );
+}

---

471-486: Chomping indicators covered for |; please add > too.

 #[test]
 fn lex_block_scalar_with_chomping_indicator() {
     assert_lex!(
         "|+",
         PIPE:1,
         PLUS:1,
         BLOCK_CONTENT_LITERAL:0,
     );
 
     assert_lex!(
         "|-",
         PIPE:1,
         DASH:1,
         BLOCK_CONTENT_LITERAL:0,
     );
+
+    assert_lex!(
+        ">-",
+        R_ANGLE:1,
+        DASH:1,
+        BLOCK_CONTENT_LITERAL:0,
+    );
+
+    assert_lex!(
+        ">+",
+        R_ANGLE:1,
+        PLUS:1,
+        BLOCK_CONTENT_LITERAL:0,
+    );
 }

---

488-512: Nice combos; add a folded variant and a two-digit indent to document permissiveness.

     assert_lex!(
         r"|2
     content",
         PIPE:1,
         INDENTATION_INDICATOR:1,
         BLOCK_CONTENT_LITERAL:12,
     );
+    assert_lex!(
+        r">2
+    content",
+        R_ANGLE:1,
+        INDENTATION_INDICATOR:1,
+        BLOCK_CONTENT_LITERAL:12,
+    );
+    // Allowed by lexer; validated later by syntax-lint
+    assert_lex!(
+        "|10",
+        PIPE:1,
+        INDENTATION_INDICATOR:2,
+        BLOCK_CONTENT_LITERAL:0,
+    );

---

536-566: Good error coverage; add a folded “junk header” for parity.

     assert_lex!(
         "| bc d
     content",
         PIPE:1,
         WHITESPACE:1,
         ERROR_TOKEN:1,
         ERROR_TOKEN:1,
         ERROR_TOKEN:1,
         ERROR_TOKEN:1,
         BLOCK_CONTENT_LITERAL:12,
     );
+
+    assert_lex!(
+        "> bb a
+    content",
+        R_ANGLE:1,
+        WHITESPACE:1,
+        ERROR_TOKEN:1,
+        ERROR_TOKEN:1,
+        WHITESPACE:1,
+        ERROR_TOKEN:1,
+        BLOCK_CONTENT_LITERAL:12,
+    );

---

588-598: Mixed indentation test is helpful; consider adding an explicit indent-indicator variant.

 #[test]
 fn lex_block_scalar_mixed_indentation() {
     assert_lex!(
         r"|
   line1
     indented
  line2",
         PIPE:1,
         BLOCK_CONTENT_LITERAL:28,
     );
+
+    assert_lex!(
+        r"|2
+  line1
+    indented
+ line2",
+        PIPE:1,
+        INDENTATION_INDICATOR:1,
+        BLOCK_CONTENT_LITERAL:28,
+    );
 }

crates/biome_yaml_parser/src/parser/parse_error.rs (1)

38-40: Clarify diagnostic wording: “block scalar header”.

Slightly more precise and matches the feature’s terminology.

-pub(crate) fn expected_header(p: &YamlParser, range: TextRange) -> ParseDiagnostic {
-    expected_node("block header", range, p)
+pub(crate) fn expected_header(p: &YamlParser, range: TextRange) -> ParseDiagnostic {
+    expected_node("block scalar header", range, p)
 }

crates/biome_yaml_parser/tests/yaml_test_suite/ok/block/scalar/literal_scalar.yaml (1)

1-7: Solid coverage; consider adding a header that combines both indicators.

You already cover chomping-only (|-), keep with empty content (|+), and indent-only (|1-). To exercise the “multiple indicators permitted” behaviour this PR adopts, add one case that combines both chomping and indent (e.g. |+2) with a line of content.

crates/biome_yaml_parser/tests/yaml_test_suite/ok/block/scalar/folded_scalar.yaml (1)

1-7: Nice spread; add a mixed-order indicators case.

Folded covers >- with content, >+ empty, and >-4. Consider one where the indentation indicator precedes the chomping indicator (e.g. >4+) to lock in permissive ordering.

crates/biome_yaml_parser/src/lexer/mod.rs (2)

175-210: Coalesce header-line garbage into a single diagnostic.

Current loop emits a chain of ERROR_TOKENs for every non-break after the header. A single diagnostic spanning the range is clearer and cheaper.

Apply this diff:

-        // So that the block content can cleanly start at a newline
-        while let Some(c) = self.current_byte() {
-            if is_break(c) {
-                break;
-            }
-            tokens.push_back(self.consume_unexpected_token());
-        }
+        // Expect a line break after the header; coalesce any extras into one diagnostic
+        if self.current_byte().is_some_and(|c| !is_break(c)) {
+            let start = self.text_position();
+            while let Some(c) = self.current_byte() {
+                if is_break(c) {
+                    break;
+                }
+                self.advance(1);
+            }
+            self.push_diagnostic(ParseDiagnostic::new(
+                "Expected a line break after the block scalar header",
+                start..self.text_position(),
+            ));
+        }

---

234-261: Tighten the indentation-indicator diagnostic.

Small copy tweak and a hint make the error self-explanatory, especially for multi-digit values.

-            let err = ParseDiagnostic::new(
-                "Block scalar indentation indicator must be between '1' and '9'",
-                start_pos..self.text_position(),
-            );
+            let err = ParseDiagnostic::new(
+                "Block scalar indentation indicator must be a single digit between '1' and '9'",
+                start_pos..self.text_position(),
+            )
+            .with_hint("YAML allows at most one indentation indicator; multi-digit values like '10' are invalid.");

crates/biome_yaml_parser/src/parser/block.rs (5)

15-15: Prefer consistent import path for flow helpers

You’re mixing crate::parser and super:: for flow imports. For consistency with nearby imports, pull parse_any_flow_node via super::flow.

-use crate::parser::{flow::parse_any_flow_node, parse_error::expected_header};
+use super::flow::parse_any_flow_node;
+use crate::parser::parse_error::expected_header;

Alternatively, move expected_header into the existing super::parse_error::{ ... } list. Happy either way.

---

257-271: DRY up literal/folded scalar parsing

Both functions are identical except for the start token and node kind. Collapse into a single helper for maintainability.

-fn parse_literal_scalar(p: &mut YamlParser) -> CompletedMarker {
-    let m = p.start();
-    p.bump(T![|]);
-    BlockHeaderList.parse_list(p);
-    parse_block_content(p);
-    m.complete(p, YAML_LITERAL_SCALAR)
-}
-
-fn parse_folded_scalar(p: &mut YamlParser) -> CompletedMarker {
-    let m = p.start();
-    p.bump(T![>]);
-    BlockHeaderList.parse_list(p);
-    parse_block_content(p);
-    m.complete(p, YAML_FOLDED_SCALAR)
-}
+fn parse_literal_scalar(p: &mut YamlParser) -> CompletedMarker {
+    parse_block_scalar(p, T![|], YAML_LITERAL_SCALAR)
+}
+
+fn parse_folded_scalar(p: &mut YamlParser) -> CompletedMarker {
+    parse_block_scalar(p, T![>], YAML_FOLDED_SCALAR)
+}

Add this helper (placement anywhere nearby is fine):

fn parse_block_scalar(
    p: &mut YamlParser,
    start_token: YamlSyntaxKind,
    node_kind: YamlSyntaxKind,
) -> CompletedMarker {
    let m = p.start();
    p.bump(start_token);
    BlockHeaderList.parse_list(p);
    parse_block_content(p);
    m.complete(p, node_kind)
}

---

308-318: Tiny duplication in chomping indicator parsers

parse_strip_indicator and parse_keep_indicator are identical bar token/kind. Optional: a small helper or macro would remove duplication.

---

335-335: Nit: extract a helper for scalar starts

For readability and reuse, consider is_at_block_scalar_start(p) and call it here.

---

291-294: No parser change needed for folded scalars
The lexer emits BLOCK_CONTENT_LITERAL for both | and >, so p.at/expect(BLOCK_CONTENT_LITERAL) handles folded content correctly. Optionally rename BLOCK_CONTENT_LITERAL to BLOCK_CONTENT in src/lexer/mod.rs for clarity.

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_parser/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:57:34.751Z
Learning: Applies to crates/biome_parser/xtask/codegen/*.ungram : Nodes representing enclosing syntax errors must include the word Bogus (e.g., HtmlBogusAttribute)

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_diagnostics/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:46:05.836Z
Learning: Applies to crates/biome_diagnostics/**/*.rs : Use helper advice types from biome_diagnostics::v2 (CodeFrameAdvice, CommandAdvice, DiffAdvice, LogAdvice) when suitable

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_diagnostics/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:46:05.836Z
Learning: Applies to crates/biome_diagnostics/**/*.rs : Types implementing Diagnostic must also implement Debug (e.g., use #[derive(Debug, Diagnostic)])

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_parser/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:57:34.751Z
Learning: Applies to crates/biome_parser/xtask/codegen/*.ungram : Bogus nodes must be included as a variant in their corresponding union

crates/biome_yaml_parser/src/lexer/mod.rs (1)

447-447: Function renaming improves clarity.

Renaming is_literal_continuation to is_scalar_continuation and no_longer_flow to breach_parent_scope better reflects their broader usage across different scalar types.

Also applies to: 479-479, 518-518, 579-579, 592-592, 650-656

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro