# yaml-test-suite case IDs currently covered by our incremental Panache YAML parser harness.
# Keep this list intentionally small and grow it with parser capability.
D9TU
3UYS
4UYU
4GC6
2CMS
652Z
J7VC
3HFZ
4H7K
6JTT
9MAG
9JBA
55WF
9KBC
9MMA
B63P
9C9N
T833
236B
4EJS
4HVU
5U3A
62EZ
6S55
7LBH
8XDJ
9CWY
BF9H
# BS4K: comment splits a multi-line plain scalar at the document root
# (no enclosing block-map). Extension of the 8XDJ/BF9H value-level
# rule into YAML_DOCUMENT scope.
BS4K
C2SP
CML9
D49Q
DK4H
DMG6
G7JE
G9HC
HU3P
CTN5
CXX2
EB22
# H7J7 (`key: &x\n!!map\n  a: b`): node property (the `!!map` tag) on a
# continuation line of a block-map value sits at the parent key's column,
# violating spec §8.2.2 which requires continuation indent > key column.
# `check_node_property_underindented` rejects it as
# PARSE_NODE_PROPERTY_UNDERINDENTED.
H7J7
HRE5
JY7Z
N4JP
RHX7
S4GJ
X4QW
ZXT5
54T7
58MP
6H3V
J5UC
SYW4
9SHH
JS2J
3GZX
E76Z
W5VH
ZH7C
CUP7
D88J
6SLA
74H7
4V8U
6KGN
CPZ3
H3Z8
65WH
FQ7F
K4SU
SSW6
Y2GN
S7BG
9FMG
9J7A
KMK3
TE2A
# Block sequence of block maps (nested block_map inside sequence item).
229Q
# Block sequence with !!int tagged scalars; projects long-form tag events.
33X3
# Top-level scalar document with explicit tag (`! a` inside `--- ... `).
52DL
# Top-level scalar document with explicit tag (`! a`) — no doc-start marker.
8MK2
# Block sequence of flow sequences, including trailing-comma items.
5KJE
# Block sequence with multi-line flow maps (implicit key across lines).
8KB6
# Nested block sequences (`- - x`) with same-line nested dash.
3ALJ
# Literal block scalar (`|`) in block-map value with blank lines.
M29M
# Standalone top-level flow sequence document.
DHP8
# Block-sequence item containing an inline flow map.
MXS3
# Block-sequence item containing a flow map with colon in URL value.
UDM2
# Block map with literal (`|`) and folded (`>`) block scalars side-by-side.
5BVJ
# Block map mixing folded and literal block scalars (baseball stats example).
HMK4
# Block map followed by explicit document-end marker `...`.
S4T7
# Block sequence of flow sequences (baseball stats example).
YD5X
# Block map with inline flow-sequence and flow-map values.
UDR7
# Block sequence with anchors and aliases.
V55R
# Block sequence with mixed flow-seq, flow-map, and quoted scalars.
Q88A
# Block sequence with a unicode anchor name.
8XYN
# Comment-only document yields no DOC events (just +STR -STR).
98YD
# Document-end-marker-only input yields no DOC events.
HWV9
# Comment followed by document-end marker yields no DOC events.
QT73
# Block sequence with tagged scalars and a leading-space top-level indent.
2AUY
# Two bare document-start markers yielding two empty documents.
6XDY
# Bare scalar document, `...` end marker, then a new implicit-start document.
7Z25
# Two block-sequence documents separated by `---` with stream-level comments.
JHB9
# Document start marker on the last line yields a trailing empty document.
PUW8
# Block sequence including a tag-only-bang scalar (`! 12`) with a leading comment.
S4JQ
# Two-document stream of block maps separated by `---`/`...` markers.
U9NS
# Flow map with trailing comma before `}` (no phantom empty entry).
5C5M
# Flow map with quoted key and adjacent/spaced colons.
5T43
# Flow map with quoted keys and quoted scalar values projection.
C2DT
# Flow map across multiple lines with mixed quoted/plain values.
LP6E
# Flow sequence containing implicit `key: value` map entries.
QF4Y
# Flow sequence containing flow-map entries with empty keys (`[: v]`).
CFD4
# Flow sequence with explicit-key indicator (`?`) and multi-line plain key.
CT4Q
# Block-map with quoted (single) key whose value is a multi-line flow seq of map entries.
87E4
# Block-map with plain key whose value is a multi-line flow seq of map entries.
L9U5
# Block-map with quoted (double) key whose value is a multi-line flow seq of map entries.
LQZ7
# Single-document scalar with `%TAG` shorthand resolving to a custom prefix (handle + suffix).
CC74
# Single-document scalar with `%TAG !yaml!` directive overriding to the secondary YAML prefix.
U3C3
# Block-sequence item with `%TAG` handle shorthand on a quoted scalar.
Z9M4
# Block sequence with anchors and tags interleaved in any order (`&a !!str a`, `!!int &c 4`).
F2C7
# Block sequence with mixed quoted scalars + tags + anchors + alias + tag-only-empty.
LE5A
# Block-sequence item containing a flow map whose implicit key wraps across lines.
NJ66
# Flow map across multiple lines whose entries separate with newlines plus tags (`!!str`).
WZ62
# Block-map value is a multi-line flow map whose entries each split on `:`.
ZF4X
# Multi-line flow map containing nested flow sequences and flow maps as values.
M7NX
# Flow map with explicit-key indicator (`{ ? foo :, : bar }`).
FRK4
# Multi-line flow map mixing explicit and implicit keys (`? explicit: ...` and a trailing `?`).
DFF7
# Comment line inside a multi-line flow sequence is dropped from projected scalar text.
7TMG
# Flow map with URL-like plain value (`http://foo.com`) — colon needs whitespace to split.
4ABK
# Tag suffix percent-encoding (`!e!tag%21`) decoded to `<...tag!>` in event projection.
6CK3
# Multi-document with `%TAG !` directive overriding the primary handle on the second doc.
6WLZ
# Same `%TAG !` primary-handle override pattern but with no `---` on the first doc.
9WXW
# Block map containing standalone explicit-key (`? a`) lines projected with empty values.
7W2P
# Block map mixing regular entries, an explicit-key (`? b`) line, and an anchored key.
ZWK4
# Double-quoted scalars with `\u`, `\x`, and control-char escapes decoded then re-escaped.
G4RS
# Double-quoted scalar containing a literal tab; literal tab re-escaped as `\t` in event.
J3BT
# Multi-doc with bare `---` ... comment ... `...` empty-body doc between content docs.
6ZKB
# Same empty-body-doc-with-comment pattern but preceded by a non-trivial mapping doc.
9DXL
# Empty-body doc whose `---` and `...` are separated by a `# Empty` comment at EOF.
UT92
# Block-seq item with inline `key: value` (`- key: value?`) projected as `+MAP ... -MAP`.
JR7V
# Block-seq item with tab between `:` and value (`- foo:\t bar`); tab counts as separator.
6BCT
# Plain block-seq inline-map keys containing literal `"` and `]` (`- bla"keks: foo`).
AZW3
# Leading-space-indented block sequence with `- key: value` items + continuation entries.
93JH
# Flow sequence as a block-map key (`[flow]: block`) projected as `+SEQ [] ... -SEQ`.
LX3P
# Comment between block-sequence items absorbed as seq-level trivia (Spec 2.12 compact nested mapping).
9U5K
# Comment between block-sequence items where the second item is a flow seq (Spec 7.10 plain characters).
DBG4
# Block-seq inline-map item with tagged empty key/value (`- !!str : !!null`); tag preserved across colon.
FH7J
# Block-scalar header with explicit chomping/indent indicators (`>-`, `|+`); empty body honors keep chomp.
K858
# Block-scalar chomping spec example: strip/clip/keep applied to non-empty body (`|-`, `|`, `|+`).
A6F9
# Plain scalar packed onto the directive-end marker line (`--- text`).
27NA
# Tab-separated payload after directive-end marker (`---<TAB>scalar`).
K54U
# Plain scalar with trailing comment after directive-end marker (`--- foo  # comment`).
L383
# Comment-only payload after directive-end marker (`--- # comment`) with %TAG directive.
5TYM
# Block scalar header packed onto directive-end line: folded scalar (`--- >`).
4Q9F
96L6
B3HG
FP8R
# Block scalar header packed onto directive-end line: folded scalar with strip chomp (`--- >-`).
93WF
# Block scalar header packed onto directive-end line: literal scalar (`--- |`).
6JQW
T26H
T5N4
# Block scalar header packed onto directive-end line: literal with strip chomp (`--- |-`).
753E
# Block scalar header packed onto directive-end line: literal with keep chomp (`--- |+`).
6FWR
# Multi-line plain scalar at top level: line breaks fold to spaces, blank lines fold to newlines.
9YRD
EX5H
# Bare top-level folded block scalar (`>` with no `---` marker), simple body.
G992
# Bare top-level folded block scalar with more-indented "literal" lines surrounded by blanks.
6VJK
# Bare top-level folded block scalar; trailing less-indented comment terminates body.
7T8X
# Folded block scalar where a line beginning with `#` at content-indent is body, not a comment.
DK3J
# Multi-line double-quoted top-level scalar: single line breaks fold to space, blank lines to `\n`.
9TFX
# Multi-line single-quoted top-level scalar with the same line-folding contract as `9TFX`.
T4YY
# Two-document stream with a multi-line double-quoted scalar followed by an anchored plain scalar.
KSS4
# Document-level anchor on its own header line before a block sequence (no `---`).
3R3P
# Document-level anchor packed onto the `---` marker line, preceding a block sequence.
FTA2
# Document-level tag packed onto the `---` marker line, preceding a block sequence (e.g. `--- !!omap`).
J7PZ
# Block-map entry whose value is empty inline (only trivia after `:`) and continued by an indented plain scalar on the next line.
5NYZ
# Anchor-only scalar in a block-map value followed by an indented nested block map; anchor annotates the nested `+MAP &name`.
26DV
# Multi-line double-quoted scalar in a block-map value; blank line folds to `\n`, single break folds to space.
XV9V
# Plain scalar `k:#foo` with no whitespace after the colon: not a key/value pair, must stay a single plain scalar continuing onto the next indented line.
3MYT
# Plain scalar key whose text contains a run of trailing colons (`key::`); only the colon followed by whitespace splits key from value.
8CWC
# Error-contract: bare scalar `top2` at root after a block-map entry (no trailing colon) — rejected with YAML_PARSE_INVALID_KEY_TOKEN.
7MNF
# Error-contract: trailing scalar at document root after a closed flow sequence — rejected with YAML_PARSE_INVALID_KEY_TOKEN.
KS4U
# Error-contract: inline content directly after a flow-map close (`}- invalid`) — rejected with YAML_PARSE_TRAILING_CONTENT_AFTER_FLOW_END.
P2EQ
# Error-contract: multi-line double-quoted scalar whose continuation lines start at column 0 (less than key indent) — rejected with YAML_PARSE_INVALID_KEY_TOKEN.
QB6E
# Error-contract: block-sequence item under-indented relative to its parent block-map entry — rejected with YAML_PARSE_INVALID_KEY_TOKEN.
ZVH3
# Document-level tag packed onto the `---` marker line, preceding a block map of explicit-key (`? key`) entries with implicit null values (e.g. `--- !!set`).
2XXW
# Explicit-key block-map entry: `? key` line followed by `: value` line (each on its own line). Implicit-key entries may interleave.
GH63
# Explicit-key block-map entries mixed with regular implicit-key entries in the same map.
RR7F
# Explicit-key block-map entries where both key and value carry leading tag shorthands (`? !!str a` / `: !!int 47`).
L94M
# Explicit-key block-map entry with a comment line between the `? key` and `: value` lines.
X8DW
# Multi-document stream where each `---` marker carries a type-tag shorthand (`!!map` / `!!seq` / `!!str`); covers tagged maps, tagged sequences, and tagged plain scalars folded across multiple lines.
35KP
# Empty stream: zero documents, zero events between +STR/-STR.
AVM7
# Stream of comment-only lines and blank lines: no documents emitted.
8G76
# Reserved (unrecognized) directive `%FOO …` is ignored; following document parses normally.
2LFX
6LVF
# Recognized future-version YAML directive (`%YAML 1.3`) accepted with warning; document body parses.
BEC7
# `%YAML 1.2` directive followed by `---` marker, document body, and `... # suffix` end-marker with trailing comment.
RTP8
# `%TAG !! tag:example.com,2000:app/` secondary handle; body uses the rebound `!!` shorthand on a plain scalar.
P76L
# Three-dashes immediately followed by content with no space (`---word1\nword2`) is a multi-line plain scalar, not a directive-end marker.
82AN
EXG3
# Multi-line plain scalar at top level whose continuation line happens to look like a YAML directive (`%YAML 1.2`); the scalar continues uninterrupted.
XLQ9
# Tab character at the start of a line followed by a flow indicator (`\t[`, `\t{`) is leading whitespace, not block-context indent.
6CA3
Q5MG
# Trailing whitespace on the line after a closed flow collection (`[1, 2, 3]  \n  `) is consumed as trivia; no further content.
4RWC
# Deeply nested flow collections on one line: maps inside sequences inside maps (`{ a: [b, c, { d: [e, f] } ] }`).
F3CP
R52L
# Nested flow collections split across lines with the closing-brace stack on a single line (`{ key: [[[\n  value\n ]]]\n}`).
ZK9H
# Flow-map entry where the key and value indicator are on different lines (`{ "foo"\n  :bar }`); colon-adjacent value still binds.
5MUD
# Flow-map entry where a comment intervenes between key and the colon-adjacent value on the next line (`{ "foo" # comment\n  :bar }`).
K3WX
# Block-map entry whose value is a comment after the colon and the actual value lives on the next indented line (`key:    # Comment\n  value`).
P94K
# Block-map with `:` key whose value section contains only blank lines (no value); subsequent blanks are document trivia.
NHX8
# Spec example 6.1: indentation spaces — block-map values include literal block scalar and flow sequence with mixed tab/space leading whitespace.
6HB6
# Multi-line double-quoted scalar with single line breaks folding to space and blank lines folding to `\n` (spec 7.6).
7A4E
# Multi-line single-quoted scalar with the same line-folding contract as 7A4E (spec 7.9).
PRH3
# Multi-line plain scalar with blank lines folding to `\n` and tab-prefixed continuation (spec 7.12).
HS5T
# Spec example 6.5: multi-line double-quoted block-map value where blank/whitespace-only lines fold to `\n` and clipped block scalar follows.
5GBF
# Spec example 6.8 [1.3]: bare top-level multi-line double-quoted scalar where leading/trailing whitespace is stripped and blank lines fold to `\n`.
6WPF
# Spec example 6.8: same flow-folding contract as 6WPF without the `---` marker, including a tab-prefixed continuation line.
TL85
# Top-level literal block scalar (`|`) whose body contains blank-only and comment-prefixed indented lines preserved as content (spec 8.8).
DWX9
# Top-level folded block scalar (`>-`) with strip chomp; trimmed content with internal blank lines folds to a single `\n` separator (spec 6.6).
K527
# Top-level literal block scalar (`|`) with tab-indented body line preserved verbatim (spec 8.7).
M9B4
# Top-level literal block scalar with strip chomp (`|-`) terminated by document-end marker (`...`).
MYW6
# Top-level folded block scalar (`>`) with internal blank lines and a re-indented continuation block.
TS54
# Block sequence whose items are block maps, each value a literal block scalar (`|2`, `|`); covers block-scalar inside block-map inside block-sequence nesting.
4WA9
# Block-map with blank lines between entries and a literal block scalar value containing internal blanks/whitespace-only lines.
H2RW
# Anchors on block-map keys (`&k1 key1: one`) and on map values (`top1: &node1\n …`); anchors interleave with comment trivia.
7BMT
U3XV
# Tag and anchor on a double-quoted block-map key (`!!str &a1 "foo": …`) and tag on the value scalar (`!!str bar`).
HMQ5
# Anchors on otherwise-empty scalars in a block sequence: `- &a` (sequence entry with anchor only) and `&a : a` (anchor on empty implicit key).
PW8X
# Multi-line plain scalar in block-map value: single line break folds to space (`b\n c` → `b c`).
A984
# Multi-line plain scalar with blank-line continuation: blanks fold to `\n` between non-empty lines (`a\n b\n\n c` → `a b\nc`).
36F6
# Multi-line plain scalar where the value begins on the line after `key:` (continuation indented under the key).
4CQQ
# Block-map mixing multi-line plain, multi-line double-quoted, and literal block-scalar values.
4ZYM
# Multi-line plain scalar with safe special characters (`?`, `:`, `-`, `#`, brackets) that don't terminate the scalar; backslash escaped to `\\` in event body.
FBC9
# Multi-line plain scalar where a tab-only line counts as a blank line and folds to `\n`.
NB6Z
# Multi-line double-quoted scalar as a flow-map key (`{ "multi\n  line": value }`) with explicit-colon entry.
9SA2
# Explicit-block-key entries (`? key\n: value`) with multi-line plain key and value text — both fold to single-line via continuation-line stripping.
JTV5
# Block-map whose value is a nested block-sequence (`key:\n - item1\n - item2`); projection now scopes top-level container detection to direct children of the document and projects nested block-sequence values explicitly.
8QBE
# Block-map containing two entries each with a nested block-sequence value; same root cause as 8QBE — descendants() walk previously collapsed the entire map into the inner sequence.
PBJ2
# Block-map entries with comments preceding the nested block-sequence value (`hr: # comment\n  - item`) — relies on direct-child top-level detection plus nested-seq value projection.
J9HZ
# Block-map with seq value where one item is itself a `key : value` flow-style mapping (`- two : three`) — exercises nested-seq projection inside a top-level block-map.
JQ4R
# Block-map with seq value containing tab-padded scalars (`seq:\t\n - a\t`) — nested-seq projection fixes the previously-collapsed shape.
DC7X
# Multi-document stream where each `---` doc is a block-map containing nested block-sequence values (Stack: [- file: .., line: ..]); recursive direct-children projection unlocks all three docs.
RZT7
# Block-map with anchors/aliases on nested block-sequence values (`hr:\n  - &SS Sammy Sosa`); top-level direct-child detection now keeps the outer map.
7BUB
# Block-sequence items containing `|` literal block-scalar values (`- |\n detected`); project_block_sequence_items now routes through the block-scalar folder before the plain-scalar fallback.
4QFQ
# Block-sequence items containing `|2-` / `|-2` block scalars (explicit indent + chomp combined in either order); same root cause as 4QFQ — the new block-scalar branch in sequence-item projection picks them up.
D83L
# Block-map values with explicit indent indicators on `>` folded scalars (`a: >2\n   more indented`); explicit indent indicator now sets content_indent to parent_col + m instead of being silently discarded.
F6MC
# Block-map with literal block-scalar values whose content begins with `#` (`strip: |-\n  # text`); keep-chomp counting now uses trailing-empty body lines (computed on stripped text) so `|+` preserves the right number of trailing newlines.
F8F9
# Block-sequence with mixed item kinds including a `|` literal scalar (`- |\n x`); same fix as 4QFQ — block-scalar dispatch in sequence-item projection.
M6YH
# Block-sequence containing a folded `>` block-scalar mixed with plain/quoted scalars (`- >\n  block`); block-scalar dispatch in sequence-item projection picks up the folded scalar.
MZX3
# Block-scalar headers carrying trailing comments (`| # Empty header`, `>1 # Indentation indicator`, `|+ # Chomping indicator`, `>1- # Both indicators`); parse_block_scalar_indicator now consumes optional trailing whitespace + comment after the chomp/indent characters.
P2AD
# Block-sequence containing a `|` block-scalar followed by compact mapping/sequence items (`- |\n block node`); same root cause as 4QFQ.
W42U
# Folded `>` scalar containing tab-prefixed or tab-only lines (`  \t bar`, ` \t`); is_blank/is_mi for folding now decided on the content-indent-stripped text rather than `trim().is_empty()` and leading-spaces count, so a stripped `\t` is content (and more-indented) per §8.1.3 instead of being collapsed into the surrounding blanks.
MJS9
R4YG

