` — fails to collapse repeated whitespace — [svelte_element_class_whitespace](../tests/fixtures/svelte/special_elements/svelte_element_class_whitespace_prettier_divergence/)
- Space after block element — strands a leading space, non-idempotent — [space_after_block](../tests/fixtures/svelte/elements/space_after_block_prettier_divergence/)
+- Space before an inline element after block-then-text — deletes the rendered space (`text1 text2 x ` → `text1 text2x `), a content change; idempotent on its own output, so nothing reveals it — [block_text_inline_space](../tests/fixtures/svelte/elements/block_text_inline_space_prettier_divergence/)
- `//` comment in a `` / ``), so it renders as page text or is dropped on the next pass; non-idempotent either way — [ws_sensitive_attr_comment_line](../tests/fixtures/svelte/elements/ws_sensitive_attr_comment_line_prettier_divergence/)
- Constrained `infer … extends` operand parens — strips required parens → output fails to re-parse — [constrained_extends_parens](../tests/fixtures/typescript/types/infer/constrained_extends_parens_prettier_divergence/)
- Negative literal type sign comment (`-/* c */ 1`) — *adds* parens to hold the comment (`-(/* c */ 1)`), but no such type exists: `-` is a negative literal type only when the next token is a numeric/bigint literal → output fails to re-parse — [negative_literal_sign_comment](../tests/fixtures/typescript/types/negative_literal_sign_comment_prettier_divergence/)
diff --git a/docs/conformance_prettier_svelte.md b/docs/conformance_prettier_svelte.md
index 5e4fb52b4..31e503f36 100644
--- a/docs/conformance_prettier_svelte.md
+++ b/docs/conformance_prettier_svelte.md
@@ -64,6 +64,7 @@ the parser keeps the wider set deliberately. See
- svelte:element `this` — ◆prettier_bug — [svelte_element_this_string](../tests/fixtures/svelte/special_elements/svelte_element_this_string_prettier_divergence/). Anything between the `{` and a string literal (a paren, or a leading comment) fails prettier's `{`-precedes-literal check and collapses the binding to the plain attribute `this="x"` — which for a comment is also ◆content_preservation, since the collapsed form has nowhere to put it and prettier drops it.
- svelte:element class ws — ◆prettier_bug — [svelte_element_class_whitespace](../tests/fixtures/svelte/special_elements/svelte_element_class_whitespace_prettier_divergence/)
- Space after block element — ◆prettier_bug — [space_after_block](../tests/fixtures/svelte/elements/space_after_block_prettier_divergence/)
+- Space before an inline element after block-then-text — ◆prettier_bug ◆content_preservation — [block_text_inline_space](../tests/fixtures/svelte/elements/block_text_inline_space_prettier_divergence/) (`b
⏎text1 text2 x ` → prettier's `text1 text2x `, which renders `text1 text2x`: its `handleTextChild` trims the text's trailing space before an inline element but, with a block-element predecessor, sets the flag that would re-emit it to false, so nothing prints it — from either authoring, for a one-word text, and whether or not the run is the fragment's first; a tag or a component follower keeps the space under both. tsv keeps it as the element's per-width wrap, as everywhere else)
- Nested foreign `` body columns — ◆prettier_bug — [template_foreign_lang_nested](../tests/fixtures/svelte/elements/template_foreign_lang_nested_prettier_divergence/)
**Fill after inline**: Prettier's fill algorithm allows lines to exceed print width when text follows an inline element closing tag. Prettier produces 111 char lines, tsv breaks at exactly 100 chars.
@@ -286,11 +287,11 @@ Note this is **orthogonal to whether the element lays out multiline at all**, wh
### What the rule does not reshape, and where convergence stops
-Five things are **not** reshaped, because none is a mere spelling difference. A **comment** keeps its authored line (its position is authorship — folding one into a fill would relocate it across a semantic boundary, see [§Comment Position Philosophy](./conformance_prettier.md#comment-position-philosophy)); a **`a ⏎text2` collapses). Two *other* gates in this rule suppress flow for every sibling kind at once (the prose gate below, and the reflowable-fill suppression the paragraph after it, which closes this rule by making the element multiline for a reason it does not read), so an element control run in a shape either one already catches keeps its lines regardless of what sits there, and reads back as "the newline rule is not about comments" when it is. — [inline_separator_comment_newline](../tests/fixtures/svelte/elements/inline_separator_comment_newline/) pins all four comment authorings, and is deliberately **not** a divergence fixture: prettier holds each one too, so there is nothing for an `output_prettier` to claim. The element twins of the one-sided pair are [inline_sibling_newline_flow](../tests/fixtures/svelte/elements/inline_sibling_newline_flow_prettier_divergence/)'s `prettier_variant_newline_after` / `prettier_variant_newline_before`, which converge on its input — that pair beside these four is the whole control. ⚠️ **The exclusion is scoped to the comment's OWN two boundaries: it BOUNDS the run, it does not STERILIZE one.** The runs a comment separates keep flowing on their own — `text1 a text2⏎⏎text3 b text4` converges from every isolated authoring of those spans, with only the comment's two newlines held. Nothing distinguishes that from the wider reading ("a run holding a comment keeps every line") unless a control puts a flowing run *beside* the comment and re-authors it: a control whose run is already hugged in every file is a fixed point under either rule and cannot separate them, which is why [inline_sibling_newline_flow](../tests/fixtures/svelte/elements/inline_sibling_newline_flow_prettier_divergence/)'s comment-boundary control is re-authored in all three `prettier_variant_*` files rather than held. The same is true of every other run-bounding sibling (that fixture's block-sibling control carries the parallel pin), so the property belongs to run boundaries in general and not to comments — what is comment-specific is only the *holding*. The practical consequence is that a comment tsv has broken onto its own line for **width** ([fill_break_before_comment_spaced_long](../tests/fixtures/svelte/elements/fill_break_before_comment_spaced_long_prettier_divergence/)) reaches a second fixed point when the run after it was authored on the next line — the same document, differing only in whether that run shares the comment's line.
-**The rule's boundary is the presence of a `fill` to reflow into, not the shape of the separator node.** Flowing means reflowing a run per width, and a run reflows only where there is prose for a `fill` to pack. So the rule reaches a whitespace-only separator standing *between two non-text siblings* — `text1⏎a ` and `a ⏎b ` converge alike — **when that separator's inline run holds prose, which is at least two words**, and not otherwise. A run of pure elements or tags (`` re-hugs on the second pass once its children fold). **A run holding a single word is a label, not prose, and keeps its lines the same way** — `x⏎prop.`), which a node-local test would hold alone on its line — the accretion the flow rule exists to heal, run in reverse — where the run's total sees the sentence it belongs to, so a one-word node ending a real sentence flows with it. The cliff is two words (`Remember me` still packs), where label and prose genuinely blur, and the count is the most words any **one** text node carries, never a sum over the run: words in two different text nodes are separated by a sibling, and that separation is the author's, so two one-word captions in one run (`text1⏎inline1 ⏎text2`), which holds; real prose has a two-word node somewhere in its run. The cliff's own cost is the mirror: one two-word caption in a list of one-word captions is prose, and packs its neighbours with it (`x ` and ` {x}` hug alike; the comment's own line is what the NEWLINE spelling holds). Prettier's `line` between a tag and its neighbour breaks with the container whatever the run holds, so a space-spelled tag after any sibling but text in a multiline container is a divergence of the same family as the prose tag pair below — tsv packs where prettier splits. **And the follower never turns a space into a newline either**: a space before a **comment**, a `{@debug}` or a control-flow block that renders inline is that follower's own per-width wrap after any sibling — an element, a component, a tag, another comment — exactly as it already was after text, so `a ` keeps its space as `text1 ` does, where prettier breaks the former with the container; the NEWLINE spelling is what holds a comment's line, on both of its sides. Only a **block element** on either side of a space still breaks it (its own break already separates them, and a wrap would strand a space after it), and a unit that **renders multiline** drops to a fresh line whole — the wrap's group breaks on its own hardlines — so a space is decided by the follower's kind alone, for every predecessor but a block. — [inline_sibling_space_before_bounding](../tests/fixtures/svelte/elements/inline_sibling_space_before_bounding_prettier_divergence/) (comment, `{@debug}` and inline-block followers after an element, a component and a tag, in a block and at the root, a comment spaced on both sides, a two-comment run; `variant_newline` the held control, with the multiline block, the block predecessor and the comment's own 100/101 as the parity controls), [inline_adjacent_comment_space_long](../tests/fixtures/svelte/elements/inline_adjacent_comment_space_long_prettier_divergence/) (the same follower at the ELEMENT's width boundary: the 101-char `` goes block-style and the comment stays on its 97-wide content line). — [inline_sibling_newline_label_hold](../tests/fixtures/svelte/elements/inline_sibling_newline_label_hold_prettier_divergence/) (every label shape held, the caption list and the fragmented sentence among them; the two-word cliff, the one-word sentence tail, the phrase's reach across a whole run and the cliff in a list flowing as `prettier_variant_newline`; `variant_space` the null control), [inline_tag_pair_space](../tests/fixtures/svelte/elements/inline_tag_pair_space_prettier_divergence/) (the space-spelled pair — wordless, before and after a word, at the root, and led by an inline element or a component — with the newline spelling as the held control), [inline_tag_pair_space_container](../tests/fixtures/svelte/elements/inline_tag_pair_space_container_prettier_divergence/) (the same pair in every container kind), [inline_tag_pair_space_bounded](../tests/fixtures/svelte/elements/inline_tag_pair_space_bounded_prettier_divergence/) (the pair after a comment, a `` / ``, ``, a component, and a `svelte:*` special element on both boundary arities (``, ``), the pair that pins the SpecialElement projection onto the same element analysis — with a prose-free run in an inline container as the null control — the one run whose authored lines survive under both formatters, which is what keeps "the container does not decide" from being satisfied by a rule that never consults the run either. **The SIBLING kind reaches one arm none of those fixtures does**: a `svelte:*` special element, which answers the flow question by the same block/inline classification a plain element does — the inline ones (``, ``, ``) flow like a ``, and the four global ones own their line. [special_element_newline_flow](../tests/fixtures/svelte/elements/special_element_newline_flow_prettier_divergence/) pins both halves, the block one as the control that keeps "a special element flows" from being satisfied by a rule that never asks the classification — it is root-only, since Svelte rejects those four inside an element or a block. Its second `prettier_variant_*` carries the classification's own divergence from the layout side: prettier has no `svelte:*` in its block list, so it keeps a **space**-authored `a ⏎a text2` packs). tsv gives the component the same inline-sibling wrap an element takes, in **both** multiline arms of the separator site: a component pair beside prose packs per width from either spelling, and an authored **space** before a component is kept where an element would keep it — in a prose-free run, after a comment, after a control-flow block, and after a predecessor that renders multiline (the component hugs the closing tag as an element does — for the **space** spelling; the newline spelling there is the layout-keyed hold above, for both kinds alike). Holding it in only one arm is a two-pass cycle, not a policy: the one time the arms disagreed, a preceding sibling that rendered multiline left the closing tag at a short column, the wrap fit the component after it, and the emitted container newline made the next pass take the other arm and split the pair. — [inline_adjacent_component_flow](../tests/fixtures/svelte/elements/inline_adjacent_component_flow_prettier_divergence/) (the prose runs, with the element pair beside them, both kind orders, components with children, prose only at the run's end, and the structural and prose-free controls), [inline_adjacent_component_space](../tests/fixtures/svelte/elements/inline_adjacent_component_space_prettier_divergence/) (the space spelling with no prose — prose-free pair, after a comment, after a block, at the root — where the newline spelling is dual-stable, `variant_newline`), [inline_adjacent_component_after_multiline](../tests/fixtures/svelte/elements/inline_adjacent_component_after_multiline_prettier_divergence/) (the multiline predecessor, whose prose-free control keeps its line). Where this rule and the render-free content boundary meet on one element, the two compose to a single form — the flowed content with the boundaries hugged — and must settle in **one pass**, since the flow and the collapse it enables are one decision ([inline_content_flow_collapse](../tests/fixtures/svelte/elements/inline_content_flow_collapse_prettier_divergence/), which pins prettier's two stable forms alongside it). **The prose gate reaches that interior side too, and reaches it at BOTH spellings of the newline.** An authored newline between two inline siblings is folded by the parser into a whitespace-only node when nothing else sits there and into the edge whitespace of the content text beside it when something does, so a rule that reads only one of them gives one document two layouts by that accident — the same accident the run scan rules out at its blank-line boundary above. A one-word run is a label with no fill, so its interior newline is the author's structure and expands the hugged element (`⏎a⏎b text1⏎ `), and it does so equally when the newline sits at a content text's edge (`text1⏎a `, `a b,⏎c` at the edge leaves the text beside it as the effective first or last), and an edge facing a SIBLING, which is the fill's separator and is therefore excluded only where there IS a fill. An element-separator run where both formatters agree once tsv flows it is pinned by `tests/fixtures/svelte/script/escapes` and `tests/fixtures/svelte/style/escapes`.
+**The rule's boundary is the presence of a `fill` to reflow into, not the shape of the separator node.** Flowing means reflowing a run per width, and a run reflows only where there is prose for a `fill` to pack. So the rule reaches a whitespace-only separator standing *between two non-text siblings* — `text1⏎<span>a</span>` and `<span>a</span>⏎<span>b</span>` converge alike — **when that separator's inline run holds prose, which is at least two words**, and not otherwise. A run of pure elements or tags (`<Comp {a} />⏎<Comp {b} />`) keeps its authored lines: with no prose its newlines are the only structure the author has, collapsing them packs independent siblings onto one line, and on a short run the collapse cascades into the parent element's own hug decision — an outright idempotency break (`<mrow>` re-hugs on the second pass once its children fold). **A run holding a single word is a label, not prose, and keeps its lines the same way** — `<Comp />⏎Delete⏎{n}`, `hue:⏎<input />`, `<input />⏎private`, `chars⏎{n}`, `{@render icon()}⏎text1` are a caption beside its icon, a field beside its unit, a label beside its value, and a fill needs a phrase to reflow into; prettier holds every such shape too, so the hold is agreement. Only the run's TEXT counts: an expression tag renders as a value, and a word beside one is a label like any other. The count is **run-level and never node-local**: at a content text's edge run the node beside the sibling is often the one-word tail a previous wrap left behind (`…<code>x</code>⏎prop.`), which a node-local test would hold alone on its line — the accretion the flow rule exists to heal, run in reverse — where the run's total sees the sentence it belongs to, so a one-word node ending a real sentence flows with it. The cliff is two words (`Remember me` still packs), where label and prose genuinely blur, and the count is the most words any **one** text node carries, never a sum over the run: words in two different text nodes are separated by a sibling, and that separation is the author's, so two one-word captions in one run (`text1⏎<input />⏎text2⏎<input />`, an icon-and-caption list) are two labels and hold — a sum packs every such list the moment it holds two entries. The cost is a sentence spelled entirely as one-word fragments between siblings (`text1⏎<span>inline1</span>⏎text2`), which holds; real prose has a two-word node somewhere in its run. The cliff's own cost is the mirror: one two-word caption in a list of one-word captions is prose, and packs its neighbours with it (`<Comp1 />⏎text1⏎<Comp2 />⏎text2 text3` → one line) — pinned as a control so it is recorded, not discovered. The gate is asked identically at all three of the rule's sites — the whitespace-only separator and a content text's leading and trailing runs — and **it is a hold, never a forced break**: it decides whether an authored newline may reflow, and says nothing about an authored space. So a run's space spelling stays inline everywhere, whatever the run holds and whatever precedes it — beside an element, a void element, a component, a render/html tag, inside a content text, and between two **tags**, where the whitespace-only separator defers to the tag's per-width group as a prose run's does: the space-spelled tag separator reads **no run gate and no neighbour gate at all**, so a wordless `{a} {b}` packs exactly as `text1 {a} {b}` does, in every container, and a tag after a comment, a `<br />` or a control-flow block keeps its authored space exactly as an inline element or component does there (`<!-- c --> <span>x</span>` and `<!-- c --> {x}` hug alike; the comment's own line is what the NEWLINE spelling holds). Prettier's `line` between a tag and its neighbour breaks with the container whatever the run holds, so a space-spelled tag after any sibling but text in a multiline container is a divergence of the same family as the prose tag pair below — tsv packs where prettier splits. **And the follower never turns a space into a newline either**: a space before a **comment**, a `{@debug}` or a control-flow block that renders inline is that follower's own per-width wrap after any sibling — an element, a component, a tag, another comment — exactly as it already was after text, so `<span>a</span> <!-- c -->` keeps its space as `text1 <!-- c -->` does, where prettier breaks the former with the container; the NEWLINE spelling is what holds a comment's line, on both of its sides. Only a **block element** on either side of a space still breaks it (its own break already separates them, and a wrap would strand a space after it), and a unit that **renders multiline** drops to a fresh line whole — the wrap's group breaks on its own hardlines — so a space is decided by the follower's kind alone, for every predecessor but a block. **The block-element follower is the last cell of that rule, and it breaks the space after a TEXT too** — at every position of the text: a block sibling's own break separates the two, so the space is spent on it whether the block renders inline (`text1 text2⏎<div>block1</div>`) or multiline (its head never ends the text line, the whole-unit drop every other unit kind has), in every fragment family and at every width. Prettier hugs the block to a **first-child** text (`text1 text2 <div>block1</div>`) and breaks it after any other predecessor — its `printChildren` returns early for a first child before the block-follower trim runs, so the text printer's own `line` survives there, an artifact rather than a stance; of that boundary's three spellings only the first-child space hugged, the glued and the newline spelling breaking under both formatters. tsv normalizes the space spelling to the newline form in one pass. — [block_after_spaced_text](../tests/fixtures/svelte/elements/block_after_spaced_text_prettier_divergence/) (the root first-child case, every container kind, a one-word label, text on both sides, the multiline block, the non-first-text and element-predecessor controls, the glued boundary both formatters split), [block_after_spaced_text_long](../tests/fixtures/svelte/elements/block_after_spaced_text_long_prettier_divergence/) (the exact 100/101: at 100 prettier keeps the hug that fits, at 101 it opens the block block-style with its head dangling on the text line, and tsv breaks before the block at both, the block collapsing inline on its fresh line), [mixed_space_before_block](../tests/fixtures/svelte/elements/mixed_space_before_block_prettier_divergence/) (the one-word instance, with its compact and over-spaced authorings), [block_after_spaced_text_kinds](../tests/fixtures/svelte/elements/block_after_spaced_text_kinds_prettier_divergence/) (every block kind — `<pre>`, `<hr />`, a `<table>` laying out block-style, `<ul>`, `<h1>`, the root-only block-classified `svelte:*` specials, a block whose attributes wrap — and every fragment family the parent does not vary; the tab spelling normalizes the same way). — [inline_sibling_space_before_bounding](../tests/fixtures/svelte/elements/inline_sibling_space_before_bounding_prettier_divergence/) (comment, `{@debug}` and inline-block followers after an element, a component and a tag, in a block and at the root, a comment spaced on both sides, a two-comment run; `variant_newline` the held control, with the multiline block, the block predecessor and the comment's own 100/101 as the parity controls), [inline_adjacent_comment_space_long](../tests/fixtures/svelte/elements/inline_adjacent_comment_space_long_prettier_divergence/) (the same follower at the ELEMENT's width boundary: the 101-char `<p>` goes block-style and the comment stays on its 97-wide content line). — [inline_sibling_newline_label_hold](../tests/fixtures/svelte/elements/inline_sibling_newline_label_hold_prettier_divergence/) (every label shape held, the caption list and the fragmented sentence among them; the two-word cliff, the one-word sentence tail, the phrase's reach across a whole run and the cliff in a list flowing as `prettier_variant_newline`; `variant_space` the null control), [inline_tag_pair_space](../tests/fixtures/svelte/elements/inline_tag_pair_space_prettier_divergence/) (the space-spelled pair — wordless, before and after a word, at the root, and led by an inline element or a component — with the newline spelling as the held control), [inline_tag_pair_space_container](../tests/fixtures/svelte/elements/inline_tag_pair_space_container_prettier_divergence/) (the same pair in every container kind), [inline_tag_pair_space_bounded](../tests/fixtures/svelte/elements/inline_tag_pair_space_bounded_prettier_divergence/) (the pair after a comment, a `<br />`, a multiline control-flow block and a multiline element — the space hugs the neighbour's line as an element's would and the newline spelling is held — with a block-element predecessor and a line-owning follower as the controls that still break), [inline_tag_pair_space_welded](../tests/fixtures/svelte/elements/inline_tag_pair_space_welded_prettier_divergence/) (a welded unit — a glued pair, an ` `, a word glued to both tags — beside a spaced boundary: the weld holds and the space packs), [inline_tag_pair_space_expr_break](../tests/fixtures/svelte/elements/inline_tag_pair_space_expr_break_prettier_divergence/) (a first tag whose expression breaks — the second hugs its closing `)}` line per width, as an element or a word does after a broken tag; the newline spelling held and a breaking second tag travelling whole are the controls), and [inline_sibling_newline_label_hold_long](../tests/fixtures/svelte/elements/inline_sibling_newline_label_hold_long_prettier_divergence/) (the hold at the print-width boundary: the space spelling stays at 100 and wraps at 101 onto the newline spelling, which is then held — the one-way ratchet the hold accepts, prettier's too, though prettier tolerates the 101-char line itself; the wrap is the Elements catalog's fill-boundary divergence). What counts as a word is the fill's own item split over the SOURCE BYTES — an NBSP-joined pair is one word, and so is an entity-encoded space (`text1 text2` is one unbreakable fill item under both formatters, so the count must not promise a seam the fill has not got; the render-side question, whether a node is a separator in content's clothing, reads the decoded text, and the two axes are deliberately distinct), punctuation alone is a word, a hyphenated pair is one, a word glued to a tag is one — and the cliff is the same at a void element (`<input /> text1 text2`, the checkbox-and-caption shape): [inline_sibling_newline_prose_words](../tests/fixtures/svelte/elements/inline_sibling_newline_prose_words_prettier_divergence/). The container is not an axis on the holding side either — the root, an inline element, a list item, a table cell, a control-flow block body and a snippet body hold a one-word run alike: [inline_sibling_newline_label_hold_container](../tests/fixtures/svelte/elements/inline_sibling_newline_label_hold_container_prettier_divergence/). A run is bounded by whatever owns its own line — a block element, a control-flow block, a comment, a `<br />` — and by an authored blank line **wherever the parser put it**: in a whitespace-only node between two siblings, or folded into the edge whitespace of the content text beside it, so that one document does not count two ways by that accident. The count is per run, so a fragment's prose does not license flow in a neighbouring run that has none — a two-word run on one side of a boundary flows right up to it, and the one-word run on the other holds: [inline_sibling_newline_run_bounded](../tests/fixtures/svelte/elements/inline_sibling_newline_run_bounded_prettier_divergence/) (every boundary kind, the blank in both spellings, prose on one side and a label on the other in each, the prose half flowing as `prettier_variant_newline`; and the unbounded twin, where the label flows with the prose). An authored blank INSIDE one text node is not a boundary — a run is a partition of nodes — and the fill collapses it under both formatters, so the sibling newlines beside such a node flow with its prose where prettier holds them: [inline_sibling_newline_interior_blank](../tests/fixtures/svelte/elements/inline_sibling_newline_interior_blank_prettier_divergence/). Bounding is not sterilizing, though: a run that *does* hold prose still flows right up against the bounding sibling, and the two spellings of that ("its own boundaries are held" vs "every line near it is held") are only separated by a control that re-authors the neighbouring run — see the comment-boundary note above. Two mechanics keep this sound and are load-bearing. First, a flowing single newline takes the **space arm verbatim** rather than a parallel one: emitting a different collapsible form for the newline than for the space it claims to equal makes the formatter write a newline that its next pass re-reads as flowable and collapses. Second, the boundary must defer to the next sibling for every follower kind — a tag, a comment, a `{@debug}`, a control-flow block — as it always did for an element: a bare `line` in the child list resolves all-or-nothing with the parent group, and a multiline fragment's parent group is always broken, so without that the one boundary owned by a content text's `fill` would flow while the rest of the same run hard-broke. The deferral is unconditional (a block-element predecessor excepted, whose own break already separates them; a declaration takes its own line): a space asks nothing about what precedes it — a comment's line is authorship, and it is the NEWLINE spelling that holds it. Note `authoring_audit` is blind to the tag half: both spellings agree there whichever form the rule picks — on the flowed form now, on the hard-broken one under a narrower gate — so it scores them as converging either way. — [inline_sibling_newline_flow](../tests/fixtures/svelte/elements/inline_sibling_newline_flow_prettier_divergence/) (an inline element, a component and all three tag kinds — expression, render and `{@html}`, one predicate arm each — plus all five controls) and [expressions/angle_escaped](../tests/fixtures/svelte/expressions/angle_escaped_prettier_divergence/) (the tag-separator case, where prettier's plain `line` holds each tag on its authored line), and the shapes the rule reaches across the suite: [fill_text_inline_collapse](../tests/fixtures/svelte/elements/fill_text_inline_collapse_prettier_divergence/), [root_text_newline_inline](../tests/fixtures/svelte/elements/root_text_newline_inline_prettier_divergence/), [block_text_multiline_collapse](../tests/fixtures/svelte/elements/block_text_multiline_collapse_prettier_divergence/), [inline_attrs_multiline_content](../tests/fixtures/svelte/elements/inline_attrs_multiline_content_prettier_divergence/), [components/root_with_text](../tests/fixtures/svelte/components/root_with_text_prettier_divergence/). **The CONTAINER holding the run is not an axis either**, and no fixture above varies it to say so — nearly all put the flowing run in a block container, and the one inline container that carries one ([inline_attrs_multiline_content](../tests/fixtures/svelte/elements/inline_attrs_multiline_content_prettier_divergence/)) reaches multiline past a 99-char attribute line, confounding the kind with the attribute wrap that fixture exists to test. An inline element reaches the multiline form by a *different boundary rule* — both-or-neither, rather than the block's leading boundary alone — so it is the kind where a container-keyed rule would show, and the run lays out identically once there: [container_kind_newline_flow](../tests/fixtures/svelte/elements/container_kind_newline_flow_prettier_divergence/) holds one run fixed and varies the container across all four kinds — `<button>` / `<label>`, `<p>`, a component, and a `svelte:*` special element on both boundary arities (`<svelte:element>`, `<svelte:head>`), the pair that pins the SpecialElement projection onto the same element analysis — with a prose-free run in an inline container as the null control — the one run whose authored lines survive under both formatters, which is what keeps "the container does not decide" from being satisfied by a rule that never consults the run either. **The SIBLING kind reaches one arm none of those fixtures does**: a `svelte:*` special element, which answers the flow question by the same block/inline classification a plain element does — the inline ones (`<svelte:element>`, `<slot>`, `<svelte:boundary>`) flow like a `<span>`, and the four global ones own their line. [special_element_newline_flow](../tests/fixtures/svelte/elements/special_element_newline_flow_prettier_divergence/) pins both halves, the block one as the control that keeps "a special element flows" from being satisfied by a rule that never asks the classification — it is root-only, since Svelte rejects those four inside an element or a block. Its second `prettier_variant_*` carries the classification's own divergence from the layout side: prettier has no `svelte:*` in its block list, so it keeps a **space**-authored `<svelte:window />` on the text line where tsv gives it its own line from either spelling. **A COMPONENT is the other sibling kind the predicate admits, and it is one follower kind with the inline element at every site that prints this separator.** Prettier's `isInlineElement` admits only a `RegularElement`, so the whitespace-only node before a component is printed as a plain `line` that breaks with the container while the text-adjacent boundaries of the same run hug — one run, two answers, in a line that fits (`text1 <Comp1 />⏎<Comp2 /> text2`, from the **space** spelling as much as the newline one), and the answer turns on which kind happens to sit on which side of the gap (`text1 <span>a</span>⏎<Comp /> text2` splits where `text1 <Comp />⏎<span>a</span> text2` packs). tsv gives the component the same inline-sibling wrap an element takes, in **both** multiline arms of the separator site: a component pair beside prose packs per width from either spelling, and an authored **space** before a component is kept where an element would keep it — in a prose-free run, after a comment, after a control-flow block, and after a predecessor that renders multiline (the component hugs the closing tag as an element does — for the **space** spelling; the newline spelling there is the layout-keyed hold above, for both kinds alike). Holding it in only one arm is a two-pass cycle, not a policy: the one time the arms disagreed, a preceding sibling that rendered multiline left the closing tag at a short column, the wrap fit the component after it, and the emitted container newline made the next pass take the other arm and split the pair. — [inline_adjacent_component_flow](../tests/fixtures/svelte/elements/inline_adjacent_component_flow_prettier_divergence/) (the prose runs, with the element pair beside them, both kind orders, components with children, prose only at the run's end, and the structural and prose-free controls), [inline_adjacent_component_space](../tests/fixtures/svelte/elements/inline_adjacent_component_space_prettier_divergence/) (the space spelling with no prose — prose-free pair, after a comment, after a block, at the root — where the newline spelling is dual-stable, `variant_newline`), [inline_adjacent_component_after_multiline](../tests/fixtures/svelte/elements/inline_adjacent_component_after_multiline_prettier_divergence/) (the multiline predecessor, whose prose-free control keeps its line). Where this rule and the render-free content boundary meet on one element, the two compose to a single form — the flowed content with the boundaries hugged — and must settle in **one pass**, since the flow and the collapse it enables are one decision ([inline_content_flow_collapse](../tests/fixtures/svelte/elements/inline_content_flow_collapse_prettier_divergence/), which pins prettier's two stable forms alongside it). **The prose gate reaches that interior side too, and reaches it at BOTH spellings of the newline.** An authored newline between two inline siblings is folded by the parser into a whitespace-only node when nothing else sits there and into the edge whitespace of the content text beside it when something does, so a rule that reads only one of them gives one document two layouts by that accident — the same accident the run scan rules out at its blank-line boundary above. A one-word run is a label with no fill, so its interior newline is the author's structure and expands the hugged element (`<span>⏎<code>a</code>⏎<code>b</code> text1⏎</span>`), and it does so equally when the newline sits at a content text's edge (`<span>text1⏎<code>a</code></span>`, `<span><code>a</code> <code>b</code>,⏎<code>c</code></span>` — a lone `,` is a word like any other). Prettier holds the newline at both spellings, so the hold is agreement and the divergence stays the block-style-vs-dangle spelling. The two-word twin is the control: the run is prose, the newline is the fill's own wrap point, and the element collapses. — [inline_interior_newline_label_hold](../tests/fixtures/svelte/elements/inline_interior_newline_label_hold_prettier_divergence/) (both spellings held, with the prose twin of each as the control). The mechanism is one gate, not two: the interior scan trims a text's edge run for two different reasons — the element's own boundary air, which is the boundary question and is excluded unconditionally (keyed on the fragment's CONTENT bounds, since a hoisted `{@debug}` / `<title>` at the edge leaves the text beside it as the effective first or last), and an edge facing a SIBLING, which is the fill's separator and is therefore excluded only where there IS a fill. An element-separator run where both formatters agree once tsv flows it is pinned by `tests/fixtures/svelte/script/escapes` and `tests/fixtures/svelte/style/escapes`.
**That same "is there a `fill`?" question decides whether an authored newline in the run's INTERIOR may select the layout** — never the content boundary, whose air the per-kind boundary rule honors regardless of what the content is made of (both boundaries for an inline element or a component, the leading one for a block: [inline_boundary_air](../tests/fixtures/svelte/elements/inline_boundary_air/) / [boundary_air_one_sided](../tests/fixtures/svelte/elements/boundary_air_one_sided_prettier_divergence/)). It is asked of the RUN, never of the separator's shape, the sibling count, or the container's kind. A fill needs two things: **prose to pack** (the run-level count above — at least two words, a one-word run being a label — shared verbatim) and **a whitespace seam to reflow at**. With both, an interior newline is the fill's own wrap point rather than authoring, so the element collapses when it fits — `<span>text1⏎text2 <code>a</code></span>` reflows to the one-line form, its `<p>` and `<Comp>` twins identically (expanding a block or a component on an interior newline, as an inline element never is, would be a split keyed on the container rather than on anything the rule is about), and a ONE-boundary newline reaches the same answer through the arity above, since the edge run it lands in is trimmed before the interior is read ([content_interior_newline_collapse](../tests/fixtures/svelte/elements/content_interior_newline_collapse/), [boundary_air_one_sided](../tests/fixtures/svelte/elements/boundary_air_one_sided_prettier_divergence/); prettier agrees with the collapse in every kind). A pure-sibling run reaches **no** fill answer, and there is deliberately no third path granting it one. `<span>{a}\t{b}</span>` holds no prose, so it has nothing to reflow into, and a pure-sibling run the author DID break keeps its lines for the same reason: with no fill, those lines are the only structure the author has. A `{a} {b}` disjunct granting such a run the fill answer (on the reading that the author left the siblings on one line themselves) would be inert: every reader of "did the author break this content?" is unified onto the two interior-newline arms, which ask the question *of a text node carrying a newline*, and a run such a disjunct accepts has none — every newline-bearing node in it would have to be prose, and a run with prose already reaches the fill answer through the prose path. ⚠️ **A separator's *spelling* still may not pick a layout** — that equality is carried by the boundary and separator paths rather than by a fill answer for content that has no fill: a space and a tab render the same and reach one form across all three sibling kinds, where testing a literal space lets the spelling pick the layout and one document reaches two — [inline_separator_tab](../tests/fixtures/svelte/elements/inline_separator_tab_prettier_divergence/), whose hugged-boundary control isolates it: the tab alone is never the trigger, only the tab *with* a newline-authored boundary that has a layout left to select. **A spelling reaches that rule through what it DECODES to, not through its bytes**, so an entity-encoded space or tab does too: ` ` decodes to whitespace the compiler collapses, which makes it interchangeable with the plain space beside it — and only the *layout* converges, since the entity's own bytes print verbatim (respelling one is a content edit) — [inline_separator_entity_collapse](../tests/fixtures/svelte/elements/inline_separator_entity_collapse_prettier_divergence/). An ` ` decodes to a non-breaking space, which renders as itself and never collapses, so it does not reach the rule at all ([inline_separator_nbsp_newline](../tests/fixtures/svelte/elements/inline_separator_nbsp_newline/)), and neither does an entity in a run the author *did* break, which holds no prose to reflow ([inline_separator_entity_newline](../tests/fixtures/svelte/elements/inline_separator_entity_newline/)). So the two questions read different texts on purpose and neither may borrow the other's axis: the whitespace scalars that decide what PRINTS read `raw` (matching prettier's `node.raw || node.data`), while the separator questions that decide LAYOUT — is this node the run's prose, is this separator interchangeable with a space — read the decoded data. ⚠️ The authority for "same render" is rule 1 for an element or component pair and the **browser's** own collapse for a tag pair, because `clean_nodes` skips the collapse whenever a neighbor is an `ExpressionTag` — `{a}⇥{b}` reaches compiled output with its tab, where `<code>a</code>⇥<code>b</code>` compiles to a space. Both are render-identical under `white-space: normal`, which is the model tsv's render oracle implements and the one this whole section already assumes ([conformance_svelte.md §Template Whitespace](./conformance_svelte.md#template-whitespace-clean_nodes)); do not restate the tag case as a rule-1 consequence, it is not one. Without a seam the content is one unbreakable unit with nothing to reflow, so the boundary is the only signal the author has and it keeps its authored lines — glued `<a>⏎{expr}text⏎</a>` stays multiline, and prettier agrees ([elements/inline_multiline_nontext](../tests/fixtures/svelte/elements/inline_multiline_nontext/)). Two consequences are load-bearing. First, the run boundary is the *same* one the flow rule uses: a comment, a control-flow block, a block element or an authored blank line ends the run, and content holding one is structured rather than flowed — without that, a `<!-- … -->` and the text beneath it flatten onto one line and an authored blank line is deleted, content-preservation breaks rather than layout choices. Second, **every** reader of "did the author break this content?" must consult this one answer. The predicate suppresses a multiline signal, and a suppressed element lays its content out as one `fill` — which, once the content is wide, wraps a prose text ACROSS LINES and so writes the very newline the other readers key on. A reader left out reports the break on the next pass, the multiline arm then freezes the authored newlines as hardlines, and the two arrangements alternate forever: a real F1 break on real prose tables, which is why a narrower predicate gating only the boundary arm is not an option. — [inline_content_flow_collapse](../tests/fixtures/svelte/elements/inline_content_flow_collapse_prettier_divergence/) carries the whole class (element pair, table cell, component pair, expression-tag pair, a lone element with prose leading and trailing, and an element pair followed by prose). The holding side of the same answer — a one-word run (or two one-word texts in one run: the count is per node), whose interior whitespace-only newline is the author's structure and so EXPANDS the hugged element, boundaries and all, where the same newline in a run whose text carries two words is the fill's wrap point and collapses — is [inline_interior_newline_label_hold](../tests/fixtures/svelte/elements/inline_interior_newline_label_hold_prettier_divergence/); prettier keeps the hug and dangles the closing delimiter from the hugged authoring, its interior newline held but never selecting the layout. ⚠️ Only the whitespace-only arm holds it: the content-text arm's edge trim still collapses a one-word interior newline at a text node's edge (`<span>text1⏎<code>a</code></span>`), so the two spellings do not yet agree — open work, deliberately unpinned. That last case is what put the whitespace-ONLY arm on the shared answer: its newline lands in a whitespace-only separator node rather than inside a content text, so the run's prose and its break live in *different* nodes — the one shape the content-text arm cannot reach, and the last arm to be left out. The two interior arms are the predicate's only layout readers, for every container kind alike; the boundary arms honor their air without consulting it.
@@ -357,7 +358,7 @@ Both formatters keep the block-style form once produced (`prettier(input) == inp
⚠️ **A welded RUN is one movable unit, and "unbreakable inside" must not be mistaken for "immovable".** A run of glued nodes — element, glued text, element (`<code>.x</code>.w<b>y</b>`) — admits no break in either of its glued boundaries, since each would inject a rendered space (`.x.wyyyyyyyy` → `.x.w yyyyyyyy`). But it still has the whitespace boundary in *front* of it, which is inter-node whitespace the compiler collapses to one space, so tsv spends that one: the whole run travels to a fresh line **together**. Enforcing only the first half leaves the run standing on the text line and tearing its last element open block-style — a break that buys nothing and strands the run. This is the same "spend the break you have" rule the glued-comment unit follows in the break-before paragraph above, and it reaches the terminal-tail fold, whose head is such an element, so it has to hold of the *run* rather than of the node that happens to end it. Prettier keeps the run on the text line and dangles the closing `>` (`</b⏎> tail`). — [inline_fold_glued_head_long](../tests/fixtures/svelte/elements/inline_fold_glued_head_long_prettier_divergence/), whose **spaced** control at the same column is the contrast that isolates it: move that one boundary *inside* the run and only the part after it travels. **The rule belongs to the unit, not to whatever ends or follows it** — [inline_welded_run_travel_long](../tests/fixtures/svelte/elements/inline_welded_run_travel_long_prettier_divergence/) varies those axes and reaches one form throughout: a run with no terminal text at all (so no fold), the same run followed by *non-terminal* text and a further element (the run travels identically and the follower packs after it — the travel decision cannot depend on what comes after the unit), a three-element run whose *middle* element is the one that overflows, a three-element run whose *last* element is the one that overflows while every earlier member still fits (the two together pin, from both sides, that no earlier short element can strand a later wide one), an ` `-glued run (glue that is *content* — it renders as itself and never collapses, so the run is unbreakable for a different reason), a component pair, an expression tag ending the run, a tag-HEADED run (`{expr}.w<b>…</b>`, at the exact 100/101 boundary and with the crossing point probed on each side of the tag — which member of the unit crosses the width cannot matter), and a run welded *through* a mid-run tag (`<code>.x</code>{ex}<b>…</b>`, the crossing past the tag). ⚠️ The unit is measured **to its own weld and no further**: what the boundary in front of it must hold is the welded part, and everything past the unit's own first whitespace is free to wrap there. Counting a welded run whole breaks the boundary far too early — `example (<Link …>see docs</Link>) for details.` would isolate `(<Link…>` on account of the ` for details.` trailing the welded `)`. ⚠️ And nothing but the render oracle guards the first half: a split glued boundary yields output that is its own fixed point, so F1, the fuzzer, `authoring_audit` and the round-trip are all blind to it. The two shapes are pinned separately — a welded pair with a *spaced* tail, where both formatters agree once tsv travels ([fill_inline_pairwise_welded_long](../tests/fixtures/svelte/elements/fill_inline_pairwise_welded_long/)), and the divergent tail forms above. ⚠️ **The rule does not depend on what precedes the run either**, and that axis is the one that has to be pinned from the *render* side rather than the build side: every case above has text in front of the run, so the boundary belongs to that text's own fill, whereas an inline **element** or **tag** sibling leaves the boundary to the run's own leading whitespace — where a head of a single glued word (`(<a …>`) is a bare text node rather than a fill, and the flag selecting the whole-flat measurement is only ever read off a fill. — [inline_welded_run_after_sibling_long](../tests/fixtures/svelte/elements/inline_welded_run_after_sibling_long_prettier_divergence/) (lone-word head at the exact 100/101 boundary, the same before a tag sibling, a two-word head at the same width — how many words head the run cannot change the answer — and the two overflow regimes: a run far too wide to pack that still fits on its own line, and one whose element is wider than a whole line and travels anyway before laying out block-style). It also bounds prettier's dangling, which is what one column buys: at exactly 101 a dangled `>` makes the line fit and prettier takes it, and past that prettier breaks at the same boundary tsv does. ⚠️ **The same independence holds when the follower is already multiline rather than merely wide**, and there the predecessor reaches the rule through a second route: a run whose fill leads with its own `line` — which is every run after a tag or an element — shifts the fill's content/separator parity by one, and the forced-break measurement (a follower that is already multiline can never "fit", since measuring it flat short-circuits at its own hardline) is answered on the word-leading parity alone. So `text1 var(<Comp …>` travelled while `{expr1} var(<Comp …>` welded and opened the component's tag mid-line — one rule with two answers keyed on a predecessor the rule is not about. — [inline_welded_run_travel_after_boundary](../tests/fixtures/svelte/elements/inline_welded_run_travel_after_boundary_prettier_divergence/) (tag and breaking-element predecessors, each against the text-predecessor and spaced-run controls that bracket the two axes; prettier welds in all four).
-- elements — [inline_multi_element_pack_boundary_long_prettier_divergence](../tests/fixtures/svelte/elements/inline_multi_element_pack_boundary_long_prettier_divergence/), [inline_before_block_break_prettier_divergence](../tests/fixtures/svelte/elements/inline_before_block_break_prettier_divergence/), [table_cell_hug_long_prettier_divergence](../tests/fixtures/svelte/elements/table_cell_hug_long_prettier_divergence/), [member_expr_break_prettier_divergence](../tests/fixtures/svelte/elements/member_expr_break_prettier_divergence/), [member_expr_break_order_prettier_divergence](../tests/fixtures/svelte/elements/member_expr_break_order_prettier_divergence/), [member_expr_break_order_long_prettier_divergence](../tests/fixtures/svelte/elements/member_expr_break_order_long_prettier_divergence/), [inline_with_if_block_prettier_divergence](../tests/fixtures/svelte/elements/inline_with_if_block_prettier_divergence/), [inline_with_if_block_multiline_prettier_divergence](../tests/fixtures/svelte/elements/inline_with_if_block_multiline_prettier_divergence/), [inline_if_content_block_style_prettier_divergence](../tests/fixtures/svelte/elements/inline_if_content_block_style_prettier_divergence/), [inline_nested_else_if_block_style_prettier_divergence](../tests/fixtures/svelte/elements/inline_nested_else_if_block_style_prettier_divergence/), [inline_nbsp_boundary_long_prettier_divergence](../tests/fixtures/svelte/elements/inline_nbsp_boundary_long_prettier_divergence/), [inline_nested_child_trailing_long_prettier_divergence](../tests/fixtures/svelte/elements/inline_nested_child_trailing_long_prettier_divergence/), [inline_content_unbreakable_prettier_divergence](../tests/fixtures/svelte/elements/inline_content_unbreakable_prettier_divergence/), [inline_nested_wrap_long_prettier_divergence](../tests/fixtures/svelte/elements/inline_nested_wrap_long_prettier_divergence/) (nested inline elements both wrap block-style; prettier double-pyramids), [inline_multiline_mixed_hug_prettier_divergence](../tests/fixtures/svelte/elements/inline_multiline_mixed_hug_prettier_divergence/) (a hugged closing boundary still lays out block-style; prettier dangles), [inline_boundary_whitespace_multiline_prettier_divergence](../tests/fixtures/svelte/elements/inline_boundary_whitespace_multiline_prettier_divergence/) (the boundary-whitespace authorings — none / space / newline — converge on one form), [inline_multiline_leading_text_long_prettier_divergence](../tests/fixtures/svelte/elements/inline_multiline_leading_text_long_prettier_divergence/) (the same convergence when the content goes multiline by **width** rather than structurally — a hugged element child at the closing boundary), [textarea_empty_hugged_long_prettier_divergence](../tests/fixtures/svelte/elements/textarea_empty_hugged_long_prettier_divergence/) (an *empty* `<textarea>` hugged by an inline `<label>`: nothing is whitespace-significant, so the label goes block-style; prettier's dangled `</label` suffix is what forces the textarea's attributes to wrap)
+- elements — [inline_multi_element_pack_boundary_long_prettier_divergence](../tests/fixtures/svelte/elements/inline_multi_element_pack_boundary_long_prettier_divergence/), [block_after_spaced_text_prettier_divergence](../tests/fixtures/svelte/elements/block_after_spaced_text_prettier_divergence/) + [block_after_spaced_text_long_prettier_divergence](../tests/fixtures/svelte/elements/block_after_spaced_text_long_prettier_divergence/) + [mixed_space_before_block_prettier_divergence](../tests/fixtures/svelte/elements/mixed_space_before_block_prettier_divergence/) + [block_after_spaced_text_kinds_prettier_divergence](../tests/fixtures/svelte/elements/block_after_spaced_text_kinds_prettier_divergence/) (a block element after spaced text takes its own line at every position of the text; prettier hugs it to a first-child text), [inline_before_block_break_prettier_divergence](../tests/fixtures/svelte/elements/inline_before_block_break_prettier_divergence/), [table_cell_hug_long_prettier_divergence](../tests/fixtures/svelte/elements/table_cell_hug_long_prettier_divergence/), [member_expr_break_prettier_divergence](../tests/fixtures/svelte/elements/member_expr_break_prettier_divergence/), [member_expr_break_order_prettier_divergence](../tests/fixtures/svelte/elements/member_expr_break_order_prettier_divergence/), [member_expr_break_order_long_prettier_divergence](../tests/fixtures/svelte/elements/member_expr_break_order_long_prettier_divergence/), [inline_with_if_block_prettier_divergence](../tests/fixtures/svelte/elements/inline_with_if_block_prettier_divergence/), [inline_with_if_block_multiline_prettier_divergence](../tests/fixtures/svelte/elements/inline_with_if_block_multiline_prettier_divergence/), [inline_if_content_block_style_prettier_divergence](../tests/fixtures/svelte/elements/inline_if_content_block_style_prettier_divergence/), [inline_nested_else_if_block_style_prettier_divergence](../tests/fixtures/svelte/elements/inline_nested_else_if_block_style_prettier_divergence/), [inline_nbsp_boundary_long_prettier_divergence](../tests/fixtures/svelte/elements/inline_nbsp_boundary_long_prettier_divergence/), [inline_nested_child_trailing_long_prettier_divergence](../tests/fixtures/svelte/elements/inline_nested_child_trailing_long_prettier_divergence/), [inline_content_unbreakable_prettier_divergence](../tests/fixtures/svelte/elements/inline_content_unbreakable_prettier_divergence/), [inline_nested_wrap_long_prettier_divergence](../tests/fixtures/svelte/elements/inline_nested_wrap_long_prettier_divergence/) (nested inline elements both wrap block-style; prettier double-pyramids), [inline_multiline_mixed_hug_prettier_divergence](../tests/fixtures/svelte/elements/inline_multiline_mixed_hug_prettier_divergence/) (a hugged closing boundary still lays out block-style; prettier dangles), [inline_boundary_whitespace_multiline_prettier_divergence](../tests/fixtures/svelte/elements/inline_boundary_whitespace_multiline_prettier_divergence/) (the boundary-whitespace authorings — none / space / newline — converge on one form), [inline_multiline_leading_text_long_prettier_divergence](../tests/fixtures/svelte/elements/inline_multiline_leading_text_long_prettier_divergence/) (the same convergence when the content goes multiline by **width** rather than structurally — a hugged element child at the closing boundary), [textarea_empty_hugged_long_prettier_divergence](../tests/fixtures/svelte/elements/textarea_empty_hugged_long_prettier_divergence/) (an *empty* `<textarea>` hugged by an inline `<label>`: nothing is whitespace-significant, so the label goes block-style; prettier's dangled `</label` suffix is what forces the textarea's attributes to wrap)
- components — [compact_block_children_prettier_divergence](../tests/fixtures/svelte/components/compact_block_children_prettier_divergence/), [compact_multiple_blocks_prettier_divergence](../tests/fixtures/svelte/components/compact_multiple_blocks_prettier_divergence/), [inline_parent_blocks_prettier_divergence](../tests/fixtures/svelte/components/inline_parent_blocks_prettier_divergence/), [text_child_long_prettier_divergence](../tests/fixtures/svelte/components/text_child_long_prettier_divergence/) (component body long inline text wraps block-style; prettier dangles), [content_boundary_convergence_prettier_divergence](../tests/fixtures/svelte/components/content_boundary_convergence_prettier_divergence/) (one document, three authorings: prettier keeps a stable form for each, tsv converges all three), [opening_newline_only_prettier_divergence](../tests/fixtures/svelte/components/opening_newline_only_prettier_divergence/) (a break on one boundary only is not an expansion signal — the content collapses back inline; prettier dangles the closing tag)
- special elements — [attrs_long_prettier_divergence](../tests/fixtures/svelte/special_elements/attrs_long_prettier_divergence/) (`<svelte:component>` with a child, attributes wrapped), [svelte_element_hug_long_prettier_divergence](../tests/fixtures/svelte/special_elements/svelte_element_hug_long_prettier_divergence/) (`<svelte:element>` with long text content), [svelte_element_attrs_multiline_value_prettier_divergence](../tests/fixtures/svelte/special_elements/svelte_element_attrs_multiline_value_prettier_divergence/) (a multiline attribute value breaks the attributes; the content still goes block-style), [closing_tag_inline_content_prettier_divergence](../tests/fixtures/svelte/special_elements/closing_tag_inline_content_prettier_divergence/) (a `{#if}` sibling hugs the intact `</slot>` rather than a dangled `>`), [slot/expanding_no_ws_prettier_divergence](../tests/fixtures/svelte/special/slot/expanding_no_ws_prettier_divergence/) (a `<slot>` whose only child is an expanding block), [slot/block_children_prettier_divergence](../tests/fixtures/svelte/special/slot/block_children_prettier_divergence/) (a `<slot>` with block-element children goes multiline in parity with a `<span>` in the same shape)
- blocks — [nested_expanding_prettier_divergence](../tests/fixtures/svelte/blocks/await/nested_expanding_prettier_divergence/), [inline_element_boundary_long_prettier_divergence](../tests/fixtures/svelte/blocks/await/inline_element_boundary_long_prettier_divergence/), [snippet/body_inline_content_prettier_divergence](../tests/fixtures/svelte/blocks/snippet/body_inline_content_prettier_divergence/) (snippet body inline content lays out block-style; prettier dangles)
@@ -494,7 +495,7 @@ The hug is the exception, and its question is **"does the head's broken form END
**Sibling `>` dangle (axis 3).** When an inline element is immediately followed — no whitespace — by a block that **renders multiline**, tsv dangles that element's **closing `>`** onto the block-head line (`<a href={root}>Home</a⏎>{#each …}`). This applies to the **four rendering block heads** — `{#if}` / `{#each}` / `{#key}` / `{#await}`. (`{#snippet}` mostly left this regime: it is a declaration and takes its own line — [the declaration rule above](#svelte-inline-content-block-style) — so a glued boundary beside it splits rather than dangling the `>`. The exception is a snippet glued to content on BOTH sides, which keeps the author's line and *stays* in this regime: when it renders multiline, the preceding sibling's `>` dangles exactly as for the four heads.) It generalizes the rule tsv already applies from the enclosing-element side: the `>` token immediately preceding a block's `{#…}` dangles, whether it's the *opening* `>` of a parent inline element holding a sole-content block (`<span⏎>{#if …}`) or the *closing* `>` of a preceding inline sibling. The `>` moves only *inside* the closing tag (`</a⏎>`), so the boundary whitespace is tag-internal and the output parses to a byte-identical AST — render-safe (verified against the Svelte compiler), the same property as the element boundary-`>` wrap. It is **strict / multiline-only**: a short block that stays inline keeps the `>` hugged (`<span>text</span>{#if c}text{/if}`), and the decision keys on whether the block actually renders multiline — not on whether its body is authored inline or on its own line — so the layout is a fixed point on its own output. It is **leading-side only**: the closing side (`{/if}<span>`) keeps flowing. **Glued** text/expression siblings (`text1{#if…}`, `{x}{#if…}`) keep hugging — there is no `>` to dangle and a glued boundary is render-significant, so it is never split; a **spaced** text sibling instead takes the fresh-line drop below (§Multiline block head after spaced text). Prettier never expands the block at all, so it always keeps the boundary hugged. **`{#await}`:** unlike `{#if}` / `{#each}` / `{#key}`, an await doesn't force its block parent multiline on its own (a lone `<div>{#await p}x{/await}</div>` stays inline, matching prettier) — it goes multiline only once it follows a **breakable** sibling: an inline element / component / expression-or-`{@html}`-or-`{@render}` tag (the `has_preceding_breakable` set). There the parent breaks so the dangle, the block-on-own-line separation for a block sibling, and the body-drop all resolve in one pass. `has_preceding_breakable` reaches only the **head** (it holds the head flat, so the sibling breaks first); the **body**-drop is width's decision alone and never keys on it — see [§Body-expand](#svelte-blocks) above. After a **non-breakable** sibling — plain text or a comment — it stays **inline**, matching prettier; the force is additionally gated on `kind.is_block()`, so an inline element or component parent never breaks for *any* sibling. This is a distinct axis from the `>` dangle above: a breakable sibling breaks the *parent* even when the short block keeps its own `>` hugged, and that break is itself a divergence (prettier keeps the short inline-authored construct inline). Cataloged at [elements/inline_sibling_gt_dangle](../tests/fixtures/svelte/elements/inline_sibling_gt_dangle_prettier_divergence/) (the dangle for the four heads + both `{#snippet}` shapes — one-side glued splits, both-sides glued dangles — + a no-dangle control), [elements/await_snippet_breakable_sibling](../tests/fixtures/svelte/elements/await_snippet_breakable_sibling_prettier_divergence/) (the short-case parent break after a breakable sibling; its snippet case additionally splits under the declaration rule), [elements/await_nonbreakable_sibling_inline](../tests/fixtures/svelte/elements/await_nonbreakable_sibling_inline/) (the non-breakable text/comment counterpart that stays inline, matching prettier), [components/await_sibling_inline](../tests/fixtures/svelte/components/await_sibling_inline/) (a component parent stays inline for any await sibling, incl. after `{@debug}`), [blocks/await/preceding_sibling_body_long](../tests/fixtures/svelte/blocks/await/preceding_sibling_body_long_prettier_divergence/) (await body-drop after a non-danglable expression-tag sibling), [elements/block_body_drop_nested_siblings](../tests/fixtures/svelte/elements/block_body_drop_nested_siblings_prettier_divergence/) (the breadcrumb `</a>` dangle in realistic context), and [elements/inline_if_sibling_fill_long](../tests/fixtures/svelte/elements/inline_if_sibling_fill_long_prettier_divergence/) (the `</span>` dangle in a fill). The **inline counterpart** of the dangle — a preceding sibling before an inline-rendering `{#await}` — **hugs** the `>` (`</a>{#await …}`) rather than dangling it. The `>` must always be **placed, never dropped** — a dropped `>` (`</a{#await …}`) is unreparseable. `{#await}` reaches this on two paths, both handled: the empty-await path (a short empty block hugs; a long head that width-wraps dangles — a *render-time* decision `will_break` can't see, so it's an `if_break`-in-`group`) and the space-only path (a `group` that hugs when it fits). Cataloged at [blocks/await/empty_sibling_gt](../tests/fixtures/svelte/blocks/await/empty_sibling_gt/) (a bare empty `{#await promise}{/await}` after a sibling — the `>` hugged in parity with prettier; its space-only-authoring variants exercise the space-only path).
-**Multiline block head after spaced text (◆design_choice).** When sibling text is followed — across ordinary whitespace — by a control-flow block that **renders multiline**, tsv moves the boundary's break in front of the head: `text1 {#if cond}⏎⇥text2⏎{/if}` becomes `text1⏎{#if cond}⏎⇥text2⏎{/if}`. Inter-sibling whitespace is significant in *presence* but free in *kind* (a space and a newline both render as one space), so the move is render-safe; the newline-authored form is a fixed point, and the two authorings converge on it, so a multiline unit's head never ends a content line — the posture every other unit kind has: a multiline inline element/component after spaced text starts on a fresh line (the break-before rule, [§Svelte: Inline content block-style](#svelte-inline-content-block-style)), a `{#snippet}` takes its own line as a declaration, and a multiline block after any **non-text** sibling (element, tag, comment, another block) already gets the hardline — with prettier agreeing there. It applies to the four rendering heads (`{#if}` / `{#each}` / `{#key}` / `{#await}`) in every fragment family: block, inline, and component content, the root, and branch interiors. It is **strict / multiline-only and render-keyed**: the mechanism is the flow boundary's own forced-break rule (`break_before_wide_flow` / `flow_forced_break`), so an inline-rendering block still packs into the fill per width (`text1 {#if b}text2{/if} text3`), and the drop keys on whether the block actually renders multiline. A **glued** head (`text1{#if …}`) is out of scope — that boundary is render-significant and never split (the sibling-`>` dangle entry above covers its element side); giving the glued shape the whole-unit travel is a separate, tracked admission. Prettier keeps the welded head stable, one form per authoring. Cataloged at [blocks/multiline_head_after_text](../tests/fixtures/svelte/blocks/multiline_head_after_text_prettier_divergence/).
+**Multiline block head after spaced text (◆design_choice).** When sibling text is followed — across ordinary whitespace — by a control-flow block that **renders multiline**, tsv moves the boundary's break in front of the head: `text1 {#if cond}⏎⇥text2⏎{/if}` becomes `text1⏎{#if cond}⏎⇥text2⏎{/if}`. Inter-sibling whitespace is significant in *presence* but free in *kind* (a space and a newline both render as one space), so the move is render-safe; the newline-authored form is a fixed point, and the two authorings converge on it, so a multiline unit's head never ends a content line — the posture every other unit kind has: a multiline inline element/component after spaced text starts on a fresh line (the break-before rule, [§Svelte: Inline content block-style](#svelte-inline-content-block-style)), a block element after spaced text takes its own line whatever it renders ([block_after_spaced_text](../tests/fixtures/svelte/elements/block_after_spaced_text_prettier_divergence/), the same section), a `{#snippet}` takes its own line as a declaration, and a multiline block after any **non-text** sibling (element, tag, comment, another block) already gets the hardline — with prettier agreeing there. It applies to the four rendering heads (`{#if}` / `{#each}` / `{#key}` / `{#await}`) in every fragment family: block, inline, and component content, the root, and branch interiors. It is **strict / multiline-only and render-keyed**: the mechanism is the flow boundary's own forced-break rule (`break_before_wide_flow` / `flow_forced_break`), so an inline-rendering block still packs into the fill per width (`text1 {#if b}text2{/if} text3`), and the drop keys on whether the block actually renders multiline. A **glued** head (`text1{#if …}`) is out of scope — that boundary is render-significant and never split (the sibling-`>` dangle entry above covers its element side); giving the glued shape the whole-unit travel is a separate, tracked admission. Prettier keeps the welded head stable, one form per authoring. Cataloged at [blocks/multiline_head_after_text](../tests/fixtures/svelte/blocks/multiline_head_after_text_prettier_divergence/).
**Empty `{#await}` sections (◆prettier_bug ◆content_preservation on `:catch`).** An **empty-body `:then`** — `{#await p} {:then v}{/await}`, or the shorthand `{#await p then v}{/await}` — is **dropped**, marker and binding, collapsing to `{#await p}{/await}` in parity with prettier (the `value` binding is unused when nothing renders; a *space-only* pending folds to the same fixed point via `await_shorthand`, while a *newline*-authored one keeps its full multiline form). But an **empty `:catch` is kept** (`{#await p}…{:catch e}{/await}`) — a deliberate divergence from prettier, which deletes it too. An empty `{:catch}` still **handles** a rejection (renders nothing); deleting it lets the rejection **propagate** instead — a semantic change, so tsv preserves the section (correctness over conformance). Kept the same way whether the construct is inline or **block-style**: the section's boundary separators are soft, so inline the empty section collapses and its markers glue (`{#await p}x{:catch e}{/await}`), while in block form it keeps its own line like any other section — `{:catch e}` and `{/await}` each on a line, the empty body's blank line between. Cataloged at [blocks/await/empty_catch](../tests/fixtures/svelte/blocks/await/empty_catch_prettier_divergence/) (inline) and [blocks/await/empty_catch_multiline](../tests/fixtures/svelte/blocks/await/empty_catch_multiline_prettier_divergence/) (block form).
diff --git a/docs/fixture_overview.md b/docs/fixture_overview.md
index 020895f1a..49ca9fd28 100644
--- a/docs/fixture_overview.md
+++ b/docs/fixture_overview.md
@@ -831,6 +831,19 @@ deno task fixtures:update
When `output_prettier.*` exists, prettier baseline validation (F3) is skipped — F2 checks the file matches prettier instead.
+**`output_prettier.*` is a claim about prettier only.** F2 pins prettier's first pass on the
+input and F4/F4b its chain to a fixed point; nothing grades what *tsv* does with that form.
+tsv's answer is one of three classes — it **holds** prettier's form, **normalizes** it back to
+input, or rewrites it to a **third** stable form — and only two are expressible today, each by a
+byte-copy of `output_prettier.*` under a variant name: a `variant_*` copy claims *holds* (N9), a
+`divergent_variant_*` copy claims *third form* (N11). *Normalizes* has no marker: a
+`prettier_variant_*` copy is refused as redundant (`RedundantPrettierVariantMatchesOutputPrettier`),
+so that claim lives in README prose only. A copy also drifts silently — `fixtures:update:formatted`
+regenerates `output_prettier.*` but never a copy of it — so prefer stating the class in the README
+and reading it live with `deno task fixtures:audit -v <pattern>`, whose `output_prettier.*` row
+(`ours -> self` / `ours -> input` / a novel form) is the grade. A validator-computed grade of that
+row is the intended replacement for the copies.
+
---
### Svelte Parser Divergence
diff --git a/tests/fixtures/svelte/elements/block_after_spaced_text_long_prettier_divergence/README.md b/tests/fixtures/svelte/elements/block_after_spaced_text_long_prettier_divergence/README.md
new file mode 100644
index 000000000..97734d7dd
--- /dev/null
+++ b/tests/fixtures/svelte/elements/block_after_spaced_text_long_prettier_divergence/README.md
@@ -0,0 +1,20 @@
+# block_after_spaced_text_long_prettier_divergence
+
+The width boundary of [block_after_spaced_text](../block_after_spaced_text_prettier_divergence/):
+a block element after a first-child spaced text takes its own line at **every** width. At exactly
+100 chars the hugged line would fit, and prettier keeps it (`prettier_variant_hugged.svelte`);
+tsv still breaks before the block. At 101 the hugged line overflows: tsv breaks before the block,
+which then collapses inline on its fresh line (89 chars), where prettier opens the block
+block-style with its head left dangling on the text line (`prettier_variant_dangled.svelte`) —
+tsv normalizes that form back to `input.svelte` too, the block's content reflowing onto its
+fresh line. `unformatted_ours_one_line.svelte` authors both cases on one line; tsv normalizes it
+to `input.svelte` in one pass and prettier lands on the dangled form.
+
+## Reason
+
+Design choice — see the sibling fixture's README: the block's own break separates it from the
+text, so no width makes the hug the right layout, and a multiline unit's head never ends a
+content line.
+
+See
+[conformance_prettier_svelte.md §Svelte: Inline content block-style](../../../../../docs/conformance_prettier_svelte.md#svelte-inline-content-block-style).
diff --git a/tests/fixtures/svelte/elements/block_after_spaced_text_long_prettier_divergence/expected.json b/tests/fixtures/svelte/elements/block_after_spaced_text_long_prettier_divergence/expected.json
new file mode 100644
index 000000000..1390eb5ea
--- /dev/null
+++ b/tests/fixtures/svelte/elements/block_after_spaced_text_long_prettier_divergence/expected.json
@@ -0,0 +1,185 @@
+{
+ "css": null,
+ "js": [],
+ "start": 0,
+ "end": 520,
+ "type": "Root",
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Comment",
+ "start": 0,
+ "end": 117,
+ "data": " width is not the axis: at 100 the hugged line would fit exactly, and the block still takes\n its own line "
+ },
+ {
+ "type": "Text",
+ "start": 117,
+ "end": 118,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 118,
+ "end": 231,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 3,
+ "column": 1,
+ "character": 119
+ },
+ "end": {
+ "line": 3,
+ "column": 4,
+ "character": 122
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 123,
+ "end": 138,
+ "raw": "\n\ttext1 text2\n\t",
+ "data": "\n\ttext1 text2\n\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 138,
+ "end": 224,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 5,
+ "column": 2,
+ "character": 139
+ },
+ "end": {
+ "line": 5,
+ "column": 5,
+ "character": 142
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 143,
+ "end": 218,
+ "raw": "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
+ "data": "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 224,
+ "end": 225,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 231,
+ "end": 233,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 233,
+ "end": 404,
+ "data": " at 101 the hugged line overflows; the block collapses inline on its fresh line (89 chars)\n rather than opening block-style with its head left on the text line "
+ },
+ {
+ "type": "Text",
+ "start": 404,
+ "end": 405,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 405,
+ "end": 519,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 10,
+ "column": 1,
+ "character": 406
+ },
+ "end": {
+ "line": 10,
+ "column": 4,
+ "character": 409
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 410,
+ "end": 425,
+ "raw": "\n\ttext1 text2\n\t",
+ "data": "\n\ttext1 text2\n\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 425,
+ "end": 512,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 12,
+ "column": 2,
+ "character": 426
+ },
+ "end": {
+ "line": 12,
+ "column": 5,
+ "character": 429
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 430,
+ "end": 506,
+ "raw": "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
+ "data": "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 512,
+ "end": 513,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ }
+ ]
+ },
+ "options": null,
+ "comments": []
+}
diff --git a/tests/fixtures/svelte/elements/block_after_spaced_text_long_prettier_divergence/input.svelte b/tests/fixtures/svelte/elements/block_after_spaced_text_long_prettier_divergence/input.svelte
new file mode 100644
index 000000000..d94062772
--- /dev/null
+++ b/tests/fixtures/svelte/elements/block_after_spaced_text_long_prettier_divergence/input.svelte
@@ -0,0 +1,13 @@
+<!-- width is not the axis: at 100 the hugged line would fit exactly, and the block still takes
+ its own line -->
+<div>
+ text1 text2
+ <div>eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee</div>
+</div>
+
+<!-- at 101 the hugged line overflows; the block collapses inline on its fresh line (89 chars)
+ rather than opening block-style with its head left on the text line -->
+<div>
+ text1 text2
+ <div>eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee</div>
+</div>
diff --git a/tests/fixtures/svelte/elements/block_after_spaced_text_long_prettier_divergence/prettier_variant_dangled.svelte b/tests/fixtures/svelte/elements/block_after_spaced_text_long_prettier_divergence/prettier_variant_dangled.svelte
new file mode 100644
index 000000000..aea5a4055
--- /dev/null
+++ b/tests/fixtures/svelte/elements/block_after_spaced_text_long_prettier_divergence/prettier_variant_dangled.svelte
@@ -0,0 +1,13 @@
+<!-- width is not the axis: at 100 the hugged line would fit exactly, and the block still takes
+ its own line -->
+<div>
+ text1 text2 <div>eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee</div>
+</div>
+
+<!-- at 101 the hugged line overflows; the block collapses inline on its fresh line (89 chars)
+ rather than opening block-style with its head left on the text line -->
+<div>
+ text1 text2 <div>
+ eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee
+ </div>
+</div>
diff --git a/tests/fixtures/svelte/elements/block_after_spaced_text_long_prettier_divergence/prettier_variant_hugged.svelte b/tests/fixtures/svelte/elements/block_after_spaced_text_long_prettier_divergence/prettier_variant_hugged.svelte
new file mode 100644
index 000000000..50ac5f3d5
--- /dev/null
+++ b/tests/fixtures/svelte/elements/block_after_spaced_text_long_prettier_divergence/prettier_variant_hugged.svelte
@@ -0,0 +1,12 @@
+<!-- width is not the axis: at 100 the hugged line would fit exactly, and the block still takes
+ its own line -->
+<div>
+ text1 text2 <div>eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee</div>
+</div>
+
+<!-- at 101 the hugged line overflows; the block collapses inline on its fresh line (89 chars)
+ rather than opening block-style with its head left on the text line -->
+<div>
+ text1 text2
+ <div>eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee</div>
+</div>
diff --git a/tests/fixtures/svelte/elements/block_after_spaced_text_long_prettier_divergence/unformatted_ours_one_line.svelte b/tests/fixtures/svelte/elements/block_after_spaced_text_long_prettier_divergence/unformatted_ours_one_line.svelte
new file mode 100644
index 000000000..32a7afe06
--- /dev/null
+++ b/tests/fixtures/svelte/elements/block_after_spaced_text_long_prettier_divergence/unformatted_ours_one_line.svelte
@@ -0,0 +1,11 @@
+<!-- width is not the axis: at 100 the hugged line would fit exactly, and the block still takes
+ its own line -->
+<div>
+ text1 text2 <div>eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee</div>
+</div>
+
+<!-- at 101 the hugged line overflows; the block collapses inline on its fresh line (89 chars)
+ rather than opening block-style with its head left on the text line -->
+<div>
+ text1 text2 <div>eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee</div>
+</div>
diff --git a/tests/fixtures/svelte/elements/block_after_spaced_text_prettier_divergence/README.md b/tests/fixtures/svelte/elements/block_after_spaced_text_prettier_divergence/README.md
new file mode 100644
index 000000000..5cdf4cf87
--- /dev/null
+++ b/tests/fixtures/svelte/elements/block_after_spaced_text_prettier_divergence/README.md
@@ -0,0 +1,31 @@
+# block_after_spaced_text_prettier_divergence
+
+**A block element after spaced text takes its own line.** A block sibling partitions the
+inline run and its own break separates the two, so the space before it is spent on that break
+in every fragment family — a block element, a section, an inline element, a component, a block
+body and the root — and whether the block renders inline (`text1 text2⏎<div>block1</div>`) or
+multiline (its head never ends the text line). Prettier keeps the block hugged to the text when
+the text is the fragment's **first child** (`text1 text2 <div>block1</div>`,
+`prettier_variant_space.svelte`) and breaks it after any other predecessor; tsv normalizes the
+space spelling to `input.svelte` in one pass.
+
+The controls agree with prettier: a text that is *not* the fragment's first child (after an
+element, after a tag) breaks before the block, an element predecessor does, and a **glued**
+boundary is split the same way (`unformatted_glued.svelte` — a block boundary is render-free,
+so both formatters normalize it to input).
+
+## Reason
+
+Design choice — the last row-dependent cell of the space rule. A space between siblings is
+decided by the follower's kind alone, and a block-element follower breaks it after an element, a
+component, a tag, a comment, a `<br />` and a control-flow block — and after a text that is not
+the fragment's first child. Only a **first-child** text kept the block on its line, and only in
+the space spelling: the glued and newline spellings of the same boundary already break. That is
+a spelling and a position selecting a layout, not a policy: prettier's hug is its
+`printChildren` returning early for a first child before the block-follower trim runs, and tsv
+had mirrored it. The multiline block is the sharper case — a multiline unit's head never ends a
+content line for an inline element, a component or a control-flow block, and the block element
+was the one unit kind still dangling its head there.
+
+See
+[conformance_prettier_svelte.md §Svelte: Inline content block-style](../../../../../docs/conformance_prettier_svelte.md#svelte-inline-content-block-style).
diff --git a/tests/fixtures/svelte/elements/block_after_spaced_text_prettier_divergence/expected.json b/tests/fixtures/svelte/elements/block_after_spaced_text_prettier_divergence/expected.json
new file mode 100644
index 000000000..1b67a68a5
--- /dev/null
+++ b/tests/fixtures/svelte/elements/block_after_spaced_text_prettier_divergence/expected.json
@@ -0,0 +1,1213 @@
+{
+ "css": null,
+ "js": [],
+ "start": 0,
+ "end": 1432,
+ "type": "Root",
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 0,
+ "end": 12,
+ "raw": "text1 text2\n",
+ "data": "text1 text2\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 12,
+ "end": 29,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 2,
+ "column": 1,
+ "character": 13
+ },
+ "end": {
+ "line": 2,
+ "column": 4,
+ "character": 16
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 17,
+ "end": 23,
+ "raw": "block1",
+ "data": "block1"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 29,
+ "end": 31,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 31,
+ "end": 356,
+ "data": "\n\tA block element after spaced text takes its own line, whether the text is the fragment's\n\tfirst child (above, at the root) or not, in every fragment family. Prettier hugs the block to\n\ta FIRST-child text (`text1 text2 <div>block1</div>`) and breaks it after any other\n\tpredecessor (`prettier_variant_space.svelte`).\n"
+ },
+ {
+ "type": "Text",
+ "start": 356,
+ "end": 358,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 358,
+ "end": 491,
+ "data": " a first-child text before a short block, in a block element, a section, an inline element,\n a component and a block body "
+ },
+ {
+ "type": "Text",
+ "start": 491,
+ "end": 492,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 492,
+ "end": 536,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 13,
+ "column": 1,
+ "character": 493
+ },
+ "end": {
+ "line": 13,
+ "column": 4,
+ "character": 496
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 497,
+ "end": 512,
+ "raw": "\n\ttext1 text2\n\t",
+ "data": "\n\ttext1 text2\n\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 512,
+ "end": 529,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 15,
+ "column": 2,
+ "character": 513
+ },
+ "end": {
+ "line": 15,
+ "column": 5,
+ "character": 516
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 517,
+ "end": 523,
+ "raw": "block1",
+ "data": "block1"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 529,
+ "end": 530,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 536,
+ "end": 537,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 537,
+ "end": 585,
+ "name": "section",
+ "name_loc": {
+ "start": {
+ "line": 17,
+ "column": 1,
+ "character": 538
+ },
+ "end": {
+ "line": 17,
+ "column": 8,
+ "character": 545
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 546,
+ "end": 561,
+ "raw": "\n\ttext1 text2\n\t",
+ "data": "\n\ttext1 text2\n\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 561,
+ "end": 574,
+ "name": "p",
+ "name_loc": {
+ "start": {
+ "line": 19,
+ "column": 2,
+ "character": 562
+ },
+ "end": {
+ "line": 19,
+ "column": 3,
+ "character": 563
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 564,
+ "end": 570,
+ "raw": "block1",
+ "data": "block1"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 574,
+ "end": 575,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 585,
+ "end": 586,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 586,
+ "end": 632,
+ "name": "span",
+ "name_loc": {
+ "start": {
+ "line": 21,
+ "column": 1,
+ "character": 587
+ },
+ "end": {
+ "line": 21,
+ "column": 5,
+ "character": 591
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 592,
+ "end": 607,
+ "raw": "\n\ttext1 text2\n\t",
+ "data": "\n\ttext1 text2\n\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 607,
+ "end": 624,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 23,
+ "column": 2,
+ "character": 608
+ },
+ "end": {
+ "line": 23,
+ "column": 5,
+ "character": 611
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 612,
+ "end": 618,
+ "raw": "block1",
+ "data": "block1"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 624,
+ "end": 625,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 632,
+ "end": 633,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "Component",
+ "start": 633,
+ "end": 679,
+ "name": "Comp",
+ "name_loc": {
+ "start": {
+ "line": 25,
+ "column": 1,
+ "character": 634
+ },
+ "end": {
+ "line": 25,
+ "column": 5,
+ "character": 638
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 639,
+ "end": 654,
+ "raw": "\n\ttext1 text2\n\t",
+ "data": "\n\ttext1 text2\n\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 654,
+ "end": 671,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 27,
+ "column": 2,
+ "character": 655
+ },
+ "end": {
+ "line": 27,
+ "column": 5,
+ "character": 658
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 659,
+ "end": 665,
+ "raw": "block1",
+ "data": "block1"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 671,
+ "end": 672,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 679,
+ "end": 680,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "IfBlock",
+ "elseif": false,
+ "start": 680,
+ "end": 728,
+ "test": {
+ "type": "Identifier",
+ "start": 685,
+ "end": 689,
+ "loc": {
+ "start": {
+ "line": 29,
+ "column": 5
+ },
+ "end": {
+ "line": 29,
+ "column": 9
+ }
+ },
+ "name": "cond"
+ },
+ "consequent": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 690,
+ "end": 705,
+ "raw": "\n\ttext1 text2\n\t",
+ "data": "\n\ttext1 text2\n\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 705,
+ "end": 722,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 31,
+ "column": 2,
+ "character": 706
+ },
+ "end": {
+ "line": 31,
+ "column": 5,
+ "character": 709
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 710,
+ "end": 716,
+ "raw": "block1",
+ "data": "block1"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 722,
+ "end": 723,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ },
+ "alternate": null
+ },
+ {
+ "type": "Text",
+ "start": 728,
+ "end": 730,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 730,
+ "end": 802,
+ "data": " a one-word label before the block, and text on both sides of it "
+ },
+ {
+ "type": "Text",
+ "start": 802,
+ "end": 803,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 803,
+ "end": 841,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 35,
+ "column": 1,
+ "character": 804
+ },
+ "end": {
+ "line": 35,
+ "column": 4,
+ "character": 807
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 808,
+ "end": 817,
+ "raw": "\n\ttext1\n\t",
+ "data": "\n\ttext1\n\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 817,
+ "end": 834,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 37,
+ "column": 2,
+ "character": 818
+ },
+ "end": {
+ "line": 37,
+ "column": 5,
+ "character": 821
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 822,
+ "end": 828,
+ "raw": "block1",
+ "data": "block1"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 834,
+ "end": 835,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 841,
+ "end": 842,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 842,
+ "end": 899,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 39,
+ "column": 1,
+ "character": 843
+ },
+ "end": {
+ "line": 39,
+ "column": 4,
+ "character": 846
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 847,
+ "end": 862,
+ "raw": "\n\ttext1 text2\n\t",
+ "data": "\n\ttext1 text2\n\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 862,
+ "end": 879,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 41,
+ "column": 2,
+ "character": 863
+ },
+ "end": {
+ "line": 41,
+ "column": 5,
+ "character": 866
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 867,
+ "end": 873,
+ "raw": "block1",
+ "data": "block1"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 879,
+ "end": 893,
+ "raw": "\n\ttext3 text4\n",
+ "data": "\n\ttext3 text4\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 899,
+ "end": 901,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 901,
+ "end": 975,
+ "data": " a block that renders multiline: its head never ends the text line "
+ },
+ {
+ "type": "Text",
+ "start": 975,
+ "end": 976,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 976,
+ "end": 1032,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 46,
+ "column": 1,
+ "character": 977
+ },
+ "end": {
+ "line": 46,
+ "column": 4,
+ "character": 980
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 981,
+ "end": 996,
+ "raw": "\n\ttext1 text2\n\t",
+ "data": "\n\ttext1 text2\n\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 996,
+ "end": 1025,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 48,
+ "column": 2,
+ "character": 997
+ },
+ "end": {
+ "line": 48,
+ "column": 5,
+ "character": 1000
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1001,
+ "end": 1004,
+ "raw": "\n\t\t",
+ "data": "\n\t\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1004,
+ "end": 1017,
+ "name": "p",
+ "name_loc": {
+ "start": {
+ "line": 49,
+ "column": 3,
+ "character": 1005
+ },
+ "end": {
+ "line": 49,
+ "column": 4,
+ "character": 1006
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1007,
+ "end": 1013,
+ "raw": "block1",
+ "data": "block1"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1017,
+ "end": 1019,
+ "raw": "\n\t",
+ "data": "\n\t"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1025,
+ "end": 1026,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1032,
+ "end": 1033,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "Component",
+ "start": 1033,
+ "end": 1091,
+ "name": "Comp",
+ "name_loc": {
+ "start": {
+ "line": 52,
+ "column": 1,
+ "character": 1034
+ },
+ "end": {
+ "line": 52,
+ "column": 5,
+ "character": 1038
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1039,
+ "end": 1054,
+ "raw": "\n\ttext1 text2\n\t",
+ "data": "\n\ttext1 text2\n\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1054,
+ "end": 1083,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 54,
+ "column": 2,
+ "character": 1055
+ },
+ "end": {
+ "line": 54,
+ "column": 5,
+ "character": 1058
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1059,
+ "end": 1062,
+ "raw": "\n\t\t",
+ "data": "\n\t\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1062,
+ "end": 1075,
+ "name": "p",
+ "name_loc": {
+ "start": {
+ "line": 55,
+ "column": 3,
+ "character": 1063
+ },
+ "end": {
+ "line": 55,
+ "column": 4,
+ "character": 1064
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1065,
+ "end": 1071,
+ "raw": "block1",
+ "data": "block1"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1075,
+ "end": 1077,
+ "raw": "\n\t",
+ "data": "\n\t"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1083,
+ "end": 1084,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1091,
+ "end": 1093,
+ "raw": "\n\n",
+ "data": "\n\n"
+ },
+ {
+ "type": "Comment",
+ "start": 1093,
+ "end": 1259,
+ "data": " controls, where both formatters break already: a text that is not the fragment's first\n child (after an element, after a tag), and an element predecessor "
+ },
+ {
+ "type": "Text",
+ "start": 1259,
+ "end": 1260,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1260,
+ "end": 1325,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 61,
+ "column": 1,
+ "character": 1261
+ },
+ "end": {
+ "line": 61,
+ "column": 4,
+ "character": 1264
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1265,
+ "end": 1267,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1267,
+ "end": 1287,
+ "name": "span",
+ "name_loc": {
+ "start": {
+ "line": 62,
+ "column": 2,
+ "character": 1268
+ },
+ "end": {
+ "line": 62,
+ "column": 6,
+ "character": 1272
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1273,
+ "end": 1280,
+ "raw": "inline1",
+ "data": "inline1"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1287,
+ "end": 1301,
+ "raw": " text1 text2\n\t",
+ "data": " text1 text2\n\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1301,
+ "end": 1318,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 63,
+ "column": 2,
+ "character": 1302
+ },
+ "end": {
+ "line": 63,
+ "column": 5,
+ "character": 1305
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1306,
+ "end": 1312,
+ "raw": "block1",
+ "data": "block1"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1318,
+ "end": 1319,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1325,
+ "end": 1326,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1326,
+ "end": 1377,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 65,
+ "column": 1,
+ "character": 1327
+ },
+ "end": {
+ "line": 65,
+ "column": 4,
+ "character": 1330
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1331,
+ "end": 1333,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "ExpressionTag",
+ "start": 1333,
+ "end": 1339,
+ "expression": {
+ "type": "Identifier",
+ "start": 1334,
+ "end": 1338,
+ "loc": {
+ "start": {
+ "line": 66,
+ "column": 2
+ },
+ "end": {
+ "line": 66,
+ "column": 6
+ }
+ },
+ "name": "expr"
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1339,
+ "end": 1353,
+ "raw": " text1 text2\n\t",
+ "data": " text1 text2\n\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1353,
+ "end": 1370,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 67,
+ "column": 2,
+ "character": 1354
+ },
+ "end": {
+ "line": 67,
+ "column": 5,
+ "character": 1357
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1358,
+ "end": 1364,
+ "raw": "block1",
+ "data": "block1"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1370,
+ "end": 1371,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1377,
+ "end": 1378,
+ "raw": "\n",
+ "data": "\n"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1378,
+ "end": 1431,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 69,
+ "column": 1,
+ "character": 1379
+ },
+ "end": {
+ "line": 69,
+ "column": 4,
+ "character": 1382
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1383,
+ "end": 1385,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1385,
+ "end": 1405,
+ "name": "span",
+ "name_loc": {
+ "start": {
+ "line": 70,
+ "column": 2,
+ "character": 1386
+ },
+ "end": {
+ "line": 70,
+ "column": 6,
+ "character": 1390
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1391,
+ "end": 1398,
+ "raw": "inline1",
+ "data": "inline1"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1405,
+ "end": 1407,
+ "raw": "\n\t",
+ "data": "\n\t"
+ },
+ {
+ "type": "RegularElement",
+ "start": 1407,
+ "end": 1424,
+ "name": "div",
+ "name_loc": {
+ "start": {
+ "line": 71,
+ "column": 2,
+ "character": 1408
+ },
+ "end": {
+ "line": 71,
+ "column": 5,
+ "character": 1411
+ }
+ },
+ "attributes": [],
+ "fragment": {
+ "type": "Fragment",
+ "nodes": [
+ {
+ "type": "Text",
+ "start": 1412,
+ "end": 1418,
+ "raw": "block1",
+ "data": "block1"
+ }
+ ]
+ }
+ },
+ {
+ "type": "Text",
+ "start": 1424,
+ "end": 1425,
+ "raw": "\n",
+ "data": "\n"
+ }
+ ]
+ }
+ }
+ ]
+ },
+ "options": null,
+ "comments": []
+}
diff --git a/tests/fixtures/svelte/elements/block_after_spaced_text_prettier_divergence/input.svelte b/tests/fixtures/svelte/elements/block_after_spaced_text_prettier_divergence/input.svelte
new file mode 100644
index 000000000..85fa10f44
--- /dev/null
+++ b/tests/fixtures/svelte/elements/block_after_spaced_text_prettier_divergence/input.svelte
@@ -0,0 +1,72 @@
+text1 text2
+<div>block1</div>
+
+<!--
+ A block element after spaced text takes its own line, whether the text is the fragment's
+ first child (above, at the root) or not, in every fragment family. Prettier hugs the block to
+ a FIRST-child text (`text1 text2 <div>block1</div>`) and breaks it after any other
+ predecessor (`prettier_variant_space.svelte`).
+-->
+
+<!-- a first-child text before a short block, in a block element, a section, an inline element,
+ a component and a block body -->
+<div>
+ text1 text2
+ <div>block1</div>
+</div>
+<section>
+ text1 text2
+ <p>block1</p>
+</section>
+<span>
+ text1 text2
+ <div>block1</div>
+</span>
+<Comp>
+ text1 text2
+ <div>block1</div>
+</Comp>
+{#if cond}
+ text1 text2
+ <div>block1</div>
+{/if}
+
+<!-- a one-word label before the block, and text on both sides of it -->
+<div>
+ text1
+ <div>block1</div>
+</div>
+<div>
+ text1 text2
+ <div>block1</div>
+ text3 text4
+</div>
+
+<!-- a block that renders multiline: its head never ends the text line -->
+<div>
+ text1 text2
+ <div>
+ <p>block1</p>
+ </div>
+</div>
+<Comp>
+ text1 text2
+ <div>
+ <p>block1</p>
+ </div>
+</Comp>
+
+<!-- controls, where both formatters break already: a text that is not the fragment's first
+ child (after an element, after a tag), and an element predecessor -->
+<div>
+ <span>inline1</span> text1 text2
+ <div>block1</div>
+</div>
+<div>
+ {expr} text1 text2
+ <div>block1</div>
+</div>
+<div>
+ <span>inline1</span>
+ <div>block1</div>
+</div>
diff --git a/tests/fixtures/svelte/elements/block_after_spaced_text_prettier_divergence/prettier_variant_space.svelte b/tests/fixtures/svelte/elements/block_after_spaced_text_prettier_divergence/prettier_variant_space.svelte
new file mode 100644
index 000000000..ce967d035
--- /dev/null
+++ b/tests/fixtures/svelte/elements/block_after_spaced_text_prettier_divergence/prettier_variant_space.svelte
@@ -0,0 +1,62 @@
+text1 text2 <div>block1</div>
+
+<!--
+ A block element after spaced text takes its own line, whether the text is the fragment's
+ first child (above, at the root) or not, in every fragment family. Prettier hugs the block to
+ a FIRST-child text (`text1 text2 <div>block1</div>`) and breaks it after any other
+ predecessor (`prettier_variant_space.svelte`).
+-->
+
+<!-- a first-child text before a short block, in a block element, a section, an inline element,
+ a component and a block body -->
+<div>
+ text1 text2 <div>block1</div>
+</div>
+<section>
+ text1 text2 <p>block1</p>
+</section>
+<span>
+ text1 text2 <div>block1</div>
+</span>
+<Comp>
+ text1 text2 <div>block1</div>
+</Comp>
+{#if cond}
+ text1 text2 <div>block1</div>
+{/if}
+
+<!-- a one-word label before the block, and text on both sides of it -->
+<div>
+ text1 <div>block1</div>
+</div>
+<div>
+ text1 text2 <div>block1</div>
+ text3 text4
+</div>
+
+<!-- a block that renders multiline: its head never ends the text line -->
+<div>
+ text1 text2 <div>
+ <p>block1</p>
+ </div>
+</div>
+<Comp>
+ text1 text2 <div>
+ <p>block1</p>
+ </div>
+</Comp>
+
+<!-- controls, where both formatters break already: a text that is not the fragment's first
+ child (after an element, after a tag), and an element predecessor -->
+<div>
+ <span>inline1</span> text1 text2
+ <div>block1</div>
+</div>
+<div>
+ {expr} text1 text2
+ <div>block1</div>
+</div>
+<div>
+ <span>inline1</span>
+ <div>block1</div>
+</div>
diff --git a/tests/fixtures/svelte/elements/block_after_spaced_text_prettier_divergence/unformatted_glued.svelte b/tests/fixtures/svelte/elements/block_after_spaced_text_prettier_divergence/unformatted_glued.svelte
new file mode 100644
index 000000000..f9511a219
--- /dev/null
+++ b/tests/fixtures/svelte/elements/block_after_spaced_text_prettier_divergence/unformatted_glued.svelte
@@ -0,0 +1,71 @@
+text1 text2
+<div>block1</div>
+
+<!--
+ A block element after spaced text takes its own line, whether the text is the fragment's
+ first child (above, at the root) or not, in every fragment family. Prettier hugs the block to
+ a FIRST-child text (`text1 text2 <div>block1</div>`) and breaks it after any other
+ predecessor (`prettier_variant_space.svelte`).
+-->
+
+<!-- a first-child text before a short block, in a block element, a section, an inline element,
+ a component and a block body -->
+<div>
+ text1 text2<div>block1</div>
+</div>
+<section>
+ text1 text2
+ <p>block1</p>
+</section>
+<span>
+ text1 text2
+ <div>block1</div>
+</span>
+<Comp>
+ text1 text2
+ <div>block1</div>
+</Comp>
+{#if cond}
+ text1 text2
+ <div>block1</div>
+{/if}
+
+<!-- a one-word label before the block, and text on both sides of it -->
+<div>
+ text1
+ <div>block1</div>
+</div>
+<div>
+ text1 text2
+ <div>block1</div>
+ text3 text4
+</div>
+
+<!-- a block that renders multiline: its head never ends the text line -->
+<div>
+ text1 text2
+ <div>
+ <p>block1</p>
+ </div>
+</div>
+<Comp>
+ text1 text2
+ <div>
+ <p>block1</p>
+ </div>
+</Comp>
+
+<!-- controls, where both formatters break already: a text that is not the fragment's first
+ child (after an element, after a tag), and an element predecessor -->
+<div>
+ <span>inline1</span> text1 text2
+ <div>block1</div>
+</div>
+<div>
+ {expr} text1 text2
+ <div>block1</div>
+</div>
+<div>
+ <span>inline1</span>
+ <div>block1</div>
+</div>
diff --git a/tests/fixtures/svelte/elements/mixed_space_before_block_prettier_divergence/README.md b/tests/fixtures/svelte/elements/mixed_space_before_block_prettier_divergence/README.md
new file mode 100644
index 000000000..068c5a15a
--- /dev/null
+++ b/tests/fixtures/svelte/elements/mixed_space_before_block_prettier_divergence/README.md
@@ -0,0 +1,17 @@
+# mixed_space_before_block_prettier_divergence
+
+A one-word text followed by a spaced block element: the block takes its own line
+(`text⏎<div>block</div>`). Prettier keeps the block hugged to the text when the text is the
+fragment's first child (`prettier_variant_space.svelte`); tsv normalizes that spelling, the
+compact authoring (`unformatted_ours_compact.svelte`) and the over-spaced one
+(`unformatted_ours_spaces.svelte`) to `input.svelte`, where prettier lands the latter two on its
+hugged form.
+
+## Reason
+
+Design choice — the one-word instance of
+[block_after_spaced_text](../block_after_spaced_text_prettier_divergence/): a block sibling's own
+break separates it from the text at every position of the text, so the space is spent on it.
+
+See
+[conformance_prettier_svelte.md §Svelte: Inline content block-style](../../../../../docs/conformance_prettier_svelte.md#svelte-inline-content-block-style).
diff --git a/tests/fixtures/svelte/elements/mixed_space_before_block/expected.json b/tests/fixtures/svelte/elements/mixed_space_before_block_prettier_divergence/expected.json
similarity index 75%
rename from tests/fixtures/svelte/elements/mixed_space_before_block/expected.json
rename to tests/fixtures/svelte/elements/mixed_space_before_block_prettier_divergence/expected.json
index bfed11d0d..cf4041518 100644
--- a/tests/fixtures/svelte/elements/mixed_space_before_block/expected.json
+++ b/tests/fixtures/svelte/elements/mixed_space_before_block_prettier_divergence/expected.json
@@ -2,7 +2,7 @@
"css": null,
"js": [],
"start": 0,
- "end": 36,
+ "end": 37,
"type": "Root",
"fragment": {
"type": "Fragment",
@@ -10,7 +10,7 @@
{
"type": "RegularElement",
"start": 0,
- "end": 35,
+ "end": 36,
"name": "div",
"name_loc": {
"start": {
@@ -31,25 +31,25 @@
{
"type": "Text",
"start": 5,
- "end": 12,
- "raw": "\n\ttext ",
- "data": "\n\ttext "
+ "end": 13,
+ "raw": "\n\ttext\n\t",
+ "data": "\n\ttext\n\t"
},
{
"type": "RegularElement",
- "start": 12,
- "end": 28,
+ "start": 13,
+ "end": 29,
"name": "div",
"name_loc": {
"start": {
- "line": 2,
- "column": 7,
- "character": 13
+ "line": 3,
+ "column": 2,
+ "character": 14
},
"end": {
- "line": 2,
- "column": 10,
- "character": 16
+ "line": 3,
+ "column": 5,
+ "character": 17
}
},
"attributes": [],
@@ -58,8 +58,8 @@
"nodes": [
{
"type": "Text",
- "start": 17,
- "end": 22,
+ "start": 18,
+ "end": 23,
"raw": "block",
"data": "block"
}
@@ -68,8 +68,8 @@
},
{
"type": "Text",
- "start": 28,
- "end": 29,
+ "start": 29,
+ "end": 30,
"raw": "\n",
"data": "\n"
}
diff --git a/tests/fixtures/svelte/elements/mixed_space_before_block_prettier_divergence/input.svelte b/tests/fixtures/svelte/elements/mixed_space_before_block_prettier_divergence/input.svelte
new file mode 100644
index 000000000..c47b5c55e
--- /dev/null
+++ b/tests/fixtures/svelte/elements/mixed_space_before_block_prettier_divergence/input.svelte
@@ -0,0 +1,4 @@
+<div>
+ text
+ <div>block</div>
+</div>
diff --git a/tests/fixtures/svelte/elements/mixed_space_before_block/input.svelte b/tests/fixtures/svelte/elements/mixed_space_before_block_prettier_divergence/prettier_variant_space.svelte
similarity index 100%
rename from tests/fixtures/svelte/elements/mixed_space_before_block/input.svelte
rename to tests/fixtures/svelte/elements/mixed_space_before_block_prettier_divergence/prettier_variant_space.svelte
diff --git a/tests/fixtures/svelte/elements/mixed_space_before_block/unformatted_compact.svelte b/tests/fixtures/svelte/elements/mixed_space_before_block_prettier_divergence/unformatted_ours_compact.svelte
similarity index 100%
rename from tests/fixtures/svelte/elements/mixed_space_before_block/unformatted_compact.svelte
rename to tests/fixtures/svelte/elements/mixed_space_before_block_prettier_divergence/unformatted_ours_compact.svelte
diff --git a/tests/fixtures/svelte/elements/mixed_space_before_block/unformatted_spaces.svelte b/tests/fixtures/svelte/elements/mixed_space_before_block_prettier_divergence/unformatted_ours_spaces.svelte
similarity index 100%
rename from tests/fixtures/svelte/elements/mixed_space_before_block/unformatted_spaces.svelte
rename to tests/fixtures/svelte/elements/mixed_space_before_block_prettier_divergence/unformatted_ours_spaces.svelte