# Plain-scalar bodies in scalar_event now go through escape_for_event so backslashes (and other control chars) emit as `\\`/`\n`/etc. — yaml-test-suite event escaping for plain scalars.
2EBW
# Block-sequence items shaped `- !!map\n  k: v` now propagate the `!!map` (and other) tag onto the `+MAP` event by routing through map_open_event_for_block_map.
735Y
# Multi-line quoted scalars inside flow sequences fold their newlines per YAML §7.3 (single break -> space) before the event escape pass — `quoted_val_event_multi_line` is now picked when a flow-seq item contains `\n`.
8UDB
# Flow-map orphan keys (`{ "multi\n  line", a: b}`) fold multi-line quoted keys before emitting; flush_pending_orphan now picks `quoted_val_event_multi_line` for newline-bearing quoted text.
9BXH
# Nested flow sequences inside a flow sequence (`[a, [b, c]]`) project as nested `+SEQ []` because the doc-level flow-seq path now uses the CST-walking projector instead of the text-based item splitter.
FUP4
# Multi-line plain scalars on block-sequence items (`- x\n  \tx`) now fold to a single space before scalar_event; project_block_sequence_items applies `cooking::cook_plain` when the body contains a newline.
UV7Q

# Indentless block sequence as a block-map value (`foo:\n- 42`): the `-`
# sits at the parent key's column, so the scanner pushes no indent and
# emits no BlockSequenceStart; the parser now synthesizes the
# YAML_BLOCK_SEQUENCE frame inside the open VALUE (closed on the parent
# map's next Key/Value/BlockEnd) so the tree matches the indented form
# (spec 8.2.1). Guarded to the value's first significant token so a `-`
# after scalar content stays unwrapped for the validator to reject.
RLU9
# Indentless block sequence followed by a plain scalar entry in the same
# map (`one:\n- 2\n- 3\nfour: 5`); previously a false-positive
# UNEXPECTED_DEDENT because the unwrapped bare entries inflated the
# validator's scalar count.
AZ63
# Indentless block sequence then an indented explicit-key block map in
# the next entry (`sequence:\n- one\n- two\nmapping:\n  ? sky\n  : blue`).
S9E8
# Nested indentless sequences mixed with empty flow collections
# (`nested sequences:\n- - - []\n- - - {}`) plus trailing flow-collection
# map values; exercises indentless wrapping under deep `- - -` nesting.
7ZZ5
# Multi-line quoted scalars whose every line is empty/whitespace-only
# (`a: '\n  '`, `e: '\n\n  '`): the scalar folds to nothing but line breaks,
# so fold_quoted_inner now flushes the trailing all-blank run (1 break -> space,
# n breaks -> n-1 newlines) instead of dropping it.
NAT4
# Block-map value shaped `<tag> <block-scalar>` where the scanner embeds the
# tag inside the leading scalar token (`folded: !foo >1\n value`), so the bare
# block-scalar detector misses the indicator; events.rs now peels the leading
# anchor/tag and folds the remainder via the shared fold_block_scalar_raw.
Z67P
# Same `<tag> <block-scalar>` shape with the tag and indicator on separate
# lines (`folded:\n   !foo\n  >1\n value`); peeling skips intervening newlines.
M5C3
# Node properties (anchor and/or tag) preceding a nested block map whose first
# entry has an empty key (`key: &anchor\n !!map\n  a: b`): the scanner fuses the
# props + fused first key into one scalar before the map, so
# extract_leading_node_properties now peels the embedded tag (not just the
# anchor) and the props hoist onto `+MAP &anchor <tag>` (anchor-first order).
BU8L
# Same hoist-onto-+MAP shape for a block-sequence item (`- !!map\n  key: value`),
# where the fused `!!map\n  key` scalar precedes a nested map with an empty
# first key; the sequence-item path now reuses the shared splice helper.
6JWB
# Verbatim tags `!<URI>` on a block-map key and value (`!<tag:yaml.org,2002:str>
# foo :` / `!<!bar> baz`): split_leading_tag now spans `!<…>` to its closing `>`
# (the URI carries commas/colons) and resolve_long_tag passes the inner URI
# through verbatim, bypassing handle resolution per YAML 1.2 §6.8.1.
7FWL
# Explicit-key (`?`) block-map entry whose KEY is itself a nested collection —
# a block/flow sequence (M5DY: `? - a\n  - b\n: ...` and `? [x, y]`) or a nested
# block map (V9D5: `? earth: blue\n: moon: white`). The collection lives as a
# child node of YAML_BLOCK_MAP_KEY; project_block_map_key_collection now projects
# it in the key position instead of emitting an empty `=VAL :`.
M5DY
V9D5
# Unlocked by the same explicit-key-collection projection: comment-heavy maps
# mixing double-quoted folding, plain multi-line values, and an explicit
# `? # comment\n - seq1\n: # comment\n - seq2` whose key/value are block
# sequences (plus a `&node` block-seq value and a folded `>` block scalar).
RZP5
XW4D
# A flow collection used as a key projects structurally instead of being
# slurped as scalar text. Two shapes: a stray flow-seq sibling inside a flow
# map that keys the next empty-key entry (SBG9: `{a: [b, c], [d, e]: f}`), and
# a flow-seq item shaped `<collection>: value` that is an implicit single-pair
# map keyed by the collection (4FJ6: nested `[[b,c]]: d` and `[ a, [...]]: 23`).
SBG9
4FJ6
# Tagged multi-line double-quoted scalar with §7.5 escaped line breaks
# (`!!binary "\<NL> base64\<NL> …"`): a line ending in an unescaped backslash
# escapes the break, so it joins with no folded space. fold_quoted_inner is now
# escaped-break-aware and the tag-decompose value path enables it for `"` bodies.
565N
# Flow-sequence single-pair implicit entries with a JSON-like key
# (`[ "JSON like":adjacent ]`, `[ {JSON: like}:adjacent ]`): per §7.4.2 a quoted
# or flow-collection key permits an adjacent value colon. Block-seq flow items
# now project via the CST walker (structural flow-collection keys) and
# flow_kv_split accepts the adjacent colon after a quoted key.
9MMW
# Zero-indented block sequence as an explicit-key (`?`) mapping key
# (`?\n- a\n- b\n:\n…`): like an indentless sequence in a VALUE, the scanner
# emits no BlockSequenceStart, so the parser now synthesizes the
# YAML_BLOCK_SEQUENCE inside the open KEY (mirroring the VALUE side).
6PBE
# Error-contract: two `%YAML` directives precede the same document
# (`%YAML 1.2\n%YAML 1.2\n---`) — at most one is allowed (§6.8.1).
# check_directives now tracks a per-document `%YAML` scope and rejects with
# YAML_PARSE_DUPLICATE_YAML_DIRECTIVE.
SF5V
# Error-contract: a `%YAML` directive with content beyond its single version
# argument (`%YAML 1.2 foo`) — rejected with YAML_PARSE_MALFORMED_YAML_DIRECTIVE.
# A trailing comment after the version stays valid.
H7TQ
# Error-contract: inline nested mapping in a block-map value — a value scalar
# followed by a second `: ` value-indicator (`a: b: c: d`, `a: 'b': c`).
# check_value_level_scalar_then_colon_map now flags single-line content
# scalars (not just multi-line implicit keys), exempting pure node-property
# scalars (W5VH/26DV); rejected with YAML_PARSE_INVALID_KEY_TOKEN.
ZCZ6
ZL4Z
# Multi-line double-quoted scalar with a §7.5 escaped line break (`\` at end of
# line) folding two lines with no separating space (spec example 7.5). The
# validator's `is_valid_dq_escape` table omitted `\n`/`\r` (and `\t`), so a bare
# `"…"` scalar with an escaped break was falsely rejected with
# LEX_INVALID_DOUBLE_QUOTED_ESCAPE — 565N only escaped this via its `!!binary`
# tag prefix shielding the token from the `starts_with('"')` check.
NP9H
Q8AD
# Consecutive empty-key (null-key) block-map entries from a bare leading `:`
# (`: a\n: b`, 2JQS). The scanner emits two bare `Value` tokens with no Key /
# BlockEnd between them; the parser used to absorb the second `:` into the first
# entry's value (tripping a false UNEXPECTED_DEDENT in the validator). The Value
# handler now closes the open block-map entry when a bare `:` arrives while
# already in_value (guaranteed a peer at the map's column by the scanner's indent
# machinery) and opens a fresh empty-key entry.
2JQS
# Same empty-key-entry fix, mixed with a regular entry and a quoted key whose
# value is an indentless block sequence (`plain key: …\n: # Both empty\n"quoted
# key":\n- entry`). Was tree:true but the `: # Both empty` line folded into the
# previous value.
S3PD
# Same fix across a multi-document stream combining block empty-keys
# (`: empty key`), flow-map empty keys (`{ key: value, : empty key }`, `{ : }`),
# and comment-only empty-key/value docs. Flow empty-keys already worked (the `,`
# closes the entry); the block-context docs were the ones tripping the false
# UNEXPECTED_DEDENT.
NKF9
# Same fix unlocks an explicit-key entry (`? &a a\n: &b b`) followed by an
# empty-key entry whose value is an alias (`: *a`). The alias/anchor events
# (`=VAL &a :a`, `=ALI *a`) were already projected; the `: *a` line was the
# piece getting absorbed into the previous value before the empty-key fix.
6M2F
# Compact block sequence on the value-indicator line of an explicit-key
# entry (`? a\n: - b\n  - c`, A2M4). YAML 1.2 `ns-l-compact-sequence` permits
# this after the explicit `:`; only implicit keys (`key: - a`, 5U3A) forbid it.
# check_inline_block_seq_in_value now exempts entries whose YAML_BLOCK_MAP_KEY
# carries a `?` (YAML_KEY) indicator.
A2M4
# Same explicit-key compact-sequence exemption, plus an explicit key that is
# itself a literal block scalar (`? |\n  block key\n: - one\n  - two`, 5WE3) and
# a folded block scalar (`complex4:\n  ? >\n    a\n  :`, KK5P). The block-map
# key projection now folds a `|`/`>` block-scalar key through
# extract_block_scalar_body instead of emitting it as a plain scalar.
5WE3
KK5P
# Error-contract: unterminated quoted scalar. The streaming scanner already
# detects a `"`/`'` scalar that never reaches its closing quote, but
# validate_yaml consumed only the token stream and dropped the lex diagnostic;
# check_unterminated_quoted now surfaces YAML_LEX_UNTERMINATED_QUOTED_SCALAR.
# CQ3W: quote runs to EOF (`key: "missing closing quote`).
CQ3W
# 5TRB / RXY3: a `---`/`...` document marker at column 0 aborts the still-open
# quoted scalar before its closing quote is found.
5TRB
RXY3
# Error-contract: block-scalar leading empty line over-indented (YAML 1.2
# §8.1.1.1). With auto-detected indentation, a leading blank line may not
# contain more spaces than the first non-empty content line; check_block_scalar_
# leading_indent walks the `>`/`|` scalar token's body and rejects it with
# YAML_PARSE_UNEXPECTED_INDENT. 5LLU/W9L4: blank lines deeper than content;
# S98Z: same shape where the first non-empty line is a literal `# comment`.
5LLU
W9L4
S98Z
# Error-contract: a comment must be preceded by whitespace or start a line
# (YAML 1.2 §6.6); a `#` abutting a non-space character is neither a valid
# comment nor a valid plain-scalar start (`#` is a c-indicator). The scanner
# still tokenizes the `#…` run as a YAML_COMMENT, so check_comment_not_
# preceded_by_space walks comment tokens and rejects the first whose preceding
# char is not space/tab/newline, with YAML_LEX_COMMENT_NOT_PRECEDED_BY_SPACE.
# SU5Z: `#` right after a closing quote (`key: "value"# comment`).
SU5Z
# CVW2: `#` right after a flow `,` separator (`[ a, b, c,#invalid ]`).
CVW2
# Multi-line plain scalar: a more-indented `- ` continuation line folds into
# the scalar instead of opening a nested sequence (libyaml rule; only `:`
# value indicators abort a plain-scalar continuation, not `-`/`?`).
AB8U
# Error-contract: a lone `-` plain scalar inside a flow collection
# (`[-]`, `- [-, -]`). In flow context `-` may only begin a plain scalar
# when followed by a non-space, non-flow-indicator char (§7.3.3
# `ns-plain-first`); when it abuts a flow indicator (`,`/`]`/`}`) it is a
# bare indicator. check_flow_lone_dash (Cluster G) surfaces
# YAML_PARSE_INVALID_PLAIN_SCALAR_IN_FLOW.
YJV2
G5U8
# Error-contract: a line at the block-sequence's own indent that is not a
# new `- item` is rejected as stray content. The parser already surfaces
# YAML_PARSE_INVALID_KEY_TOKEN ("stray content following a block sequence
# item at its indent level") for these.
# BD7L: a mapping key (`invalid: x`) after `- item1 / - item2`.
BD7L
# TD5N: a bare scalar (`invalid`) after `- item1 / - item2`.
TD5N
# GT5M (`- item1\n&node\n- item2`): once anchor dispatch landed, the
# previous `stray content following a block sequence item` diagnostic
# no longer fires — `&node` between items now parses as a node
# property for the next item. The real error (anchor with no following
# value at sequence-indent) needs the Phase 6 lex-level error pass to
# be re-allowlisted.
# GT5M
# Error-contract: a second mapping key indented deeper than the first in
# the same block map (`k1: v1\n k2: v2`). An implicit key cannot span
# lines (§7.4.2.4); the parser surfaces YAML_PARSE_INVALID_KEY_TOKEN
# ("implicit key cannot span lines").
EW3V
# Error-contract: a `#` mid-line inside a multi-line plain scalar
# (`this is #not a: key`). A comment cannot appear inside a plain scalar
# (§6.6); the parser surfaces YAML_PARSE_UNEXPECTED_DEDENT ("comment
# cannot appear inside a multi-line plain scalar").
GDY7
# Error-contract: bare content following a closed quoted scalar on the
# same line (`key: "quoted" trailing content`). A flow-quoted scalar
# terminates at its closing quote; subsequent non-trivia on the same
# line is invalid. The existing multi-line plain-scalar guard rejects
# the document via YAML_PARSE_UNEXPECTED_DEDENT — wording is approximate
# but the rejection is correct.
Q4CL
# Error-contract DROPPED: tag dispatch now silently accepts the shape,
# as flagged in the prior comment here. The fixture's real spec error
# (`!prefix!` shorthand defined only in the first document but used in
# subsequent docs without re-declaration) needs a dedicated check_*
# cluster in validator.rs — `%TAG` handles are document-scoped per
# YAML 1.2 §6.8.2 and must not leak across `---`. Re-add this case
# once that check lands.
# Doc-root literal/folded block scalar with column-0 body (e.g. `--- |\n%!PS-Adobe-2.0`).
# Per YAML 1.2 §8.1.1.1 content indent must be strictly greater than the
# block scalar's parent indent; at doc root parent = -1, so column 0 is
# permitted. The scanner now uses floor = parent+1 (>=0) instead of the
# libyaml `max(parent,0)+1` shortcut, so the body — including lines
# starting with `%`, `#`, `...` does NOT terminate early — is
# captured as a single Scalar token.
M7A3
W4TN
# Error-contract: a content scalar value (e.g. `key1: "quoted1"`)
# followed on the next line by a deeper-indent block-map entry inside
# the same block-map value slot. YAML 1.2 §8.2.2 lets an implicit
# block-mapping value hold a single node or be empty; once a scalar
# fills the slot, a nested block collection at a deeper indent under
# the same key is rejected. `check_block_collection_after_value_scalar`
# exempts node-property–only shadow scalars (`&anchor`/`!tag`/`*alias`)
# so anchor/tag placeholders preceding a real block value (7BMT,
# U3XV, 6JWB, RZP5, XW4D) keep parsing.
U44R
# Error-contract: a YAML document marker (`---` or `...`) appearing at
# the start of a line inside a flow collection. YAML 1.2 §9.1.1
# forbids document marker lines from interrupting flow content; once
# `[` or `{` opens a flow context the entire flow must close before a
# new document can begin. The scanner currently folds the marker into
# a plain scalar at column 0, so `check_flow_doc_markers` surfaces the
# violation by walking flow-collection scalars and matching
# `---`/`...` followed by space, newline, or end-of-input.
N782
# Error-contract: a multi-line quoted scalar key inside a nested
# block-sequence item whose continuation drops to column 0 (e.g.
# `- - "bar\nbar": x`). YAML 1.2 line folding requires continuation
# lines of a quoted scalar to indent past the enclosing block
# container's column. `check_multiline_quoted_indent` now also walks
# `YAML_BLOCK_SEQUENCE_ITEM` (in addition to `YAML_BLOCK_MAP_VALUE`)
# so the continuation column is compared against the block sequence's
# parent indent.
JKF3
# Complex key: a flow collection (`{...}` or `[...]`) used as a
# block-mapping key on a single line (e.g. `{ first: Sammy, last: Sosa }:`
# followed by a nested block-map value). The scanner now registers the
# flow-collection start as a simple-key candidate at the outer flow
# level so a subsequent `:` on the same line splices `Key` (and
# `BlockMappingStart` at level 0) before the flow start. The projector
# walks `YAML_FLOW_SEQUENCE`/`YAML_FLOW_MAP` nested directly inside a
# `YAML_FLOW_MAP_KEY` as a structural collection rather than slurped
# scalar text — this also tightens SBG9 (`{[d, e]: f}`), LX3P
# (`[flow]: block`), UDR7 (`{ sky: blue, ... }`), and ZF4X.
Q9WF
# 2SXE: anchor/alias names containing `:` (libyaml relaxed name class).
# `&a:` parses as a YAML_ANCHOR whose name is `a:`, and `*a:` as a
# YAML_ALIAS with the same name. Unlocked by Phase 1 of the scanner
# anchor/alias dispatch work.
2SXE
# Anchors and aliases in flow contexts and on complex/structural keys.
# The event projector now (a) propagates a `&anchor` sitting in the KEY
# wrapper before a flow-collection-as-key onto the `+SEQ [] &anchor` /
# `+MAP {} &anchor` open event, (b) propagates an item-level `&anchor`
# preceding a nested flow collection in a `YAML_FLOW_SEQUENCE_ITEM`
# onto its open event, (c) carries a doc-level `&anchor` on a
# doc-direct flow seq/map (`&flowseq [...]`) by preferring children()
# over descendants() in `project_document`, (d) routes plain-text flow
# seq items through `flow_scalar_event` so node properties survive
# (`[&item a, b]`), (e) includes `YAML_ANCHOR`/`YAML_ALIAS` in the
# flow-map key text and the flow-seq item text so the key/value
# scalar projection sees them, and (f) emits `=ALI *name` for any
# scalar whose body begins with `*` (aliases never appear as plain
# scalars per the YAML 1.2 character set).
6BFJ
# CN3R: doc-direct flow sequence with a doc-level `&flowseq` anchor
# whose items mix bare kv pairs, anchored kv pairs (`&c c: d`), and
# nested flow maps with both anchored keys (`{ &e e: f }`) and
# anchors on the nested map itself (`&g { g: h }`). Unlocked by the
# anchor-propagation paths above.
CN3R
# X38W: flow map whose first key is a flow sequence with its own
# `&a` anchor, whose value is a bare alias (`*b`), and whose second
# key is itself an alias (`*a`) with a flow-sequence value
# containing an embedded alias item. Unlocked by the flow-context
# anchor propagation + alias-aware `flow_scalar_event` paths.
X38W
# SKE5: indentless block sequence as map value, with a `&anchor`
# decoration on its own line between the `:` and the first `-`.
# The anchor sits inside the value scope (column > parent mapping
# indent), so the parser now treats anchors/tags/aliases as
# transparent when deciding whether to synthesize the
# YAML_BLOCK_SEQUENCE wrapper, and gates the wrap on the
# decoration column > BlockEntry column. Event projection's
# `absorb_preceding_anchor_and_tag` picks up the sibling anchor and
# emits `+SEQ &anchor`. G9HC (anchor at column 0, parent indent)
# stays rejected by the column gate.
SKE5
# Tag dispatch in scanner: `!`-prefixed tokens (verbatim `!<uri>`,
# shorthand `!handle`/`!!type`) now emit a dedicated YAML_TAG token
# instead of folding into a plain-scalar placeholder. Five fixtures
# share this shape and unblock as a cluster:
# UGM3: verbatim tag `!<tag:...>` on the `---` line, then a block map.
# 57H4: nested block sequence tagged `- !!seq\n - nested` inside a
# parent indentless seq value.
# C4HZ: %TAG-prefixed local tags on block-seq items + flow-map value
# anchor `&ORIGIN { ... }`.
# EHF6: nested flow-map / flow-seq decorated with `!!map`, `!!seq`,
# `!!str` across multiple lines.
UGM3
57H4
C4HZ
EHF6
# 9KAX: doc-level scalars and block-maps decorated with `&anchor`
# and `!!str`/`!!map` in either order, across multiple lines.
# Exposed two projection gaps:
#   - `scalar_document_value`'s tagged-plain branch never peeled an
#     anchor token off the folded body, so `&a1\n!!str\nscalar1`
#     projected `=VAL <tag> :&a1 scalar1` instead of
#     `=VAL &a1 <tag> :scalar1`. Now decomposes the folded text and
#     routes through `scalar_event`.
#   - `+MAP`/`+SEQ` open events emitted tag before anchor; the
#     yaml-test-suite canonical order is anchor first. Aligned
#     `map_open_event_for_block_map` and `seq_open_event` with
#     `map_open_event_from_props`.
9KAX
# 9HCY: `!foo "bar"\n%TAG ...\n---\n!foo "bar"\n` — an explicit `%TAG`
# directive after document content with no preceding `...` close.
# Now that the scanner tokenizes `!foo` as a `Tag` (instead of folding
# the line into a plain scalar that swallows the following `%TAG`),
# the `check_directives` cluster sees the directive in its real
# position and fires `PARSE_DIRECTIVE_AFTER_CONTENT`. Closes the gap
# the validator docstring flagged for cluster F.
9HCY
# Cluster J — anchor decorates alias. YAML 1.2 §6.9.2: an alias is a
# complete node and cannot carry node properties, so `&anchor *alias`
# is invalid in any position.
# SR86: anchor + alias as a block-map value (`key2: &b *a`).
# SU74: anchor + alias as a block-map key (`&b *alias : value2`).
SR86
SU74
# Cluster N — invalid character in tag. YAML 1.2 §5.6: `ns-tag-char`
# excludes `!` and the c-flow-indicators `,`, `[`, `]`, `{`, `}`. The
# streaming scanner keeps these characters inside the tag token in
# block context for losslessness; the validator now rejects the
# resulting tag at the first offending byte. Verbatim form `!<uri>`
# stays untouched because its body is `ns-uri-char+`.
# LHL4: tag with `{}` in suffix (`!invalid{}tag scalar`).
# U99R: tag with `,` in suffix (`- !!str, xxx`).
LHL4
U99R
# Cluster M extension — multiple anchors on a single node. YAML 1.2
# §6.9.2 allows only one anchor per node, alongside the existing
# anchor-decorates-alias rule.
# 4JVG: `top2: &node2\n  &v2 val2` — the value's `&v2` follows
# `&node2` after only newline/whitespace within the same block-map
# value, so the second anchor is rejected as duplicate decoration.
4JVG
# Cluster O — anchor immediately precedes a block-sequence indicator
# on the same line. YAML 1.2 §8.1 requires the `-` to start a new
# line; an anchor sharing the line with the first `-` cannot decorate
# the sequence node.
# SY6V: `&anchor - sequence entry` — anchor and the leading `-` sit
# on the same line.
SY6V
# Cluster P — anchor inside a block-sequence item with no target.
# YAML 1.2 §6.9.2 requires every node property to be attached to a
# following node; a stray anchor folded into the preceding sequence
# item has nothing to decorate.
# GT5M: `- item1\n&node\n- item2` — `&node` lands inside item1 after
# its value scalar with no node behind it.
GT5M
# --- yaml-test-suite numbered subcases ---
# These live under hashed parents that don't carry a top-level
# `in.yaml`; the harness now recurses into hashed parents so each
# `<ID>/<NN>` is its own case. The subcases below already parse
# losslessly and project events matching `test.event`; grouped by
# parent theme.
# 2G84 literal-modifiers — block scalar `|`/`>` headers with chomp
# and indent indicators. /02 = `--- |1-`, /03 = `--- |1+` parse cleanly;
# /00 = `--- |0` (zero indent indicator) and /01 = `--- |10` (multi-digit
# run) are error contracts caught by `check_block_scalar_header` — the
# indent indicator must be a single digit in range 1-9 per §8.1.1.1.
2G84/00
2G84/01
2G84/02
2G84/03
# 3RLN leading-tabs-in-double-quoted — double-quoted scalars whose
# continuation lines begin with a `\t` escape after fold/indent.
3RLN/00
3RLN/01
3RLN/02
3RLN/03
3RLN/04
3RLN/05
# 4MUZ flow-mapping-colon-on-line-after-key — `{"foo"\n: "bar"}`
# style where the `:` for a flow-map entry appears on the next line.
4MUZ/00
4MUZ/01
4MUZ/02
# 96NN leading-tab-content-in-literals — block literal scalars whose
# content lines begin with a tab inside the literal body.
96NN/00
96NN/01
# 9MQT scalar-doc-with-in-content — bare-document quoted scalars that
# contain a `...` or `---` sequence inside the scalar body.
9MQT/00
# DE56 trailing-tabs-in-double-quoted — double-quoted scalar whose
# folded line ends in a tab before the join.
DE56/00
DE56/01
DE56/04
DE56/05
# DK95 tabs-that-look-like-indentation — block map/sequence values
# whose continuation line uses a tab where space-indent would be
# expected. /01 = `foo: "bar\n\tbaz"` (tab in the required-indentation
# slot of a multi-line double-quoted continuation) is an error contract
# caught by `check_quoted_scalar_continuation`'s §6.1 guard; the guard
# only fires when leading spaces do not already exceed `parent_indent`
# so 4ZYM (`  \tlines` after enough space-indent) stays content-only.
DK95/00
DK95/01
DK95/02
DK95/03
DK95/05
DK95/07
DK95/08
# HM87 scalars-in-flow-start-with-syntax-char — flow-seq/map plain
# scalars beginning with `:` or other syntax chars (`[:x]`).
HM87/00
HM87/01
# JEF9 trailing-whitespace-in-streams — block-scalar chomp `|+`
# followed by trailing blank lines forming the keep-trailing newlines.
JEF9/00
# KH5V inline-tabs-in-double-quoted — `\t` and literal tab inline in
# double-quoted scalars (no fold/continuation).
KH5V/00
KH5V/01
KH5V/02
# L24T trailing-line-of-spaces — block literal scalar whose final
# content line is whitespace-only.
L24T/00
L24T/01
# M2N8 question-mark-edge-cases — `- ? : x` style explicit-key entries
# in nested block-sequence/map context.
M2N8/00
M2N8/01
# MUS6 directive-variants — `%YAML 1.1` / `%YAML 1.2` directives with
# extra spacing or comments before `---`.
MUS6/02
MUS6/03
MUS6/04
MUS6/05
MUS6/06
# MUS6/00 — `%YAML 1.1#...` glues `#` to the version with no preceding
# whitespace; spec §6.6 requires whitespace before a comment, so the
# version field becomes `1.1#...` and isn't a valid `digits.digits`.
# `check_directives` via `is_valid_yaml_version` rejects it as
# PARSE_MALFORMED_YAML_DIRECTIVE.
MUS6/00
# SM9W single-character-streams — minimal valid streams of one byte
# (`-` for empty seq, similar).
SM9W/00
SM9W/01
# UKK6 syntax-character-edge-cases — block-seq entries whose plain
# scalar is just `:` or another syntax marker.
UKK6/00
UKK6/01
UKK6/02
# VJP3 flow-collections-over-many-lines — flow map split across
# multiple continuation lines (`k: {\n k\n :\n v\n }`).
VJP3/01
# Y79Y tabs-in-various-contexts — tabs inside flow collections and
# block-sequence continuation lines.
Y79Y/002
Y79Y/010
# DE56/02-03 trailing-tab-via-escape-in-double-quoted — `\<TAB>` is
# the YAML escape for a tab character (§5.7); the fold's
# trailing-whitespace strip now preserves the escape argument before
# applying line folding and the line-continuation `\<newline>` test.
DE56/02
DE56/03
# JEF9/01-02 keep-chomp-with-whitespace-only-body — `|+` block scalar
# whose only body line is whitespace; content indent now falls back
# to the max leading-space count when no line has past-indent content,
# and Keep chomp emits one `\n` per whitespace-only line even when
# the source has no terminating newline.
JEF9/01
JEF9/02
# Y79Y/001 tab-after-indent-in-literal — literal block scalar value
# whose content line is ` \t`; the leading space is indent, the tab
# is content, and content-indent detection now treats tabs past
# leading spaces as content rather than whitespace.
Y79Y/001
# Y79Y/000, Y79Y/003-009 tab-in-indent-slot — tab characters in
# indentation position are illegal per §6.1. `check_tab_as_indent`
# now covers three shapes: a leading-tab WHITESPACE in a body line
# of a flow container nested under a block (Y79Y/003), a leading-
# tab WHITESPACE immediately after a block scalar (`|`/`>`) header
# that ends with `\n` (Y79Y/000), and a tab-bearing WHITESPACE
# between a block indicator (`-`/`?`/`:`) and a nested block
# collection (Y79Y/004-009). Whitespace-only tab lines are skipped
# so 6CA3 and 6HB6 still accept tabs as flow-context separators.
Y79Y/000
Y79Y/003
Y79Y/004
Y79Y/005
Y79Y/006
Y79Y/007
Y79Y/008
Y79Y/009
# DK95/04 tab-only blank line between block-map entries — bonus
# unlock from the case-(a-newline) refinement: a whitespace-only
# `\t` line between `foo: 1` and `bar: 2` is now treated as a
# blank separator (the existing check would have rejected it).
DK95/04
# 9MQT/01 unterminated-double-quoted-spans-doc-end — `--- "a\n... x\nb"`
# opens a double-quoted scalar that visually wraps a `...` doc-end
# marker. The scanner reports `YAML_LEX_UNTERMINATED_QUOTED_SCALAR`
# because the doc-end marker cannot live inside a multi-line flow
# scalar; allowlist locks in the rejection.
9MQT/01
# DK95/06 tab-as-indent-on-nested-map-entry — `^Ib: 2` sits where
# spaces are required to keep the entry indented under `a: 1`; the
# parser surfaces `YAML_PARSE_INVALID_KEY_TOKEN` (implicit key
# cannot span lines) because the tab forces `b` outside the inner
# block-map indent. Lock in the rejection.
DK95/06
# MUS6/01 directive-after-empty-document — `%YAML 1.2 --- %YAML 1.2 ---`
# starts a fresh directive section before the prior doc closes with
# `...`. `YAML_PARSE_DIRECTIVE_AFTER_CONTENT` fires on the second
# directive; lock in the rejection.
MUS6/01
# VJP3/00 flow-collection-under-indent — `k: {` opens a flow mapping
# at col 4, but the subsequent `k`, `:`, `v`, `}` lines start at
# col 1, below the block-context indent of the surrounding map.
# `YAML_LEX_WRONG_INDENTED_FLOW` enforces the §9.2 indent rule;
# lock in the rejection.
VJP3/00
# QLJ7 tag-handle-not-scoped-per-document — `%TAG !prefix!` is
# declared only in doc 1; docs 2/3 reuse `!prefix!B`/`!prefix!C`
# without redeclaring. Per YAML 1.2 §6.8.2 tag directives don't
# carry across `---`, so doc 2's tag use must error.
# `YAML_PARSE_UNDEFINED_TAG_HANDLE` fires on the first undeclared
# handle; lock in the rejection.
QLJ7
