diff --git a/CLAUDE.md b/CLAUDE.md
index 463bf9ca1..541cf9750 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -185,6 +185,8 @@ deno task binding:audit              # comment↔token binding audit: does forma
 deno task authoring:audit            # authoring-independence over Svelte boundary whitespace: every render-equivalent authoring of one document (hug ↔ space ↔ newline at a tag's content boundary; space ↔ newline between siblings) must reach ONE tsv fixed point (pure Rust, no sidecar; gated in `deno task check`) — exits 1 on any non-idempotency, site-level or a base-non-idempotent FILE; see Debug Tooling
 deno task fuzz:audit                 # seeded mutational fuzzer over tests/fixtures (fixed --seed 0 --iterations 5000; pure Rust, no sidecar; gated in `deno task check`) — asserts no-panic + idempotency + structural-reparse, on every seed file AS AUTHORED and then on mutated input; see Debug Tooling
 deno task comments:audit             # print-once comment ledger: every comment a document PARSES must be EMITTED exactly once (pure Rust, no sidecar; gated in `deno task check`) — reports DROPPED (silent content loss) and DOUBLE-PRINTED; the structural guard on the detached comment model, tsv's `ensureAllCommentsPrinted`; see Debug Tooling
+deno task gaps:audit                 # gap-injection audit: inject a comment into EVERY gap (five payloads, one per ownership path) and re-run the ledger — the discovery arm `comments:audit` can't be, since it only formats each file AS AUTHORED and no fixture covers most positions (eight such drops were found BY HAND, all green on every gate). Pure Rust, no sidecar; gated in `deno task check` as a RATCHET over a generated shape snapshot (`gap_audit_known.txt`): every line is a known bug and the file shrinking is the goal, so a shape not on the list, one on it that no longer fires, or any PANIC, FAILS. ~17 s. Full reference: ./docs/gap_audit.md
+deno task gaps:audit:update          # regenerate that snapshot after fixing a shape (or when a new fixture merely REACHES a pre-existing one); refuses a narrowed run
 deno task idempotency:sweep          # F1 (idempotency) sweep over the real-code corpus (the `perf` view — sibling dev repos + upstream framework source). NOT in `deno task check`: machine-dependent corpus, minutes not seconds. Run at conformance cadence or after a printer change; see Debug Tooling
 ```
 
@@ -882,6 +884,30 @@ cargo run -p tsv_debug --features comment_check comment_audit ~/dev/zzz/src   #
 # source), so they are outside the model by construction.
 ```
 
+**Gap-Injection Audit (dropped-comment discovery):**
+
+```bash
+# gap_audit - inject a comment into EVERY gap and re-run the print-once ledger. The
+# DISCOVERY arm `comments:audit` can't be: the ledger only ever sees a document AS
+# AUTHORED, so a gap no fixture puts a comment in is one it never checks (eight such
+# drops were found BY HAND, all green on every gate). Pure Rust, no sidecar.
+cargo run --profile corpus -p tsv_debug --features comment_check gap_audit   # tests/fixtures
+cargo run --profile corpus -p tsv_debug --features comment_check gap_audit ~/dev/zzz/src
+# Also: --json, --jobs N, --limit N, --payload <one>, --all-bytes, --update.
+# Build with `--profile corpus` (release + panic=unwind): plain `--release` is
+# panic=abort, so a formatter panic kills the process instead of being caught + reported.
+#
+# GATED as a RATCHET, not a green gate: `gap_audit_known.txt` is a machine-generated
+# snapshot of the ~717 shapes tests/fixtures produces, every line a KNOWN BUG, the file
+# shrinking is the goal. A shape not on the list, one on it that no longer fires, or any
+# PANIC, FAILS. `--limit`/`--payload`/`--all-bytes`/a path narrow a run, so they skip the
+# ratchet and refuse `--update`. ~17 s.
+```
+
+Full reference — flags, the ratchet, reading a finding, triage + re-pin workflow,
+scope: ./docs/gap_audit.md. Design rationale (why byte offsets and not tokens, why the
+ledger is the oracle, why five payloads) lives in the `gap_audit` module docs.
+
 **Build-Fanout Audit (exponential-rebuild regression guard):**
 
 ```bash
diff --git a/crates/tsv_debug/src/cli/commands/gap_audit.rs b/crates/tsv_debug/src/cli/commands/gap_audit.rs
new file mode 100644
index 000000000..2ece89117
--- /dev/null
+++ b/crates/tsv_debug/src/cli/commands/gap_audit.rs
@@ -0,0 +1,1937 @@
+//! Gap-injection audit — the mechanized form of hunting the dropped-comment class.
+//!
+//! ## Why this exists
+//!
+//! One recurring bug class: **a printer that concatenates fixed pieces without scanning
+//! the gaps between them silently DROPS any comment an author wrote in a gap.** A header
+//! built as `d.text("import.source(")` scans neither of its two dot gaps, so
+//! `import./* c */source(x)` loses the comment — no error, no diff, just gone.
+//!
+//! The print-once ledger ([`comment_ledger`]) would catch every one of these. It just
+//! never sees them: [`comment_audit`](super::comment_audit) formats each file **as
+//! authored**, and a gap only becomes a finding once a comment is actually *in* it. Eight
+//! such sites were found BY HAND, and every one was green on every gate — `cargo test`,
+//! `comments:audit`, `roundtrip:audit`, the corpus diff — purely because no fixture
+//! happened to put a comment in that position. The gates were not wrong; the corpus was
+//! silent.
+//!
+//! This audit closes that hole: for each seed file it injects a comment into **every**
+//! candidate gap, one at a time, formats, and runs the ledger over the result.
+//!
+//! ## Design
+//!
+//! Pure Rust, no sidecar, no new deps — the [`fuzz`](super::fuzz) /
+//! [`comment_audit`](super::comment_audit) direction. Deliberately **targeted, not
+//! random**: byte mutation would essentially never synthesize a valid comment in a dot
+//! gap, which is the whole point of the class.
+//!
+//! **Sites are byte offsets, not tokens.** A token-stream enumeration would need a flat
+//! Svelte token contract that doesn't exist — and `.svelte` is where this class lives,
+//! since TS-only syntax is fixtured as `.svelte` + `lang="ts"` (a TS-only audit reaches 53
+//! of 6,689 fixture files). Worse, it would carry exactly the blind spot the class
+//! exploits: a punctuator-joined header is a **zero-width** gap, the first thing a
+//! "between two tokens" abstraction elides. A byte offset has no such notion, so it cannot
+//! miss one.
+//!
+//! **But an offset must first be somewhere the payload IS a comment**, and tsv's own parser
+//! cannot answer that. It is deliberately more permissive than the canonical one, so
+//! "tsv accepted it" does not mean "an author could write it": tsv parses
+//! `<script lang="ts"/* c */>` — which Svelte rejects outright — lexes the `/* c */` in the
+//! tag as a comment, and drops it. Real content loss, but an *over-acceptance* bug, not
+//! this class; and `/* … */` is not a comment in Svelte markup under any reading, so
+//! injecting one there tests nothing while burying the report in shapes like `IDENT⟨⟩␣`.
+//!
+//! So sites come from [`code_regions`] — the spans the AST says are JS or CSS — and inside
+//! those two existing layers filter for free:
+//!
+//! - **inside a word** (`fo/* c */o` → `fo o`) — the parser rejects it, so the site is
+//!   skipped. Correctly: that gap exists in no real document.
+//! - **inside a string literal** (`"fo/* c */o"`) — parses, but the injected text is never
+//!   *lexed* as a comment, so the ledger registers nothing and reports nothing.
+//!
+//! And because the ledger asks only "was each comment printed exactly once?" — never "did
+//! the layout change?" — an injection that legitimately reflows the file, or even changes
+//! the program via ASI (`return// c⏎ x`), cannot produce a false positive. That is why the
+//! oracle here is the ledger and not an output diff.
+//!
+//! ## Scope — what a green run does NOT prove
+//!
+//! Two limits compose, and neither is visible in a `✓`.
+//!
+//! The audit inherits **the ledger's scope** exactly: only the **detached** comments a
+//! format entry registers. A Svelte `<!-- … -->` and a CSS in-block comment are AST nodes
+//! carried by the tree, and a CSS declaration's *value* comments are never lexed as
+//! `Comment`s at all — all outside the model by construction (see [`comment_ledger`]'s
+//! module docs). So this speaks for the detached-comment model — the class that bit us
+//! eight times — and not for CSS values. CSS also has no line comments, so the `line`
+//! payload is inert in a `.css` file (harmless: it simply never registers).
+//!
+//! It also inherits **[`code_regions`]' reach**: a gap the region walk doesn't name is a
+//! gap never probed. Today that means a `.svelte` file's `<style>` content and the
+//! non-expression interior of a block tag (the `{#if ⟨here⟩ a.b}` prefix) are unprobed —
+//! see that function's TODO.
+
+use argh::FromArgs;
+use std::collections::{BTreeMap, BTreeSet};
+use std::path::PathBuf;
+
+use crate::cli::CliError;
+use tsv_cli::cli::format_source::format_source;
+use tsv_cli::cli::input::ParserType;
+use tsv_lang::comment_ledger::{self, CommentFinding, CommentFindingKind};
+
+use super::profile::resolve_files;
+use super::roundtrip_audit::tsv_parse_to_value;
+
+/// Inject a comment into every gap and assert the print-once ledger still holds.
+///
+/// For each seed file, injects each payload at each candidate byte offset (one at a time),
+/// formats, and reports every comment the format DROPPED or DOUBLE-PRINTED. Pure Rust — no
+/// Deno. Defaults to `tests/fixtures`; the real yield is external corpora. Exits 1 on any
+/// finding.
+#[derive(FromArgs, Debug)]
+#[argh(subcommand, name = "gap_audit")]
+#[allow(clippy::struct_excessive_bools)] // independent CLI flags
+pub struct GapAuditCommand {
+    /// emit JSON
+    #[argh(switch)]
+    json: bool,
+
+    /// print the full per-shape report even when the ratchet holds. A passing gate is
+    /// summary-only by default — ~700 shapes it already knows about is noise in
+    /// `deno task check`. Any run with something to act on reports regardless
+    #[argh(switch)]
+    report: bool,
+
+    /// inject at EVERY char boundary, including positions strictly inside a word.
+    /// A diagnostic, not a stricter mode: it does surface extra shapes, but on the
+    /// corpus they are artifacts of mutilating an existing comment, not gap bugs
+    /// (see `injection_sites`)
+    #[argh(switch)]
+    all_bytes: bool,
+
+    /// only inject this payload (block | line | jsdoc_cast | annotation | multiline);
+    /// default: all five
+    #[argh(option)]
+    payload: Option<String>,
+
+    /// worker threads (default: available parallelism). Each file's whole inject
+    /// loop stays on one thread — the ledger is thread-local
+    #[argh(option)]
+    jobs: Option<usize>,
+
+    /// cap the number of seed files (0 = unlimited)
+    #[argh(option, default = "0")]
+    limit: usize,
+
+    /// rewrite the committed shape snapshot from this run. Only valid on a FULL default
+    /// run — the snapshot describes every payload over `tests/fixtures` and nothing else,
+    /// so any narrowing flag is refused rather than silently pinning a partial set
+    #[argh(switch)]
+    update: bool,
+
+    /// seed file paths / directories (default: tests/fixtures)
+    #[argh(positional)]
+    paths: Vec<String>,
+}
+
+/// One injected comment shape.
+///
+/// Each drives a **distinct path** through the ownership model (root `CLAUDE.md` §Comment
+/// Handling), so a drop can live on one and not the others — which is the whole reason the
+/// payload set is plural rather than just a block comment.
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug)]
+enum Payload {
+    /// A plain glued block comment — `owned_by_node`, printed by the innermost node its
+    /// token begins rather than by the enclosing gap.
+    Block,
+    /// A line comment — never owned (`owned ⇒ is_block`), and rides the `line_suffix`
+    /// hoist-to-EOL path instead.
+    Line,
+    /// A JSDoc type cast — the **one** remaining content sniff
+    /// (`is_jsdoc_type_cast_comment`), which governs paren retention by building a
+    /// `JsdocCast` node that prints the comment itself.
+    JsdocCast,
+    /// A bundler annotation — owned exactly like any other glued block comment (no sniff).
+    /// Called out because losing one is silently *semantic*: the marked call stops being
+    /// droppable.
+    Annotation,
+    /// A multi-line block comment — sets `Comment::multiline`, the precomputed flag every
+    /// multi-line-block expansion gate reads.
+    Multiline,
+}
+
+impl Payload {
+    const ALL: [Payload; 5] = [
+        Self::Block,
+        Self::Line,
+        Self::JsdocCast,
+        Self::Annotation,
+        Self::Multiline,
+    ];
+
+    /// The exact text injected.
+    fn text(self) -> &'static str {
+        match self {
+            // A trailing newline, so the payload comments out only itself and not the
+            // rest of the author's line — `x// c⏎ + 1` is a line comment in a gap, while
+            // `x// c + 1` is a line comment that ate an operand.
+            Self::Line => "// c\n",
+            Self::Block => "/* c */",
+            Self::JsdocCast => "/** @type {T} */",
+            Self::Annotation => "/* @__PURE__ */",
+            Self::Multiline => "/* a\nb */",
+        }
+    }
+
+    fn label(self) -> &'static str {
+        match self {
+            Self::Block => "block",
+            Self::Line => "line",
+            Self::JsdocCast => "jsdoc_cast",
+            Self::Annotation => "annotation",
+            Self::Multiline => "multiline",
+        }
+    }
+
+    fn from_label(s: &str) -> Option<Self> {
+        Self::ALL.into_iter().find(|p| p.label() == s)
+    }
+}
+
+/// The committed snapshot of every finding shape `tests/fixtures` currently produces —
+/// the ratchet `deno task check` gates on.
+///
+/// **Machine-generated** (`deno task gaps:audit:update`), unlike
+/// [`scan_audit`](super::scan_audit)'s hand-curated `ALLOW`: at ~700 shapes a per-entry
+/// rationale is not a thing a human can keep honest, so this deliberately carries none. It
+/// is a ratchet, not a sanction — every line is a **known bug**, and the file shrinking is
+/// the goal.
+///
+/// What it buys: a shape that is not on the list fails the gate, so no *new* kind of drop
+/// lands silently. What it does not: a new drop at an **existing** shape is invisible (the
+/// key is the shape, not the count — counts churn with every ordinary fixture PR, and a
+/// gate that fails per added fixture would just be turned off). Fixing a shape must remove
+/// its line; a stale entry fails the gate too, so the list can't rot.
+const KNOWN_SHAPES: &str = include_str!("gap_audit_known.txt");
+
+/// Where [`KNOWN_SHAPES`] lives, for `--update` to rewrite.
+fn known_shapes_path() -> PathBuf {
+    PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("src/cli/commands/gap_audit_known.txt")
+}
+
+/// One snapshot line: what the ratchet actually pins.
+///
+/// The payload set is part of the key, not decoration. A shape that drops only a `line`
+/// comment today and starts dropping a `block` one tomorrow is a **new bug on a new
+/// ownership path** — keyed on the shape alone it would land inside an existing entry and
+/// never be seen. It is also stable in the way a count is not: it changes when the bug's
+/// character changes, not when a fixture is added.
+type KnownKey = (String, String, String);
+
+/// Render a payload set into its snapshot column.
+fn payload_column(payloads: &BTreeSet<&'static str>) -> String {
+    payloads.iter().copied().collect::<Vec<_>>().join(",")
+}
+
+/// Whether a shape is something the snapshot may pin — everything but a [`Kind::Panic`].
+///
+/// A panic is not a "known bug" to ratchet alongside the drops. The invariant it breaks is
+/// **absolute** (a comment in a gap must never crash the formatter), so it always fails the
+/// gate and is never pinnable — otherwise `--update` would quietly absorb a crash into the
+/// same list whose shrinking is the goal. [`render_known`] and [`found_keys`] share this
+/// filter so the two stay in lockstep: a panic can't be written, so it can never read back
+/// as stale.
+fn is_pinnable(kind: Kind) -> bool {
+    kind != Kind::Panic
+}
+
+/// How many of `shapes` crash the formatter — the shapes [`is_pinnable`] keeps out of the
+/// snapshot, and which therefore need their own accounting on every exit path.
+fn count_panics(shapes: &BTreeMap<(Kind, String), ShapeAgg>) -> usize {
+    shapes.keys().filter(|(k, _)| *k == Kind::Panic).count()
+}
+
+/// What the ratchet found, computed **before** anything prints.
+///
+/// Grading is split from reporting for one reason: a ratchet that holds has nothing to act
+/// on, so printing its ~700 known shapes is thousands of lines of noise inside
+/// `deno task check` — and whether it holds is only knowable after the diff. Deciding first
+/// lets a clean gate print a summary instead.
+struct GateDiff {
+    /// How many shapes the snapshot pins — the denominator in the ✓ line.
+    known: usize,
+    /// Shapes the snapshot has never seen: a new kind of drop.
+    new: Vec<KnownKey>,
+    /// Pinned shapes that no longer fire — a fixed bug, or a rotting list.
+    stale: Vec<KnownKey>,
+    /// Crashes. Never pinned (see [`is_pinnable`]), so they are graded on their own.
+    panics: usize,
+}
+
+impl GateDiff {
+    fn holds(&self) -> bool {
+        self.new.is_empty() && self.stale.is_empty() && self.panics == 0
+    }
+}
+
+/// Diff a run's shapes against the committed snapshot. Pure — it prints nothing and decides
+/// nothing; see [`GateDiff`].
+fn grade_against_snapshot(shapes: &BTreeMap<(Kind, String), ShapeAgg>) -> GateDiff {
+    let known = parse_known();
+    let found = found_keys(shapes);
+    GateDiff {
+        new: found.difference(&known).cloned().collect(),
+        stale: known.difference(&found).cloned().collect(),
+        panics: count_panics(shapes),
+        known: known.len(),
+    }
+}
+
+/// Parse the snapshot into its keys.
+fn parse_known() -> BTreeSet<KnownKey> {
+    KNOWN_SHAPES
+        .lines()
+        .map(str::trim_end)
+        .filter(|l| !l.is_empty() && !l.starts_with('#'))
+        .filter_map(|l| {
+            let mut cols = l.split('\t');
+            let kind = cols.next()?.to_string();
+            let shape = cols.next()?.to_string();
+            let payloads = cols.next()?.to_string();
+            Some((kind, shape, payloads))
+        })
+        .collect()
+}
+
+/// The keys a run's shapes produce — the pinnable ones (see [`is_pinnable`]).
+fn found_keys(shapes: &BTreeMap<(Kind, String), ShapeAgg>) -> BTreeSet<KnownKey> {
+    shapes
+        .iter()
+        .filter(|((kind, _), _)| is_pinnable(*kind))
+        .map(|((kind, shape), agg)| {
+            (
+                kind.label().to_string(),
+                shape.clone(),
+                payload_column(&agg.payloads),
+            )
+        })
+        .collect()
+}
+
+/// Render the snapshot file for `shapes`.
+fn render_known(shapes: &BTreeMap<(Kind, String), ShapeAgg>) -> String {
+    let mut out = String::new();
+    out.push_str(
+        "# Generated by `deno task gaps:audit:update` — do NOT hand-edit.\n\
+         #\n\
+         # Every line is a KNOWN BUG: a site shape where injecting a comment makes the\n\
+         # formatter drop or double-print one. The gate fails on a line that is NOT here\n\
+         # (a new kind of drop) and on a line here that no longer fires (a stale entry —\n\
+         # delete it when you fix one). Counts are deliberately not pinned: they churn with\n\
+         # every ordinary fixture PR, and a gate that fails per added fixture gets turned\n\
+         # off. The PAYLOAD set is pinned, though: a shape that starts dropping a comment\n\
+         # kind it used to survive is a new bug on a new ownership path.\n\
+         #\n\
+         # A PANIC is never listed here — that invariant is absolute, so it always fails\n\
+         # the gate rather than being pinned.\n\
+         #\n\
+         # Format: KIND<TAB>SHAPE<TAB>PAYLOADS\n",
+    );
+    for ((kind, shape), agg) in shapes.iter().filter(|((k, _), _)| is_pinnable(*k)) {
+        out.push_str(kind.label());
+        out.push('\t');
+        out.push_str(shape);
+        out.push('\t');
+        out.push_str(&payload_column(&agg.payloads));
+        out.push('\n');
+    }
+    out
+}
+
+/// Whether `c` can sit inside an identifier — the site filter's notion of "in a word".
+fn is_word(c: char) -> bool {
+    c.is_alphanumeric() || c == '_' || c == '$'
+}
+
+/// `(start, end)` of a wire node, when it carries a span — in the wire's own position
+/// space, **not** bytes. See [`Utf16ToByte`].
+fn span_of(node: &serde_json::Value) -> Option<(usize, usize)> {
+    let s = node.get("start")?.as_u64()? as usize;
+    let e = node.get("end")?.as_u64()? as usize;
+    (e >= s).then_some((s, e))
+}
+
+/// Translates the wire AST's positions into byte offsets.
+///
+/// The wire emits **UTF-16 code-unit** offsets (`tsv_lang::location::ByteToCharMap`), not
+/// byte offsets — they coincide on ASCII and diverge the moment a file holds a `é` or an
+/// emoji. Slicing `source` with a raw wire offset is then off by the multi-byte count:
+/// wrong regions, or a panic on a non-char-boundary. Nothing downstream can catch that —
+/// an ASCII-only corpus grades identical either way — so the map is unit-tested against a
+/// direct `char_indices` walk instead.
+struct Utf16ToByte {
+    /// `None` for an all-ASCII source, where the two spaces are identical and the table is
+    /// pure overhead (the overwhelmingly common case).
+    table: Option<Vec<usize>>,
+    len: usize,
+}
+
+impl Utf16ToByte {
+    fn new(source: &str) -> Self {
+        if source.is_ascii() {
+            return Self {
+                table: None,
+                len: source.len(),
+            };
+        }
+        // One entry per UTF-16 code unit; an astral char spans two units and both map to
+        // the char's byte start, so a boundary offset always lands on a char boundary.
+        let mut table = Vec::with_capacity(source.len() + 1);
+        for (byte, ch) in source.char_indices() {
+            for _ in 0..ch.len_utf16() {
+                table.push(byte);
+            }
+        }
+        table.push(source.len());
+        Self {
+            table: Some(table),
+            len: source.len(),
+        }
+    }
+
+    /// The byte offset for a wire offset, or `None` if it is out of range.
+    fn byte(&self, wire: usize) -> Option<usize> {
+        match &self.table {
+            None => (wire <= self.len).then_some(wire),
+            Some(t) => t.get(wire).copied(),
+        }
+    }
+}
+
+/// Collect the ranges the payload would actually be **lexed as a comment** in.
+///
+/// For a `.ts` / `.css` file that is the whole file. For `.svelte` it must be asked of the
+/// AST, because the markup around the code is *not* a comment context — see the module docs
+/// on why tsv's own acceptance can't be used for this.
+///
+/// Two carriers, both read straight off the wire shape rather than by scanning source:
+/// a `Script`'s `content` (the `Program` span is exactly the `>`-to-`</script>` region),
+/// and an `ExpressionTag`'s brace interior (`{ /* c */ x.y }` is legal).
+///
+/// TODO: `<style>` content and the non-expression interior of a block tag (`{#if ⟨here⟩
+/// a.b}`) are not yet named, so no comment is ever probed there. The block-tag prefix needs
+/// the tag's own span rather than its expression's; `<style>` needs the `StyleSheet`'s
+/// content region, which the wire shape only gives via its children's extent.
+fn code_regions(source: &str, parser: ParserType) -> Vec<(usize, usize)> {
+    match parser {
+        ParserType::TypeScript | ParserType::Css => vec![(0, source.len())],
+        ParserType::Svelte => {
+            let Some(wire) = tsv_parse_to_value(source, parser) else {
+                return Vec::new();
+            };
+            let mut wire_spans = Vec::new();
+            collect_regions(&wire, &mut wire_spans);
+            let map = Utf16ToByte::new(source);
+            let byte_spans = wire_spans
+                .into_iter()
+                .filter_map(|(s, e)| Some((map.byte(s)?, map.byte(e)?)))
+                .collect();
+            merge_regions(byte_spans)
+        }
+    }
+}
+
+/// Walk the wire AST accumulating [`code_regions`]' carriers.
+fn collect_regions(node: &serde_json::Value, out: &mut Vec<(usize, usize)>) {
+    match node {
+        serde_json::Value::Object(obj) => {
+            match obj.get("type").and_then(serde_json::Value::as_str) {
+                Some("Script") => {
+                    if let Some(span) = obj.get("content").and_then(span_of) {
+                        out.push(span);
+                    }
+                }
+                // The braces themselves aren't a comment context; their interior is.
+                Some("ExpressionTag") => {
+                    if let Some((s, e)) = span_of(node)
+                        && e > s + 1
+                    {
+                        out.push((s + 1, e - 1));
+                    }
+                }
+                _ => {}
+            }
+            for (k, v) in obj {
+                if k != "loc" {
+                    collect_regions(v, out);
+                }
+            }
+        }
+        serde_json::Value::Array(items) => {
+            for v in items {
+                collect_regions(v, out);
+            }
+        }
+        _ => {}
+    }
+}
+
+/// Sort and coalesce overlapping/adjacent ranges, so a site is never injected twice.
+fn merge_regions(mut regions: Vec<(usize, usize)>) -> Vec<(usize, usize)> {
+    regions.sort_unstable();
+    let mut merged: Vec<(usize, usize)> = Vec::with_capacity(regions.len());
+    for (s, e) in regions {
+        match merged.last_mut() {
+            Some(last) if s <= last.1 => last.1 = last.1.max(e),
+            _ => merged.push((s, e)),
+        }
+    }
+    merged
+}
+
+/// The byte offsets to inject at: every `char` boundary within a code region, minus the
+/// ones strictly **inside a word**.
+///
+/// The word filter keeps every punctuator- and whitespace-adjacent offset, so `describe`
+/// `.` `only` retains **both** dot gaps — the exact positions the class hides in — while the
+/// two word interiors go. Splitting `describe` into `desc/* c */ribe` probes a gap that
+/// exists in no real document. Worth ~2.2× on real source.
+///
+/// **It is a heuristic, not a proof, and `--all-bytes` disagrees with it.** On the corpus
+/// the extra sites yield a handful of extra shapes, and every one inspected was an artifact
+/// of injecting *into an existing comment's text* — `// after empty i⟨⟩nit` with the `line`
+/// payload terminates the author's comment early and turns `nit` into code, which then reads
+/// as that comment being dropped. Junk, correctly excluded, but by accident: the filter
+/// screens word interiors and comment prose is mostly words.
+///
+/// TODO: exclude sites inside an existing comment's span outright. The word filter misses
+/// the punctuator boundaries within one (`/* c1 ⟨⟩*/`), so that artifact class is only
+/// mostly suppressed. It needs the parsed comment list, which the ledger holds but does not
+/// expose.
+fn injection_sites(source: &str, regions: &[(usize, usize)], all_bytes: bool) -> Vec<usize> {
+    let mut sites = Vec::new();
+    for &(start, end) in regions {
+        let mut prev: Option<char> = source[..start].chars().next_back();
+        // Inclusive of `end`: the last offset of a region is a gap like any other (the
+        // position just before `</script>` is where a trailing comment goes).
+        for (i, ch) in source[start..end].char_indices() {
+            if all_bytes || !(prev.is_some_and(is_word) && is_word(ch)) {
+                sites.push(start + i);
+            }
+            prev = Some(ch);
+        }
+        let tail_is_word = source[end..].chars().next().is_some_and(is_word);
+        if all_bytes || !(prev.is_some_and(is_word) && tail_is_word) {
+            sites.push(end);
+        }
+    }
+    sites
+}
+
+/// Words kept verbatim in a [`site_shape`] rather than abstracted to `IDENT`.
+///
+/// Heuristic and deliberately generous: a shape is a **report/dedup key**, not a parse. The
+/// point is that `import⟨⟩.` and `IDENT⟨⟩.` name different bugs — the meta-property/import-
+/// phase header versus every member access in the corpus — so a keyword that heads a
+/// concatenated construct must survive. `source` / `defer` / `meta` / `target` are here for
+/// exactly that reason despite being contextual keywords.
+const SHAPE_KEYWORDS: &[&str] = &[
+    "abstract",
+    "as",
+    "async",
+    "await",
+    "break",
+    "case",
+    "catch",
+    "class",
+    "const",
+    "constructor",
+    "continue",
+    "declare",
+    "default",
+    "defer",
+    "delete",
+    "do",
+    "else",
+    "enum",
+    "export",
+    "extends",
+    "finally",
+    "for",
+    "from",
+    "function",
+    "get",
+    "global",
+    "if",
+    "implements",
+    "import",
+    "in",
+    "infer",
+    "instanceof",
+    "interface",
+    "is",
+    "keyof",
+    "let",
+    "meta",
+    "module",
+    "namespace",
+    "new",
+    "of",
+    "out",
+    "private",
+    "protected",
+    "public",
+    "readonly",
+    "require",
+    "return",
+    "satisfies",
+    "set",
+    "source",
+    "static",
+    "super",
+    "switch",
+    "target",
+    "this",
+    "throw",
+    "try",
+    "type",
+    "typeof",
+    "unique",
+    "var",
+    "void",
+    "while",
+    "yield",
+];
+
+/// The word ending at `end`, or `None` when the char before `end` isn't identifier-ish.
+fn word_before(source: &str, end: usize) -> Option<&str> {
+    let start = source[..end]
+        .char_indices()
+        .rev()
+        .take_while(|(_, c)| is_word(*c))
+        .map(|(i, _)| i)
+        .last()?;
+    Some(&source[start..end])
+}
+
+/// The word starting at `start`, or `None` when the char at `start` isn't identifier-ish.
+fn word_after(source: &str, start: usize) -> Option<&str> {
+    let len: usize = source[start..]
+        .chars()
+        .take_while(|c| is_word(*c))
+        .map(char::len_utf8)
+        .sum();
+    (len > 0).then(|| &source[start..start + len])
+}
+
+/// Render one side of a shape: a keyword verbatim, any other word as `IDENT`.
+fn shape_word(w: &str) -> String {
+    if SHAPE_KEYWORDS.contains(&w) {
+        w.to_string()
+    } else if w.chars().next().is_some_and(|c| c.is_ascii_digit()) {
+        "NUM".to_string()
+    } else {
+        "IDENT".to_string()
+    }
+}
+
+/// The non-word, non-whitespace run (a punctuator) ending at `end`, capped at 3 chars.
+fn punct_before(source: &str, end: usize) -> String {
+    let s: String = source[..end]
+        .chars()
+        .rev()
+        .take_while(|c| !is_word(*c) && !c.is_whitespace())
+        .take(3)
+        .collect();
+    s.chars().rev().collect()
+}
+
+/// The non-word, non-whitespace run (a punctuator) starting at `start`, capped at 3 chars.
+fn punct_after(source: &str, start: usize) -> String {
+    source[start..]
+        .chars()
+        .take_while(|c| !is_word(*c) && !c.is_whitespace())
+        .take(3)
+        .collect()
+}
+
+/// A compact, **file-independent** name for an injection position: the source token on
+/// each side, with identifiers abstracted.
+///
+/// This is the dedup key of the whole report. One bug fires at every site that reaches it —
+/// a member-access drop would land thousands of times across the corpus — so raw
+/// `(file, offset)` findings are unreadable and, as a ratchet key, would go stale on the
+/// next fixture edit. A shape collapses those to one line: `import⟨⟩.`, `IDENT⟨⟩=`,
+/// `.⟨⟩IDENT`. Whitespace is elided rather than represented, since a gap's *width* is not
+/// what distinguishes the position.
+fn site_shape(source: &str, offset: usize) -> String {
+    let before = word_before(source, offset).map_or_else(
+        || {
+            let p = punct_before(source, offset);
+            if p.is_empty() { "␣".to_string() } else { p }
+        },
+        shape_word,
+    );
+    let after = word_after(source, offset).map_or_else(
+        || {
+            let p = punct_after(source, offset);
+            if p.is_empty() { "␣".to_string() } else { p }
+        },
+        shape_word,
+    );
+    format!("{before}⟨⟩{after}")
+}
+
+/// A readable source window around an injection point — the eyeball companion to the
+/// abstracted [`site_shape`], so a finding can be reproduced by hand.
+fn snippet(source: &str, offset: usize) -> String {
+    let lo = (0..=offset)
+        .rev()
+        .find(|i| source.is_char_boundary(*i) && offset - i >= 28)
+        .unwrap_or(0);
+    let hi = (offset..=source.len())
+        .find(|i| source.is_char_boundary(*i) && i - offset >= 28)
+        .unwrap_or(source.len());
+    let one_line = |s: &str| s.replace('\n', "⏎").replace('\t', "→");
+    format!(
+        "{}⟨⟩{}",
+        one_line(&source[lo..offset]),
+        one_line(&source[offset..hi])
+    )
+}
+
+/// Why a site is a finding. `Dropped`/`DoublePrinted` mirror the ledger; `Panic` is this
+/// audit's own (a comment in a gap must never crash the formatter).
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug)]
+enum Kind {
+    Dropped,
+    DoublePrinted,
+    Panic,
+}
+
+impl Kind {
+    fn label(self) -> &'static str {
+        match self {
+            Self::Dropped => "DROPPED",
+            Self::DoublePrinted => "DOUBLE-PRINTED",
+            Self::Panic => "PANIC",
+        }
+    }
+}
+
+/// One reproducible instance of a shape — everything needed to re-create the finding by
+/// hand, and nothing else.
+///
+/// Kept as a unit rather than as loose `example_*` fields on [`ShapeAgg`], because they are
+/// only meaningful together: [`Self::payload`] at [`Self::offset`] in [`Self::path`] is a
+/// *triple*, and mixing one shape's offset with another's payload reproduces nothing.
+#[derive(Clone)]
+struct Example {
+    /// The payload that produced **this** example. Distinct from [`ShapeAgg::payloads`],
+    /// which is the union over every hit: re-injecting some other payload of the union at
+    /// this offset need not fire, or even parse.
+    payload: &'static str,
+    path: String,
+    offset: usize,
+    snippet: String,
+    /// The offending comment's text — the injected payload only when [`Self::injected`].
+    text: String,
+    /// Whether the offending comment is the injected one rather than a bystander the
+    /// injection knocked out.
+    injected: bool,
+}
+
+impl Example {
+    /// The tie-break that makes the chosen example **thread-count independent**.
+    ///
+    /// Threads take files by stride, so which one first sees a shape depends on `--jobs`;
+    /// picking the smallest `(path, offset)` instead of "whoever merged first" keeps a
+    /// report (and any diff of one) stable across `--jobs 1` and `--jobs 12`.
+    fn sort_key(&self) -> (&str, usize) {
+        (&self.path, self.offset)
+    }
+}
+
+/// Everything a shape accumulates. Counts stay exact; only one example is kept, so a
+/// corpus that fires a bug a million times still reports in constant memory.
+#[derive(Clone)]
+struct ShapeAgg {
+    count: usize,
+    /// Which payloads reach this shape — a drop on `line` but not `block` is a different
+    /// bug from one on both, so this is part of the ratchet key.
+    payloads: BTreeSet<&'static str>,
+    /// Hits where the offending comment is a **bystander** — a comment the author already
+    /// had, knocked out by an injection elsewhere. Tracked apart from the total because it
+    /// is the scarier half: an existing comment vanishing because someone added another one
+    /// nearby.
+    bystander_hits: usize,
+    /// Distinct seed files the shape fired in — separates "one weird fixture" from
+    /// "everything with a dot in it". Bounded by the corpus, and shapes are few.
+    files: BTreeSet<String>,
+    example: Example,
+    /// The in-run self-verification verdict — `None` until the verify pass runs.
+    verdict: Option<Verdict>,
+}
+
+/// Whether a shape's example survives an **observational** re-check, independent of the
+/// ledger that reported it.
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+enum Verdict {
+    /// Re-formatting really does lose (or duplicate) a comment. The ledger's claim is
+    /// visible in the output.
+    Confirmed,
+    /// The ledger says a comment was never emitted, yet the output holds just as many
+    /// comments as its input. Something printed it without recording the emit — or printed
+    /// a *mangled* rebuild of it (`/* a⏎b */` → `/* ab */`, one comment either way). Real
+    /// either way, but not the plain drop it is filed as.
+    Unconfirmed,
+}
+
+/// One thread's slice of the work.
+#[derive(Default)]
+struct Tally {
+    shapes: BTreeMap<(Kind, String), ShapeAgg>,
+    sites: usize,
+    injections: usize,
+    accepted: usize,
+    files_done: usize,
+    parse_skipped: usize,
+    /// Files already non-clean before injection — reported, never injected into (see
+    /// [`audit_file`]).
+    dirty_files: Vec<String>,
+}
+
+/// One finding at one site, before aggregation into its [`ShapeAgg`].
+struct Hit<'a> {
+    kind: Kind,
+    payload: Payload,
+    path: &'a str,
+    /// The seed source — the shape and snippet are derived from it, so the caller never
+    /// computes them for a site that turns out not to fire.
+    source: &'a str,
+    offset: usize,
+    /// The offending comment's text, which is the *injected* payload only when
+    /// [`Self::injected`] holds.
+    text: String,
+    /// Whether the offending comment is the injected one rather than a bystander.
+    injected: bool,
+}
+
+impl Tally {
+    fn record(&mut self, hit: Hit<'_>) {
+        let shape = site_shape(hit.source, hit.offset);
+        let candidate = Example {
+            payload: hit.payload.label(),
+            path: hit.path.to_string(),
+            offset: hit.offset,
+            snippet: snippet(hit.source, hit.offset),
+            text: hit.text,
+            injected: hit.injected,
+        };
+        let e = self
+            .shapes
+            .entry((hit.kind, shape))
+            .or_insert_with(|| ShapeAgg {
+                count: 0,
+                payloads: BTreeSet::new(),
+                bystander_hits: 0,
+                files: BTreeSet::new(),
+                example: candidate.clone(),
+                verdict: None,
+            });
+        e.count += 1;
+        if !hit.injected {
+            e.bystander_hits += 1;
+        }
+        e.payloads.insert(hit.payload.label());
+        e.files.insert(hit.path.to_string());
+        if candidate.sort_key() < e.example.sort_key() {
+            e.example = candidate;
+        }
+    }
+
+    fn merge(&mut self, other: Tally) {
+        self.sites += other.sites;
+        self.injections += other.injections;
+        self.accepted += other.accepted;
+        self.files_done += other.files_done;
+        self.parse_skipped += other.parse_skipped;
+        self.dirty_files.extend(other.dirty_files);
+        for (k, v) in other.shapes {
+            match self.shapes.get_mut(&k) {
+                Some(e) => {
+                    e.count += v.count;
+                    e.bystander_hits += v.bystander_hits;
+                    e.payloads.extend(v.payloads);
+                    e.files.extend(v.files);
+                    // Smallest (path, offset) wins, NOT whoever merged first — see
+                    // `Example::sort_key`.
+                    if v.example.sort_key() < e.example.sort_key() {
+                        e.example = v.example;
+                    }
+                }
+                None => {
+                    self.shapes.insert(k, v);
+                }
+            }
+        }
+    }
+}
+
+/// What one ledger-armed format did.
+enum Formatted {
+    /// The parser or printer panicked — a finding in its own right (a comment in a gap
+    /// must never crash the formatter).
+    Panicked,
+    /// The source did not parse, so the injection is not a legal comment here. The
+    /// overwhelmingly common case, and **not** a finding: it means the offset names no gap.
+    Rejected,
+    /// Formatted.
+    Ok {
+        /// The ledger's findings — normally empty.
+        findings: Vec<CommentFinding>,
+        /// How many comments the document registered. Doubles as a needle-free "how many
+        /// comments are in this text" measure: `ledger_format(text).parsed` counts them
+        /// with the real lexer, so [`verify_example`] never has to string-match a comment
+        /// whose text the printer may legitimately re-indent.
+        parsed: usize,
+        /// The formatted text, already built by `format_source` — free to carry.
+        output: String,
+    },
+}
+
+/// Format `src` with the ledger armed and drain it.
+///
+/// Drains on every path, including the failing ones: the ledger is thread-local and keyed
+/// on source identity, so a straggler left by a rejected parse could otherwise be attributed
+/// to the next injection.
+fn ledger_format(src: &str, parser: ParserType) -> Formatted {
+    let _ = comment_ledger::take_comment_ledger();
+    let result =
+        std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| format_source(src, parser)));
+    match result {
+        Err(_) => {
+            let _ = comment_ledger::take_comment_ledger();
+            Formatted::Panicked
+        }
+        Ok(Err(_)) => {
+            let _ = comment_ledger::take_comment_ledger();
+            Formatted::Rejected
+        }
+        Ok(Ok(output)) => {
+            let ledger = comment_ledger::take_comment_ledger();
+            Formatted::Ok {
+                findings: ledger.findings,
+                parsed: ledger.parsed,
+                output,
+            }
+        }
+    }
+}
+
+/// Re-derive a finding's **observable** claim, independently of the ledger that made it.
+///
+/// The ledger is an instrument, and an instrument that only ever agrees with itself is not
+/// evidence — every mistake found while building this audit was of exactly that shape (a
+/// stale needle, a char-vs-byte offset, checking the injected comment when the finding was
+/// about a bystander). So each shape's example is re-run and the ledger is made to *predict*
+/// something falsifiable: if it says this format drops `d` comments and double-prints `p`,
+/// then the output must reparse to exactly `parsed - d + p` comments. Anything else means
+/// the ledger's account and the actual output disagree.
+///
+/// Counting via a reparse rather than by matching the comment's text is what makes this
+/// sound: a printer may legitimately re-indent a multi-line comment, so text matching
+/// produces false alarms, while the count is exact. It is also what leaves the
+/// [`Verdict::Unconfirmed`] bucket meaningful — a *mangled* rebuild is still one comment, so
+/// it shows up as "the ledger says dropped but nothing is missing", which is precisely the
+/// signal wanted.
+///
+/// The residual blind spot, named rather than hidden: counts can balance. A format that
+/// drops one comment and duplicates another nets to zero and reads as confirmed-ish. No
+/// example in the corpus does this today, and the per-shape example is a sample of the
+/// shape's hits, never a proof about all of them.
+fn verify_example(agg: &ShapeAgg, kind: Kind, parser: ParserType) -> Verdict {
+    // A panic is self-evident: it either happens or it doesn't, and it was caught to get here.
+    if kind == Kind::Panic {
+        return Verdict::Confirmed;
+    }
+    let Ok(source) = std::fs::read_to_string(&agg.example.path) else {
+        return Verdict::Unconfirmed;
+    };
+    let Some(payload) = Payload::from_label(agg.example.payload) else {
+        return Verdict::Unconfirmed;
+    };
+    let offset = agg.example.offset;
+    if offset > source.len() || !source.is_char_boundary(offset) {
+        return Verdict::Unconfirmed;
+    }
+    let mut injected = String::with_capacity(source.len() + 24);
+    injected.push_str(&source[..offset]);
+    injected.push_str(payload.text());
+    injected.push_str(&source[offset..]);
+
+    let Formatted::Ok {
+        findings,
+        parsed,
+        output,
+    } = ledger_format(&injected, parser)
+    else {
+        return Verdict::Unconfirmed;
+    };
+    if findings.is_empty() {
+        // The example no longer fires at all — the ledger and the re-run disagree outright.
+        return Verdict::Unconfirmed;
+    }
+    let Formatted::Ok {
+        parsed: reparsed, ..
+    } = ledger_format(&output, parser)
+    else {
+        // The formatter's own output doesn't parse. A real bug, but `roundtrip_audit`'s.
+        return Verdict::Unconfirmed;
+    };
+
+    if reparsed == predict_comment_count(parsed, &findings) {
+        Verdict::Confirmed
+    } else {
+        Verdict::Unconfirmed
+    }
+}
+
+/// How many comments the output must hold, if the ledger's account of `findings` is true.
+///
+/// Each dropped comment removes one. Each double-printed one adds `emitted - 1` — **not**
+/// one: `CommentFinding::emitted` is documented as `>= 2`, so a comment printed three times
+/// adds two, and assuming "double" means exactly twice would mispredict it as
+/// [`Verdict::Unconfirmed`].
+///
+/// Split out and unit-tested because it is arithmetic: an off-by-one here changes a verdict
+/// and nothing else, and no corpus run would show it — the audit would simply file a
+/// confirmed finding under the wrong bucket.
+fn predict_comment_count(parsed: usize, findings: &[CommentFinding]) -> usize {
+    let dropped = findings
+        .iter()
+        .filter(|f| f.kind == CommentFindingKind::Dropped)
+        .count();
+    let extra: usize = findings
+        .iter()
+        .filter(|f| f.kind == CommentFindingKind::DoublePrinted)
+        .map(|f| f.emitted.saturating_sub(1))
+        .sum();
+    // `dropped` counts registered comments, so it can never exceed `parsed`; saturate
+    // rather than risk a panic on a ledger that ever breaks that invariant.
+    parsed.saturating_sub(dropped) + extra
+}
+
+/// Audit one file: verify it is clean **as authored**, then inject at every site.
+///
+/// The pristine check is load-bearing, not a formality. A file that already drops a comment
+/// would re-report that same drop at every one of its thousands of sites, drowning the
+/// signal — so such a file is reported once and skipped. Over `tests/fixtures` this never
+/// fires (`comments:audit` gates it green); over a real corpus it is the honest split
+/// between "you already knew" and "the injection found it".
+fn audit_file(path: &std::path::Path, payloads: &[Payload], all_bytes: bool, tally: &mut Tally) {
+    let display = path.to_string_lossy().into_owned();
+    // Intentionally-invalid fixtures don't parse — nothing to inject into.
+    if path
+        .file_name()
+        .and_then(|n| n.to_str())
+        .is_some_and(|n| n.starts_with("input_invalid"))
+    {
+        return;
+    }
+    let Ok(source) = std::fs::read_to_string(path) else {
+        return;
+    };
+    let parser = ParserType::from_extension(&display);
+
+    match ledger_format(&source, parser) {
+        Formatted::Panicked | Formatted::Rejected => {
+            tally.parse_skipped += 1;
+            return;
+        }
+        Formatted::Ok { findings, .. } if !findings.is_empty() => {
+            tally.dirty_files.push(display);
+            return;
+        }
+        Formatted::Ok { .. } => {}
+    }
+    tally.files_done += 1;
+
+    let regions = code_regions(&source, parser);
+    let sites = injection_sites(&source, &regions, all_bytes);
+    tally.sites += sites.len();
+
+    let mut injected_src = String::with_capacity(source.len() + 24);
+    for &payload in payloads {
+        let text = payload.text();
+        for &offset in &sites {
+            injected_src.clear();
+            injected_src.push_str(&source[..offset]);
+            injected_src.push_str(text);
+            injected_src.push_str(&source[offset..]);
+            tally.injections += 1;
+
+            let findings = match ledger_format(&injected_src, parser) {
+                Formatted::Panicked => {
+                    tally.record(Hit {
+                        kind: Kind::Panic,
+                        payload,
+                        path: &display,
+                        source: &source,
+                        offset,
+                        text: text.to_string(),
+                        injected: true,
+                    });
+                    continue;
+                }
+                // The injection isn't a legal comment here — the offset names no gap.
+                Formatted::Rejected => continue,
+                Formatted::Ok { findings, .. } => findings,
+            };
+            tally.accepted += 1;
+            for f in findings {
+                tally.record(Hit {
+                    kind: match f.kind {
+                        CommentFindingKind::Dropped => Kind::Dropped,
+                        CommentFindingKind::DoublePrinted => Kind::DoublePrinted,
+                    },
+                    payload,
+                    path: &display,
+                    source: &source,
+                    offset,
+                    text: f.text,
+                    // The injected comment starts exactly at the injection point; anything
+                    // else is a bystander the injection knocked out.
+                    injected: f.span.start as usize == offset,
+                });
+            }
+        }
+    }
+}
+
+impl GapAuditCommand {
+    /// The flags in effect that make this run something other than the one the snapshot
+    /// describes: every payload, at every non-word site, over all of `tests/fixtures`.
+    ///
+    /// Empty ⇒ the run is both gradable against the snapshot and pinnable into it. Anything
+    /// else reaches a different shape set — a subset for `--limit` / `--payload` / a path,
+    /// a superset for `--all-bytes` — which is neither. One list, two uses (the `--update`
+    /// refusal and the gate skip), so the two can't drift apart into disagreeing about what
+    /// a full run is.
+    fn narrowing_flags(&self) -> Vec<&'static str> {
+        let mut flags = Vec::new();
+        if !self.paths.is_empty() {
+            flags.push("<paths>");
+        }
+        if self.limit > 0 {
+            flags.push("--limit");
+        }
+        if self.payload.is_some() {
+            flags.push("--payload");
+        }
+        if self.all_bytes {
+            flags.push("--all-bytes");
+        }
+        flags
+    }
+
+    pub(crate) fn run(self) -> Result<(), CliError> {
+        let payloads: Vec<Payload> = match &self.payload {
+            None => Payload::ALL.to_vec(),
+            Some(s) => match Payload::from_label(s) {
+                Some(p) => vec![p],
+                None => {
+                    eprintln!(
+                        "Error: unknown --payload {s:?} (expected one of: {})",
+                        Payload::ALL
+                            .iter()
+                            .map(|p| p.label())
+                            .collect::<Vec<_>>()
+                            .join(" | ")
+                    );
+                    return Err(CliError::Failed);
+                }
+            },
+        };
+
+        let default_paths = self.paths.is_empty();
+        let narrowed = self.narrowing_flags();
+        if self.update && !narrowed.is_empty() {
+            eprintln!(
+                "Error: --update pins the FULL default run (all {} payloads over \
+                 tests/fixtures). This run is narrowed by {}, so its shape set is a \
+                 SUBSET (or, for --all-bytes, a superset) of what the snapshot means — \
+                 writing it would silently unpin real bugs. Re-run without {}.",
+                Payload::ALL.len(),
+                narrowed.join(" / "),
+                narrowed.join(" / ")
+            );
+            return Err(CliError::Failed);
+        }
+        let paths = if default_paths {
+            vec!["tests/fixtures".to_string()]
+        } else {
+            self.paths.clone()
+        };
+        let mut files = match resolve_files(&paths) {
+            Ok(f) => f,
+            Err(e) => {
+                eprintln!("Error: {e}");
+                return Err(CliError::Failed);
+            }
+        };
+        if self.limit > 0 {
+            files.truncate(self.limit);
+        }
+        if files.is_empty() {
+            eprintln!("Error: no seed files found (searched {paths:?})");
+            return Err(CliError::Failed);
+        }
+
+        // Process-global; the per-thread ledgers below are thread-local, so arming once
+        // here covers every worker.
+        comment_ledger::set_comment_check(true);
+
+        // The audit provokes panics on purpose (a formatter crash IS a finding), so keep
+        // the default hook from printing each one.
+        let prev_hook = std::panic::take_hook();
+        std::panic::set_hook(Box::new(|_| {}));
+
+        let jobs = self
+            .jobs
+            .filter(|j| *j > 0)
+            .or_else(|| {
+                std::thread::available_parallelism()
+                    .ok()
+                    .map(std::num::NonZero::get)
+            })
+            .unwrap_or(1)
+            .min(files.len());
+
+        let all_bytes = self.all_bytes;
+        let mut total = Tally::default();
+        // Chunk by stride rather than by block: fixture sizes cluster by directory, and
+        // the work is QUADRATIC in file size, so contiguous blocks would leave one thread
+        // holding every large file.
+        std::thread::scope(|scope| {
+            let handles: Vec<_> = (0..jobs)
+                .map(|worker| {
+                    let files = &files;
+                    let payloads = &payloads;
+                    scope.spawn(move || {
+                        let mut tally = Tally::default();
+                        for path in files.iter().skip(worker).step_by(jobs) {
+                            audit_file(path, payloads, all_bytes, &mut tally);
+                        }
+                        tally
+                    })
+                })
+                .collect();
+            for h in handles {
+                match h.join() {
+                    Ok(t) => total.merge(t),
+                    Err(_) => eprintln!("warning: a worker thread panicked outside the audit loop"),
+                }
+            }
+        });
+
+        // Self-verify each shape's example against the output (cheap: once per shape, not
+        // per site — ~700 formats against millions). Single-threaded and after the join, so
+        // it can't interleave with a worker's thread-local ledger.
+        let verdicts: Vec<((Kind, String), Verdict)> = total
+            .shapes
+            .iter()
+            .map(|((kind, shape), agg)| {
+                let parser = ParserType::from_extension(&agg.example.path);
+                ((*kind, shape.clone()), verify_example(agg, *kind, parser))
+            })
+            .collect();
+        for (key, verdict) in verdicts {
+            if let Some(agg) = total.shapes.get_mut(&key) {
+                agg.verdict = Some(verdict);
+            }
+        }
+
+        std::panic::set_hook(prev_hook);
+        comment_ledger::set_comment_check(false);
+
+        if self.update {
+            let path = known_shapes_path();
+            let rendered = render_known(&total.shapes);
+            if let Err(e) = std::fs::write(&path, &rendered) {
+                eprintln!("Error: cannot write {}: {e}", path.display());
+                return Err(CliError::Failed);
+            }
+            // Count what was actually written, not every shape — a panic is not pinned
+            // (see `is_pinnable`), so reporting `total.shapes.len()` would overstate the
+            // file by exactly the crashes it deliberately omits.
+            println!(
+                "✓ wrote {} shape(s) to {}",
+                found_keys(&total.shapes).len(),
+                path.display()
+            );
+            // Spend the verify pass rather than discarding it. Pinning is the moment ~700
+            // claims get frozen, so it is exactly when it's worth saying which ones the
+            // audit could not reproduce. A WARNING, not a refusal: an unconfirmed shape is
+            // still a real finding, and the verdict describes the shape's one sampled
+            // example rather than the shape, so refusing on it would both block `--update`
+            // and flip with which fixture happens to sort first.
+            let unconfirmed = count_unconfirmed(&total.shapes);
+            if unconfirmed > 0 {
+                println!(
+                    "  ⚠ {unconfirmed} of them UNCONFIRMED — filed as dropped/double-printed, \
+                     yet the output reparses to just as many comments as its input. Likely \
+                     MANGLES (a rebuilt comment) rather than plain drops; see \
+                     docs/gap_audit.md."
+                );
+            }
+            let panics = count_panics(&total.shapes);
+            if panics > 0 {
+                eprintln!(
+                    "\n✗ {panics} PANIC shape(s) were NOT pinned — a comment in a gap must \
+                     never crash the formatter, so the gate will keep failing until they \
+                     are fixed."
+                );
+                return Err(CliError::Failed);
+            }
+            return Ok(());
+        }
+
+        // Grade BEFORE printing. Only a run that is actually graded can be quiet — a
+        // narrowed or off-corpus run has no verdict to be quiet about, so it always reports.
+        let graded = if default_paths && narrowed.is_empty() {
+            Some(grade_against_snapshot(&total.shapes))
+        } else {
+            None
+        };
+
+        if self.json {
+            print_json(&total, &payloads);
+        } else if graded.as_ref().is_some_and(GateDiff::holds) && !self.report {
+            // Nothing to act on: every shape is one the snapshot already pins, so the
+            // per-shape report is thousands of lines of noise in `deno task check`.
+            print_summary(&total, &payloads);
+        } else {
+            print_report(&total, &payloads);
+        }
+
+        // Off the default corpus the snapshot doesn't apply — every finding is news.
+        if !default_paths {
+            return if total.shapes.is_empty() {
+                Ok(())
+            } else {
+                Err(CliError::Failed)
+            };
+        }
+        // A narrowed default run reaches only part of the snapshot's shape set (or, under
+        // --all-bytes, more than it), so grading it would report every shape the narrowing
+        // simply didn't reach as a stale entry — a wall of noise that says nothing about
+        // the code. These flags are diagnostics; report and stop rather than fail on the
+        // narrowing itself.
+        if !narrowed.is_empty() {
+            eprintln!(
+                "\n○ ratchet SKIPPED — {} narrows this run, and the snapshot pins the full \
+                 default one. Findings above are reported, NOT graded: this is not a \
+                 passing gate.",
+                narrowed.join(" / ")
+            );
+            return Ok(());
+        }
+        match &graded {
+            Some(diff) => self.report_gate(diff, &total),
+            // Unreachable: `graded` is Some exactly when default-pathed and un-narrowed,
+            // which the two returns above have just established.
+            None => Ok(()),
+        }
+    }
+
+    /// Report a [`GateDiff`] and turn it into an exit status. See [`KNOWN_SHAPES`] for why
+    /// the key is the shape and not the count.
+    fn report_gate(&self, diff: &GateDiff, total: &Tally) -> Result<(), CliError> {
+        let GateDiff { new, stale, .. } = diff;
+
+        // Panics are graded on their own, never against the snapshot: `is_pinnable` keeps
+        // them out of both sides of the diff, so without this arm a crash would fail
+        // nothing at all.
+        let panics: Vec<_> = total
+            .shapes
+            .iter()
+            .filter(|((kind, _), _)| *kind == Kind::Panic)
+            .collect();
+        if !panics.is_empty() {
+            eprintln!(
+                "\n✗ {} shape(s) CRASH the formatter — a comment in a gap must never panic \
+                 it. Not pinnable and not a ratchet entry: fix the crash.",
+                panics.len()
+            );
+            for ((_, shape), agg) in panics.iter().take(40) {
+                eprintln!(
+                    "    {shape:<20} e.g. inject {} at {}:{}",
+                    agg.example.payload, agg.example.path, agg.example.offset
+                );
+            }
+            if panics.len() > 40 {
+                eprintln!("    … and {} more", panics.len() - 40);
+            }
+        }
+
+        if !new.is_empty() {
+            eprintln!(
+                "\n✗ {} NEW finding shape(s) — a comment in one of these gaps is dropped or \
+                 double-printed, and the snapshot has never seen it:",
+                new.len()
+            );
+            for (kind, shape, payloads) in new.iter().take(40) {
+                eprintln!("    {kind:<14} {shape:<20} [{payloads}]");
+            }
+            if new.len() > 40 {
+                eprintln!("    … and {} more", new.len() - 40);
+            }
+            eprintln!(
+                "  Fix the drop, or — if it is genuinely pre-existing and merely newly \
+                 REACHED by a fixture — re-run `deno task gaps:audit:update`."
+            );
+        }
+        if !stale.is_empty() {
+            eprintln!(
+                "\n✗ {} STALE snapshot entry/entries — these no longer fire. If you fixed \
+                 them, drop the lines (`deno task gaps:audit:update`):",
+                stale.len()
+            );
+            for (kind, shape, payloads) in stale.iter().take(40) {
+                eprintln!("    {kind:<14} {shape:<20} [{payloads}]");
+            }
+            if stale.len() > 40 {
+                eprintln!("    … and {} more", stale.len() - 40);
+            }
+        }
+
+        if diff.holds() {
+            // Under `--json`, stdout is the report and nothing else — a trailing status line
+            // makes it unparseable. Logs go to stderr (the `corpus:compare --json` contract).
+            let msg = format!(
+                "\n✓ ratchet holds — every finding shape is a known bug ({} pinned); no new \
+                 gap drops a comment",
+                diff.known
+            );
+            if self.json {
+                eprintln!("{msg}");
+            } else {
+                println!("{msg}");
+            }
+            Ok(())
+        } else {
+            Err(CliError::Failed)
+        }
+    }
+}
+
+/// How many pinnable shapes carry [`Verdict::Unconfirmed`] — the ledger's account of them
+/// couldn't be reproduced against the output.
+fn count_unconfirmed(shapes: &BTreeMap<(Kind, String), ShapeAgg>) -> usize {
+    shapes
+        .iter()
+        .filter(|((kind, _), agg)| is_pinnable(*kind) && agg.verdict == Some(Verdict::Unconfirmed))
+        .count()
+}
+
+/// The header every report opens with — totals, then any file that was **skipped**.
+///
+/// The skip notice lives here, not in [`print_report`], because it is a statement about
+/// COVERAGE, not a finding: a dirty file is one this audit never probed. Quiet modes may
+/// drop findings the snapshot already pins; they must never drop the fact that a file went
+/// unprobed, or a shrinking corpus reads as a passing gate.
+fn print_header(t: &Tally, payloads: &[Payload]) {
+    let labels: Vec<&str> = payloads.iter().map(|p| p.label()).collect();
+    println!(
+        "gap_audit — {} files · {} sites · {} injections ({} accepted) · payloads: {}\n",
+        t.files_done,
+        t.sites,
+        t.injections,
+        t.accepted,
+        labels.join(", ")
+    );
+
+    if !t.dirty_files.is_empty() {
+        println!(
+            "○ {} file(s) already had ledger findings AS AUTHORED — reported by \
+             `comments:audit`, not injected into here:",
+            t.dirty_files.len()
+        );
+        for p in t.dirty_files.iter().take(10) {
+            println!("    {p}");
+        }
+        if t.dirty_files.len() > 10 {
+            println!("    … and {} more", t.dirty_files.len() - 10);
+        }
+        println!();
+    }
+}
+
+/// What a run with nothing to act on prints: the header, the totals, and nothing else.
+///
+/// The per-shape report is for shapes you might *do* something about. When the ratchet
+/// holds, every one is already pinned — printing all ~700 buries the `✓` under thousands of
+/// lines in `deno task check`. `--report` brings them back.
+fn print_summary(t: &Tally, payloads: &[Payload]) {
+    print_header(t, payloads);
+    let findings: usize = t.shapes.values().map(|s| s.count).sum();
+    println!(
+        "○ {findings} finding(s) across {} known site shape(s) — all pinned; re-run with \
+         --report for the per-shape detail",
+        t.shapes.len()
+    );
+}
+
+fn print_report(t: &Tally, payloads: &[Payload]) {
+    print_header(t, payloads);
+
+    if t.shapes.is_empty() {
+        println!(
+            "✓ every injected comment printed exactly once — no gap drops a comment across \
+             {} injections",
+            t.accepted
+        );
+        return;
+    }
+
+    let total: usize = t.shapes.values().map(|s| s.count).sum();
+    println!(
+        "✗ {total} finding(s) across {} distinct site shape(s)\n",
+        t.shapes.len()
+    );
+
+    // Worst-first: a shape firing everywhere is one bug on a hot path, and fixing it
+    // collapses the whole list.
+    let mut rows: Vec<(&(Kind, String), &ShapeAgg)> = t.shapes.iter().collect();
+    rows.sort_by(|a, b| b.1.count.cmp(&a.1.count).then(a.0.cmp(b.0)));
+
+    for ((kind, shape), agg) in &rows {
+        let verdict = match agg.verdict {
+            Some(Verdict::Confirmed) | None => String::new(),
+            Some(Verdict::Unconfirmed) => "  ⚠ UNCONFIRMED".to_string(),
+        };
+        println!(
+            "  {:>7}×  {:<14} {}{}",
+            agg.count,
+            kind.label(),
+            shape,
+            verdict
+        );
+        println!(
+            "            {} file(s) · payloads: {}{}",
+            agg.files.len(),
+            agg.payloads.iter().copied().collect::<Vec<_>>().join(", "),
+            match agg.bystander_hits {
+                0 => String::new(),
+                n if n == agg.count => "  (ALL hits knock out a BYSTANDER comment)".to_string(),
+                n => format!("  ({n} of {} hits knock out a bystander)", agg.count),
+            }
+        );
+        println!(
+            "            e.g. inject {} at {}:{}  {}",
+            agg.example.payload, agg.example.path, agg.example.offset, agg.example.snippet
+        );
+        println!("            comment: {:?}", agg.example.text);
+        println!();
+    }
+
+    let unconfirmed = rows
+        .iter()
+        .filter(|(_, a)| a.verdict == Some(Verdict::Unconfirmed))
+        .count();
+    if unconfirmed > 0 {
+        println!(
+            "⚠ {unconfirmed} shape(s) UNCONFIRMED: the ledger says a comment was never emitted, \
+             yet the\n  output reparses to just as many comments as its input. Something printed \
+             it without\n  recording the emit — or printed a MANGLED rebuild (`/* a⏎b */` → \
+             `/* ab */`, one\n  comment either way). Real either way, but not the plain drop it \
+             is filed as.\n"
+        );
+    }
+}
+
+fn print_json(t: &Tally, payloads: &[Payload]) {
+    let shapes: Vec<serde_json::Value> = t
+        .shapes
+        .iter()
+        .map(|((kind, shape), agg)| {
+            serde_json::json!({
+                "kind": kind.label(),
+                "shape": shape,
+                "count": agg.count,
+                "files": agg.files.len(),
+                "payloads": agg.payloads.iter().copied().collect::<Vec<_>>(),
+                "bystander_hits": agg.bystander_hits,
+                "verdict": match agg.verdict {
+                    Some(Verdict::Confirmed) => "confirmed",
+                    Some(Verdict::Unconfirmed) => "unconfirmed",
+                    None => "unverified",
+                },
+                "example_payload": agg.example.payload,
+                "example_path": agg.example.path,
+                "example_offset": agg.example.offset,
+                "example_snippet": agg.example.snippet,
+                "example_text": agg.example.text,
+                "example_injected": agg.example.injected,
+            })
+        })
+        .collect();
+    let out = serde_json::json!({
+        "files": t.files_done,
+        "sites": t.sites,
+        "injections": t.injections,
+        "accepted": t.accepted,
+        "parse_skipped": t.parse_skipped,
+        "dirty_files": t.dirty_files,
+        "payloads": payloads.iter().map(|p| p.label()).collect::<Vec<_>>(),
+        "findings": t.shapes.values().map(|s| s.count).sum::<usize>(),
+        "shapes": shapes,
+    });
+    println!("{}", serde_json::to_string_pretty(&out).unwrap_or_default());
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// The wire→byte map, graded against a direct walk on every prefix of strings covering
+    /// each width class: ASCII (1 byte / 1 unit), 2- and 3-byte BMP (n bytes / 1 unit), and
+    /// astral (4 bytes / **2** units — the arm an "offset == char index" reading gets wrong).
+    ///
+    /// This is the only thing that can fail on a bad map: the corpus is ~all ASCII, where
+    /// every arm is the identity, so a broken translation formats byte-identically.
+    #[test]
+    fn utf16_to_byte_matches_a_direct_walk() {
+        for src in [
+            "",
+            "abc",
+            "é",
+            "aéb",
+            "日本語",
+            "a😀b",
+            "😀😀",
+            "const é = 1; // 日本\nx😀y",
+        ] {
+            let map = Utf16ToByte::new(src);
+
+            // Every char boundary must round-trip: the char's UTF-16 offset maps back to
+            // exactly its byte offset.
+            let mut units = 0usize;
+            for (byte, ch) in src.char_indices() {
+                assert_eq!(
+                    map.byte(units),
+                    Some(byte),
+                    "src {src:?}: utf16 offset {units} should be byte {byte}"
+                );
+                units += ch.len_utf16();
+            }
+            // The end offset maps to the source length, and one past it is out of range.
+            assert_eq!(map.byte(units), Some(src.len()), "src {src:?}: end offset");
+            assert_eq!(map.byte(units + 1), None, "src {src:?}: past the end");
+
+            // Every produced offset is a char boundary — the property that keeps slicing
+            // from panicking.
+            for u in 0..=units {
+                let b = map.byte(u).expect("in range");
+                assert!(src.is_char_boundary(b), "src {src:?}: byte {b} mid-char");
+            }
+        }
+    }
+
+    /// The ASCII fast path must be indistinguishable from the table, not merely close.
+    #[test]
+    fn utf16_to_byte_ascii_fast_path_matches_the_table() {
+        let src = "const a = 1;\n\tb();";
+        let fast = Utf16ToByte::new(src);
+        assert!(fast.table.is_none(), "ASCII source should skip the table");
+        for u in 0..=src.len() + 1 {
+            let table_answer = if u <= src.len() { Some(u) } else { None };
+            assert_eq!(fast.byte(u), table_answer, "offset {u}");
+        }
+    }
+
+    /// A region is only useful if it names a spot a comment can actually go: the `Program`
+    /// span must start after `>` and end before `</script>`.
+    #[test]
+    fn code_regions_name_the_script_body_only() {
+        let src = "<script lang=\"ts\">\n\tconst a = 1;\n</script>\n";
+        let regions = code_regions(src, ParserType::Svelte);
+        assert_eq!(regions.len(), 1, "one script body: {regions:?}");
+        let (s, e) = regions[0];
+        assert_eq!(&src[s..e], "\n\tconst a = 1;\n");
+    }
+
+    /// The shape is the **ratchet key** — the thing the gate diffs against the snapshot —
+    /// so what it abstracts and what it keeps is a contract, not a formatting choice.
+    #[test]
+    fn site_shape_keeps_keywords_and_abstracts_identifiers() {
+        // A keyword must survive verbatim on both sides: `import⟨⟩.` names the
+        // meta-property/import-phase header, while `IDENT⟨⟩.` names every member access in
+        // the corpus. Collapsing the two would hide one bug inside the other's entry.
+        assert_eq!(site_shape("import.meta", 6), "import⟨⟩.");
+        assert_eq!(site_shape("import.meta", 7), ".⟨⟩meta");
+        assert_eq!(site_shape("new.target", 3), "new⟨⟩.");
+
+        // A non-keyword word abstracts, so one bug is one line however many identifiers
+        // reach it.
+        assert_eq!(site_shape("foo.bar", 3), "IDENT⟨⟩.");
+        assert_eq!(site_shape("foo.bar", 4), ".⟨⟩IDENT");
+        assert_eq!(site_shape("x9.y", 2), "IDENT⟨⟩.");
+
+        // Digits are their own class — `1⟨⟩.` (a float's point) is not `IDENT⟨⟩.`.
+        assert_eq!(site_shape("1.5", 1), "NUM⟨⟩.");
+
+        // Whitespace is elided rather than represented: a gap's WIDTH doesn't distinguish
+        // the position, so `a  =` and `a =` must land on one shape.
+        assert_eq!(site_shape("a = 1", 2), "␣⟨⟩=");
+        assert_eq!(site_shape("a  = 1", 2), "␣⟨⟩␣");
+
+        // Punctuator runs are kept literally, capped, and read in source order.
+        assert_eq!(site_shape("a);", 1), "IDENT⟨⟩);");
+        assert_eq!(site_shape("f(x)", 2), "(⟨⟩IDENT");
+
+        // The ends of a file are gaps too and must not panic.
+        assert_eq!(site_shape("ab", 0), "␣⟨⟩IDENT");
+        assert_eq!(site_shape("ab", 2), "IDENT⟨⟩␣");
+
+        // Non-ASCII must not panic or slice mid-char.
+        assert_eq!(site_shape("é.b", 2), "IDENT⟨⟩.");
+    }
+
+    /// A minimal shape carrying `payloads` — only the snapshot columns matter here, so the
+    /// example is filler.
+    fn mk_agg(payloads: &[&'static str]) -> ShapeAgg {
+        ShapeAgg {
+            count: 1,
+            payloads: payloads.iter().copied().collect(),
+            bystander_hits: 0,
+            files: BTreeSet::new(),
+            example: Example {
+                payload: "block",
+                path: "p.svelte".to_string(),
+                offset: 0,
+                snippet: String::new(),
+                text: "/* c */".to_string(),
+                injected: true,
+            },
+            verdict: None,
+        }
+    }
+
+    /// The snapshot is the gate's on-disk contract: whatever `--update` writes, the gate
+    /// must read back as the identical key set, or a green run means nothing.
+    #[test]
+    fn snapshot_render_and_parse_round_trip() {
+        let mut shapes: BTreeMap<(Kind, String), ShapeAgg> = BTreeMap::new();
+        shapes.insert((Kind::Dropped, "import⟨⟩.".to_string()), mk_agg(&["block"]));
+        shapes.insert(
+            (Kind::DoublePrinted, "IDENT⟨⟩=".to_string()),
+            mk_agg(&["line", "block"]),
+        );
+
+        let rendered = render_known(&shapes);
+        // Every non-comment line must be a complete key — a dropped column would make the
+        // gate silently compare fewer fields than it pins.
+        let parsed: BTreeSet<KnownKey> = rendered
+            .lines()
+            .filter(|l| !l.is_empty() && !l.starts_with('#'))
+            .map(|l| {
+                let mut c = l.split('\t');
+                (
+                    c.next().unwrap().to_string(),
+                    c.next().unwrap().to_string(),
+                    c.next().unwrap().to_string(),
+                )
+            })
+            .collect();
+
+        assert_eq!(
+            parsed,
+            found_keys(&shapes),
+            "render → parse must round-trip"
+        );
+        // The payload column is part of the key: same shape, different payload set ⇒
+        // different entry, so a shape that starts dropping a new comment kind fails the gate.
+        assert!(rendered.contains("DROPPED\timport⟨⟩.\tblock\n"));
+        assert!(rendered.contains("DOUBLE-PRINTED\tIDENT⟨⟩=\tblock,line\n"));
+    }
+
+    /// A panic must never reach the snapshot — not via `--update`, and not as a key the
+    /// gate diffs. The corpus cannot grade this: `tests/fixtures` panics nowhere today, so
+    /// both arms are vacuously green there and would stay green if the filter were dropped.
+    #[test]
+    fn a_panic_is_never_pinned() {
+        let mut shapes: BTreeMap<(Kind, String), ShapeAgg> = BTreeMap::new();
+        shapes.insert((Kind::Dropped, "import⟨⟩.".to_string()), mk_agg(&["block"]));
+        shapes.insert((Kind::Panic, "IDENT⟨⟩(".to_string()), mk_agg(&["block"]));
+
+        // Not written: a crash must not land in the list whose shrinking is the goal.
+        // Checked over the DATA lines, not the whole file — the header explains the panic
+        // rule in prose, so a substring search over it matches that and proves nothing.
+        let rendered = render_known(&shapes);
+        let data: Vec<&str> = rendered
+            .lines()
+            .filter(|l| !l.is_empty() && !l.starts_with('#'))
+            .collect();
+        assert_eq!(
+            data,
+            vec!["DROPPED\timport⟨⟩.\tblock"],
+            "only the pinnable shape is written"
+        );
+
+        // Nor diffed: were it a found key it would read as NEW, and `--update` would then
+        // "fix" the gate by pinning it — the exact laundering this prevents.
+        let keys = found_keys(&shapes);
+        assert_eq!(keys.len(), 1, "only the pinnable shape is a key: {keys:?}");
+        assert!(keys.iter().all(|(kind, _, _)| kind != "PANIC"));
+
+        assert_eq!(
+            count_panics(&shapes),
+            1,
+            "but it is still counted, and fails"
+        );
+    }
+
+    /// The ledger's falsifiable prediction. Arithmetic, so the corpus cannot grade it.
+    #[test]
+    fn predicted_comment_count_accounts_for_each_finding() {
+        let f = |kind, emitted| CommentFinding {
+            kind,
+            text: "/* c */".to_string(),
+            span: tsv_lang::Span { start: 0, end: 7 },
+            emitted,
+        };
+        // No findings ⇒ the output keeps every comment.
+        assert_eq!(predict_comment_count(5, &[]), 5);
+        // A drop removes exactly one.
+        assert_eq!(
+            predict_comment_count(5, &[f(CommentFindingKind::Dropped, 0)]),
+            4
+        );
+        // A comment printed TWICE adds one — but one printed THREE times adds two. This is
+        // the case a "double means 2" reading gets wrong.
+        assert_eq!(
+            predict_comment_count(5, &[f(CommentFindingKind::DoublePrinted, 2)]),
+            6
+        );
+        assert_eq!(
+            predict_comment_count(5, &[f(CommentFindingKind::DoublePrinted, 3)]),
+            7
+        );
+        // Mixed findings compose.
+        assert_eq!(
+            predict_comment_count(
+                5,
+                &[
+                    f(CommentFindingKind::Dropped, 0),
+                    f(CommentFindingKind::DoublePrinted, 2)
+                ]
+            ),
+            5
+        );
+        // A ledger that broke its own invariant must not panic the audit.
+        assert_eq!(
+            predict_comment_count(
+                0,
+                &[
+                    f(CommentFindingKind::Dropped, 0),
+                    f(CommentFindingKind::Dropped, 0)
+                ]
+            ),
+            0
+        );
+    }
+
+    /// A full default run, as a baseline for the narrowing cases below.
+    fn full_run() -> GapAuditCommand {
+        GapAuditCommand {
+            json: false,
+            report: false,
+            all_bytes: false,
+            payload: None,
+            jobs: None,
+            limit: 0,
+            update: false,
+            paths: Vec::new(),
+        }
+    }
+
+    /// Every flag that changes which shapes a run reaches must be named here, because this
+    /// one list decides both whether `--update` may write the snapshot and whether the gate
+    /// may grade against it. A flag missing from it silently pins (or grades) a shape set
+    /// that isn't the one the snapshot means — `--limit 30 --payload block --update` wrote
+    /// an EMPTY snapshot over 717 pinned bugs and reported success.
+    #[test]
+    fn every_narrowing_flag_disqualifies_a_run() {
+        assert!(
+            full_run().narrowing_flags().is_empty(),
+            "the default run is the one the snapshot describes"
+        );
+
+        // Each flag must disqualify a run ON ITS OWN — spelled out rather than looped, so
+        // a flag dropped from `narrowing_flags` fails as its own named assertion.
+        let paths = GapAuditCommand {
+            paths: vec!["src".to_string()],
+            ..full_run()
+        };
+        assert_eq!(paths.narrowing_flags(), vec!["<paths>"]);
+
+        let limit = GapAuditCommand {
+            limit: 30,
+            ..full_run()
+        };
+        assert_eq!(limit.narrowing_flags(), vec!["--limit"]);
+
+        let payload = GapAuditCommand {
+            payload: Some("block".to_string()),
+            ..full_run()
+        };
+        assert_eq!(payload.narrowing_flags(), vec!["--payload"]);
+
+        // A superset, not a subset — but equally not the pinned set.
+        let all_bytes = GapAuditCommand {
+            all_bytes: true,
+            ..full_run()
+        };
+        assert_eq!(all_bytes.narrowing_flags(), vec!["--all-bytes"]);
+
+        // `--json` / `--report` / `--jobs` change how a run is REPORTED and scheduled, never
+        // which sites it reaches, so they must not disqualify one — a gate you can't run
+        // under --json, or on a fixed thread count, would just get bypassed.
+        let reporting_only = GapAuditCommand {
+            json: true,
+            report: true,
+            jobs: Some(1),
+            ..full_run()
+        };
+        assert!(
+            reporting_only.narrowing_flags().is_empty(),
+            "--json / --report / --jobs don't change the shape set"
+        );
+
+        // They compose, so the error message can name every offender at once.
+        let both = GapAuditCommand {
+            limit: 30,
+            payload: Some("block".to_string()),
+            ..full_run()
+        };
+        assert_eq!(both.narrowing_flags(), vec!["--limit", "--payload"]);
+    }
+
+    /// The word filter must keep both dot gaps of a punctuator-joined header — the exact
+    /// positions the whole audit exists to probe — while dropping word interiors.
+    #[test]
+    fn injection_sites_keep_dot_gaps_and_drop_word_interiors() {
+        let src = "a.b";
+        let sites = injection_sites(src, &[(0, src.len())], false);
+        assert_eq!(sites, vec![0, 1, 2, 3], "every gap around `.` is a site");
+
+        let src = "ab";
+        let sites = injection_sites(src, &[(0, src.len())], false);
+        assert_eq!(sites, vec![0, 2], "the interior of `ab` is not a gap");
+        let all = injection_sites(src, &[(0, src.len())], true);
+        assert_eq!(all, vec![0, 1, 2], "--all-bytes keeps the interior");
+    }
+}
diff --git a/crates/tsv_debug/src/cli/commands/gap_audit_known.txt b/crates/tsv_debug/src/cli/commands/gap_audit_known.txt
new file mode 100644
index 000000000..33ad1c50c
--- /dev/null
+++ b/crates/tsv_debug/src/cli/commands/gap_audit_known.txt
@@ -0,0 +1,713 @@
+# Generated by `deno task gaps:audit:update` — do NOT hand-edit.
+#
+# Every line is a KNOWN BUG: a site shape where injecting a comment makes the
+# formatter drop or double-print one. The gate fails on a line that is NOT here
+# (a new kind of drop) and on a line here that no longer fires (a stale entry —
+# delete it when you fix one). Counts are deliberately not pinned: they churn with
+# every ordinary fixture PR, and a gate that fails per added fixture gets turned
+# off. The PAYLOAD set is pinned, though: a shape that starts dropping a comment
+# kind it used to survive is a new bug on a new ownership path.
+#
+# A PANIC is never listed here — that invariant is absolute, so it always fails
+# the gate rather than being pinned.
+#
+# Format: KIND<TAB>SHAPE<TAB>PAYLOADS
+DROPPED	!)⟨⟩!.	annotation,block,jsdoc_cast
+DROPPED	!⟨⟩(	jsdoc_cast
+DROPPED	!⟨⟩((	jsdoc_cast
+DROPPED	#⟨⟩IDENT	annotation,block,jsdoc_cast,line,multiline
+DROPPED	#⟨⟩\	annotation,block,jsdoc_cast,line,multiline
+DROPPED	#⟨⟩private	annotation,block,jsdoc_cast,line,multiline
+DROPPED	&⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DROPPED	')⟨⟩);	annotation,block,jsdoc_cast,line,multiline
+DROPPED	')⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DROPPED	',,⟨⟩,'	annotation,block,jsdoc_cast
+DROPPED	',⟨⟩()=	line
+DROPPED	',⟨⟩,'	annotation,block,jsdoc_cast
+DROPPED	',⟨⟩,,'	annotation,block,jsdoc_cast
+DROPPED	',⟨⟩,];	annotation,block,jsdoc_cast
+DROPPED	',⟨⟩//	annotation,block,jsdoc_cast
+DROPPED	',⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DROPPED	']⟨⟩);	annotation,block,jsdoc_cast,multiline
+DROPPED	']⟨⟩␣	annotation,block,jsdoc_cast,multiline
+DROPPED	'},⟨⟩␣	annotation,block,jsdoc_cast,multiline
+DROPPED	'⟨⟩));	annotation,block,jsdoc_cast,line,multiline
+DROPPED	'⟨⟩),	annotation,block,jsdoc_cast,line,multiline
+DROPPED	'⟨⟩);	annotation,block,jsdoc_cast,line,multiline
+DROPPED	'⟨⟩,	annotation,block,jsdoc_cast,line,multiline
+DROPPED	'⟨⟩,()	annotation,block,jsdoc_cast,line,multiline
+DROPPED	'⟨⟩,/*	line
+DROPPED	'⟨⟩/*	line,multiline
+DROPPED	'⟨⟩//	line,multiline
+DROPPED	'⟨⟩;	annotation,block,jsdoc_cast,line,multiline
+DROPPED	'⟨⟩>(	annotation,block,jsdoc_cast,multiline
+DROPPED	'⟨⟩]	annotation,block,jsdoc_cast,line,multiline
+DROPPED	'⟨⟩]&	annotation,block,jsdoc_cast,line,multiline
+DROPPED	'⟨⟩],	annotation,block,jsdoc_cast,line,multiline
+DROPPED	'⟨⟩],'	annotation,block,jsdoc_cast,line,multiline
+DROPPED	'⟨⟩];	annotation,block,jsdoc_cast,line,multiline
+DROPPED	'⟨⟩]>;	annotation,block,jsdoc_cast,line,multiline
+DROPPED	'⟨⟩]>}	annotation,block,jsdoc_cast,line,multiline
+DROPPED	'⟨⟩]|	annotation,block,jsdoc_cast,line,multiline
+DROPPED	'⟨⟩});	annotation,block,jsdoc_cast,multiline
+DROPPED	'⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DROPPED	(((⟨⟩(	annotation,block,jsdoc_cast,multiline
+DROPPED	(((⟨⟩({}	annotation,block,line,multiline
+DROPPED	(((⟨⟩IDENT	line
+DROPPED	(((⟨⟩{}!	line
+DROPPED	(()⟨⟩=>	annotation,block,jsdoc_cast
+DROPPED	(()⟨⟩␣	annotation,block,jsdoc_cast
+DROPPED	((/⟨⟩*	multiline
+DROPPED	((<⟨⟩IDENT	annotation,block,jsdoc_cast,multiline
+DROPPED	((⟨⟩'	line
+DROPPED	((⟨⟩...	annotation,jsdoc_cast
+DROPPED	((⟨⟩/*	line
+DROPPED	((⟨⟩IDENT	annotation,block,jsdoc_cast,line,multiline
+DROPPED	((⟨⟩␣	line
+DROPPED	())⟨⟩!()	annotation,block,jsdoc_cast
+DROPPED	())⟨⟩!`	annotation,block,jsdoc_cast
+DROPPED	())⟨⟩);	annotation,block,jsdoc_cast,line,multiline
+DROPPED	():⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DROPPED	();⟨⟩;;;	line
+DROPPED	()⟨⟩!	annotation,block,jsdoc_cast
+DROPPED	()⟨⟩!.	annotation,block,jsdoc_cast
+DROPPED	()⟨⟩!?.	annotation,block,jsdoc_cast
+DROPPED	()⟨⟩)	annotation,block,jsdoc_cast,line,multiline
+DROPPED	()⟨⟩));	annotation,block,jsdoc_cast,line,multiline
+DROPPED	()⟨⟩);	annotation,block,jsdoc_cast,line,multiline
+DROPPED	()⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DROPPED	(++⟨⟩IDENT	line
+DROPPED	(--⟨⟩IDENT	line
+DROPPED	(/)⟨⟩␣	annotation,block,jsdoc_cast
+DROPPED	(/⟨⟩*	multiline
+DROPPED	(/⟨⟩IDENT	multiline
+DROPPED	(<⟨⟩IDENT	annotation,block,jsdoc_cast,multiline
+DROPPED	([(⟨⟩IDENT	line
+DROPPED	({}⟨⟩));	annotation,block,jsdoc_cast,line,multiline
+DROPPED	({⟨⟩IDENT	annotation,block,jsdoc_cast
+DROPPED	({⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DROPPED	(⟨⟩'	line
+DROPPED	(⟨⟩(	annotation,block,jsdoc_cast,line,multiline
+DROPPED	(⟨⟩('	annotation,block,line,multiline
+DROPPED	(⟨⟩()	annotation,block,jsdoc_cast,line,multiline
+DROPPED	(⟨⟩()=	line
+DROPPED	(⟨⟩(..	line
+DROPPED	(⟨⟩(/*	line
+DROPPED	(⟨⟩([	annotation,block,jsdoc_cast,line,multiline
+DROPPED	(⟨⟩({	line
+DROPPED	(⟨⟩...	line
+DROPPED	(⟨⟩/	line
+DROPPED	(⟨⟩/*	annotation,block,jsdoc_cast,line,multiline
+DROPPED	(⟨⟩//	annotation,block,jsdoc_cast,multiline
+DROPPED	(⟨⟩<	line
+DROPPED	(⟨⟩IDENT	annotation,block,jsdoc_cast,line,multiline
+DROPPED	(⟨⟩NUM	line
+DROPPED	(⟨⟩[	annotation,block,jsdoc_cast,line,multiline
+DROPPED	(⟨⟩['	line
+DROPPED	(⟨⟩[['	line
+DROPPED	(⟨⟩async	line
+DROPPED	(⟨⟩await	line
+DROPPED	(⟨⟩function	line
+DROPPED	(⟨⟩module	line
+DROPPED	(⟨⟩type	line
+DROPPED	(⟨⟩yield	line
+DROPPED	(⟨⟩{	annotation,block,jsdoc_cast,line,multiline
+DROPPED	(⟨⟩{})	line
+DROPPED	(⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DROPPED	)()⟨⟩)	annotation,block,jsdoc_cast,line,multiline
+DROPPED	)))⟨⟩))	annotation,block,jsdoc_cast,line,multiline
+DROPPED	)))⟨⟩[])	annotation,block,jsdoc_cast
+DROPPED	))[⟨⟩]);	annotation,block,jsdoc_cast,line,multiline
+DROPPED	))[⟨⟩];	annotation,block,jsdoc_cast,line,multiline
+DROPPED	))⟨⟩)	annotation,block,jsdoc_cast,line,multiline
+DROPPED	))⟨⟩);	annotation,block,jsdoc_cast,line,multiline
+DROPPED	))⟨⟩?];	annotation,block,jsdoc_cast,line,multiline
+DROPPED	))⟨⟩[])	annotation,block,jsdoc_cast
+DROPPED	))⟨⟩[];	annotation,block,jsdoc_cast
+DROPPED	),⟨⟩␣	multiline
+DROPPED	):|⟨⟩/*	line
+DROPPED	):⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DROPPED	);;⟨⟩;;	line
+DROPPED	)=>⟨⟩(	jsdoc_cast
+DROPPED	)=>⟨⟩((	jsdoc_cast
+DROPPED	)=>⟨⟩({	jsdoc_cast
+DROPPED	)=>⟨⟩[	annotation,block,jsdoc_cast
+DROPPED	)[]⟨⟩[];	annotation,block,jsdoc_cast
+DROPPED	)[⟨⟩]);	annotation,block,jsdoc_cast,line,multiline
+DROPPED	)[⟨⟩])[	annotation,block,jsdoc_cast,line,multiline
+DROPPED	)[⟨⟩];	annotation,block,jsdoc_cast,line,multiline
+DROPPED	)[⟨⟩][]	annotation,block,jsdoc_cast,line,multiline
+DROPPED	)|(⟨⟩/*	line
+DROPPED	)⟨⟩!()	annotation,block,jsdoc_cast
+DROPPED	)⟨⟩!`	annotation,block,jsdoc_cast
+DROPPED	)⟨⟩)	annotation,block,jsdoc_cast,line,multiline
+DROPPED	)⟨⟩));	annotation,block,jsdoc_cast,line,multiline
+DROPPED	)⟨⟩),	annotation,block,jsdoc_cast,line,multiline
+DROPPED	)⟨⟩);	annotation,block,jsdoc_cast,line,multiline
+DROPPED	)⟨⟩)?]	annotation,block,jsdoc_cast,line,multiline
+DROPPED	)⟨⟩++;	annotation,block,jsdoc_cast
+DROPPED	)⟨⟩,	annotation,block,jsdoc_cast,line,multiline
+DROPPED	)⟨⟩;	annotation,block,jsdoc_cast,line,multiline
+DROPPED	)⟨⟩=>	annotation,block,jsdoc_cast
+DROPPED	)⟨⟩=>(	annotation,block,jsdoc_cast
+DROPPED	)⟨⟩=>[	annotation,block,jsdoc_cast
+DROPPED	)⟨⟩?];	annotation,block,jsdoc_cast,line,multiline
+DROPPED	)⟨⟩[])	annotation,block,jsdoc_cast
+DROPPED	)⟨⟩[];	annotation,block,jsdoc_cast
+DROPPED	)⟨⟩[][	annotation,block,jsdoc_cast
+DROPPED	)⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DROPPED	*#⟨⟩IDENT	annotation,block,jsdoc_cast,line,multiline
+DROPPED	*/(⟨⟩IDENT	line,multiline
+DROPPED	*/,⟨⟩,	annotation,block,jsdoc_cast
+DROPPED	*/,⟨⟩,,]	annotation,block,jsdoc_cast
+DROPPED	*/,⟨⟩//	annotation,block,jsdoc_cast
+DROPPED	*/,⟨⟩␣	annotation,block,jsdoc_cast
+DROPPED	*/⟨⟩(	jsdoc_cast
+DROPPED	*/⟨⟩,	annotation,block,jsdoc_cast,line,multiline
+DROPPED	*/⟨⟩,/*	line
+DROPPED	*/⟨⟩...	line
+DROPPED	*/⟨⟩/*	line,multiline
+DROPPED	*/⟨⟩IDENT	line
+DROPPED	*/⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DROPPED	++(⟨⟩IDENT	line
+DROPPED	++(⟨⟩␣	line
+DROPPED	++⟨⟩(	annotation,block,line,multiline
+DROPPED	++⟨⟩);	annotation,block,jsdoc_cast,multiline
+DROPPED	++⟨⟩IDENT	line
+DROPPED	++⟨⟩␣	line,multiline
+DROPPED	+⟨⟩IDENT	line
+DROPPED	+⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DROPPED	,(⟨⟩IDENT	annotation,block,jsdoc_cast,line,multiline
+DROPPED	,,,⟨⟩,/*	annotation,block,jsdoc_cast
+DROPPED	,,⟨⟩,	annotation,block,jsdoc_cast
+DROPPED	,[]⟨⟩);	annotation,block,jsdoc_cast,multiline
+DROPPED	,{}⟨⟩);	annotation,block,jsdoc_cast,multiline
+DROPPED	,⟨⟩,	annotation,block,jsdoc_cast
+DROPPED	,⟨⟩,,	annotation,block,jsdoc_cast
+DROPPED	,⟨⟩/*	multiline
+DROPPED	,⟨⟩//	annotation,block,jsdoc_cast,multiline
+DROPPED	,⟨⟩>(	annotation,block,jsdoc_cast,multiline
+DROPPED	,⟨⟩>()	annotation,block,jsdoc_cast,multiline
+DROPPED	,⟨⟩>(/	annotation,block,jsdoc_cast,multiline
+DROPPED	,⟨⟩>/*	annotation,block,jsdoc_cast,multiline
+DROPPED	,⟨⟩IDENT	annotation,block,jsdoc_cast,multiline
+DROPPED	,⟨⟩]	annotation,block,jsdoc_cast,multiline
+DROPPED	,⟨⟩]);	multiline
+DROPPED	,⟨⟩];	annotation,block,jsdoc_cast,multiline
+DROPPED	,⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DROPPED	--⟨⟩IDENT	line
+DROPPED	--⟨⟩␣	line
+DROPPED	-⟨⟩NUM	annotation,block,jsdoc_cast,line,multiline
+DROPPED	.#⟨⟩IDENT	annotation,block,jsdoc_cast,line,multiline
+DROPPED	.()⟨⟩)!(	annotation,block,jsdoc_cast,line,multiline
+DROPPED	.()⟨⟩)!`	annotation,block,jsdoc_cast,line,multiline
+DROPPED	...⟨⟩(	jsdoc_cast
+DROPPED	./⟨⟩*	multiline
+DROPPED	/*⟨⟩␣	line
+DROPPED	/,,⟨⟩,];	annotation,block,jsdoc_cast
+DROPPED	//*⟨⟩␣	line
+DROPPED	//⟨⟩␣	line
+DROPPED	/⟨⟩);	annotation,block,jsdoc_cast,multiline
+DROPPED	/⟨⟩*	multiline
+DROPPED	/⟨⟩/	multiline
+DROPPED	/⟨⟩/*	line,multiline
+DROPPED	/⟨⟩␣	line,multiline
+DROPPED	:(|⟨⟩/*	line
+DROPPED	:(⟨⟩//	annotation,block,jsdoc_cast,multiline
+DROPPED	:|⟨⟩/*	line
+DROPPED	:⟨⟩//	multiline
+DROPPED	:⟨⟩␣	multiline
+DROPPED	;#⟨⟩IDENT	annotation,block,jsdoc_cast,line,multiline
+DROPPED	<-⟨⟩NUM	annotation,block,jsdoc_cast,line,multiline
+DROPPED	<⟨⟩IDENT	annotation,block,jsdoc_cast,multiline
+DROPPED	<⟨⟩const	annotation,block,jsdoc_cast,multiline
+DROPPED	<⟨⟩{	annotation,block,jsdoc_cast,multiline
+DROPPED	<⟨⟩{[	annotation,block,jsdoc_cast,multiline
+DROPPED	<⟨⟩␣	annotation,block,jsdoc_cast,multiline
+DROPPED	=&⟨⟩/*	line
+DROPPED	=(<⟨⟩IDENT	annotation,block,jsdoc_cast,multiline
+DROPPED	=(⟨⟩/*	line
+DROPPED	=(⟨⟩<	line
+DROPPED	=(⟨⟩IDENT	line
+DROPPED	=++⟨⟩IDENT	line
+DROPPED	=--⟨⟩IDENT	line
+DROPPED	=-⟨⟩NUM	annotation,block,jsdoc_cast,line,multiline
+DROPPED	=<⟨⟩IDENT	annotation,block,jsdoc_cast,multiline
+DROPPED	=>(⟨⟩{	line
+DROPPED	=>(⟨⟩{})	line
+DROPPED	=>⟨⟩␣	annotation,block,jsdoc_cast
+DROPPED	=[,⟨⟩,,,	annotation,block,jsdoc_cast
+DROPPED	=[,⟨⟩,,]	annotation,block,jsdoc_cast
+DROPPED	=[,⟨⟩,/*	annotation,block,jsdoc_cast
+DROPPED	=[,⟨⟩,];	annotation,block,jsdoc_cast
+DROPPED	=[⟨⟩,	annotation,block,jsdoc_cast,multiline
+DROPPED	=[⟨⟩,,,	annotation,block,jsdoc_cast,multiline
+DROPPED	=[⟨⟩,,/	annotation,block,jsdoc_cast,multiline
+DROPPED	=[⟨⟩,,]	annotation,block,jsdoc_cast,multiline
+DROPPED	=[⟨⟩,/*	annotation,block,jsdoc_cast,multiline
+DROPPED	=[⟨⟩,];	annotation,block,jsdoc_cast
+DROPPED	={⟨⟩IDENT	annotation,block,jsdoc_cast,line,multiline
+DROPPED	=|⟨⟩/*	line
+DROPPED	=⟨⟩␣	annotation,block,jsdoc_cast,multiline
+DROPPED	>(⟨⟩()=	line
+DROPPED	>(⟨⟩␣	line
+DROPPED	>)⟨⟩␣	annotation,jsdoc_cast
+DROPPED	>,⟨⟩>()	annotation,block,jsdoc_cast,multiline
+DROPPED	>?(⟨⟩IDENT	annotation,block,jsdoc_cast,multiline
+DROPPED	>[⟨⟩]]>	annotation,block,jsdoc_cast,line,multiline
+DROPPED	>}}⟨⟩␣	annotation,block,jsdoc_cast
+DROPPED	>}⟨⟩>()	annotation,block,jsdoc_cast,multiline
+DROPPED	>⟨⟩(	line
+DROPPED	>⟨⟩(()	line
+DROPPED	>⟨⟩)	annotation,jsdoc_cast
+DROPPED	>⟨⟩,>(	annotation,block,jsdoc_cast,multiline
+DROPPED	>⟨⟩[]]	annotation,block,jsdoc_cast
+DROPPED	>⟨⟩␣	annotation,block,jsdoc_cast,multiline
+DROPPED	?(⟨⟩//	annotation,block,jsdoc_cast,multiline
+DROPPED	?.#⟨⟩IDENT	annotation,block,jsdoc_cast,line,multiline
+DROPPED	?⟨⟩:	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩!	annotation,block,jsdoc_cast
+DROPPED	IDENT⟨⟩!!;	annotation,block,jsdoc_cast
+DROPPED	IDENT⟨⟩!()	annotation,block,jsdoc_cast
+DROPPED	IDENT⟨⟩!.	annotation,block,jsdoc_cast
+DROPPED	IDENT⟨⟩(	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩('	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩((	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩(()	line
+DROPPED	IDENT⟨⟩((/	line
+DROPPED	IDENT⟨⟩(({	line
+DROPPED	IDENT⟨⟩(..	line
+DROPPED	IDENT⟨⟩(/	line
+DROPPED	IDENT⟨⟩(/*	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩([	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩(['	line
+DROPPED	IDENT⟨⟩([[	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩(`	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩({	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩)	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩)!(	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩)!`	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩)()	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩))	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩)))	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩)).	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩));	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩)++	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩)+=	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩),	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩).	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩):	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩);	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩);}	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩)<	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩)=	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩)=>	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩)>	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩)>=	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩)?	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩)|	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩)}	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩)}>	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩+	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩++	annotation,block,jsdoc_cast
+DROPPED	IDENT⟨⟩++)	annotation,block,jsdoc_cast
+DROPPED	IDENT⟨⟩++,	annotation,block,jsdoc_cast
+DROPPED	IDENT⟨⟩++;	annotation,block,jsdoc_cast
+DROPPED	IDENT⟨⟩++}	annotation,block,jsdoc_cast
+DROPPED	IDENT⟨⟩,	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩,/*	line,multiline
+DROPPED	IDENT⟨⟩,//	line,multiline
+DROPPED	IDENT⟨⟩,>(	annotation,block,jsdoc_cast,multiline
+DROPPED	IDENT⟨⟩,>/	annotation,block,jsdoc_cast,multiline
+DROPPED	IDENT⟨⟩--	annotation,block,jsdoc_cast
+DROPPED	IDENT⟨⟩--)	annotation,block,jsdoc_cast
+DROPPED	IDENT⟨⟩--;	annotation,block,jsdoc_cast
+DROPPED	IDENT⟨⟩/	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩/*	line,multiline
+DROPPED	IDENT⟨⟩/*,	multiline
+DROPPED	IDENT⟨⟩:	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩:[.	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩=	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩=>	annotation,block,jsdoc_cast
+DROPPED	IDENT⟨⟩>	annotation,block,jsdoc_cast,multiline
+DROPPED	IDENT⟨⟩>(	annotation,block,jsdoc_cast,multiline
+DROPPED	IDENT⟨⟩>()	annotation,block,jsdoc_cast,multiline
+DROPPED	IDENT⟨⟩>(.	annotation,block,jsdoc_cast,multiline
+DROPPED	IDENT⟨⟩?	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩?)	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩?,	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩?:	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩?]	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩?];	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩[	annotation,block,jsdoc_cast
+DROPPED	IDENT⟨⟩[]	annotation,block,jsdoc_cast
+DROPPED	IDENT⟨⟩[])	annotation,block,jsdoc_cast
+DROPPED	IDENT⟨⟩[],	annotation,block,jsdoc_cast
+DROPPED	IDENT⟨⟩[];	annotation,block,jsdoc_cast
+DROPPED	IDENT⟨⟩[]=	annotation,block,jsdoc_cast
+DROPPED	IDENT⟨⟩[]>	annotation,block,jsdoc_cast
+DROPPED	IDENT⟨⟩[]]	annotation,block,jsdoc_cast
+DROPPED	IDENT⟨⟩[]{	annotation,block,jsdoc_cast
+DROPPED	IDENT⟨⟩[]|	annotation,block,jsdoc_cast
+DROPPED	IDENT⟨⟩]	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩]);	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩]:	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩];	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩]=>	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩]>	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩]>(	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩]>:	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩]>;	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩]>=	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩][	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩][]	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩]}	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩]})	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩]};	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩}	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩}`	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩}`;	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩}`}	annotation,block,jsdoc_cast,line,multiline
+DROPPED	IDENT⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DROPPED	NUM⟨⟩);	annotation,block,jsdoc_cast,multiline
+DROPPED	NUM⟨⟩/*	line,multiline
+DROPPED	NUM⟨⟩];	annotation,block,jsdoc_cast,line,multiline
+DROPPED	NUM⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DROPPED	[((⟨⟩IDENT	line
+DROPPED	[(⟨⟩(	annotation,block,jsdoc_cast,line,multiline
+DROPPED	[(⟨⟩IDENT	line
+DROPPED	[,,⟨⟩,,/	annotation,block,jsdoc_cast
+DROPPED	[,,⟨⟩,];	annotation,block,jsdoc_cast
+DROPPED	[,⟨⟩␣	annotation,block,jsdoc_cast
+DROPPED	[])⟨⟩[])	annotation,block,jsdoc_cast
+DROPPED	[])⟨⟩[];	annotation,block,jsdoc_cast
+DROPPED	[][⟨⟩];	annotation,block,jsdoc_cast,line,multiline
+DROPPED	[]⟨⟩);	annotation,block,jsdoc_cast,multiline
+DROPPED	[]⟨⟩:	annotation,block,jsdoc_cast,multiline
+DROPPED	[]⟨⟩>(.	annotation,block,jsdoc_cast,multiline
+DROPPED	[]⟨⟩␣	annotation,block,jsdoc_cast,multiline
+DROPPED	[⟨⟩,	annotation,block,jsdoc_cast,multiline
+DROPPED	[⟨⟩,];	annotation,block,jsdoc_cast
+DROPPED	[⟨⟩NUM	line
+DROPPED	[⟨⟩]	annotation,block,jsdoc_cast,line,multiline
+DROPPED	[⟨⟩])	annotation,block,jsdoc_cast,line,multiline
+DROPPED	[⟨⟩]))	annotation,block,jsdoc_cast,line,multiline
+DROPPED	[⟨⟩]),	annotation,block,jsdoc_cast,line,multiline
+DROPPED	[⟨⟩]):	annotation,block,jsdoc_cast,line,multiline
+DROPPED	[⟨⟩])=	annotation,block,jsdoc_cast,line,multiline
+DROPPED	[⟨⟩])[	annotation,block,jsdoc_cast,line,multiline
+DROPPED	[⟨⟩])]	annotation,block,jsdoc_cast,line,multiline
+DROPPED	[⟨⟩]){	annotation,block,jsdoc_cast,line,multiline
+DROPPED	[⟨⟩],	annotation,block,jsdoc_cast,line,multiline
+DROPPED	[⟨⟩],/	annotation,block,jsdoc_cast,line,multiline
+DROPPED	[⟨⟩];	annotation,block,jsdoc_cast,line,multiline
+DROPPED	[⟨⟩];}	annotation,block,jsdoc_cast,line,multiline
+DROPPED	[⟨⟩]=>	annotation,block,jsdoc_cast,line,multiline
+DROPPED	[⟨⟩]=[	annotation,block,jsdoc_cast,line,multiline
+DROPPED	[⟨⟩]>	annotation,block,jsdoc_cast,line,multiline
+DROPPED	[⟨⟩]>(	annotation,block,jsdoc_cast,line,multiline
+DROPPED	[⟨⟩]>=	annotation,block,jsdoc_cast,line,multiline
+DROPPED	[⟨⟩]>>	annotation,block,jsdoc_cast,line,multiline
+DROPPED	[⟨⟩]]	annotation,block,jsdoc_cast,line,multiline
+DROPPED	[⟨⟩]];	annotation,block,jsdoc_cast,line,multiline
+DROPPED	[⟨⟩]{	annotation,block,jsdoc_cast,line,multiline
+DROPPED	[⟨⟩]{}	annotation,block,jsdoc_cast,line,multiline
+DROPPED	[⟨⟩]|	annotation,block,jsdoc_cast,line,multiline
+DROPPED	[⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DROPPED	\(/⟨⟩)	annotation,block,jsdoc_cast,line,multiline
+DROPPED	]))⟨⟩[];	annotation,block,jsdoc_cast
+DROPPED	])[⟨⟩]))	annotation,block,jsdoc_cast,line,multiline
+DROPPED	])[⟨⟩]);	annotation,block,jsdoc_cast,line,multiline
+DROPPED	])[⟨⟩];	annotation,block,jsdoc_cast,line,multiline
+DROPPED	])⟨⟩[])	annotation,block,jsdoc_cast
+DROPPED	])⟨⟩␣	annotation,block,jsdoc_cast
+DROPPED	],⟨⟩␣	multiline
+DROPPED	][⟨⟩]);	annotation,block,jsdoc_cast,line,multiline
+DROPPED	][⟨⟩];	annotation,block,jsdoc_cast,line,multiline
+DROPPED	]⟨⟩)	annotation,block,jsdoc_cast,line,multiline
+DROPPED	]⟨⟩)*=	annotation,block,jsdoc_cast,line,multiline
+DROPPED	]⟨⟩);	annotation,block,jsdoc_cast,line,multiline
+DROPPED	]⟨⟩++;	annotation,block,jsdoc_cast
+DROPPED	]⟨⟩:	annotation,block,jsdoc_cast,line,multiline
+DROPPED	]⟨⟩[])	annotation,block,jsdoc_cast
+DROPPED	]⟨⟩[];	annotation,block,jsdoc_cast
+DROPPED	]⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DROPPED	`,⟨⟩,'	annotation,block,jsdoc_cast
+DROPPED	`,⟨⟩␣	annotation,block,jsdoc_cast
+DROPPED	`⟨⟩);	annotation,block,jsdoc_cast,line,multiline
+DROPPED	`⟨⟩␣	annotation,block,jsdoc_cast,multiline
+DROPPED	async⟨⟩(	annotation,block,jsdoc_cast,line,multiline
+DROPPED	async⟨⟩()=	annotation,block,jsdoc_cast,line,multiline
+DROPPED	async⟨⟩<	annotation,block,jsdoc_cast,line,multiline
+DROPPED	async⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DROPPED	await⟨⟩␣	jsdoc_cast
+DROPPED	case⟨⟩'	line
+DROPPED	case⟨⟩␣	line
+DROPPED	class⟨⟩<	annotation,block,jsdoc_cast,line,multiline
+DROPPED	class⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DROPPED	const⟨⟩,	line
+DROPPED	export⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DROPPED	function⟨⟩*	annotation,block,jsdoc_cast,line,multiline
+DROPPED	function⟨⟩*/*	annotation,block,jsdoc_cast,line,multiline
+DROPPED	function⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DROPPED	import⟨⟩(	annotation,block,jsdoc_cast,line,multiline
+DROPPED	import⟨⟩("	annotation,block,jsdoc_cast,line,multiline
+DROPPED	import⟨⟩(".	annotation,block,jsdoc_cast,line,multiline
+DROPPED	import⟨⟩('	annotation,block,jsdoc_cast,line,multiline
+DROPPED	import⟨⟩('.	annotation,block,jsdoc_cast,line,multiline
+DROPPED	import⟨⟩(/*	annotation,block,jsdoc_cast,line,multiline
+DROPPED	import⟨⟩(//	annotation,block,jsdoc_cast,line,multiline
+DROPPED	import⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DROPPED	require⟨⟩(	annotation,block,jsdoc_cast,line,multiline
+DROPPED	require⟨⟩('	annotation,block,jsdoc_cast,line,multiline
+DROPPED	require⟨⟩('.	annotation,block,jsdoc_cast,line,multiline
+DROPPED	require⟨⟩(/*	annotation,block,jsdoc_cast,line,multiline
+DROPPED	require⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DROPPED	return⟨⟩␣	jsdoc_cast,line,multiline
+DROPPED	typeof⟨⟩␣	jsdoc_cast
+DROPPED	type⟨⟩)];	annotation,block,jsdoc_cast,line,multiline
+DROPPED	type⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DROPPED	void⟨⟩␣	annotation,block,jsdoc_cast
+DROPPED	yield⟨⟩*	annotation,block,jsdoc_cast,line,multiline
+DROPPED	{#⟨⟩IDENT	annotation,block,jsdoc_cast,line,multiline
+DROPPED	{(<⟨⟩IDENT	annotation,block,jsdoc_cast,multiline
+DROPPED	{++⟨⟩IDENT	line
+DROPPED	{},⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DROPPED	{}⟨⟩);	annotation,block,jsdoc_cast,line,multiline
+DROPPED	{}⟨⟩,	annotation,block,jsdoc_cast,line,multiline
+DROPPED	{}⟨⟩:	annotation,block,jsdoc_cast,multiline
+DROPPED	{}⟨⟩␣	multiline
+DROPPED	|(⟨⟩/*	line
+DROPPED	|(⟨⟩//	annotation,block,jsdoc_cast,multiline
+DROPPED	|⟨⟩␣	line
+DROPPED	})⟨⟩!.	annotation,block,jsdoc_cast
+DROPPED	})⟨⟩![	annotation,block,jsdoc_cast
+DROPPED	})⟨⟩)	annotation,block,jsdoc_cast,line,multiline
+DROPPED	})⟨⟩);	annotation,block,jsdoc_cast,multiline
+DROPPED	})⟨⟩␣	annotation,block,jsdoc_cast,multiline
+DROPPED	}*#⟨⟩IDENT	annotation,block,jsdoc_cast,line,multiline
+DROPPED	},⟨⟩//	multiline
+DROPPED	},⟨⟩>(	annotation,block,jsdoc_cast,multiline
+DROPPED	},⟨⟩>()	annotation,block,jsdoc_cast,multiline
+DROPPED	},⟨⟩␣	annotation,block,jsdoc_cast,multiline
+DROPPED	}`⟨⟩}`;	annotation,block,jsdoc_cast,line,multiline
+DROPPED	}`⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DROPPED	}⟨⟩)	annotation,block,jsdoc_cast,line,multiline
+DROPPED	}⟨⟩))	annotation,block,jsdoc_cast,line,multiline
+DROPPED	}⟨⟩)).	annotation,block,jsdoc_cast,line,multiline
+DROPPED	}⟨⟩));	annotation,block,jsdoc_cast,multiline
+DROPPED	}⟨⟩).	annotation,block,jsdoc_cast,line,multiline
+DROPPED	}⟨⟩);	annotation,block,jsdoc_cast,line,multiline
+DROPPED	}⟨⟩,	annotation,block,jsdoc_cast,multiline
+DROPPED	}⟨⟩,//	multiline
+DROPPED	}⟨⟩,>(	annotation,block,jsdoc_cast,multiline
+DROPPED	}⟨⟩:	annotation,block,jsdoc_cast,line,multiline
+DROPPED	}⟨⟩:{	annotation,block,jsdoc_cast,line,multiline
+DROPPED	}⟨⟩>(	annotation,block,jsdoc_cast,multiline
+DROPPED	}⟨⟩>('	annotation,block,jsdoc_cast,multiline
+DROPPED	}⟨⟩>()	annotation,block,jsdoc_cast,multiline
+DROPPED	}⟨⟩>(`	annotation,block,jsdoc_cast,multiline
+DROPPED	}⟨⟩>;	annotation,block,jsdoc_cast,multiline
+DROPPED	}⟨⟩>`	annotation,block,jsdoc_cast,multiline
+DROPPED	}⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DROPPED	~⟨⟩(	jsdoc_cast
+DROPPED	␣⟨⟩!.	annotation,block,jsdoc_cast
+DROPPED	␣⟨⟩"	annotation,block,jsdoc_cast,multiline
+DROPPED	␣⟨⟩"\"	annotation,block,jsdoc_cast,multiline
+DROPPED	␣⟨⟩&	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩'	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩'\	annotation,block,jsdoc_cast,multiline
+DROPPED	␣⟨⟩'\'	annotation,block,jsdoc_cast,multiline
+DROPPED	␣⟨⟩'\\	annotation,block,jsdoc_cast,multiline
+DROPPED	␣⟨⟩(	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩((	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩(()	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩(([	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩()	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩():	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩()=	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩([	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩({	jsdoc_cast
+DROPPED	␣⟨⟩({}	multiline
+DROPPED	␣⟨⟩)	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩)!`	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩)!}	annotation,block,jsdoc_cast,multiline
+DROPPED	␣⟨⟩)(	annotation,block,jsdoc_cast,multiline
+DROPPED	␣⟨⟩)++	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩),	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩).	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩)//	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩);	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩);/	annotation,block,jsdoc_cast,multiline
+DROPPED	␣⟨⟩)?.	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩)[/	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩)}'	annotation,block,jsdoc_cast,multiline
+DROPPED	␣⟨⟩)}`	annotation,block,jsdoc_cast,multiline
+DROPPED	␣⟨⟩*/	line
+DROPPED	␣⟨⟩*//	line
+DROPPED	␣⟨⟩+	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩++	annotation,block,jsdoc_cast
+DROPPED	␣⟨⟩++;	annotation,block,jsdoc_cast
+DROPPED	␣⟨⟩,	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩,'	annotation,block,jsdoc_cast
+DROPPED	␣⟨⟩,/*	annotation,block,jsdoc_cast
+DROPPED	␣⟨⟩,];	annotation,block,jsdoc_cast
+DROPPED	␣⟨⟩--;	annotation,block,jsdoc_cast
+DROPPED	␣⟨⟩...	line,multiline
+DROPPED	␣⟨⟩/	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩/*	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩/*,	multiline
+DROPPED	␣⟨⟩//	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩:	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩;	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩<	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩=	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩=/*	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩=>	annotation,block,jsdoc_cast
+DROPPED	␣⟨⟩>	annotation,block,jsdoc_cast,multiline
+DROPPED	␣⟨⟩>(	annotation,block,jsdoc_cast,multiline
+DROPPED	␣⟨⟩>()	multiline
+DROPPED	␣⟨⟩IDENT	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩NUM	line
+DROPPED	␣⟨⟩[	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩['	line,multiline
+DROPPED	␣⟨⟩]	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩];	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩][	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩][]	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩as	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩class	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩{	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩{}	multiline
+DROPPED	␣⟨⟩{})	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩}	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩})!	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩}).	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩});	multiline
+DROPPED	␣⟨⟩})?	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩})[	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩}`	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩}`;	annotation,block,jsdoc_cast,line,multiline
+DROPPED	␣⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	',⟨⟩␣	annotation,block,jsdoc_cast,multiline
+DOUBLE-PRINTED	'}⟨⟩/*	line
+DOUBLE-PRINTED	'}⟨⟩;	line
+DOUBLE-PRINTED	'⟨⟩,	line
+DOUBLE-PRINTED	'⟨⟩,/*	line
+DOUBLE-PRINTED	'⟨⟩}/*	line
+DOUBLE-PRINTED	'⟨⟩};	line
+DOUBLE-PRINTED	'⟨⟩␣	line
+DOUBLE-PRINTED	(;⟨⟩IDENT	line
+DOUBLE-PRINTED	(;⟨⟩␣	annotation,block,line,multiline
+DOUBLE-PRINTED	(@⟨⟩/*	line
+DOUBLE-PRINTED	(@⟨⟩IDENT	line
+DOUBLE-PRINTED	(@⟨⟩␣	line
+DOUBLE-PRINTED	([⟨⟩(	jsdoc_cast
+DOUBLE-PRINTED	([⟨⟩␣	jsdoc_cast
+DOUBLE-PRINTED	(⟨⟩IDENT	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	(⟨⟩NUM	line
+DOUBLE-PRINTED	).⟨⟩IDENT	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	);⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	)⟨⟩.	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	)⟨⟩␣	line
+DOUBLE-PRINTED	*/)⟨⟩);	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	*/,⟨⟩/*	multiline
+DOUBLE-PRINTED	*/,⟨⟩IDENT	annotation,block,jsdoc_cast,multiline
+DOUBLE-PRINTED	*/,⟨⟩␣	annotation,block,jsdoc_cast,multiline
+DOUBLE-PRINTED	*/}⟨⟩;	line
+DOUBLE-PRINTED	*/⟨⟩,	line
+DOUBLE-PRINTED	*/⟨⟩,/*	line,multiline
+DOUBLE-PRINTED	*/⟨⟩;	line
+DOUBLE-PRINTED	*/⟨⟩IDENT	line
+DOUBLE-PRINTED	*/⟨⟩␣	line
+DOUBLE-PRINTED	,⟨⟩/*	line,multiline
+DOUBLE-PRINTED	,⟨⟩//	annotation,block,jsdoc_cast,multiline
+DOUBLE-PRINTED	,⟨⟩IDENT	annotation,block,jsdoc_cast,multiline
+DOUBLE-PRINTED	,⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	...⟨⟩IDENT	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	/*⟨⟩␣	line
+DOUBLE-PRINTED	:⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	;;;⟨⟩␣	multiline
+DOUBLE-PRINTED	;;⟨⟩IDENT	line
+DOUBLE-PRINTED	;⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	<⟨⟩IDENT	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	=>⟨⟩␣	annotation,block,jsdoc_cast,multiline
+DOUBLE-PRINTED	=⟨⟩␣	annotation,block,jsdoc_cast,multiline
+DOUBLE-PRINTED	>{⟨⟩IDENT	line
+DOUBLE-PRINTED	>⟨⟩()	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	?,⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	?⟨⟩,	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	?⟨⟩]	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	?⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	@⟨⟩IDENT	line
+DOUBLE-PRINTED	IDENT⟨⟩(	line
+DOUBLE-PRINTED	IDENT⟨⟩)	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	IDENT⟨⟩).	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	IDENT⟨⟩,	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	IDENT⟨⟩,/*	line,multiline
+DOUBLE-PRINTED	IDENT⟨⟩,//	line,multiline
+DOUBLE-PRINTED	IDENT⟨⟩/*	line,multiline
+DOUBLE-PRINTED	IDENT⟨⟩:	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	IDENT⟨⟩;	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	IDENT⟨⟩>()	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	IDENT⟨⟩]	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	IDENT⟨⟩])	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	IDENT⟨⟩]]	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	IDENT⟨⟩}	line
+DOUBLE-PRINTED	IDENT⟨⟩};	line
+DOUBLE-PRINTED	IDENT⟨⟩}</	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	IDENT⟨⟩}{:	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	IDENT⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	NUM⟨⟩)	line
+DOUBLE-PRINTED	[[⟨⟩IDENT	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	[]⟨⟩]	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	[{⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	[⟨⟩(	jsdoc_cast
+DOUBLE-PRINTED	[⟨⟩IDENT	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	[⟨⟩[	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	[⟨⟩{	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	[⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	\)/⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	]:⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	]?:⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	]]:⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	]⟨⟩]	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	extends⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	{⟨⟩IDENT	line
+DOUBLE-PRINTED	{⟨⟩type	line
+DOUBLE-PRINTED	{⟨⟩␣	line
+DOUBLE-PRINTED	};⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	}{⟨⟩IDENT	line
+DOUBLE-PRINTED	}⟨⟩)	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	}⟨⟩)};	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	}⟨⟩;	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	}⟨⟩]	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	}⟨⟩␣	line
+DOUBLE-PRINTED	␣⟨⟩(	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	␣⟨⟩(<	jsdoc_cast
+DOUBLE-PRINTED	␣⟨⟩*/,	line
+DOUBLE-PRINTED	␣⟨⟩...	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	␣⟨⟩/*	line,multiline
+DOUBLE-PRINTED	␣⟨⟩//	annotation,block,jsdoc_cast,multiline
+DOUBLE-PRINTED	␣⟨⟩:	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	␣⟨⟩;	line
+DOUBLE-PRINTED	␣⟨⟩?	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	␣⟨⟩@	line
+DOUBLE-PRINTED	␣⟨⟩IDENT	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	␣⟨⟩[	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	␣⟨⟩[[	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	␣⟨⟩[{	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	␣⟨⟩async	annotation,block,jsdoc_cast,multiline
+DOUBLE-PRINTED	␣⟨⟩extends	annotation,block,jsdoc_cast
+DOUBLE-PRINTED	␣⟨⟩from	annotation,block,jsdoc_cast,multiline
+DOUBLE-PRINTED	␣⟨⟩private	line
+DOUBLE-PRINTED	␣⟨⟩protected	line
+DOUBLE-PRINTED	␣⟨⟩public	line
+DOUBLE-PRINTED	␣⟨⟩readonly	line
+DOUBLE-PRINTED	␣⟨⟩type	line
+DOUBLE-PRINTED	␣⟨⟩{	line
+DOUBLE-PRINTED	␣⟨⟩}	line
+DOUBLE-PRINTED	␣⟨⟩})	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	␣⟨⟩};	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	␣⟨⟩}]	annotation,block,jsdoc_cast,line,multiline
+DOUBLE-PRINTED	␣⟨⟩␣	annotation,block,jsdoc_cast,line,multiline
diff --git a/crates/tsv_debug/src/cli/commands/mod.rs b/crates/tsv_debug/src/cli/commands/mod.rs
index aa1e984f2..64fda82d4 100644
--- a/crates/tsv_debug/src/cli/commands/mod.rs
+++ b/crates/tsv_debug/src/cli/commands/mod.rs
@@ -18,6 +18,8 @@ pub mod fixtures_update_parsed;
 pub mod fixtures_validate;
 pub mod format_prettier;
 pub mod fuzz;
+#[cfg(feature = "comment_check")]
+pub mod gap_audit;
 pub mod json_profile;
 pub mod lex_diff;
 pub mod line_width;
diff --git a/crates/tsv_debug/src/cli/mod.rs b/crates/tsv_debug/src/cli/mod.rs
index ac57a751c..14131db1d 100644
--- a/crates/tsv_debug/src/cli/mod.rs
+++ b/crates/tsv_debug/src/cli/mod.rs
@@ -3,6 +3,8 @@ pub mod commands;
 use argh::FromArgs;
 #[cfg(feature = "comment_check")]
 use commands::comment_audit::CommentAuditCommand;
+#[cfg(feature = "comment_check")]
+use commands::gap_audit::GapAuditCommand;
 #[cfg(feature = "swallow_check")]
 use commands::swallow_audit::SwallowAuditCommand;
 use commands::{
@@ -71,6 +73,10 @@ pub enum Subcommand {
     // `comments:audit` deno task passes it.
     #[cfg(feature = "comment_check")]
     CommentAudit(CommentAuditCommand),
+    // Same `comment_check` gate as `CommentAudit` — it drives the same ledger; the
+    // `gaps:audit` deno task passes the feature.
+    #[cfg(feature = "comment_check")]
+    GapAudit(GapAuditCommand),
     Compare(CompareCommand),
     ConformanceAudit(ConformanceAuditCommand),
     AstDiff(AstDiffCommand),
@@ -117,6 +123,8 @@ impl TopLevel {
             Subcommand::BuildFanoutAudit(c) => c.run(),
             #[cfg(feature = "comment_check")]
             Subcommand::CommentAudit(c) => c.run(),
+            #[cfg(feature = "comment_check")]
+            Subcommand::GapAudit(c) => c.run(),
             Subcommand::Compare(c) => c.run(),
             Subcommand::ConformanceAudit(c) => c.run(),
             Subcommand::AstDiff(c) => c.run(),
diff --git a/crates/tsv_lang/src/doc/arena.rs b/crates/tsv_lang/src/doc/arena.rs
index 00dba2ead..11ed2ba7b 100644
--- a/crates/tsv_lang/src/doc/arena.rs
+++ b/crates/tsv_lang/src/doc/arena.rs
@@ -32,6 +32,21 @@ use super::types::{
     TEXT_WIDTH_NOT_COMPUTED,
 };
 
+/// Whether a line-flattening walk may delete a **hard** line.
+///
+/// The two answers are two different operations wearing one walk — see
+/// [`DocArena::remove_lines`] (prettier's `removeLines`, [`Self::Keep`]) versus
+/// [`DocArena::flatten_all_lines`] (atomize, [`Self::Drop`]). Naming the axis is the point:
+/// dropping a hard line deletes a newline the content required, so it is only ever sound
+/// where the caller has proved none is required.
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+enum HardLines {
+    /// Leave hard/literal lines (and `MultilineText`) alone — prettier's `!doc.hard` gate.
+    Keep,
+    /// Delete them, fusing whatever sat on either side.
+    Drop,
+}
+
 /// Index into `DocArena.nodes`.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub struct DocId(u32);
@@ -1537,14 +1552,61 @@ impl DocArena {
         }
     }
 
-    /// Remove all line breaks from a doc, forcing it to stay on a single line.
+    /// Statically flatten a doc's **soft and normal** lines.
     /// Creates new nodes; old nodes remain in the arena (they're just unused).
+    ///
+    /// **A hard line is deliberately left alone** — prettier's `removeLinesFn`
+    /// (`src/document/utilities/index.js`) gates on `!doc.hard` and says why: *"Hard lines
+    /// should still output because there's too great of a chance of breaking existing
+    /// assumptions otherwise."* Removing one doesn't relayout the doc, it **deletes a
+    /// newline the content required**, and the content on either side fuses. A multi-line
+    /// block comment in a flattened arrow signature is the case that bit us: `/* a⏎b */`
+    /// came out `/* ab */`, silently gluing `a` to `b` (fixture
+    /// `typescript/expressions/calls/arrow_array_return_multiline_comment`).
+    ///
+    /// [`DocNode::MultilineText`] is left alone for the same reason: its `\n`s *are* hard
+    /// lines — the render arm emits each as a context-indented hardline — merely
+    /// pre-joined into one pooled body. Flattening it is removing hard lines by another
+    /// name.
+    ///
+    /// So this cannot promise a single line, and never could: a caller flattening a doc
+    /// that contains a hard line gets a shorter doc, not a one-line one. That is prettier's
+    /// contract too — `expandLastArg` flattens the signature so *breakable* params can't
+    /// break, not to overrule content that must break. A caller that genuinely needs
+    /// one line no matter what wants [`Self::flatten_all_lines`] — a different question,
+    /// and now a different name.
     pub fn remove_lines(&self, id: DocId) -> DocId {
+        self.remove_lines_impl(id, HardLines::Keep)
+    }
+
+    /// Flatten **every** line — hard ones included — onto a single line.
+    ///
+    /// Not prettier's `removeLines` (that is [`Self::remove_lines`], which keeps hard
+    /// lines). This is the stronger, un-prettier-like *atomize*: force a doc onto one line
+    /// even past the print width. Prettier reaches the same place by re-rendering the doc
+    /// at `printWidth: Infinity` and substituting the resulting string
+    /// (`template-literal.js`); this achieves it as a doc transform.
+    ///
+    /// **Only sound where the content provably has no required newline.** Deleting a hard
+    /// line does not relayout anything — it deletes a newline the content demanded, fusing
+    /// whatever sat on either side (`/* a⏎b */` → `/* ab */`, gluing `a` to `b`). Its one
+    /// caller, the template-interpolation atomizer, first routes any interpolation
+    /// containing a comment or a source newline down a *different* branch, so nothing that
+    /// must break can reach here.
+    ///
+    /// The two used to be one function that kept prettier's name while quietly doing this,
+    /// which is how a multi-line comment in a flattened arrow signature got its newline
+    /// deleted. Two questions, two names.
+    pub fn flatten_all_lines(&self, id: DocId) -> DocId {
+        self.remove_lines_impl(id, HardLines::Drop)
+    }
+
+    fn remove_lines_impl(&self, id: DocId, hard: HardLines) -> DocId {
         // Extract node info while borrowing, then release borrow before allocating.
         // This pattern avoids RefCell conflicts since alloc() needs borrow_mut().
         enum Info {
             Keep, // Return id unchanged
-            MultilineText(String),
+            FlattenedMultilineText(String),
             Line(LineKind),
             Indent(DocId),
             Dedent(DocId),
@@ -1568,13 +1630,15 @@ impl DocArena {
             let nodes = self.nodes.borrow();
             match &nodes[id.index()] {
                 DocNode::Text(_) | DocNode::LineSuffixBoundary => Info::Keep,
-                // Flatten: drop the internal hardlines (→ empty) and join the
-                // lines with no separator — identical to remove_lines over the
-                // per-line `concat([text, hardline, text, …])` this replaces.
-                DocNode::MultilineText { span, .. } => {
-                    let pool = self.text_pool.borrow();
-                    Info::MultilineText(span.slice(&pool).replace('\n', ""))
-                }
+                // `MultilineText`'s `\n`s are hard lines pre-joined into one body, so it
+                // follows `hard` for the same reason a `Line(Hard)` does — see the fn docs.
+                DocNode::MultilineText { span, .. } => match hard {
+                    HardLines::Keep => Info::Keep,
+                    HardLines::Drop => {
+                        let pool = self.text_pool.borrow();
+                        Info::FlattenedMultilineText(span.slice(&pool).replace('\n', ""))
+                    }
+                },
                 DocNode::Line(kind) => Info::Line(*kind),
                 DocNode::Indent(inner) => Info::Indent(*inner),
                 DocNode::Dedent(inner) => Info::Dedent(*inner),
@@ -1608,21 +1672,29 @@ impl DocArena {
 
         match info {
             Info::Keep => id,
-            Info::MultilineText(flat) => self.text_pooled(&flat),
+            Info::FlattenedMultilineText(flat) => self.text_pooled(&flat),
             Info::Line(kind) => match kind {
                 LineKind::Normal => self.text(" "),
-                LineKind::Soft | LineKind::Hard | LineKind::Literal => self.empty(),
+                LineKind::Soft => self.empty(),
+                // Prettier's `!doc.hard` gate: a hard line passes through untouched, because
+                // removing one deletes a required newline rather than relayouting anything.
+                // Only `flatten_all_lines`, whose content provably has no required newline,
+                // drops them.
+                LineKind::Hard | LineKind::Literal => match hard {
+                    HardLines::Keep => id,
+                    HardLines::Drop => self.empty(),
+                },
             },
             Info::Indent(inner) => {
-                let new_inner = self.remove_lines(inner);
+                let new_inner = self.remove_lines_impl(inner, hard);
                 self.indent(new_inner)
             }
             Info::Dedent(inner) => {
-                let new_inner = self.remove_lines(inner);
+                let new_inner = self.remove_lines_impl(inner, hard);
                 self.dedent(new_inner)
             }
             Info::Align(n, contents) => {
-                let new_contents = self.remove_lines(contents);
+                let new_contents = self.remove_lines_impl(contents, hard);
                 self.align(n, new_contents)
             }
             Info::Group {
@@ -1631,7 +1703,7 @@ impl DocArena {
                 id: group_id,
                 should_break,
             } => {
-                let flat_contents = self.remove_lines(contents);
+                let flat_contents = self.remove_lines_impl(contents, hard);
                 if should_break {
                     self.alloc(DocNode::Group {
                         contents: flat_contents,
@@ -1647,8 +1719,10 @@ impl DocArena {
                             let children = self.children.borrow();
                             DocBuf::from_slice(expanded_states.resolve(&children))
                         };
-                        let new_kids: DocBuf =
-                            kids.into_iter().map(|kid| self.remove_lines(kid)).collect();
+                        let new_kids: DocBuf = kids
+                            .into_iter()
+                            .map(|kid| self.remove_lines_impl(kid, hard))
+                            .collect();
                         self.alloc_children(&new_kids)
                     };
                     self.alloc(DocNode::Group {
@@ -1659,25 +1733,29 @@ impl DocArena {
                     })
                 }
             }
-            Info::IfBreakFlat(flat_doc) => self.remove_lines(flat_doc),
-            Info::IndentIfBreakContents(contents) => self.remove_lines(contents),
+            Info::IfBreakFlat(flat_doc) => self.remove_lines_impl(flat_doc, hard),
+            Info::IndentIfBreakContents(contents) => self.remove_lines_impl(contents, hard),
             Info::Concat(kids) => {
-                let flattened: DocBuf =
-                    kids.into_iter().map(|kid| self.remove_lines(kid)).collect();
+                let flattened: DocBuf = kids
+                    .into_iter()
+                    .map(|kid| self.remove_lines_impl(kid, hard))
+                    .collect();
                 self.concat(&flattened)
             }
             Info::Fill(kids) => {
                 // Fill becomes regular concat when flattened
-                let flattened: DocBuf =
-                    kids.into_iter().map(|kid| self.remove_lines(kid)).collect();
+                let flattened: DocBuf = kids
+                    .into_iter()
+                    .map(|kid| self.remove_lines_impl(kid, hard))
+                    .collect();
                 self.concat(&flattened)
             }
             Info::WithContext(doc, context) => {
-                let new_doc = self.remove_lines(doc);
+                let new_doc = self.remove_lines_impl(doc, hard);
                 self.with_context(new_doc, context)
             }
             Info::LineSuffix(inner) => {
-                let new_inner = self.remove_lines(inner);
+                let new_inner = self.remove_lines_impl(inner, hard);
                 self.line_suffix(new_inner)
             }
             Info::BreakParent => self.empty(),
diff --git a/crates/tsv_lang/src/doc/mod.rs b/crates/tsv_lang/src/doc/mod.rs
index d308c77b8..7edd8db17 100644
--- a/crates/tsv_lang/src/doc/mod.rs
+++ b/crates/tsv_lang/src/doc/mod.rs
@@ -485,11 +485,50 @@ mod arena_tests {
 
     #[test]
     fn test_arena_multiline_text_remove_lines() {
-        // Flattening drops the internal hardlines (→ empty) and joins the lines
-        // with no separator — matches `remove_lines` over the per-line concat.
+        // `remove_lines` must NOT touch a `MultilineText`: its `\n`s are hard lines, and
+        // prettier's `removeLinesFn` gates on `!doc.hard` precisely so content that must
+        // break still breaks.
         let a = DocArena::new();
         let flat = a.remove_lines(a.multiline_text("/*a\n b\n c*/"));
-        assert_eq!(render_default(&a, flat), "/*a b c*/");
+        assert_eq!(render_default(&a, flat), "/*a\n b\n c*/");
+    }
+
+    /// The glue this guards against, in the shape that shows it.
+    ///
+    /// The old behavior joined the lines with no separator, and the case above CANNOT see
+    /// that: every line of `/*a\n b\n c*/` already starts with a space, so dropping the
+    /// newlines still rendered `/*a b c*/` — which reads fine. Only a body whose lines
+    /// would FUSE reveals it, so pin one.
+    #[test]
+    fn test_arena_multiline_text_remove_lines_does_not_glue_words() {
+        let a = DocArena::new();
+        let flat = a.remove_lines(a.multiline_text("/*text1\ntext2*/"));
+        assert_eq!(
+            render_default(&a, flat),
+            "/*text1\ntext2*/",
+            "flattening must not fuse `text1` and `text2` into `text1text2`"
+        );
+    }
+
+    /// A hard line survives; a soft/normal one does not. The whole contract in one case.
+    #[test]
+    fn test_arena_remove_lines_keeps_hard_drops_soft_and_normal() {
+        let a = DocArena::new();
+        // Normal → space, soft → nothing: the flattening `remove_lines` really does do.
+        let soft_and_normal = a.concat(&[
+            a.text("a"),
+            a.line(),
+            a.text("b"),
+            a.softline(),
+            a.text("c"),
+        ]);
+        assert_eq!(render_default(&a, a.remove_lines(soft_and_normal)), "a bc");
+
+        // Hard and literal → untouched, because removing one deletes a required newline.
+        let hard = a.concat(&[a.text("a"), a.hardline(), a.text("b")]);
+        assert_eq!(render_default(&a, a.remove_lines(hard)), "a\nb");
+        let literal = a.concat(&[a.text("a"), a.literalline(), a.text("b")]);
+        assert_eq!(render_default(&a, a.remove_lines(literal)), "a\nb");
     }
 
     #[test]
diff --git a/crates/tsv_svelte/src/printer/nodes/helpers.rs b/crates/tsv_svelte/src/printer/nodes/helpers.rs
index 625bac260..354d09bf2 100644
--- a/crates/tsv_svelte/src/printer/nodes/helpers.rs
+++ b/crates/tsv_svelte/src/printer/nodes/helpers.rs
@@ -630,7 +630,27 @@ impl<'a> Printer<'a> {
             .map(|c| self.build_trailing_js_comment_doc(c))
             .collect();
 
-        self.concat_with_surrounding_comments(leading_docs, expr_doc, trailing_docs)
+        let body = self.concat_with_surrounding_comments(leading_docs, expr_doc, trailing_docs);
+
+        // A leading LINE comment breaks the head (`build_leading_js_comment_doc` ends it
+        // with a hardline), so what follows starts a genuine continuation line and takes the
+        // continuation indent — the same shape a width-wrapped head gets:
+        //
+        //     {#if a &&        {#if // c1
+        //         b            \tcond
+        //     }                }
+        //
+        // The rule is keyed on *that* the head broke, not on why; without the indent the
+        // condition sits at base with the `}` dangling below it, closing nothing.
+        //
+        // A leading BLOCK comment is deliberately excluded, multi-line or not. It ends with
+        // a space, never a hardline: a single-line one doesn't break the head at all, and a
+        // multi-line one's newlines live *inside* its verbatim source span, which renders
+        // with no context indent by design (the interior stays as authored), so its
+        // continuation is the comment's own line and there is nothing to indent.
+        let breaks_head =
+            comments_to_emit_in_range(self.comments, span_start, expr_start).any(|c| !c.is_block);
+        if breaks_head { d.indent(body) } else { body }
     }
 
     /// Build a block head's expression doc, deriving both the comment-scan start offset
diff --git a/crates/tsv_ts/src/printer/analysis.rs b/crates/tsv_ts/src/printer/analysis.rs
index cf2609f62..4947622c0 100644
--- a/crates/tsv_ts/src/printer/analysis.rs
+++ b/crates/tsv_ts/src/printer/analysis.rs
@@ -516,13 +516,18 @@ pub(crate) fn build_entity_name_doc(
     printer: &Printer<'_>,
     name: &internal::TSEntityName<'_>,
 ) -> DocId {
-    let d = printer.d();
     match name {
         internal::TSEntityName::Identifier(id) => printer.identifier_name_doc(id),
-        internal::TSEntityName::QualifiedName(qn) => d.concat(&[
+        // A qualified name is a dotted pair, so both gaps around the `.` are positions an
+        // author can comment in (`ns /* c */.Type`, `ns./* c */ Type`). The shared printer
+        // emits them; concatenating the three pieces scans neither and drops what's there.
+        // One printer serves every qualified name, so this reaches type references,
+        // interface heritage, and import-equals module references alike.
+        internal::TSEntityName::QualifiedName(qn) => printer.build_dotted_pair_doc(
             build_entity_name_doc(printer, &qn.left),
-            d.text("."),
             printer.identifier_name_doc(&qn.right),
-        ]),
+            qn.left.span().end,
+            qn.right.span.start,
+        ),
     }
 }
diff --git a/crates/tsv_ts/src/printer/calls/call_formatting.rs b/crates/tsv_ts/src/printer/calls/call_formatting.rs
index 023fe245f..3b2bf826a 100644
--- a/crates/tsv_ts/src/printer/calls/call_formatting.rs
+++ b/crates/tsv_ts/src/printer/calls/call_formatting.rs
@@ -27,6 +27,7 @@ use super::module_paths::{get_module_path_chain_break, is_boolean_call, is_modul
 use super::test_patterns::{build_test_callee_flat_doc, is_test_call};
 use crate::ast::internal;
 use crate::printer::CommentVec;
+use crate::printer::expressions::functions::arrow_signature_has_breaking_comments;
 use smallvec::smallvec;
 use tsv_lang::comments_to_emit_in_range;
 use tsv_lang::doc::DocBuf;
@@ -651,12 +652,17 @@ fn try_single_arg_hug(
                     internal::Expression::ObjectExpression(_)
                         | internal::Expression::ArrayExpression(_)
                 ) {
-                    return Some(d.concat(&[
-                        callee,
-                        d.text("("),
-                        printer.build_expression_doc(arg),
-                        d.text(")"),
-                    ]));
+                    // A break forced inside the signature invalidates the hug — see
+                    // `arrow_signature_has_breaking_comments`. Route to the broken-out
+                    // layout instead, which is where prettier's conditionalGroup lands.
+                    // Only a FORCED break counts: a merely long body array breaks on fits,
+                    // not on a hard line, so it still hugs and expands internally — the
+                    // whole point of this arm.
+                    let arg_doc = printer.build_expression_doc(arg);
+                    if arrow_signature_has_breaking_comments(printer, arrow) {
+                        return Some(wrap_call_with_soft_breaks(d, callee, arg_doc));
+                    }
+                    return Some(d.concat(&[callee, d.text("("), arg_doc, d.text(")")]));
                 }
 
                 // Expandable body (ternary): use conditional parens
diff --git a/crates/tsv_ts/src/printer/calls/chain_args.rs b/crates/tsv_ts/src/printer/calls/chain_args.rs
index 1e9d99304..34ac890f3 100644
--- a/crates/tsv_ts/src/printer/calls/chain_args.rs
+++ b/crates/tsv_ts/src/printer/calls/chain_args.rs
@@ -24,6 +24,7 @@ use super::arg_wrapping::{
     wrap_huggable_arg,
 };
 use crate::ast::internal::{self, Expression};
+use crate::printer::expressions::functions::arrow_signature_has_breaking_comments;
 use smallvec::smallvec;
 use tsv_lang::doc::DocBuf;
 use tsv_lang::doc::arena::{DocArena, DocId};
@@ -778,6 +779,11 @@ fn build_chain_args_single(
         // hug must refuse it too — a to-emit gate would hug blind.
         && !(has_any_comment_text
             && last_arg_has_comments(call.arguments, printer, call.span.end, paren_open))
+        // A comment LEADING the arg isn't the only shape that defeats the hug: one INSIDE
+        // the signature forces a break the one-line hug can't honor. Same predicate as the
+        // non-chain path — see `arrow_signature_has_breaking_comments`.
+        && !(has_any_comment_text
+            && arrow_signature_has_breaking_comments(printer, arrow))
     {
         // Render the arrow with flat params (prettier's expandLastArg
         // `removeLines`) so the force-broken state breaks the body, not the
@@ -921,7 +927,17 @@ fn build_chain_args_single(
     // Leading comments prevent hugging — prettier's shouldExpandLastArg
     // returns false when hasComment(lastArg, Leading), so the default
     // expansion path is used instead of expand-last hugging.
-    let kind = if has_leading_comment_on_page {
+    //
+    // A comment that FORCES a break inside an arrow's signature does the same, and for the
+    // same reason: hugging would strand the break mid-signature. This is the last of the
+    // three places that must agree on when a hug is legal (the expand-last gate above, and
+    // `call_formatting.rs`'s non-chain arm) — all asking the one predicate, because the
+    // hug that mangled `arr.map(…)` while `fn(…)` stayed correct was precisely two of them
+    // disagreeing. See `arrow_signature_has_breaking_comments`.
+    let signature_forces_break = has_any_comment_text
+        && matches!(arg, Expression::ArrowFunctionExpression(arrow)
+            if arrow_signature_has_breaking_comments(printer, arrow));
+    let kind = if has_leading_comment_on_page || signature_forces_break {
         ChainArgKind::NeedsSoftWrap
     } else {
         classify_chain_arg(arg)
diff --git a/crates/tsv_ts/src/printer/calls/import_expr.rs b/crates/tsv_ts/src/printer/calls/import_expr.rs
index 8eaa6d16b..51ef35901 100644
--- a/crates/tsv_ts/src/printer/calls/import_expr.rs
+++ b/crates/tsv_ts/src/printer/calls/import_expr.rs
@@ -4,7 +4,7 @@
 // - Dynamic import: `import('module')`, `import('module', options)`
 // - Meta properties: `import.meta`, `new.target`
 
-use super::super::{CommentSpacing, Printer};
+use super::super::Printer;
 use super::arg_comments::{
     PartitionedComments, has_blank_line_between_args, should_force_expansion_for_comments,
 };
@@ -14,34 +14,83 @@ use smallvec::smallvec;
 use tsv_lang::doc::DocBuf;
 use tsv_lang::doc::arena::{DocArena, DocId};
 
-/// The opening token of a (possibly phased) dynamic import: `import(`,
-/// `import.source(`, or `import.defer(`.
-fn import_open(phase: internal::ImportPhase) -> &'static str {
+/// The phase keyword of a phased dynamic import (`source` / `defer`), or `None` for a
+/// plain `import(`.
+fn import_phase_word(phase: internal::ImportPhase) -> Option<&'static str> {
     match phase {
-        internal::ImportPhase::None => "import(",
-        internal::ImportPhase::Source => "import.source(",
-        internal::ImportPhase::Defer => "import.defer(",
+        internal::ImportPhase::None => None,
+        internal::ImportPhase::Source => Some("source"),
+        internal::ImportPhase::Defer => Some("defer"),
     }
 }
 
+/// The whole opening of a (possibly phased) dynamic import — `import`, the phase
+/// (`.source` / `.defer`) when there is one, and the `(` — plus the offset where the
+/// caller's leading-comment scan must begin.
+///
+/// A phased import is a dotted pair (`import` `.` `source`), so both gaps around its dot
+/// are positions an author can comment in; the shared printer emits them. Baking the
+/// pair into one fixed text (`"import.source("`) scans neither and drops what's there.
+///
+/// The returned offset is the **head's end** — just past `import`, or past the phase
+/// word — deliberately *before* the `(` rather than after it. The caller scans from
+/// there to the first argument, so that one range covers both the head→`(` gap and the
+/// `(`→argument gap, and every comment in the opening reaches the caller's emitter
+/// exactly as before. `span.start + import_open(phase).len()` could not: it assumes the
+/// opening is contiguous, so a comment inside it shifts the real `(` past that offset
+/// and the scan starts mid-comment, missing it. That was the drop.
+fn build_import_open_doc(
+    printer: &Printer<'_>,
+    import_expr: &internal::ImportExpression<'_>,
+) -> (DocId, u32) {
+    let d = printer.d();
+    let start = import_expr.span.start;
+    let import_end = start + "import".len() as u32;
+    // Bounds every scan below: the first argument is the next real token, and no `(` or
+    // phase word of this import's own lies past it.
+    let source_start = import_expr.source.span().start;
+
+    // The head (`import`, plus `.source` / `.defer`) and where it ends in source.
+    let (head, head_end) = match import_phase_word(import_expr.phase) {
+        None => (d.text("import"), import_end),
+        Some(word) => match printer.find_keyword_in_range(import_end, source_start, word) {
+            Some(word_start) => (
+                printer.build_dotted_pair_doc(
+                    d.text("import"),
+                    d.text(word),
+                    import_end,
+                    word_start,
+                ),
+                word_start + word.len() as u32,
+            ),
+            None => {
+                // Only reachable on a synthetic span: the parser set the phase by
+                // reading this very word out of the source.
+                debug_assert!(
+                    false,
+                    "phased import has no `{word}` in source[{import_end}..{source_start}]"
+                );
+                (d.text("import"), import_end)
+            }
+        },
+    };
+
+    (d.concat(&[head, d.text("(")]), head_end)
+}
+
 /// Wrap import args in a breakable group: `<open>` + softline-indented `inner` +
 /// softline + `)`. Stays inline when it fits, breaks each side onto its own line
 /// otherwise. The shared shell for every block-comment / no-line-comment layout.
-fn wrap_import_group(d: &DocArena, open: &'static str, inner: DocId) -> DocId {
-    d.group(d.concat(&[
-        d.text(open),
-        d.indent_softline(inner),
-        d.softline(),
-        d.text(")"),
-    ]))
+fn wrap_import_group(d: &DocArena, open: DocId, inner: DocId) -> DocId {
+    d.group(d.concat(&[open, d.indent_softline(inner), d.softline(), d.text(")")]))
 }
 
 /// Wrap import args in a forced-multiline layout: `<open>` + hardline-indented
 /// `inner` + hardline + `)`. Used whenever a line comment (which runs to EOL) or an
 /// own-line comment forces the parens open.
-fn wrap_import_hardline(d: &DocArena, open: &'static str, inner: DocId) -> DocId {
+fn wrap_import_hardline(d: &DocArena, open: DocId, inner: DocId) -> DocId {
     d.concat(&[
-        d.text(open),
+        open,
         d.indent(d.concat(&[d.hardline(), inner])),
         d.hardline(),
         d.text(")"),
@@ -59,14 +108,12 @@ pub(super) fn build_import_expression_doc(
 ) -> DocId {
     let d = printer.d();
 
-    // Opening token: `import(`, `import.source(`, or `import.defer(` (import-phase
-    // proposals). Threaded into every wrapper and used to bound the leading-comment scan.
-    let open = import_open(import_expr.phase);
-
-    // Preserve comments between the `(` and the source expression, e.g.
-    // import(/* @vite-ignore */ expr) — they would otherwise be lost. Own-line
+    // The opening — `import`, any phase (`.source` / `.defer`), and the `(` — built once
+    // and threaded into every wrapper. It also reports where the leading-comment scan
+    // starts: the head's end, so the scan spans the `(` and catches a comment on either
+    // side of it (`import /* c */ ('m')`, `import(/* @vite-ignore */ m)`). Own-line
     // comments force the parens to break; `leading_forces_break` drives that below.
-    let open_paren_end = import_expr.span.start + open.len() as u32;
+    let (open, leading_scan_start) = build_import_open_doc(printer, import_expr);
     let source_start = import_expr.source.span().start;
 
     // Parenthesize an `in` argument inside a for-header init (`for (a = import(m,
@@ -77,7 +124,7 @@ pub(super) fn build_import_expression_doc(
         printer.build_expression_doc(import_expr.source),
     );
     let (source_doc, leading_forces_break) =
-        printer.build_paren_leading_value_doc(open_paren_end, source_start, raw_source_doc);
+        printer.build_paren_leading_value_doc(leading_scan_start, source_start, raw_source_doc);
 
     let source_end = import_expr.source.span().end;
     let paren_close = import_expr.span.end;
@@ -219,17 +266,11 @@ pub(super) fn build_import_expression_doc(
         // State 0: all flat — import('source', {with: {type: 'json'}})
         // State 1: expand-last — import('source', {\n\twith: ...\n})
         // State 2: expand-all — import(\n\t'source',\n\t{...}\n)
-        let state_flat = d.concat(&[
-            d.text(open),
-            source_doc,
-            d.text(", "),
-            options_doc,
-            d.text(")"),
-        ]);
+        let state_flat = d.concat(&[open, source_doc, d.text(", "), options_doc, d.text(")")]);
 
         let expanded_options = d.group_break(options_doc);
         let state_expand_last = d.concat(&[
-            d.text(open),
+            open,
             source_doc,
             d.text(", "),
             expanded_options,
@@ -238,7 +279,7 @@ pub(super) fn build_import_expression_doc(
 
         let arg_parts = d.join_doc([source_doc, options_doc], d.comma_line());
         let state_expand_all = d.concat(&[
-            d.text(open),
+            open,
             d.indent_softline(arg_parts),
             d.softline(),
             d.text(")"),
@@ -254,68 +295,18 @@ pub(super) fn build_import_expression_doc(
 
 /// Build a Doc for a meta property: `import.meta`, `new.target`
 ///
-/// Both gaps around the `.` are real source positions an author can comment in
-/// (`new /* c */.target`, `new./* c */ target`), so each is located and emitted.
-/// Concatenating the three pieces scans neither gap and drops whatever is in it — the
-/// same class as a comment inside a multi-word keyword (see `build_keyword_words_doc`
-/// in `printer/comments/declarations.rs`), and the reason that class's usual detector
-/// (a `d.text` literal with an *interior* space) is only a proxy: here the pieces are
-/// joined by `"."`, which has no space to find.
-///
-/// Each side stays where it was authored, which is also what prettier prints: the
-/// comment hugs the `.` and keeps its space on the identifier's side. A *line* comment
-/// before the `.` ends its line, so `.property` continues one level down
-/// (`new // c⏎\t.target`) — the shape a member access already takes.
+/// A meta property is a dotted pair of names, so it delegates to the shared
+/// [`Printer::build_dotted_pair_doc`] — which emits both gaps around the `.`, the
+/// positions an author can comment in (`new /* c */.target`, `new./* c */ target`).
+/// A qualified name (`ns.Type`) is the same shape and shares that printer.
 pub(super) fn build_meta_property_doc(
     printer: &Printer<'_>,
     meta: &internal::MetaProperty<'_>,
 ) -> DocId {
-    let d = printer.d();
-    let meta_doc = printer.identifier_name_doc(&meta.meta);
-    let prop_doc = printer.identifier_name_doc(&meta.property);
-    let gap_start = meta.meta.span.end;
-    let gap_end = meta.property.span.start;
-
-    // `new.target` / `import.meta` with both gaps empty — every ordinary occurrence.
-    if !printer.has_comments_to_emit_between(gap_start, gap_end) {
-        return d.concat(&[meta_doc, d.text("."), prop_doc]);
-    }
-
-    let Some(dot) = printer.find_char_outside_comments(gap_start, gap_end, b'.') else {
-        debug_assert!(
-            false,
-            "a meta property always spells a `.` between its two names"
-        );
-        return d.concat(&[meta_doc, d.text("."), prop_doc]);
-    };
-
-    // `.`→property: a block comment keeps its space on the property's side
-    // (`./* c */ target`); a line comment ends the line, so the property drops a level.
-    let after_dot = if !printer.has_comments_to_emit_between(dot + 1, gap_end) {
-        prop_doc
-    } else if printer.has_line_comments_between(dot + 1, gap_end) {
-        printer.build_continuation_indent(dot + 1, gap_end, prop_doc)
-    } else {
-        d.concat(&[
-            printer.build_comments_between(dot + 1, gap_end, CommentSpacing::Trailing),
-            prop_doc,
-        ])
-    };
-    let tail = d.concat(&[d.text("."), after_dot]);
-
-    // meta→`.`: a line comment takes the whole `.property` onto the next line with it.
-    if printer.has_line_comments_between(gap_start, dot) {
-        return d.concat(&[
-            meta_doc,
-            printer.build_continuation_indent(gap_start, dot, tail),
-        ]);
-    }
-    if printer.has_comments_to_emit_between(gap_start, dot) {
-        return d.concat(&[
-            meta_doc,
-            printer.build_comments_between(gap_start, dot, CommentSpacing::Leading),
-            tail,
-        ]);
-    }
-    d.concat(&[meta_doc, tail])
+    printer.build_dotted_pair_doc(
+        printer.identifier_name_doc(&meta.meta),
+        printer.identifier_name_doc(&meta.property),
+        meta.meta.span.end,
+        meta.property.span.start,
+    )
 }
diff --git a/crates/tsv_ts/src/printer/calls/test_patterns.rs b/crates/tsv_ts/src/printer/calls/test_patterns.rs
index 7cdf5f712..c3ca3530d 100644
--- a/crates/tsv_ts/src/printer/calls/test_patterns.rs
+++ b/crates/tsv_ts/src/printer/calls/test_patterns.rs
@@ -7,7 +7,6 @@ use super::super::Printer;
 use crate::ast::internal::{self, IdentName};
 use smallvec::SmallVec;
 use tsv_lang::SymbolResolver;
-use tsv_lang::doc::DocBuf;
 use tsv_lang::doc::arena::DocId;
 
 /// Test function patterns that Prettier keeps on a single line
@@ -45,9 +44,9 @@ pub(super) const TEST_CALL_PATTERNS: &[&str] = &[
 ];
 
 /// Get the name channel (+ span start) of an identifier if it's a simple identifier
-fn get_identifier_name(expr: &internal::Expression<'_>) -> Option<(IdentName, u32)> {
+fn get_identifier_name(expr: &internal::Expression<'_>) -> Option<(IdentName, u32, u32)> {
     if let internal::Expression::Identifier(id) = expr {
-        Some((id.ident_name(), id.span.start))
+        Some((id.ident_name(), id.span.start, id.span.end))
     } else {
         None
     }
@@ -66,34 +65,45 @@ fn get_identifier_name(expr: &internal::Expression<'_>) -> Option<(IdentName, u3
 /// pattern list against the same chain parts directly (also no allocation) via
 /// the shared [`get_member_chain_parts`], so the two stay in lockstep on which
 /// callees qualify.
+///
+/// Each `.` goes through the shared dotted-pair printer, which emits the gaps
+/// around it — the positions an author can comment in (`describe /* c */.only`,
+/// `test./* c */ skip`). Joining the parts with a bare `d.text(".")` scans none of
+/// them and drops what's there. It stays break-free: with no comment in a gap the
+/// pair is the same three text nodes as before.
 pub(super) fn build_test_callee_flat_doc(
     expr: &internal::Expression<'_>,
     printer: &Printer<'_>,
 ) -> Option<DocId> {
     let parts = get_member_chain_parts(expr)?;
-    let d = printer.d();
-    // Parts come out leaf→root; reverse to root→leaf (`test.describe.only`).
-    let mut doc_parts = DocBuf::new();
-    for (i, (name, name_start)) in parts.iter().rev().enumerate() {
-        if i > 0 {
-            doc_parts.push(d.text("."));
-        }
-        doc_parts.push(printer.ident_name_doc(*name, *name_start));
+    // Parts come out leaf→root; reverse to root→leaf (`test.describe.only`), which is
+    // also the AST's own association — each pair's left is everything before its dot.
+    let mut iter = parts.iter().rev();
+    // A single-part callee (`it`) is the bare name: the loop never runs.
+    let &(name, start, mut prev_end) = iter.next()?;
+    let mut doc = printer.ident_name_doc(name, start);
+    for &(name, start, end) in iter {
+        doc = printer.build_dotted_pair_doc(
+            doc,
+            printer.ident_name_doc(name, start),
+            prev_end,
+            start,
+        );
+        prev_end = end;
     }
-    // `concat` short-circuits a single-part callee (`it`) to the bare symbol.
-    Some(d.concat(&doc_parts))
+    Some(doc)
 }
 
 /// Get the member chain parts from an expression
 /// Returns parts reversed, e.g. `["skip", "test"]` for `test.skip`.
 fn get_member_chain_parts(
     expr: &internal::Expression<'_>,
-) -> Option<SmallVec<[(IdentName, u32); 8]>> {
-    let mut parts: SmallVec<[(IdentName, u32); 8]> = SmallVec::new();
+) -> Option<SmallVec<[(IdentName, u32, u32); 8]>> {
+    let mut parts: SmallVec<[(IdentName, u32, u32); 8]> = SmallVec::new();
 
     match expr {
         internal::Expression::Identifier(id) => {
-            parts.push((id.ident_name(), id.span.start));
+            parts.push((id.ident_name(), id.span.start, id.span.end));
             Some(parts)
         }
         internal::Expression::MemberExpression(member) => {
@@ -182,7 +192,7 @@ pub(super) fn is_test_call(call: &internal::CallExpression<'_>, printer: &Printe
     let names: SmallVec<[&str; 8]> = parts
         .iter()
         .rev()
-        .map(|&(name, name_start)| name.resolve(name_start, printer.source, &interner))
+        .map(|&(name, name_start, _)| name.resolve(name_start, printer.source, &interner))
         .collect();
     TEST_CALL_PATTERNS
         .iter()
diff --git a/crates/tsv_ts/src/printer/comments/declarations.rs b/crates/tsv_ts/src/printer/comments/declarations.rs
index f65e6b2b5..11673fe4f 100644
--- a/crates/tsv_ts/src/printer/comments/declarations.rs
+++ b/crates/tsv_ts/src/printer/comments/declarations.rs
@@ -354,6 +354,79 @@ impl<'a> Printer<'a> {
         ])
     }
 
+    /// A dotted pair of names, with **both** gaps around the `.` emitted: a meta property
+    /// (`new` `.` `target`, `import` `.` `meta`) or a qualified name (`ns` `.` `Type`).
+    ///
+    /// Concatenating `left` + `"."` + `right` scans neither gap and drops whatever an
+    /// author wrote in one. That is the punctuator-joined member of the multi-word-keyword
+    /// class (see [`build_keyword_words_doc`](Self::build_keyword_words_doc)) — and the
+    /// case that shows why the class's usual detector, a `d.text` literal with an
+    /// *interior* space, is only a proxy: the joining literal is `"."`, which has no space
+    /// to find. Both shapes route here so neither can regrow the hole independently.
+    ///
+    /// Each side stays where it was authored, which is what prettier prints for a **block**
+    /// comment: it hugs the `.` and keeps its space on the identifier's side. A **line**
+    /// comment ends its line, so the tail continues one level down — that half is a
+    /// divergence (prettier relocates it out of the construct, past the `;`).
+    ///
+    /// `gap_start` is `left`'s source end; `gap_end` is `right`'s source start.
+    pub(crate) fn build_dotted_pair_doc(
+        &self,
+        left: DocId,
+        right: DocId,
+        gap_start: u32,
+        gap_end: u32,
+    ) -> DocId {
+        let d = self.d();
+        // Both gaps empty — every ordinary occurrence, and the only one that is hot.
+        if !self.has_comments_to_emit_between(gap_start, gap_end) {
+            return d.concat(&[left, d.text("."), right]);
+        }
+        let Some(dot) = self.find_char_outside_comments(gap_start, gap_end, b'.') else {
+            debug_assert!(
+                false,
+                "a dotted pair always spells a `.` between its two names"
+            );
+            return d.concat(&[left, d.text("."), right]);
+        };
+        // `.`→right, then left→`.` wrapping it: the tail is built first so a line comment
+        // in the left gap takes the whole `.right` down with it.
+        let tail = d.concat(&[
+            d.text("."),
+            self.build_dot_gap_doc(dot + 1, gap_end, right, CommentSpacing::Trailing),
+        ]);
+        d.concat(&[
+            left,
+            self.build_dot_gap_doc(gap_start, dot, tail, CommentSpacing::Leading),
+        ])
+    }
+
+    /// One of the two gaps around a dotted pair's `.`: the comments authored in
+    /// `[start, end)`, then `tail`.
+    ///
+    /// Both sides obey the same rule, so both call this — a *line* comment ends its line
+    /// and `tail` continues one level down; a block comment stays inline ahead of it. Only
+    /// the spacing differs, since a gap's comment sits after the `.` on one side and
+    /// before it on the other.
+    fn build_dot_gap_doc(
+        &self,
+        start: u32,
+        end: u32,
+        tail: DocId,
+        spacing: CommentSpacing,
+    ) -> DocId {
+        // The caller established that *some* comment lies between the two names, but not
+        // which side of the `.` — so each gap still gates, and an empty one adds nothing.
+        if !self.has_comments_to_emit_between(start, end) {
+            return tail;
+        }
+        if self.has_line_comments_between(start, end) {
+            return self.build_continuation_indent(start, end, tail);
+        }
+        self.d()
+            .concat(&[self.build_comments_between(start, end, spacing), tail])
+    }
+
     /// Build a **multi-word keyword** (`export default`, `await using`, `declare
     /// const`, `export as namespace`), preserving a comment authored in one of its
     /// interior gaps.
@@ -411,8 +484,20 @@ impl<'a> Printer<'a> {
             return (d.text(word), start + word.len() as u32);
         }
 
-        let mut starts: SmallVec<[u32; 4]> = SmallVec::new();
+        // Left-to-right and FLAT: every gap emits its comments where the author wrote
+        // them, but none of them indents on its own — the whole tail is wrapped once,
+        // below. Indenting per gap would compound, and the staircase it builds is not
+        // just deep, it is wrong: the caller emits the keyword→value gap at the header's
+        // own level, so a two-broken-gap keyword would leave its last word sitting a
+        // level *below* the value that follows it.
+        //
+        // Locating and emitting ride one pass: a word's gap runs from the previous
+        // word's end (`cursor`) to this word's start, both of which this loop already
+        // holds — so nothing needs to remember where the earlier words landed.
+        let mut tail: DocBuf = DocBuf::new();
+        let mut any_line = false;
         let mut cursor = start;
+        let mut in_gap = false;
         for word in words {
             let Some(pos) = self.find_keyword_in_range(cursor, search_end, word) else {
                 // The source doesn't hold the shape the caller named — only reachable
@@ -428,36 +513,29 @@ impl<'a> Printer<'a> {
                      — caller passed a synthetic span or a bad search_end"
                 );
                 let mut parts: DocBuf = DocBuf::new();
+                let mut measured = start;
                 for (i, w) in words.iter().enumerate() {
                     if i > 0 {
                         parts.push(d.text(" "));
+                        measured += 1;
                     }
                     parts.push(d.text(w));
+                    measured += w.len() as u32;
                 }
-                let width: u32 = words.iter().map(|w| w.len() as u32).sum();
-                let measured = start + width + words.len() as u32 - 1;
                 return (d.concat(&parts), measured);
             };
-            starts.push(pos);
+            // The first word is emitted by the caller below, outside the indent — it
+            // leads the header, so no gap precedes it.
+            if in_gap {
+                let (gap_doc, has_line) = self.build_keyword_gap_doc(cursor, pos);
+                any_line |= has_line;
+                tail.push(gap_doc);
+                tail.push(d.text(word));
+            }
+            in_gap = true;
             cursor = pos + word.len() as u32;
         }
         let keyword_end = cursor;
-
-        // Left-to-right and FLAT: every gap emits its comments where the author wrote
-        // them, but none of them indents on its own — the whole tail is wrapped once,
-        // below. Indenting per gap would compound, and the staircase it builds is not
-        // just deep, it is wrong: the caller emits the keyword→value gap at the header's
-        // own level, so a two-broken-gap keyword would leave its last word sitting a
-        // level *below* the value that follows it.
-        let mut tail: DocBuf = DocBuf::new();
-        let mut any_line = false;
-        for i in 0..words.len() - 1 {
-            let gap_start = starts[i] + words[i].len() as u32;
-            let (gap_doc, has_line) = self.build_keyword_gap_doc(gap_start, starts[i + 1]);
-            any_line |= has_line;
-            tail.push(gap_doc);
-            tail.push(d.text(words[i + 1]));
-        }
         let tail_doc = d.concat(&tail);
         // One level for the whole header — the same thing the single-gap rule says: a
         // broken gap reads as one statement continuation, never as N nested ones. With
@@ -525,8 +603,13 @@ impl<'a> Printer<'a> {
     /// so a caller with *several* gaps can emit each one and then decide **once** what
     /// to indent. Indenting per gap compounds: two broken gaps would put the keyword's
     /// last word two levels deep, below the value that follows it at one.
+    ///
+    /// Two callers: [`build_keyword_words_doc`](Self::build_keyword_words_doc) for a
+    /// keyword's interior gaps, and the import-equals header — the one multi-gap header
+    /// whose words aren't contiguous (its name sits between `import` and `=`), so it
+    /// drives this directly instead.
     #[inline]
-    fn build_keyword_gap_doc(&self, start: u32, end: u32) -> (DocId, bool) {
+    pub(crate) fn build_keyword_gap_doc(&self, start: u32, end: u32) -> (DocId, bool) {
         let d = self.d();
         // One search settles the gap. With no comment there is nothing to emit but the
         // separator — no empty child, and neither of the per-shape searches below runs.
diff --git a/crates/tsv_ts/src/printer/comments/lists.rs b/crates/tsv_ts/src/printer/comments/lists.rs
index 0a1b0403e..df5c74f65 100644
--- a/crates/tsv_ts/src/printer/comments/lists.rs
+++ b/crates/tsv_ts/src/printer/comments/lists.rs
@@ -926,6 +926,32 @@ impl<'a> Printer<'a> {
         )
     }
 
+    /// The [`split_separator_gap_comments`](Self::split_separator_gap_comments) caller
+    /// idiom for a **`;` terminator**, in one call: the gap's pre-`;` comments, the `;`,
+    /// then the comments that belong after it.
+    ///
+    /// The ordering is the reason this exists rather than three lines at each site: the
+    /// returned docs must be pushed *after* the `;` text, and a site that inlines the
+    /// idiom can invert it silently — an own-line comment emitted before the separator
+    /// puts the `;` on the comment's line, where a `//` swallows it outright.
+    ///
+    /// `block_after_separator` is the terminator's own axis, not a caller preference:
+    /// `true` for a statement/member `;` (prettier trails a same-line block past it —
+    /// `expr; /* c */`), `false` where the operand keeps it (`import =` / `export =` /
+    /// `export as namespace`). A caller whose split is *conditional* keeps the raw idiom.
+    pub(crate) fn push_semicolon_with_gap_comments(
+        &self,
+        parts: &mut DocBuf,
+        start: u32,
+        semicolon_pos: u32,
+        block_after_separator: bool,
+    ) {
+        let after =
+            self.split_separator_gap_comments(parts, start, semicolon_pos, block_after_separator);
+        parts.push(self.d().text(";"));
+        parts.extend(after);
+    }
+
     /// The **type-member `;`** variant of `split_separator_gap_comments`: a same-line
     /// block stays *before* the `;` (`a: A /* c */;`, like a list separator) **but** a
     /// blank line before an own-line comment IS preserved (like a statement terminator).
diff --git a/crates/tsv_ts/src/printer/expressions/functions.rs b/crates/tsv_ts/src/printer/expressions/functions.rs
index dbc849287..22f2c598e 100644
--- a/crates/tsv_ts/src/printer/expressions/functions.rs
+++ b/crates/tsv_ts/src/printer/expressions/functions.rs
@@ -97,6 +97,41 @@ pub(in crate::printer) fn has_leftmost_object_expression(expr: &internal::Expres
 /// keeping `({` and `}: Type)` together while letting the pattern's content break.
 ///
 /// Shared with the signature-param path (`build_signature_params_doc`) so bodyless
+/// Whether `arrow`'s signature — its params' `(` through its `=>` — holds a comment that
+/// **forces** a break.
+///
+/// The expand-last-arg hug renders that signature on one line, which such a comment makes
+/// impossible: the break is forced out mid-hug (`map(([/* a⏎b */ x, y]) => …`) instead of
+/// breaking the call, which is neither layout anyone asked for.
+///
+/// Prettier reaches the same conclusion by another route: the hug state's hard line
+/// propagates a break to its enclosing `conditionalGroup`, whose printer then jumps
+/// straight to the most-expanded state (`call-arguments.js`, `printer.js`'s `doc.break`
+/// arm). tsv has no break-propagation pass — `should_break` is only ever set explicitly —
+/// so the question is asked here instead, of the **source**, before either hug path builds
+/// anything. Asking pre-build is also what keeps this off the exponential-rebuild rake: the
+/// alternative, building the arrow and inspecting `will_break`, needs a second build of the
+/// same subtree on the fall-through.
+///
+/// Both hug paths (`call_formatting.rs`'s plain call, `chain_args.rs`'s member chain) route
+/// through this one predicate — the two disagreeing about when a hug is legal is exactly
+/// how the mangle survived on `arr.map(…)` while `fn(…)` was fine.
+///
+/// A **single-line** block comment is deliberately absent: `fn(([/* c */ x, y]) => [y, x])`
+/// hugs, in tsv and prettier alike, because it inlines without forcing anything.
+pub(in crate::printer) fn arrow_signature_has_breaking_comments(
+    printer: &Printer<'_>,
+    arrow: &internal::ArrowFunctionExpression<'_>,
+) -> bool {
+    // `arrow_token` is the `=>`, captured by the parser for exactly this kind of question.
+    // An unparenthesized `x => …` has no `(`, so the signature starts at the arrow node
+    // itself — which still catches `x /* a⏎b */ => y`.
+    let start = arrow.params_start.unwrap_or(arrow.span.start);
+    let end = arrow.arrow_token;
+    printer.has_line_comments_between(start, end)
+        || printer.has_multiline_block_comments_on_page_between(start, end)
+}
+
 /// declarations (declare / overload) and type-member signatures (method / call /
 /// construct) hug the lone param exactly like value-param functions do.
 pub(in crate::printer) fn is_huggable_pattern(expr: &internal::Expression<'_>) -> bool {
diff --git a/crates/tsv_ts/src/printer/expressions/patterns.rs b/crates/tsv_ts/src/printer/expressions/patterns.rs
index 0a28426e0..423fecefa 100644
--- a/crates/tsv_ts/src/printer/expressions/patterns.rs
+++ b/crates/tsv_ts/src/printer/expressions/patterns.rs
@@ -836,33 +836,45 @@ impl<'a> Printer<'a> {
             return self.build_empty_array_pattern_doc(arr);
         }
 
-        // Expand if line comments or own-line block comments. One whole-span
-        // comment pre-check gates both scans; array patterns don't force-expand on
-        // blank lines, so a comment-free pattern skips the element scan entirely.
+        // Expand if line comments, multi-line block comments, or own-line block comments.
+        // One whole-span comment pre-check gates the scans; array patterns don't
+        // force-expand on blank lines, so a comment-free pattern skips the element scan
+        // entirely.
+        //
+        // The three sub-questions must match the array EXPRESSION's gate
+        // (`arrays.rs`'s `has_expanding_comments`) — this asked only two, and a comment
+        // shape that expands `[a, b /* x⏎y */]` but not `const [a, b /* x⏎y */] = arr` is
+        // a bug every time. It was: only the expanded path emits the dangling comments
+        // after the last element, so a multi-line one landed on the grouped path and was
+        // DROPPED outright (fixture `array_own_line_multiline_comment_expand`).
+        // `has_own_line_block_comments_in_bracket_list` deliberately skips multi-line
+        // comments — the multi-line question is this separate predicate's, not its.
         let boundary = arr
             .type_annotation
             .as_ref()
             .map_or(arr.span.end, |t| t.span.start);
         let has_comments = self.has_comments_on_page_between(arr.span.start, boundary);
-        let (has_line_comments, has_own_line_block) = if has_comments {
-            // Flatten once (skip holes) and share across both scans.
+        let (has_line_comments, has_multiline_block, has_own_line_block) = if has_comments {
+            // Flatten once (skip holes) and share across the scans.
             let non_null: SmallVec<[_; 8]> = arr.elements.iter().flatten().collect();
             let has_line_comments = self
                 .collection_formatting_hints(arr.span.start, boundary, &non_null, true, |elem| {
                     elem.span()
                 })
                 .0;
+            let has_multiline_block =
+                self.has_multiline_block_comments_on_page_between(arr.span.start, boundary);
             let has_own_line_block = self.has_own_line_block_comments_in_bracket_list(
                 Span::new(arr.span.start, boundary),
                 &non_null,
                 |elem| elem.span(),
             );
-            (has_line_comments, has_own_line_block)
+            (has_line_comments, has_multiline_block, has_own_line_block)
         } else {
-            (false, false)
+            (false, false, false)
         };
 
-        if has_line_comments || has_own_line_block {
+        if has_line_comments || has_multiline_block || has_own_line_block {
             self.build_expanded_array_pattern_doc(arr)
         } else {
             self.build_grouped_array_pattern_doc(arr, has_comments)
diff --git a/crates/tsv_ts/src/printer/expressions/template_literal.rs b/crates/tsv_ts/src/printer/expressions/template_literal.rs
index 863416fac..837878173 100644
--- a/crates/tsv_ts/src/printer/expressions/template_literal.rs
+++ b/crates/tsv_ts/src/printer/expressions/template_literal.rs
@@ -153,10 +153,16 @@ impl<'a> Printer<'a> {
                     }
                 } else {
                     // No newline in the interpolation and nothing forces a break:
-                    // atomize by removing all soft breaks so the `${…}` stays on one
-                    // line even past print width (prettier replaces the expression
-                    // doc with its `printWidth: Infinity` rendering here).
-                    d.remove_lines(full_expr_doc)
+                    // atomize so the `${…}` stays on one line even past print width
+                    // (prettier replaces the expression doc with its `printWidth: Infinity`
+                    // rendering here).
+                    //
+                    // `flatten_all_lines`, not `remove_lines`: this genuinely wants ONE
+                    // line, hard lines included, which prettier's `removeLines` deliberately
+                    // won't do. Sound only because the branches above already claimed every
+                    // interpolation holding a comment or a source newline — so nothing that
+                    // must break reaches here.
+                    d.flatten_all_lines(full_expr_doc)
                 };
 
                 // Apply alignment based on quasi indent (Prettier's addAlignmentToDoc).
diff --git a/crates/tsv_ts/src/printer/statements/class.rs b/crates/tsv_ts/src/printer/statements/class.rs
index 5f3c313c2..c89d16b33 100644
--- a/crates/tsv_ts/src/printer/statements/class.rs
+++ b/crates/tsv_ts/src/printer/statements/class.rs
@@ -554,9 +554,7 @@ impl<'a> Printer<'a> {
             .map(|v| v.span().end)
             .or_else(|| prop.type_annotation.as_ref().map(|ta| ta.span.end))
             .unwrap_or(after_modifier);
-        let after = self.split_separator_gap_comments(&mut parts, content_end, prop.span.end, true);
-        parts.push(d.text(";"));
-        parts.extend(after);
+        self.push_semicolon_with_gap_comments(&mut parts, content_end, prop.span.end, true);
 
         d.concat(&parts)
     }
@@ -786,10 +784,7 @@ impl<'a> Printer<'a> {
                 |rt| rt.span.end,
             );
             let semicolon_pos = method.span.end.saturating_sub(1);
-            let after =
-                self.split_separator_gap_comments(&mut parts, content_end, semicolon_pos, true);
-            parts.push(d.text(";"));
-            parts.extend(after);
+            self.push_semicolon_with_gap_comments(&mut parts, content_end, semicolon_pos, true);
         } else {
             self.append_body_with_sig_comments(&mut parts, sig_end, &method.value.body);
         }
diff --git a/crates/tsv_ts/src/printer/statements/control_flow/loops/for_loop.rs b/crates/tsv_ts/src/printer/statements/control_flow/loops/for_loop.rs
index 2983c3314..de7fea4b5 100644
--- a/crates/tsv_ts/src/printer/statements/control_flow/loops/for_loop.rs
+++ b/crates/tsv_ts/src/printer/statements/control_flow/loops/for_loop.rs
@@ -1499,6 +1499,17 @@ impl<'a> Printer<'a> {
         match left {
             internal::ForInOfLeft::VariableDeclaration(decl) => {
                 let Some(declarator) = decl.declarations.first() else {
+                    // A for-in/of head always binds something (`for (const of x)` is a
+                    // parse error), so there is no declarator to bound a gap search at
+                    // and nothing to print but the kind. `as_str()` is the joined text —
+                    // the very thing `words()` exists to avoid, since it emits `await
+                    // using`'s interior gap as a fixed space and would drop a comment
+                    // authored there. Safe only because this arm is unreachable; assert
+                    // that rather than let a future caller reach it silently.
+                    debug_assert!(
+                        false,
+                        "a for-in/of variable declaration always has a declarator"
+                    );
                     return d.concat(&[d.text(decl.kind.as_str()), d.text(" ")]);
                 };
                 // The keyword→binding gap carries a comment (`for (const /* c */ x of y)`)
diff --git a/crates/tsv_ts/src/printer/statements/control_flow/loops/while_loop.rs b/crates/tsv_ts/src/printer/statements/control_flow/loops/while_loop.rs
index 0bc0f2596..508011b6c 100644
--- a/crates/tsv_ts/src/printer/statements/control_flow/loops/while_loop.rs
+++ b/crates/tsv_ts/src/printer/statements/control_flow/loops/while_loop.rs
@@ -212,10 +212,7 @@ impl<'a> Printer<'a> {
         if let Some(close) = close_paren {
             parts.push(d.text(")"));
             let semicolon_pos = stmt.span.end.saturating_sub(1);
-            let after =
-                self.split_separator_gap_comments(&mut parts, close + 1, semicolon_pos, true);
-            parts.push(d.text(";"));
-            parts.extend(after);
+            self.push_semicolon_with_gap_comments(&mut parts, close + 1, semicolon_pos, true);
         } else {
             parts.push(d.text(");"));
         }
diff --git a/crates/tsv_ts/src/printer/statements/control_flow/try_jump.rs b/crates/tsv_ts/src/printer/statements/control_flow/try_jump.rs
index f963b3652..02ba7a7e1 100644
--- a/crates/tsv_ts/src/printer/statements/control_flow/try_jump.rs
+++ b/crates/tsv_ts/src/printer/statements/control_flow/try_jump.rs
@@ -199,10 +199,7 @@ impl<'a> Printer<'a> {
             // (`break loop; /* c */`, prettier 3.9), a same-line line via `line_suffix`,
             // an own-line comment on its own line after. See `split_separator_gap_comments`.
             let semicolon_pos = span.end.saturating_sub(1);
-            let after =
-                self.split_separator_gap_comments(&mut parts, label.span.end, semicolon_pos, true);
-            parts.push(d.text(";"));
-            parts.extend(after);
+            self.push_semicolon_with_gap_comments(&mut parts, label.span.end, semicolon_pos, true);
             d.concat(&parts)
         } else {
             // No label: a bare keyword closed by `;`. It swallows a following explicit
diff --git a/crates/tsv_ts/src/printer/statements/mod.rs b/crates/tsv_ts/src/printer/statements/mod.rs
index b148706a9..d4f8c667d 100644
--- a/crates/tsv_ts/src/printer/statements/mod.rs
+++ b/crates/tsv_ts/src/printer/statements/mod.rs
@@ -294,9 +294,7 @@ impl<'a> Printer<'a> {
         // `split_separator_gap_comments`.
         let expr_end = stmt.expression.span().end;
         let semicolon_pos = stmt.span.end.saturating_sub(1);
-        let after = self.split_separator_gap_comments(&mut parts, expr_end, semicolon_pos, true);
-        parts.push(d.text(";"));
-        parts.extend(after);
+        self.push_semicolon_with_gap_comments(&mut parts, expr_end, semicolon_pos, true);
         d.concat(&parts)
     }
 
@@ -359,9 +357,7 @@ impl<'a> Printer<'a> {
         let keyword_end = span.start + keyword.len() as u32;
         let semicolon_pos = span.end.saturating_sub(1);
         let mut parts: DocBuf = smallvec![d.text(keyword)];
-        let after = self.split_separator_gap_comments(&mut parts, keyword_end, semicolon_pos, true);
-        parts.push(d.text(";"));
-        parts.extend(after);
+        self.push_semicolon_with_gap_comments(&mut parts, keyword_end, semicolon_pos, true);
         d.concat(&parts)
     }
 
diff --git a/crates/tsv_ts/src/printer/statements/modules/mod.rs b/crates/tsv_ts/src/printer/statements/modules/mod.rs
index 2806042e4..cb703d6cd 100644
--- a/crates/tsv_ts/src/printer/statements/modules/mod.rs
+++ b/crates/tsv_ts/src/printer/statements/modules/mod.rs
@@ -17,6 +17,7 @@ mod specifier_list;
 pub(super) use super::{Printer, build_entity_name_doc};
 
 use crate::ast::internal;
+use crate::printer::calls::PartitionedComments;
 use crate::printer::needs_parens::export_default_needs_parens;
 use smallvec::SmallVec;
 use smallvec::smallvec;
@@ -766,26 +767,45 @@ impl<'a> Printer<'a> {
             self.identifier_name_doc(&decl.id),
         ));
 
+        // One walk of the reference: its span bounds and its doc. Built whole (rather
+        // than pushed piecemeal) so the `=`→reference gap below can pass it as its
+        // continuation — a line comment there indents the reference, and every break
+        // *inside* it has to land at that level too.
+        let (module_ref_start, ref_end, module_ref_doc) = match &decl.module_reference {
+            internal::TSModuleReference::ExternalModuleReference(ext) => (
+                ext.span.start,
+                ext.span.end,
+                self.build_external_module_reference_doc(ext),
+            ),
+            internal::TSModuleReference::EntityName(entity) => (
+                entity.span().start,
+                entity.span().end,
+                build_entity_name_doc(self, entity),
+            ),
+        };
+
         // identifier→`=` and `=`→module-reference gaps. Both are preserved in place
         // (prettier keeps them there too). Nothing else scans them — a module
         // reference is not an expression, so a comment glued to `require` is not
         // owned by any node and would be dropped if this gap didn't emit it.
-        let module_ref_start = match &decl.module_reference {
-            internal::TSModuleReference::ExternalModuleReference(ext) => ext.span.start,
-            internal::TSModuleReference::EntityName(entity) => entity.span().start,
-        };
         match self.find_keyword_in_range(decl.id.span.end, module_ref_start, "=") {
             Some(eq_start) => {
-                parts.push(self.build_keyword_to_name_continuation(
-                    decl.id.span.end,
-                    eq_start,
-                    d.text("="),
-                ));
-                parts.push(self.build_keyword_to_name_continuation(
-                    eq_start + 1,
-                    module_ref_start,
-                    d.empty(),
-                ));
+                // Both gaps FLAT, one `indent` for the whole tail — the multi-word
+                // keyword rule (`build_keyword_words_doc`), which this header is the
+                // other instance of. Indenting per gap compounds; and the tail must be
+                // *inside* the indent, not a sibling after it, or the reference's own
+                // line breaks resolve at the outer level — leaving `require(`'s
+                // contents level with it and its `)` a level above.
+                let (before_eq, line_before) =
+                    self.build_keyword_gap_doc(decl.id.span.end, eq_start);
+                let (after_eq, line_after) =
+                    self.build_keyword_gap_doc(eq_start + 1, module_ref_start);
+                let tail = d.concat(&[before_eq, d.text("="), after_eq, module_ref_doc]);
+                parts.push(if line_before || line_after {
+                    d.indent(tail)
+                } else {
+                    tail
+                });
             }
             None => {
                 // Same landmine as `build_keyword_words_doc`'s fallback: this arm scans
@@ -799,59 +819,7 @@ impl<'a> Printer<'a> {
                     decl.id.span.end
                 );
                 parts.push(d.text(" = "));
-            }
-        }
-
-        // module reference
-        match &decl.module_reference {
-            internal::TSModuleReference::ExternalModuleReference(ext_ref) => {
-                // Check for comments inside require() - expand if present
-                // The require() span includes `require(` at start and `)` at end
-                // Comments can be between `require(` and the string literal
-                let require_open_end = ext_ref.span.start + "require(".len() as u32;
-                let literal_start = ext_ref.expression.span.start;
-                let has_comments = self.has_line_comments_between(require_open_end, literal_start);
-
-                if has_comments {
-                    // Multi-line format with comments
-                    // Build comments doc: each comment on its own line
-                    let mut comment_parts = DocBuf::new();
-                    for comment in
-                        comments_to_emit_in_range(self.comments, require_open_end, literal_start)
-                    {
-                        comment_parts.push(self.build_comment_doc(comment));
-                        comment_parts.push(d.hardline());
-                    }
-
-                    parts.push(d.text("require("));
-                    parts.push(d.indent(d.concat(&[
-                        d.hardline(),
-                        d.concat(&comment_parts),
-                        self.build_literal_doc(&ext_ref.expression),
-                    ])));
-                    parts.push(d.hardline());
-                    parts.push(d.text(")"));
-                } else {
-                    // Check for inline block comments
-                    let has_inline_comments =
-                        self.has_comments_to_emit_between(require_open_end, literal_start);
-                    if has_inline_comments {
-                        parts.push(d.text("require("));
-                        parts.push(
-                            self.build_inline_comments_between_doc(require_open_end, literal_start),
-                        );
-                        parts.push(self.build_literal_doc(&ext_ref.expression));
-                        parts.push(d.text(")"));
-                    } else {
-                        // Simple compact format
-                        parts.push(d.text("require("));
-                        parts.push(self.build_literal_doc(&ext_ref.expression));
-                        parts.push(d.text(")"));
-                    }
-                }
-            }
-            internal::TSModuleReference::EntityName(entity_name) => {
-                parts.push(build_entity_name_doc(self, entity_name));
+                parts.push(module_ref_doc);
             }
         }
 
@@ -860,17 +828,95 @@ impl<'a> Printer<'a> {
         // *before* the `;` (operand-attached — prettier 3.9 keeps it), while a same-line
         // **line** comment floats after the `;` via `line_suffix`. So this uses the
         // comma-style `block_after_separator: false`, not `finish_with_pre_semi`.
-        let ref_end = match &decl.module_reference {
-            internal::TSModuleReference::ExternalModuleReference(ext_ref) => ext_ref.span.end,
-            internal::TSModuleReference::EntityName(entity_name) => entity_name.span().end,
-        };
         let semicolon_pos = decl.span.end.saturating_sub(1);
-        let after = self.split_separator_gap_comments(&mut parts, ref_end, semicolon_pos, false);
-        parts.push(d.text(";"));
-        parts.extend(after);
+        self.push_semicolon_with_gap_comments(&mut parts, ref_end, semicolon_pos, false);
         d.concat(&parts)
     }
 
+    /// The `require('m')` form of an import-equals module reference, as one doc.
+    ///
+    /// **Both** in-paren gaps are emitted — `require(`→literal and literal→`)`. Nothing
+    /// else scans either: a module reference is not an expression, so no node owns a
+    /// comment written here and a gap this printer skips is a gap whose comment is
+    /// dropped outright (silent content loss, which is what the literal→`)` gap used to
+    /// do).
+    ///
+    /// The close gap takes the shape a call's **last argument** already has
+    /// ([`PartitionedComments::emit_last_arg_comments`]): a same-line comment trails the
+    /// literal, an own-line one dangles above the `)`. There is no trailing comma to
+    /// split around (`trailingComma: 'none'`), which is exactly that helper's premise.
+    fn build_external_module_reference_doc(
+        &self,
+        ext_ref: &internal::TSExternalModuleReference<'_>,
+    ) -> DocId {
+        let d = self.d();
+        let require_open_end = ext_ref.span.start + "require(".len() as u32;
+        let literal_start = ext_ref.expression.span.start;
+        let close_paren = ext_ref.span.end.saturating_sub(1);
+
+        // The literal plus whatever trails it inside the parens.
+        let close = PartitionedComments::new(
+            self.comments,
+            self.line_breaks,
+            ext_ref.expression.span.end,
+            close_paren,
+        );
+        let mut value: DocBuf = smallvec![self.build_literal_doc(&ext_ref.expression)];
+        close.emit_last_arg_comments(&mut value, self);
+        let value_doc = d.concat(&value);
+
+        // A line comment runs to EOL and an own-line comment must keep its own line, so
+        // either side having one forces the parens open; a lone same-line block stays
+        // inline. Same rule as the dynamic-import parens (`calls/import_expr.rs`).
+        let open_has_line = self.has_line_comments_between(require_open_end, literal_start);
+        let open_has_any = self.has_comments_to_emit_between(require_open_end, literal_start);
+        let close_forces_break = close.has_trailing_line() || !close.leading.is_empty();
+
+        if open_has_line || close_forces_break {
+            let mut inner = DocBuf::new();
+            if open_has_line {
+                // Each open-gap comment on its own line — a line comment there can't
+                // share one with the literal.
+                for comment in
+                    comments_to_emit_in_range(self.comments, require_open_end, literal_start)
+                {
+                    inner.push(self.build_comment_doc(comment));
+                    inner.push(d.hardline());
+                }
+            } else if open_has_any {
+                // Only the close gap forced the break, so an open-gap block keeps
+                // hugging the literal rather than being relocated to its own line.
+                inner.push(self.build_inline_comments_between_doc_trailing_space(
+                    require_open_end,
+                    literal_start,
+                ));
+            }
+            inner.push(value_doc);
+            return d.concat(&[
+                d.text("require("),
+                d.indent(d.concat(&[d.hardline(), d.concat(&inner)])),
+                d.hardline(),
+                d.text(")"),
+            ]);
+        }
+        if open_has_any {
+            // The comment hugs the `(` and keeps its space on the literal's side
+            // (`require(/* c */ 'm')`) — the dotted pair's after-`.` rule, and prettier's.
+            // An author who wrote it *before* the `(` lands here too: both formatters move
+            // it inside, so the two authorings converge (`unformatted_before_paren`).
+            return d.concat(&[
+                d.text("require("),
+                self.build_inline_comments_between_doc_trailing_space(
+                    require_open_end,
+                    literal_start,
+                ),
+                value_doc,
+                d.text(")"),
+            ]);
+        }
+        d.concat(&[d.text("require("), value_doc, d.text(")")])
+    }
+
     /// `export as namespace Foo;` — TypeScript UMD global export declaration.
     pub(super) fn build_namespace_export_declaration_doc(
         &self,
@@ -890,10 +936,7 @@ impl<'a> Printer<'a> {
         // Trailing comment between the name and `;` (mirrors `export =` / import-equals):
         // a same-line block comment stays before `;`, a line comment floats after it.
         let semicolon_pos = decl.span.end.saturating_sub(1);
-        let after =
-            self.split_separator_gap_comments(&mut parts, decl.id.span.end, semicolon_pos, false);
-        parts.push(d.text(";"));
-        parts.extend(after);
+        self.push_semicolon_with_gap_comments(&mut parts, decl.id.span.end, semicolon_pos, false);
         d.concat(&parts)
     }
 }
diff --git a/crates/tsv_ts/src/printer/statements/type_declarations.rs b/crates/tsv_ts/src/printer/statements/type_declarations.rs
index cc8737279..494ebcd08 100644
--- a/crates/tsv_ts/src/printer/statements/type_declarations.rs
+++ b/crates/tsv_ts/src/printer/statements/type_declarations.rs
@@ -1153,13 +1153,29 @@ impl<'a> Printer<'a> {
                     ),
                 );
             }
-            match &decl.id {
-                internal::TSModuleName::Identifier(id) => {
-                    parts.push(self.identifier_name_doc(id));
-                }
-                internal::TSModuleName::Literal(lit) => {
-                    parts.push(self.build_literal_doc(lit));
+            let name_doc = match &decl.id {
+                internal::TSModuleName::Identifier(id) => self.identifier_name_doc(id),
+                internal::TSModuleName::Literal(lit) => self.build_literal_doc(lit),
+            };
+            // A dotted namespace (`namespace Outer.Inner {}`) pairs this name with the
+            // nested one, and both gaps around that `.` are positions an author can
+            // comment in — so the shared dotted-pair printer emits the name, the dot and
+            // the gaps together (it needs the left doc, hence holding it until here).
+            // Pushing name + `d.text(".")` scans neither gap and drops what's in it.
+            match &decl.body {
+                Some(internal::TSModuleDeclarationBody::TSModuleDeclaration(nested)) => {
+                    let name_end = match &decl.id {
+                        internal::TSModuleName::Identifier(id) => id.span.end,
+                        internal::TSModuleName::Literal(lit) => lit.span.end,
+                    };
+                    parts.push(self.build_dotted_pair_doc(
+                        name_doc,
+                        self.build_module_declaration_doc_inner(nested, false),
+                        name_end,
+                        nested.span.start,
+                    ));
                 }
+                _ => parts.push(name_doc),
             }
         }
 
@@ -1223,11 +1239,11 @@ impl<'a> Printer<'a> {
                     parts.push(d.text("}"));
                 }
             }
-            Some(internal::TSModuleDeclarationBody::TSModuleDeclaration(nested)) => {
-                // Nested namespace: `namespace Outer.Inner { }`
-                // Print as `Outer.Inner` (dot-separated)
-                parts.push(d.text("."));
-                parts.push(self.build_module_declaration_doc_inner(nested, false));
+            Some(internal::TSModuleDeclarationBody::TSModuleDeclaration(_)) => {
+                // A dotted namespace (`namespace Outer.Inner {}`) is emitted with the
+                // name above — the `.` and both its gaps belong to that pair, and only
+                // that path holds the left doc the shared printer needs. A `global`
+                // namespace can't be dotted, so the name path always ran.
             }
             None => {
                 // Shorthand ambient module: `declare module 'name';`
diff --git a/deno.json b/deno.json
index a64d35ebf..5156a3248 100644
--- a/deno.json
+++ b/deno.json
@@ -25,7 +25,7 @@
 		"typecheck": "cargo check --workspace",
 		"test": "cargo test --workspace",
 		"lint": "cargo clippy --workspace -- -D warnings",
-		"check": "cargo fmt --check && deno task pins:audit && deno task typecheck && deno task conformance:audit && deno task scan:audit && deno task fanout:audit && deno task roundtrip:audit && deno task binding:audit && deno task authoring:audit && deno task fuzz:audit && deno task test:deno && deno task test && deno task swallow:audit && deno task comments:audit && deno task check:ast-types && deno task lint",
+		"check": "cargo fmt --check && deno task pins:audit && deno task typecheck && deno task conformance:audit && deno task scan:audit && deno task fanout:audit && deno task roundtrip:audit && deno task binding:audit && deno task authoring:audit && deno task fuzz:audit && deno task test:deno && deno task test && deno task swallow:audit && deno task comments:audit && deno task gaps:audit && deno task check:ast-types && deno task lint",
 		"check:ast-types": "deno run --allow-read --allow-write=scripts --allow-run=cargo,deno scripts/check_ast_types.ts",
 		"doctor": "deno run --allow-read --allow-sys --allow-run=deno,node,bun,cargo,wasm-pack,npm --config benches/js/deno.json scripts/doctor.ts",
 
@@ -41,6 +41,8 @@
 		"pins:audit": "deno run --allow-read --allow-run=git scripts/check_canonical_pins.ts",
 		"swallow:audit": "cargo test -p tsv_lang --features swallow_check --quiet && cargo run -p tsv_debug --features swallow_check --quiet swallow_audit",
 		"comments:audit": "cargo test -p tsv_lang --features comment_check --quiet && cargo run -p tsv_debug --features comment_check --quiet comment_audit",
+		"gaps:audit": "cargo run --profile corpus -p tsv_debug --features comment_check --quiet gap_audit",
+		"gaps:audit:update": "cargo run --profile corpus -p tsv_debug --features comment_check --quiet gap_audit --update",
 		"scan:audit": "cargo run -p tsv_debug --quiet scan_audit",
 		"fanout:audit": "cargo run -p tsv_debug --quiet build_fanout_audit",
 		"roundtrip:audit": "cargo run -p tsv_debug --quiet roundtrip_audit --gate",
diff --git a/docs/conformance_prettier.md b/docs/conformance_prettier.md
index 9c9419e66..7cd72bc72 100644
--- a/docs/conformance_prettier.md
+++ b/docs/conformance_prettier.md
@@ -436,6 +436,18 @@ Standalone head wrap + dangle + body-expand:
 - `{#if}` (binary / member chain / call / `{:else if}`) — [if_long](../tests/fixtures/svelte/blocks/if/long_prettier_divergence/)
 - `{#if}` last block quirk — [last_block](../tests/fixtures/svelte/blocks/if/last_block_prettier_divergence/)
 
+The shape is keyed on **that the head broke, not on why**: tsv's block head hugs its first
+fragment to `{#if`, indents what follows, and drops `}` to base — whether the break came from
+printWidth or from a comment. A head far under printWidth still takes that shape when a *line*
+comment forces the break. (A **multi-line block** comment's newlines live inside its verbatim
+source span, which renders with no context indent by design, so its continuation is the
+comment's own line and only the `}` dangle shows; a **single-line block** comment breaks
+nothing and the head stays inline, both formatters agreeing.) Prettier never dangles a block
+head's `}` whatever broke it, so this is the one divergence on a second trigger — not a
+print-width tolerance:
+
+- `{#if}` (comment-forced head break) — [if/condition_breaking_comment](../tests/fixtures/svelte/blocks/if/condition_breaking_comment_prettier_divergence/)
+
 Same layout inside an inline element (head wraps + body expands, element hugs the outer boundary):
 
 - `{#if}` — [if/inline_element_long](../tests/fixtures/svelte/blocks/if/inline_element_long_prettier_divergence/)
@@ -767,8 +779,10 @@ Prettier moves comments between syntactic boundaries into adjacent blocks, paren
 - `export`→`=` (export assignment) → After the `=`, leading the value (`export = /* c */ value`); tsv keeps it after `export`, matching the `export`→`const`/`function` gap both formatters preserve. The operand-side gap agrees in both — [export_equals_keyword_comment](../tests/fixtures/typescript/modules/exports/export_equals_keyword_comment_prettier_divergence/)
 - `export as namespace` keyword-interior gaps (`export`→`as`, `as`→`namespace`) → Both relocated past the whole keyword and stacked before the name (`export as namespace /* c1 */ /* c2 */ Foo`), collapsing two distinct positions into one; tsv keeps each on its authored side. The `namespace`→name gap agrees in both (regular [export_as_namespace_name_comment](../tests/fixtures/typescript/modules/exports/export_as_namespace_name_comment/)) — [export_as_namespace_keyword_comment](../tests/fixtures/typescript/modules/exports/export_as_namespace_keyword_comment_prettier_divergence/)
 - Meta-property dot gaps (line) → Out of the meta property entirely: past the `;` for `new.target` (`return new.target; // c`), or after `.meta` for `import.meta`; tsv keeps it in the gap and continues `.property` one level down. Block comments in the same gaps agree in both (regular [dot_gap_comments](../tests/fixtures/typescript/expressions/misc/meta_property/dot_gap_comments/)) — [dot_gap_line_comment](../tests/fixtures/typescript/expressions/misc/meta_property/dot_gap_line_comment_prettier_divergence/)
+- Qualified-name dot gaps (line) → Past the `;` (`let a: ns.Type; // c`); tsv keeps it in the gap and continues the rest of the name one level down. The meta property's twin — same `name` `.` `name` shape, one shared printer — so it reaches type references, interface heritage, and import-equals module references alike. Block comments in the same gaps agree in both (regular [qualified_name_dot_gap_comments](../tests/fixtures/typescript/types/qualified_name_dot_gap_comments/)) — [qualified_name_dot_gap_line_comment](../tests/fixtures/typescript/types/qualified_name_dot_gap_line_comment_prettier_divergence/)
 - `export as namespace` keyword gaps (line) → All relocated past the whole keyword and stacked flush before the name (`export as namespace // c1⏎// c2⏎// c3⏎Foo`); tsv keeps each on its authored side, continuing the header at **one** indent level rather than a staircase — [export_as_namespace_line_comment](../tests/fixtures/typescript/modules/exports/export_as_namespace_line_comment_prettier_divergence/)
 - Import-equals `import`→`type` → Binding side of `type` (`import type /* c */ C = require('./c')`, the same rule as a default import); tsv preserves. The **only** diverging gap of that header — the other four agree in both and are pinned by the regular [equals_header_comment](../tests/fixtures/typescript/modules/imports/equals_header_comment/) — [equals_type_keyword_comment](../tests/fixtures/typescript/modules/imports/equals_type_keyword_comment_prettier_divergence/)
+- Import-equals header gaps (line) → Relocated past the `=` to trail the whole statement (`A = require('./a'); // c3`) with the rest stacked flush below it, and the `=`→reference gap's comment onto the `require(` line; tsv keeps each on its authored side, continuing the header at **one** indent level. The module reference is the only such tail that can break *internally*, so this also pins that its own breaks nest **inside** that level — its contents one deeper than `require(`, its `)` back at the reference's level. Prettier is non-idempotent on its own output here (a second pass moves the `require(` comment again; `audit_signature.txt` pins the chain) — [equals_header_line_comment](../tests/fixtures/typescript/modules/imports/equals_header_line_comment_prettier_divergence/)
 - `export default`→first decorator, comment **glued** to `@dec` → Relocated back past `default` (`export default /* c */`), then one blank line added per pass, saturating at two (Prettier non-idempotent; `output_prettier.*` is its first pass, `audit_signature.txt` pins the chain); tsv keeps it glued to `@dec`, where the parser bound it. The complementary own-line authoring is *not* glued, so it is emitted by the keyword→decorator gap instead — both authorings preserved — [default_decorator_lead_comment](../tests/fixtures/typescript/modules/exports/default_decorator_lead_comment_prettier_divergence/)
 - Import binding to `from` (line) → After `;` — [from_comment](../tests/fixtures/typescript/modules/imports/from_comment_prettier_divergence/)
 - Import specifiers to `from` → Into the specifier braces — [from_comment](../tests/fixtures/typescript/modules/imports/from_comment_prettier_divergence/)
@@ -1009,6 +1023,14 @@ compounds, and the staircase is not merely deep — the keyword→value gap is e
 own level, so the keyword's last word would sit *below* the value following it. Only a three-word
 keyword (`export as namespace`, the import-equals header) can show the difference.
 
+The tail has to be *inside* that one `indent`, not a sibling after it. The distinction is invisible
+for a tail that can't break — a bare name renders the same either way, because the gap's hardline
+has already written the indent the name lands on. It shows only when the tail breaks **internally**,
+and the import-equals module reference is the one that can: as a sibling, `require(`'s own line
+breaks resolve at the *outer* level, leaving its contents level with it and its `)` a level above
+the `require(` it closes
+([equals_header_line_comment](../tests/fixtures/typescript/modules/imports/equals_header_line_comment_prettier_divergence/)).
+
 Not every multi-word keyword admits an interior comment: `declare // c⏎const x` ASI-splits into
 two statements, and `await /* c⏎ */ using` demotes (the comment *is* a `LineTerminator`, and
 `await [no LT] using` requires none) — see the exclusions under [Declaration- and module-header
@@ -1017,15 +1039,21 @@ line-comment continuation indent](#comment-relocation).
 The same rule covers a keyword whose second word is a punctuator (`export /* c */ = value`) and
 multi-gap headers (`export /* c1 */ as /* c2 */ namespace Foo`, the import-equals header).
 
-It reaches past keywords, too: a **meta property** is the same shape — `new` `.` `target` — and both
+It reaches past keywords, too. A **meta property** is the same shape — `new` `.` `target` — and both
 gaps around its dot are positions an author can mean (`new /* c */.target`, `new./* c */ target`).
-tsv keeps each on its authored side, which is what prettier does for a block comment; a *line*
-comment there is a divergence
-([dot_gap_line_comment](../tests/fixtures/typescript/expressions/misc/meta_property/dot_gap_line_comment_prettier_divergence/)).
-That case is worth knowing for a different reason: the detector for this class — a `d.text` literal
-with an *interior* space — **cannot see it**, because the joining literal is `"."`. The class is
+So is a **qualified name** (`ns` `.` `Type`), which is why one printer (`build_dotted_pair_doc`)
+serves both: neither can regrow the hole independently, and through the qualified name it covers
+type references, interface heritage, and import-equals module references at once. tsv keeps each
+comment on its authored side, which is what prettier does for a block comment; a *line* comment
+there is a divergence
+([dot_gap_line_comment](../tests/fixtures/typescript/expressions/misc/meta_property/dot_gap_line_comment_prettier_divergence/),
+[qualified_name_dot_gap_line_comment](../tests/fixtures/typescript/types/qualified_name_dot_gap_line_comment_prettier_divergence/)).
+
+Those two are worth knowing for a different reason: the detector for this class — a `d.text` literal
+with an *interior* space — **cannot see them**, because the joining literal is `"."`. The class is
 "a header that concatenates fixed pieces without scanning the gaps between them"; the interior-space
 grep is a proxy for it, not a definition of it, so a punctuator-joined header needs finding by hand.
+Both were found that way, and both had been **dropping** every comment in both gaps.
 
 **Preserving is not the same as diverging, and most of these gaps are neither.** Prettier's
 treatment is not uniform: it relocates the `export as namespace` keyword-interior gaps, but
@@ -1047,7 +1075,9 @@ Catalogued in [§Comment relocation](#comment-relocation):
 [export_equals_keyword_comment](../tests/fixtures/typescript/modules/exports/export_equals_keyword_comment_prettier_divergence/),
 [export_as_namespace_keyword_comment](../tests/fixtures/typescript/modules/exports/export_as_namespace_keyword_comment_prettier_divergence/),
 [export_as_namespace_line_comment](../tests/fixtures/typescript/modules/exports/export_as_namespace_line_comment_prettier_divergence/),
-[equals_type_keyword_comment](../tests/fixtures/typescript/modules/imports/equals_type_keyword_comment_prettier_divergence/).
+[equals_type_keyword_comment](../tests/fixtures/typescript/modules/imports/equals_type_keyword_comment_prettier_divergence/),
+[equals_header_line_comment](../tests/fixtures/typescript/modules/imports/equals_header_line_comment_prettier_divergence/),
+[qualified_name_dot_gap_line_comment](../tests/fixtures/typescript/types/qualified_name_dot_gap_line_comment_prettier_divergence/).
 
 #### JSDoc / paren semantics
 
diff --git a/docs/gap_audit.md b/docs/gap_audit.md
new file mode 100644
index 000000000..d25caa1be
--- /dev/null
+++ b/docs/gap_audit.md
@@ -0,0 +1,172 @@
+# Gap-Injection Audit
+
+> Inject a comment into every gap and re-run the print-once ledger
+
+`gap_audit` is the **discovery** arm of the dropped-comment class. The print-once ledger
+([Comment Ledger Audit](../CLAUDE.md#debug-tooling)) is the detector, but it only ever sees
+a document **as authored** — so a gap no fixture happens to put a comment in is a gap it
+never checks. Eight such drops were found by hand, each green on `cargo test`,
+`comments:audit`, `roundtrip:audit`, and the corpus diff, purely because no fixture covered
+the position. This audit closes that hole mechanically: for each seed file it injects a
+comment into **every** candidate gap, one at a time, formats, and runs the ledger over the
+result.
+
+Pure Rust, no sidecar. Gated in `deno task check` as a **ratchet**, not a green gate.
+
+**Design rationale lives next to the code** — why sites are byte offsets rather than tokens,
+why the ledger (and not an output diff) is the oracle, why the payload set is plural, and
+what a green run does *not* prove: see the module docs at the top of
+`crates/tsv_debug/src/cli/commands/gap_audit.rs`. This file is the operator's reference.
+
+## Running it
+
+```bash
+deno task gaps:audit           # the gate: tests/fixtures, ~17 s
+deno task gaps:audit:update    # regenerate the snapshot after fixing a shape
+
+# Directly, against a real codebase — where the real yield is:
+cargo run --profile corpus -p tsv_debug --features comment_check gap_audit ~/dev/zzz/src
+```
+
+Build with **`--profile corpus`** (release + `panic = "unwind"`). Plain `--release` is
+`panic = "abort"`, so a formatter panic would kill the run instead of being caught and
+reported as the finding it is.
+
+| flag | effect |
+| --- | --- |
+| `--json` | machine-readable report on stdout (logs go to stderr) |
+| `--jobs N` | worker threads (default: available parallelism) |
+| `--limit N` | cap the seed files |
+| `--payload <one>` | `block` \| `line` \| `jsdoc_cast` \| `annotation` \| `multiline` |
+| `--all-bytes` | also inject strictly inside words — a diagnostic, not a stricter mode |
+| `--update` | rewrite the committed snapshot |
+
+### Full runs vs narrowed runs
+
+The snapshot describes exactly one run: **every payload, at every non-word site, over all of
+`tests/fixtures`**. Any flag that changes which shapes a run reaches — `--limit`,
+`--payload`, `--all-bytes`, or an explicit path — makes its shape set something other than
+what the snapshot means, so:
+
+- **`--update` refuses** a narrowed run outright. It would otherwise pin a subset (or, for
+  `--all-bytes`, a superset) and silently unpin real bugs.
+- **the ratchet is skipped**, with an explicit `○ ratchet SKIPPED` note. A narrowed run
+  reports; it does not grade, and a green one is *not* a passing gate.
+
+`--json` and `--jobs` change how a run is reported and scheduled, never which sites it
+reaches, so they don't narrow it.
+
+Off the default corpus (an explicit path) the snapshot doesn't apply at all — every finding
+is news, and any finding exits 1.
+
+## The ratchet
+
+`crates/tsv_debug/src/cli/commands/gap_audit_known.txt` is a **machine-generated** snapshot
+of every finding shape `tests/fixtures` currently produces. Unlike `scan_audit`'s
+hand-curated `ALLOW`, it carries **no per-entry rationale by design**: at ~700 shapes that is
+not a thing a human can keep honest. Every line is a **known bug**, and the file shrinking is
+the goal.
+
+```
+# Format: KIND<TAB>SHAPE<TAB>PAYLOADS
+DROPPED	import⟨⟩.	block
+DOUBLE-PRINTED	IDENT⟨⟩=	block,line
+```
+
+The gate fails on:
+
+- a shape **not** on the list — a new *kind* of drop, which must not land silently;
+- a listed shape that **no longer fires** — a stale entry, so the list can't rot;
+- a **panic**, always. A crash is never pinnable (see below).
+
+What it deliberately does **not** pin is **counts**. They churn with every ordinary fixture
+PR, and a gate that fails per added fixture would just get turned off. The tradeoff is named:
+a new drop at an **existing** shape is invisible.
+
+The **payload set is** part of the key, though. A shape that drops only a `line` comment
+today and starts dropping a `block` one tomorrow is a new bug on a new ownership path — keyed
+on the shape alone it would land inside an existing entry and never be seen. It is also
+stable in the way a count is not: it changes when the bug's character changes, not when a
+fixture is added.
+
+### A panic is never pinned
+
+A `PANIC` shape is excluded from the snapshot and always fails the gate. The invariant it
+breaks is absolute — a comment in a gap must never crash the formatter — so it is not a
+"known bug" to ratchet alongside the drops, and `--update` must not be able to quietly absorb
+a crash into the list whose shrinking is the goal. `--update` still writes the drops while a
+panic fires, but exits 1 rather than reporting a clean `✓`.
+
+## Reading a finding
+
+Findings dedup by **site shape** — the adjacent tokens with identifiers abstracted
+(`import⟨⟩.`, `IDENT⟨⟩=`, `.⟨⟩IDENT`). One bug fires at every site that reaches it, so raw
+`(file, offset)` findings would be unreadable and, as a ratchet key, would go stale on the
+next fixture edit.
+
+```
+     4123×  DROPPED        import⟨⟩.
+            37 file(s) · payloads: annotation, block, jsdoc_cast
+            e.g. inject block at tests/fixtures/…/input.svelte:412  …⏎import⟨⟩.source(x)…
+            comment: "/* c */"
+```
+
+- **`e.g. inject <payload> at <path>:<offset>`** is a *triple* — the payload that produced
+  **this** example, at this offset, in this file. Re-injecting some other payload of the
+  union at that offset need not fire, or even parse.
+- **`(N of M hits knock out a bystander)`** is the scarier half: the offending comment is one
+  the author already had, knocked out by an injection *elsewhere*. An existing comment
+  vanishing because someone added another one nearby.
+- **`⚠ UNCONFIRMED`** — see below.
+
+### `UNCONFIRMED`
+
+Each shape's example is **self-verified in-run**, because an instrument that only ever agrees
+with itself is not evidence. The ledger is made to predict something falsifiable: if it says
+this format drops `d` comments and double-prints `p`, the output must reparse to exactly
+`parsed - d + p` comments. Counting via reparse rather than matching the comment's *text* is
+what makes it sound — a printer may legitimately re-indent a multi-line comment, so text
+matching false-alarms.
+
+A shape whose prediction fails is reported `UNCONFIRMED`, not silently dropped. The output
+holds as many comments as its input, so something printed it without recording the emit — or
+printed a **mangled** rebuild (`/* a⏎b */` → `/* ab */`, one comment either way). **Real
+either way, but not the plain drop it is filed as**, so it wants different triage.
+
+`UNCONFIRMED` is triage information, not a gate signal: it is a property of the shape's one
+sampled example, not of the shape, so it is deliberately not part of the ratchet key.
+
+## Triaging and fixing a shape
+
+1. **Reproduce by hand.** Take the example triple verbatim — inject that payload at that
+   offset in that file — and format. The report gives you everything needed; nothing else is
+   required.
+2. **Check it's this class**, not an over-acceptance. tsv's parser is deliberately more
+   permissive than the canonical one, so confirm the injected form is something an author
+   could actually write (Svelte rejects `<script lang="ts"/* c */>` outright, for instance —
+   a comment dropped there is a different bug).
+3. **Fix the printer**, fixtures-first per the repo's TDD rule. The fix is usually to route
+   the gap through a comment-aware scan rather than concatenating fixed pieces.
+4. **Re-pin**: `deno task gaps:audit:update`, and confirm the shape's line is **gone** from
+   the snapshot rather than merely changed.
+
+If a shape is genuinely pre-existing and merely newly *reached* by a fixture you added, the
+same `gaps:audit:update` is the right move — the bug was always there; the corpus just went
+quiet about it until now.
+
+## Scope — what a green run does not prove
+
+Two limits compose, and neither is visible in a `✓`. Both are detailed in the module docs;
+the short version:
+
+- **The ledger's scope.** Only **detached** comments count. A Svelte `<!-- … -->` and a CSS
+  in-block comment are AST nodes carried by the tree; a CSS declaration's *value* comments are
+  never lexed as `Comment`s at all. All outside the model by construction. CSS also has no
+  line comments, so the `line` payload is inert in a `.css` file.
+- **`code_regions`' reach.** A gap the region walk doesn't name is a gap never probed. Today
+  a `.svelte` file's `<style>` content and the non-expression interior of a block tag
+  (`{#if ⟨here⟩ a.b}`) are unprobed — so, for example, a Svelte fixture containing only a
+  `<style>` block yields **zero sites**.
+
+Related: [Comment Ledger Audit](../CLAUDE.md#debug-tooling) (the detector this drives),
+[conformance_prettier.md §Comment Position Philosophy](conformance_prettier.md#comment-position-philosophy).
diff --git a/tests/fixtures/svelte/blocks/if/condition_breaking_comment_prettier_divergence/README.md b/tests/fixtures/svelte/blocks/if/condition_breaking_comment_prettier_divergence/README.md
new file mode 100644
index 000000000..f1dcbca75
--- /dev/null
+++ b/tests/fixtures/svelte/blocks/if/condition_breaking_comment_prettier_divergence/README.md
@@ -0,0 +1,46 @@
+# condition_breaking_comment_prettier_divergence
+
+A `{#if …}` head broken by a **comment** rather than by width. tsv indents the continuation
+and dangles the closing `}` at the tag's base indent; prettier keeps `cond}` hugged.
+
+This is the same head-wrap shape as [long_prettier_divergence](../long_prettier_divergence/) —
+only the *trigger* differs. tsv's block head hugs its first fragment to `{#if`, indents what
+follows, and drops `}` to base:
+
+```
+{#if a &&          {#if // c1
+	b                  cond
+}                  }
+```
+
+The rule is keyed on **that the head broke, not on why**, which is the whole reason this is a
+sanction and not a second layout: a head can break because it exceeds printWidth or because a
+comment forces it, and both produce one shape. Prettier never dangles a block head's `}`
+whatever broke the head.
+
+Boundary shapes covered:
+
+- **line comment** — ends in a hardline, so `cond` starts a real continuation line and takes
+  the indent.
+- **multi-line block comment** — its newlines live *inside* its verbatim source span, which
+  renders with no context indent by design (the interior stays exactly as authored). So
+  `cond` rides the comment's own last line (`c2 */ cond`); there is no continuation line, and
+  nothing to indent. The `}` still dangles.
+- **single-line block comment** — breaks nothing. The head stays inline and both formatters
+  agree, pinning that the trigger is the *break*, not a comment's mere presence.
+
+## Reason
+
+See [conformance_prettier.md §Svelte: Blocks](../../../../../../docs/conformance_prettier.md#svelte-blocks)
+for the head-wrap + `}` dangle + body-expand model and why tsv diverges (consistent with its
+JS `if (⏎…⏎) {` and broken-element `>`; block-body whitespace is render-non-significant).
+
+Note this is **not** an instance of the print-width divergence, though it shares its shape:
+the head here is far under printWidth, so prettier is not choosing to run long. It simply
+does not dangle.
+
+## Related
+
+- [long_prettier_divergence](../long_prettier_divergence/) — the same shape, triggered by width
+- [if_brace_in_regex_comment](../if_brace_in_regex_comment/) — a `}` inside a comment/regex in
+  the head must not close the tag early (a parse concern, not a layout one)
diff --git a/tests/fixtures/svelte/blocks/if/condition_breaking_comment_prettier_divergence/expected.json b/tests/fixtures/svelte/blocks/if/condition_breaking_comment_prettier_divergence/expected.json
new file mode 100644
index 000000000..96f949416
--- /dev/null
+++ b/tests/fixtures/svelte/blocks/if/condition_breaking_comment_prettier_divergence/expected.json
@@ -0,0 +1,359 @@
+{
+	"css": null,
+	"js": [],
+	"start": 0,
+	"end": 389,
+	"type": "Root",
+	"fragment": {
+		"type": "Fragment",
+		"nodes": [
+			{
+				"type": "Comment",
+				"start": 0,
+				"end": 83,
+				"data": " line comment breaks the head: continuation indents, } dangles (divergence) "
+			},
+			{
+				"type": "Text",
+				"start": 83,
+				"end": 84,
+				"raw": "\n",
+				"data": "\n"
+			},
+			{
+				"type": "IfBlock",
+				"elseif": false,
+				"start": 84,
+				"end": 121,
+				"test": {
+					"type": "Identifier",
+					"start": 96,
+					"end": 100,
+					"loc": {
+						"start": {
+							"line": 3,
+							"column": 1
+						},
+						"end": {
+							"line": 3,
+							"column": 5
+						}
+					},
+					"name": "cond",
+					"leadingComments": [
+						{
+							"type": "Line",
+							"value": " c1",
+							"start": 89,
+							"end": 94
+						}
+					]
+				},
+				"consequent": {
+					"type": "Fragment",
+					"nodes": [
+						{
+							"type": "Text",
+							"start": 102,
+							"end": 104,
+							"raw": "\n\t",
+							"data": "\n\t"
+						},
+						{
+							"type": "RegularElement",
+							"start": 104,
+							"end": 115,
+							"name": "p",
+							"name_loc": {
+								"start": {
+									"line": 5,
+									"column": 2,
+									"character": 105
+								},
+								"end": {
+									"line": 5,
+									"column": 3,
+									"character": 106
+								}
+							},
+							"attributes": [],
+							"fragment": {
+								"type": "Fragment",
+								"nodes": [
+									{
+										"type": "Text",
+										"start": 107,
+										"end": 111,
+										"raw": "text",
+										"data": "text"
+									}
+								]
+							}
+						},
+						{
+							"type": "Text",
+							"start": 115,
+							"end": 116,
+							"raw": "\n",
+							"data": "\n"
+						}
+					]
+				},
+				"alternate": null
+			},
+			{
+				"type": "Text",
+				"start": 121,
+				"end": 123,
+				"raw": "\n\n",
+				"data": "\n\n"
+			},
+			{
+				"type": "Comment",
+				"start": 123,
+				"end": 224,
+				"data": " multiline block comment breaks the head; its interior stays verbatim, } dangles (divergence) "
+			},
+			{
+				"type": "Text",
+				"start": 224,
+				"end": 225,
+				"raw": "\n",
+				"data": "\n"
+			},
+			{
+				"type": "IfBlock",
+				"elseif": false,
+				"start": 225,
+				"end": 267,
+				"test": {
+					"type": "Identifier",
+					"start": 242,
+					"end": 246,
+					"loc": {
+						"start": {
+							"line": 10,
+							"column": 6
+						},
+						"end": {
+							"line": 10,
+							"column": 10
+						}
+					},
+					"name": "cond",
+					"leadingComments": [
+						{
+							"type": "Block",
+							"value": " c1\nc2 ",
+							"start": 230,
+							"end": 241
+						}
+					]
+				},
+				"consequent": {
+					"type": "Fragment",
+					"nodes": [
+						{
+							"type": "Text",
+							"start": 248,
+							"end": 250,
+							"raw": "\n\t",
+							"data": "\n\t"
+						},
+						{
+							"type": "RegularElement",
+							"start": 250,
+							"end": 261,
+							"name": "p",
+							"name_loc": {
+								"start": {
+									"line": 12,
+									"column": 2,
+									"character": 251
+								},
+								"end": {
+									"line": 12,
+									"column": 3,
+									"character": 252
+								}
+							},
+							"attributes": [],
+							"fragment": {
+								"type": "Fragment",
+								"nodes": [
+									{
+										"type": "Text",
+										"start": 253,
+										"end": 257,
+										"raw": "text",
+										"data": "text"
+									}
+								]
+							}
+						},
+						{
+							"type": "Text",
+							"start": 261,
+							"end": 262,
+							"raw": "\n",
+							"data": "\n"
+						}
+					]
+				},
+				"alternate": null
+			},
+			{
+				"type": "Text",
+				"start": 267,
+				"end": 269,
+				"raw": "\n\n",
+				"data": "\n\n"
+			},
+			{
+				"type": "Comment",
+				"start": 269,
+				"end": 349,
+				"data": " single-line block comment breaks nothing: head stays inline, both agree "
+			},
+			{
+				"type": "Text",
+				"start": 349,
+				"end": 350,
+				"raw": "\n",
+				"data": "\n"
+			},
+			{
+				"type": "IfBlock",
+				"elseif": false,
+				"start": 350,
+				"end": 388,
+				"test": {
+					"type": "Identifier",
+					"start": 364,
+					"end": 368,
+					"loc": {
+						"start": {
+							"line": 16,
+							"column": 14
+						},
+						"end": {
+							"line": 16,
+							"column": 18
+						}
+					},
+					"name": "cond",
+					"leadingComments": [
+						{
+							"type": "Block",
+							"value": " c1 ",
+							"start": 355,
+							"end": 363
+						}
+					]
+				},
+				"consequent": {
+					"type": "Fragment",
+					"nodes": [
+						{
+							"type": "Text",
+							"start": 369,
+							"end": 371,
+							"raw": "\n\t",
+							"data": "\n\t"
+						},
+						{
+							"type": "RegularElement",
+							"start": 371,
+							"end": 382,
+							"name": "p",
+							"name_loc": {
+								"start": {
+									"line": 17,
+									"column": 2,
+									"character": 372
+								},
+								"end": {
+									"line": 17,
+									"column": 3,
+									"character": 373
+								}
+							},
+							"attributes": [],
+							"fragment": {
+								"type": "Fragment",
+								"nodes": [
+									{
+										"type": "Text",
+										"start": 374,
+										"end": 378,
+										"raw": "text",
+										"data": "text"
+									}
+								]
+							}
+						},
+						{
+							"type": "Text",
+							"start": 382,
+							"end": 383,
+							"raw": "\n",
+							"data": "\n"
+						}
+					]
+				},
+				"alternate": null
+			}
+		]
+	},
+	"options": null,
+	"comments": [
+		{
+			"type": "Line",
+			"value": " c1",
+			"start": 89,
+			"end": 94,
+			"loc": {
+				"start": {
+					"line": 2,
+					"column": 5
+				},
+				"end": {
+					"line": 2,
+					"column": 10
+				}
+			}
+		},
+		{
+			"type": "Block",
+			"value": " c1\nc2 ",
+			"start": 230,
+			"end": 241,
+			"loc": {
+				"start": {
+					"line": 9,
+					"column": 5
+				},
+				"end": {
+					"line": 10,
+					"column": 5
+				}
+			}
+		},
+		{
+			"type": "Block",
+			"value": " c1 ",
+			"start": 355,
+			"end": 363,
+			"loc": {
+				"start": {
+					"line": 16,
+					"column": 5
+				},
+				"end": {
+					"line": 16,
+					"column": 13
+				}
+			}
+		}
+	]
+}
diff --git a/tests/fixtures/svelte/blocks/if/condition_breaking_comment_prettier_divergence/input.svelte b/tests/fixtures/svelte/blocks/if/condition_breaking_comment_prettier_divergence/input.svelte
new file mode 100644
index 000000000..480bce15c
--- /dev/null
+++ b/tests/fixtures/svelte/blocks/if/condition_breaking_comment_prettier_divergence/input.svelte
@@ -0,0 +1,18 @@
+<!-- line comment breaks the head: continuation indents, } dangles (divergence) -->
+{#if // c1
+	cond
+}
+	<p>text</p>
+{/if}
+
+<!-- multiline block comment breaks the head; its interior stays verbatim, } dangles (divergence) -->
+{#if /* c1
+c2 */ cond
+}
+	<p>text</p>
+{/if}
+
+<!-- single-line block comment breaks nothing: head stays inline, both agree -->
+{#if /* c1 */ cond}
+	<p>text</p>
+{/if}
diff --git a/tests/fixtures/svelte/blocks/if/condition_breaking_comment_prettier_divergence/output_prettier.svelte b/tests/fixtures/svelte/blocks/if/condition_breaking_comment_prettier_divergence/output_prettier.svelte
new file mode 100644
index 000000000..c3e504cea
--- /dev/null
+++ b/tests/fixtures/svelte/blocks/if/condition_breaking_comment_prettier_divergence/output_prettier.svelte
@@ -0,0 +1,16 @@
+<!-- line comment breaks the head: continuation indents, } dangles (divergence) -->
+{#if // c1
+cond}
+	<p>text</p>
+{/if}
+
+<!-- multiline block comment breaks the head; its interior stays verbatim, } dangles (divergence) -->
+{#if /* c1
+c2 */ cond}
+	<p>text</p>
+{/if}
+
+<!-- single-line block comment breaks nothing: head stays inline, both agree -->
+{#if /* c1 */ cond}
+	<p>text</p>
+{/if}
diff --git a/tests/fixtures/typescript/declarations/namespace/nested_dot_comment/expected.json b/tests/fixtures/typescript/declarations/namespace/nested_dot_comment/expected.json
new file mode 100644
index 000000000..d12a5f43b
--- /dev/null
+++ b/tests/fixtures/typescript/declarations/namespace/nested_dot_comment/expected.json
@@ -0,0 +1,755 @@
+{
+	"css": null,
+	"js": [],
+	"start": 0,
+	"end": 349,
+	"type": "Root",
+	"fragment": {
+		"type": "Fragment",
+		"nodes": []
+	},
+	"options": null,
+	"comments": [
+		{
+			"type": "Line",
+			"value": " Block comment before the `.` of a dotted namespace — stays there",
+			"start": 20,
+			"end": 87,
+			"loc": {
+				"start": {
+					"line": 2,
+					"column": 1
+				},
+				"end": {
+					"line": 2,
+					"column": 68
+				}
+			}
+		},
+		{
+			"type": "Block",
+			"value": " c1 ",
+			"start": 101,
+			"end": 109,
+			"loc": {
+				"start": {
+					"line": 3,
+					"column": 13
+				},
+				"end": {
+					"line": 3,
+					"column": 21
+				}
+			}
+		},
+		{
+			"type": "Line",
+			"value": " Block comment after the `.` — stays on that side",
+			"start": 141,
+			"end": 192,
+			"loc": {
+				"start": {
+					"line": 7,
+					"column": 1
+				},
+				"end": {
+					"line": 7,
+					"column": 52
+				}
+			}
+		},
+		{
+			"type": "Block",
+			"value": " c2 ",
+			"start": 206,
+			"end": 214,
+			"loc": {
+				"start": {
+					"line": 8,
+					"column": 13
+				},
+				"end": {
+					"line": 8,
+					"column": 21
+				}
+			}
+		},
+		{
+			"type": "Line",
+			"value": " Both gaps in a deeper chain",
+			"start": 246,
+			"end": 276,
+			"loc": {
+				"start": {
+					"line": 12,
+					"column": 1
+				},
+				"end": {
+					"line": 12,
+					"column": 31
+				}
+			}
+		},
+		{
+			"type": "Block",
+			"value": " c3 ",
+			"start": 290,
+			"end": 298,
+			"loc": {
+				"start": {
+					"line": 13,
+					"column": 13
+				},
+				"end": {
+					"line": 13,
+					"column": 21
+				}
+			}
+		},
+		{
+			"type": "Block",
+			"value": " c4 ",
+			"start": 301,
+			"end": 309,
+			"loc": {
+				"start": {
+					"line": 13,
+					"column": 24
+				},
+				"end": {
+					"line": 13,
+					"column": 32
+				}
+			}
+		}
+	],
+	"instance": {
+		"type": "Script",
+		"start": 0,
+		"end": 348,
+		"context": "default",
+		"content": {
+			"type": "Program",
+			"start": 18,
+			"end": 339,
+			"loc": {
+				"start": {
+					"line": 1,
+					"column": 0
+				},
+				"end": {
+					"line": 16,
+					"column": 9
+				}
+			},
+			"body": [
+				{
+					"type": "TSModuleDeclaration",
+					"start": 89,
+					"end": 138,
+					"loc": {
+						"start": {
+							"line": 3,
+							"column": 1
+						},
+						"end": {
+							"line": 5,
+							"column": 2
+						}
+					},
+					"id": {
+						"type": "Identifier",
+						"start": 99,
+						"end": 100,
+						"loc": {
+							"start": {
+								"line": 3,
+								"column": 11
+							},
+							"end": {
+								"line": 3,
+								"column": 12
+							}
+						},
+						"name": "A",
+						"trailingComments": [
+							{
+								"type": "Block",
+								"value": " c1 ",
+								"start": 101,
+								"end": 109
+							}
+						]
+					},
+					"body": {
+						"type": "TSModuleDeclaration",
+						"start": 110,
+						"end": 138,
+						"loc": {
+							"start": {
+								"line": 3,
+								"column": 22
+							},
+							"end": {
+								"line": 5,
+								"column": 2
+							}
+						},
+						"id": {
+							"type": "Identifier",
+							"start": 110,
+							"end": 111,
+							"loc": {
+								"start": {
+									"line": 3,
+									"column": 22
+								},
+								"end": {
+									"line": 3,
+									"column": 23
+								}
+							},
+							"name": "B"
+						},
+						"body": {
+							"type": "TSModuleBlock",
+							"start": 112,
+							"end": 138,
+							"loc": {
+								"start": {
+									"line": 3,
+									"column": 24
+								},
+								"end": {
+									"line": 5,
+									"column": 2
+								}
+							},
+							"body": [
+								{
+									"type": "ExportNamedDeclaration",
+									"start": 116,
+									"end": 135,
+									"loc": {
+										"start": {
+											"line": 4,
+											"column": 2
+										},
+										"end": {
+											"line": 4,
+											"column": 21
+										}
+									},
+									"exportKind": "value",
+									"declaration": {
+										"type": "VariableDeclaration",
+										"start": 123,
+										"end": 135,
+										"loc": {
+											"start": {
+												"line": 4,
+												"column": 9
+											},
+											"end": {
+												"line": 4,
+												"column": 21
+											}
+										},
+										"declarations": [
+											{
+												"type": "VariableDeclarator",
+												"start": 129,
+												"end": 134,
+												"loc": {
+													"start": {
+														"line": 4,
+														"column": 15
+													},
+													"end": {
+														"line": 4,
+														"column": 20
+													}
+												},
+												"id": {
+													"type": "Identifier",
+													"start": 129,
+													"end": 130,
+													"loc": {
+														"start": {
+															"line": 4,
+															"column": 15
+														},
+														"end": {
+															"line": 4,
+															"column": 16
+														}
+													},
+													"name": "a"
+												},
+												"init": {
+													"type": "Literal",
+													"start": 133,
+													"end": 134,
+													"loc": {
+														"start": {
+															"line": 4,
+															"column": 19
+														},
+														"end": {
+															"line": 4,
+															"column": 20
+														}
+													},
+													"value": 1,
+													"raw": "1"
+												}
+											}
+										],
+										"kind": "const"
+									},
+									"specifiers": [],
+									"source": null
+								}
+							]
+						}
+					},
+					"leadingComments": [
+						{
+							"type": "Line",
+							"value": " Block comment before the `.` of a dotted namespace — stays there",
+							"start": 20,
+							"end": 87
+						}
+					]
+				},
+				{
+					"type": "TSModuleDeclaration",
+					"start": 194,
+					"end": 243,
+					"loc": {
+						"start": {
+							"line": 8,
+							"column": 1
+						},
+						"end": {
+							"line": 10,
+							"column": 2
+						}
+					},
+					"id": {
+						"type": "Identifier",
+						"start": 204,
+						"end": 205,
+						"loc": {
+							"start": {
+								"line": 8,
+								"column": 11
+							},
+							"end": {
+								"line": 8,
+								"column": 12
+							}
+						},
+						"name": "C"
+					},
+					"body": {
+						"type": "TSModuleDeclaration",
+						"start": 215,
+						"end": 243,
+						"loc": {
+							"start": {
+								"line": 8,
+								"column": 22
+							},
+							"end": {
+								"line": 10,
+								"column": 2
+							}
+						},
+						"id": {
+							"type": "Identifier",
+							"start": 215,
+							"end": 216,
+							"loc": {
+								"start": {
+									"line": 8,
+									"column": 22
+								},
+								"end": {
+									"line": 8,
+									"column": 23
+								}
+							},
+							"name": "D"
+						},
+						"body": {
+							"type": "TSModuleBlock",
+							"start": 217,
+							"end": 243,
+							"loc": {
+								"start": {
+									"line": 8,
+									"column": 24
+								},
+								"end": {
+									"line": 10,
+									"column": 2
+								}
+							},
+							"body": [
+								{
+									"type": "ExportNamedDeclaration",
+									"start": 221,
+									"end": 240,
+									"loc": {
+										"start": {
+											"line": 9,
+											"column": 2
+										},
+										"end": {
+											"line": 9,
+											"column": 21
+										}
+									},
+									"exportKind": "value",
+									"declaration": {
+										"type": "VariableDeclaration",
+										"start": 228,
+										"end": 240,
+										"loc": {
+											"start": {
+												"line": 9,
+												"column": 9
+											},
+											"end": {
+												"line": 9,
+												"column": 21
+											}
+										},
+										"declarations": [
+											{
+												"type": "VariableDeclarator",
+												"start": 234,
+												"end": 239,
+												"loc": {
+													"start": {
+														"line": 9,
+														"column": 15
+													},
+													"end": {
+														"line": 9,
+														"column": 20
+													}
+												},
+												"id": {
+													"type": "Identifier",
+													"start": 234,
+													"end": 235,
+													"loc": {
+														"start": {
+															"line": 9,
+															"column": 15
+														},
+														"end": {
+															"line": 9,
+															"column": 16
+														}
+													},
+													"name": "a"
+												},
+												"init": {
+													"type": "Literal",
+													"start": 238,
+													"end": 239,
+													"loc": {
+														"start": {
+															"line": 9,
+															"column": 19
+														},
+														"end": {
+															"line": 9,
+															"column": 20
+														}
+													},
+													"value": 1,
+													"raw": "1"
+												}
+											}
+										],
+										"kind": "const"
+									},
+									"specifiers": [],
+									"source": null
+								}
+							]
+						},
+						"leadingComments": [
+							{
+								"type": "Block",
+								"value": " c2 ",
+								"start": 206,
+								"end": 214
+							}
+						]
+					},
+					"leadingComments": [
+						{
+							"type": "Line",
+							"value": " Block comment after the `.` — stays on that side",
+							"start": 141,
+							"end": 192
+						}
+					]
+				},
+				{
+					"type": "TSModuleDeclaration",
+					"start": 278,
+					"end": 338,
+					"loc": {
+						"start": {
+							"line": 13,
+							"column": 1
+						},
+						"end": {
+							"line": 15,
+							"column": 2
+						}
+					},
+					"id": {
+						"type": "Identifier",
+						"start": 288,
+						"end": 289,
+						"loc": {
+							"start": {
+								"line": 13,
+								"column": 11
+							},
+							"end": {
+								"line": 13,
+								"column": 12
+							}
+						},
+						"name": "E"
+					},
+					"body": {
+						"type": "TSModuleDeclaration",
+						"start": 299,
+						"end": 338,
+						"loc": {
+							"start": {
+								"line": 13,
+								"column": 22
+							},
+							"end": {
+								"line": 15,
+								"column": 2
+							}
+						},
+						"id": {
+							"type": "Identifier",
+							"start": 299,
+							"end": 300,
+							"loc": {
+								"start": {
+									"line": 13,
+									"column": 22
+								},
+								"end": {
+									"line": 13,
+									"column": 23
+								}
+							},
+							"name": "F",
+							"trailingComments": [
+								{
+									"type": "Block",
+									"value": " c4 ",
+									"start": 301,
+									"end": 309
+								}
+							]
+						},
+						"body": {
+							"type": "TSModuleDeclaration",
+							"start": 310,
+							"end": 338,
+							"loc": {
+								"start": {
+									"line": 13,
+									"column": 33
+								},
+								"end": {
+									"line": 15,
+									"column": 2
+								}
+							},
+							"id": {
+								"type": "Identifier",
+								"start": 310,
+								"end": 311,
+								"loc": {
+									"start": {
+										"line": 13,
+										"column": 33
+									},
+									"end": {
+										"line": 13,
+										"column": 34
+									}
+								},
+								"name": "G"
+							},
+							"body": {
+								"type": "TSModuleBlock",
+								"start": 312,
+								"end": 338,
+								"loc": {
+									"start": {
+										"line": 13,
+										"column": 35
+									},
+									"end": {
+										"line": 15,
+										"column": 2
+									}
+								},
+								"body": [
+									{
+										"type": "ExportNamedDeclaration",
+										"start": 316,
+										"end": 335,
+										"loc": {
+											"start": {
+												"line": 14,
+												"column": 2
+											},
+											"end": {
+												"line": 14,
+												"column": 21
+											}
+										},
+										"exportKind": "value",
+										"declaration": {
+											"type": "VariableDeclaration",
+											"start": 323,
+											"end": 335,
+											"loc": {
+												"start": {
+													"line": 14,
+													"column": 9
+												},
+												"end": {
+													"line": 14,
+													"column": 21
+												}
+											},
+											"declarations": [
+												{
+													"type": "VariableDeclarator",
+													"start": 329,
+													"end": 334,
+													"loc": {
+														"start": {
+															"line": 14,
+															"column": 15
+														},
+														"end": {
+															"line": 14,
+															"column": 20
+														}
+													},
+													"id": {
+														"type": "Identifier",
+														"start": 329,
+														"end": 330,
+														"loc": {
+															"start": {
+																"line": 14,
+																"column": 15
+															},
+															"end": {
+																"line": 14,
+																"column": 16
+															}
+														},
+														"name": "a"
+													},
+													"init": {
+														"type": "Literal",
+														"start": 333,
+														"end": 334,
+														"loc": {
+															"start": {
+																"line": 14,
+																"column": 19
+															},
+															"end": {
+																"line": 14,
+																"column": 20
+															}
+														},
+														"value": 1,
+														"raw": "1"
+													}
+												}
+											],
+											"kind": "const"
+										},
+										"specifiers": [],
+										"source": null
+									}
+								]
+							}
+						},
+						"leadingComments": [
+							{
+								"type": "Block",
+								"value": " c3 ",
+								"start": 290,
+								"end": 298
+							}
+						]
+					},
+					"leadingComments": [
+						{
+							"type": "Line",
+							"value": " Both gaps in a deeper chain",
+							"start": 246,
+							"end": 276
+						}
+					]
+				}
+			],
+			"sourceType": "module"
+		},
+		"attributes": [
+			{
+				"type": "Attribute",
+				"start": 8,
+				"end": 17,
+				"name": "lang",
+				"name_loc": {
+					"start": {
+						"line": 1,
+						"column": 8,
+						"character": 8
+					},
+					"end": {
+						"line": 1,
+						"column": 12,
+						"character": 12
+					}
+				},
+				"value": [
+					{
+						"start": 14,
+						"end": 16,
+						"type": "Text",
+						"raw": "ts",
+						"data": "ts"
+					}
+				]
+			}
+		]
+	}
+}
diff --git a/tests/fixtures/typescript/declarations/namespace/nested_dot_comment/input.svelte b/tests/fixtures/typescript/declarations/namespace/nested_dot_comment/input.svelte
new file mode 100644
index 000000000..c4c0a2eda
--- /dev/null
+++ b/tests/fixtures/typescript/declarations/namespace/nested_dot_comment/input.svelte
@@ -0,0 +1,16 @@
+<script lang="ts">
+	// Block comment before the `.` of a dotted namespace — stays there
+	namespace A /* c1 */.B {
+		export const a = 1;
+	}
+
+	// Block comment after the `.` — stays on that side
+	namespace C./* c2 */ D {
+		export const a = 1;
+	}
+
+	// Both gaps in a deeper chain
+	namespace E./* c3 */ F /* c4 */.G {
+		export const a = 1;
+	}
+</script>
diff --git a/tests/fixtures/typescript/expressions/calls/arrow_array_return_multiline_comment/expected.json b/tests/fixtures/typescript/expressions/calls/arrow_array_return_multiline_comment/expected.json
new file mode 100644
index 000000000..f390287d4
--- /dev/null
+++ b/tests/fixtures/typescript/expressions/calls/arrow_array_return_multiline_comment/expected.json
@@ -0,0 +1,811 @@
+{
+	"css": null,
+	"js": [],
+	"start": 0,
+	"end": 223,
+	"type": "Root",
+	"fragment": {
+		"type": "Fragment",
+		"nodes": []
+	},
+	"options": null,
+	"comments": [
+		{
+			"type": "Block",
+			"value": " text1\ntext2 ",
+			"start": 47,
+			"end": 64,
+			"loc": {
+				"start": {
+					"line": 4,
+					"column": 3
+				},
+				"end": {
+					"line": 5,
+					"column": 8
+				}
+			}
+		},
+		{
+			"type": "Block",
+			"value": " text1\ntext2 ",
+			"start": 121,
+			"end": 138,
+			"loc": {
+				"start": {
+					"line": 12,
+					"column": 3
+				},
+				"end": {
+					"line": 13,
+					"column": 8
+				}
+			}
+		},
+		{
+			"type": "Block",
+			"value": " text ",
+			"start": 183,
+			"end": 193,
+			"loc": {
+				"start": {
+					"line": 18,
+					"column": 21
+				},
+				"end": {
+					"line": 18,
+					"column": 31
+				}
+			}
+		}
+	],
+	"instance": {
+		"type": "Script",
+		"start": 0,
+		"end": 222,
+		"context": "default",
+		"content": {
+			"type": "Program",
+			"start": 18,
+			"end": 213,
+			"loc": {
+				"start": {
+					"line": 1,
+					"column": 0
+				},
+				"end": {
+					"line": 19,
+					"column": 9
+				}
+			},
+			"body": [
+				{
+					"type": "VariableDeclaration",
+					"start": 20,
+					"end": 91,
+					"loc": {
+						"start": {
+							"line": 2,
+							"column": 1
+						},
+						"end": {
+							"line": 8,
+							"column": 3
+						}
+					},
+					"declarations": [
+						{
+							"type": "VariableDeclarator",
+							"start": 26,
+							"end": 90,
+							"loc": {
+								"start": {
+									"line": 2,
+									"column": 7
+								},
+								"end": {
+									"line": 8,
+									"column": 2
+								}
+							},
+							"id": {
+								"type": "Identifier",
+								"start": 26,
+								"end": 27,
+								"loc": {
+									"start": {
+										"line": 2,
+										"column": 7
+									},
+									"end": {
+										"line": 2,
+										"column": 8
+									}
+								},
+								"name": "a"
+							},
+							"init": {
+								"type": "CallExpression",
+								"start": 30,
+								"end": 90,
+								"loc": {
+									"start": {
+										"line": 2,
+										"column": 11
+									},
+									"end": {
+										"line": 8,
+										"column": 2
+									}
+								},
+								"callee": {
+									"type": "MemberExpression",
+									"start": 30,
+									"end": 37,
+									"loc": {
+										"start": {
+											"line": 2,
+											"column": 11
+										},
+										"end": {
+											"line": 2,
+											"column": 18
+										}
+									},
+									"object": {
+										"type": "Identifier",
+										"start": 30,
+										"end": 33,
+										"loc": {
+											"start": {
+												"line": 2,
+												"column": 11
+											},
+											"end": {
+												"line": 2,
+												"column": 14
+											}
+										},
+										"name": "arr"
+									},
+									"property": {
+										"type": "Identifier",
+										"start": 34,
+										"end": 37,
+										"loc": {
+											"start": {
+												"line": 2,
+												"column": 15
+											},
+											"end": {
+												"line": 2,
+												"column": 18
+											}
+										},
+										"name": "map"
+									},
+									"computed": false,
+									"optional": false
+								},
+								"arguments": [
+									{
+										"type": "ArrowFunctionExpression",
+										"start": 41,
+										"end": 87,
+										"loc": {
+											"start": {
+												"line": 3,
+												"column": 2
+											},
+											"end": {
+												"line": 7,
+												"column": 14
+											}
+										},
+										"id": null,
+										"expression": true,
+										"generator": false,
+										"async": false,
+										"params": [
+											{
+												"type": "ArrayPattern",
+												"start": 42,
+												"end": 76,
+												"loc": {
+													"start": {
+														"line": 3,
+														"column": 3
+													},
+													"end": {
+														"line": 7,
+														"column": 3
+													}
+												},
+												"elements": [
+													{
+														"type": "Identifier",
+														"start": 65,
+														"end": 66,
+														"loc": {
+															"start": {
+																"line": 5,
+																"column": 9
+															},
+															"end": {
+																"line": 5,
+																"column": 10
+															}
+														},
+														"name": "x",
+														"leadingComments": [
+															{
+																"type": "Block",
+																"value": " text1\ntext2 ",
+																"start": 47,
+																"end": 64
+															}
+														]
+													},
+													{
+														"type": "Identifier",
+														"start": 71,
+														"end": 72,
+														"loc": {
+															"start": {
+																"line": 6,
+																"column": 3
+															},
+															"end": {
+																"line": 6,
+																"column": 4
+															}
+														},
+														"name": "y"
+													}
+												]
+											}
+										],
+										"body": {
+											"type": "ArrayExpression",
+											"start": 81,
+											"end": 87,
+											"loc": {
+												"start": {
+													"line": 7,
+													"column": 8
+												},
+												"end": {
+													"line": 7,
+													"column": 14
+												}
+											},
+											"elements": [
+												{
+													"type": "Identifier",
+													"start": 82,
+													"end": 83,
+													"loc": {
+														"start": {
+															"line": 7,
+															"column": 9
+														},
+														"end": {
+															"line": 7,
+															"column": 10
+														}
+													},
+													"name": "y"
+												},
+												{
+													"type": "Identifier",
+													"start": 85,
+													"end": 86,
+													"loc": {
+														"start": {
+															"line": 7,
+															"column": 12
+														},
+														"end": {
+															"line": 7,
+															"column": 13
+														}
+													},
+													"name": "x"
+												}
+											]
+										}
+									}
+								],
+								"optional": false
+							}
+						}
+					],
+					"kind": "const"
+				},
+				{
+					"type": "VariableDeclaration",
+					"start": 94,
+					"end": 160,
+					"loc": {
+						"start": {
+							"line": 10,
+							"column": 1
+						},
+						"end": {
+							"line": 16,
+							"column": 3
+						}
+					},
+					"declarations": [
+						{
+							"type": "VariableDeclarator",
+							"start": 100,
+							"end": 159,
+							"loc": {
+								"start": {
+									"line": 10,
+									"column": 7
+								},
+								"end": {
+									"line": 16,
+									"column": 2
+								}
+							},
+							"id": {
+								"type": "Identifier",
+								"start": 100,
+								"end": 101,
+								"loc": {
+									"start": {
+										"line": 10,
+										"column": 7
+									},
+									"end": {
+										"line": 10,
+										"column": 8
+									}
+								},
+								"name": "b"
+							},
+							"init": {
+								"type": "CallExpression",
+								"start": 104,
+								"end": 159,
+								"loc": {
+									"start": {
+										"line": 10,
+										"column": 11
+									},
+									"end": {
+										"line": 16,
+										"column": 2
+									}
+								},
+								"callee": {
+									"type": "MemberExpression",
+									"start": 104,
+									"end": 111,
+									"loc": {
+										"start": {
+											"line": 10,
+											"column": 11
+										},
+										"end": {
+											"line": 10,
+											"column": 18
+										}
+									},
+									"object": {
+										"type": "Identifier",
+										"start": 104,
+										"end": 107,
+										"loc": {
+											"start": {
+												"line": 10,
+												"column": 11
+											},
+											"end": {
+												"line": 10,
+												"column": 14
+											}
+										},
+										"name": "arr"
+									},
+									"property": {
+										"type": "Identifier",
+										"start": 108,
+										"end": 111,
+										"loc": {
+											"start": {
+												"line": 10,
+												"column": 15
+											},
+											"end": {
+												"line": 10,
+												"column": 18
+											}
+										},
+										"name": "map"
+									},
+									"computed": false,
+									"optional": false
+								},
+								"arguments": [
+									{
+										"type": "ArrowFunctionExpression",
+										"start": 115,
+										"end": 156,
+										"loc": {
+											"start": {
+												"line": 11,
+												"column": 2
+											},
+											"end": {
+												"line": 15,
+												"column": 9
+											}
+										},
+										"id": null,
+										"expression": true,
+										"generator": false,
+										"async": false,
+										"params": [
+											{
+												"type": "ArrayPattern",
+												"start": 116,
+												"end": 150,
+												"loc": {
+													"start": {
+														"line": 11,
+														"column": 3
+													},
+													"end": {
+														"line": 15,
+														"column": 3
+													}
+												},
+												"elements": [
+													{
+														"type": "Identifier",
+														"start": 139,
+														"end": 140,
+														"loc": {
+															"start": {
+																"line": 13,
+																"column": 9
+															},
+															"end": {
+																"line": 13,
+																"column": 10
+															}
+														},
+														"name": "x",
+														"leadingComments": [
+															{
+																"type": "Block",
+																"value": " text1\ntext2 ",
+																"start": 121,
+																"end": 138
+															}
+														]
+													},
+													{
+														"type": "Identifier",
+														"start": 145,
+														"end": 146,
+														"loc": {
+															"start": {
+																"line": 14,
+																"column": 3
+															},
+															"end": {
+																"line": 14,
+																"column": 4
+															}
+														},
+														"name": "y"
+													}
+												]
+											}
+										],
+										"body": {
+											"type": "Identifier",
+											"start": 155,
+											"end": 156,
+											"loc": {
+												"start": {
+													"line": 15,
+													"column": 8
+												},
+												"end": {
+													"line": 15,
+													"column": 9
+												}
+											},
+											"name": "x"
+										}
+									}
+								],
+								"optional": false
+							}
+						}
+					],
+					"kind": "const"
+				},
+				{
+					"type": "VariableDeclaration",
+					"start": 163,
+					"end": 212,
+					"loc": {
+						"start": {
+							"line": 18,
+							"column": 1
+						},
+						"end": {
+							"line": 18,
+							"column": 50
+						}
+					},
+					"declarations": [
+						{
+							"type": "VariableDeclarator",
+							"start": 169,
+							"end": 211,
+							"loc": {
+								"start": {
+									"line": 18,
+									"column": 7
+								},
+								"end": {
+									"line": 18,
+									"column": 49
+								}
+							},
+							"id": {
+								"type": "Identifier",
+								"start": 169,
+								"end": 170,
+								"loc": {
+									"start": {
+										"line": 18,
+										"column": 7
+									},
+									"end": {
+										"line": 18,
+										"column": 8
+									}
+								},
+								"name": "c"
+							},
+							"init": {
+								"type": "CallExpression",
+								"start": 173,
+								"end": 211,
+								"loc": {
+									"start": {
+										"line": 18,
+										"column": 11
+									},
+									"end": {
+										"line": 18,
+										"column": 49
+									}
+								},
+								"callee": {
+									"type": "MemberExpression",
+									"start": 173,
+									"end": 180,
+									"loc": {
+										"start": {
+											"line": 18,
+											"column": 11
+										},
+										"end": {
+											"line": 18,
+											"column": 18
+										}
+									},
+									"object": {
+										"type": "Identifier",
+										"start": 173,
+										"end": 176,
+										"loc": {
+											"start": {
+												"line": 18,
+												"column": 11
+											},
+											"end": {
+												"line": 18,
+												"column": 14
+											}
+										},
+										"name": "arr"
+									},
+									"property": {
+										"type": "Identifier",
+										"start": 177,
+										"end": 180,
+										"loc": {
+											"start": {
+												"line": 18,
+												"column": 15
+											},
+											"end": {
+												"line": 18,
+												"column": 18
+											}
+										},
+										"name": "map"
+									},
+									"computed": false,
+									"optional": false
+								},
+								"arguments": [
+									{
+										"type": "ArrowFunctionExpression",
+										"start": 181,
+										"end": 210,
+										"loc": {
+											"start": {
+												"line": 18,
+												"column": 19
+											},
+											"end": {
+												"line": 18,
+												"column": 48
+											}
+										},
+										"id": null,
+										"expression": true,
+										"generator": false,
+										"async": false,
+										"params": [
+											{
+												"type": "ArrayPattern",
+												"start": 182,
+												"end": 199,
+												"loc": {
+													"start": {
+														"line": 18,
+														"column": 20
+													},
+													"end": {
+														"line": 18,
+														"column": 37
+													}
+												},
+												"elements": [
+													{
+														"type": "Identifier",
+														"start": 194,
+														"end": 195,
+														"loc": {
+															"start": {
+																"line": 18,
+																"column": 32
+															},
+															"end": {
+																"line": 18,
+																"column": 33
+															}
+														},
+														"name": "x",
+														"leadingComments": [
+															{
+																"type": "Block",
+																"value": " text ",
+																"start": 183,
+																"end": 193
+															}
+														]
+													},
+													{
+														"type": "Identifier",
+														"start": 197,
+														"end": 198,
+														"loc": {
+															"start": {
+																"line": 18,
+																"column": 35
+															},
+															"end": {
+																"line": 18,
+																"column": 36
+															}
+														},
+														"name": "y"
+													}
+												]
+											}
+										],
+										"body": {
+											"type": "ArrayExpression",
+											"start": 204,
+											"end": 210,
+											"loc": {
+												"start": {
+													"line": 18,
+													"column": 42
+												},
+												"end": {
+													"line": 18,
+													"column": 48
+												}
+											},
+											"elements": [
+												{
+													"type": "Identifier",
+													"start": 205,
+													"end": 206,
+													"loc": {
+														"start": {
+															"line": 18,
+															"column": 43
+														},
+														"end": {
+															"line": 18,
+															"column": 44
+														}
+													},
+													"name": "y"
+												},
+												{
+													"type": "Identifier",
+													"start": 208,
+													"end": 209,
+													"loc": {
+														"start": {
+															"line": 18,
+															"column": 46
+														},
+														"end": {
+															"line": 18,
+															"column": 47
+														}
+													},
+													"name": "x"
+												}
+											]
+										}
+									}
+								],
+								"optional": false
+							}
+						}
+					],
+					"kind": "const"
+				}
+			],
+			"sourceType": "module"
+		},
+		"attributes": [
+			{
+				"type": "Attribute",
+				"start": 8,
+				"end": 17,
+				"name": "lang",
+				"name_loc": {
+					"start": {
+						"line": 1,
+						"column": 8,
+						"character": 8
+					},
+					"end": {
+						"line": 1,
+						"column": 12,
+						"character": 12
+					}
+				},
+				"value": [
+					{
+						"start": 14,
+						"end": 16,
+						"type": "Text",
+						"raw": "ts",
+						"data": "ts"
+					}
+				]
+			}
+		]
+	}
+}
diff --git a/tests/fixtures/typescript/expressions/calls/arrow_array_return_multiline_comment/input.svelte b/tests/fixtures/typescript/expressions/calls/arrow_array_return_multiline_comment/input.svelte
new file mode 100644
index 000000000..011d47391
--- /dev/null
+++ b/tests/fixtures/typescript/expressions/calls/arrow_array_return_multiline_comment/input.svelte
@@ -0,0 +1,19 @@
+<script lang="ts">
+	const a = arr.map(
+		([
+			/* text1
+text2 */ x,
+			y
+		]) => [y, x]
+	);
+
+	const b = arr.map(
+		([
+			/* text1
+text2 */ x,
+			y
+		]) => x
+	);
+
+	const c = arr.map(([/* text */ x, y]) => [y, x]);
+</script>
diff --git a/tests/fixtures/typescript/expressions/calls/test_function_dot_comment/expected.json b/tests/fixtures/typescript/expressions/calls/test_function_dot_comment/expected.json
new file mode 100644
index 000000000..1e09ecc59
--- /dev/null
+++ b/tests/fixtures/typescript/expressions/calls/test_function_dot_comment/expected.json
@@ -0,0 +1,775 @@
+{
+	"css": null,
+	"js": [],
+	"start": 0,
+	"end": 359,
+	"type": "Root",
+	"fragment": {
+		"type": "Fragment",
+		"nodes": []
+	},
+	"options": null,
+	"comments": [
+		{
+			"type": "Line",
+			"value": " Block comment before the `.` of a test-pattern chain — stays there",
+			"start": 20,
+			"end": 89,
+			"loc": {
+				"start": {
+					"line": 2,
+					"column": 1
+				},
+				"end": {
+					"line": 2,
+					"column": 70
+				}
+			}
+		},
+		{
+			"type": "Block",
+			"value": " c1 ",
+			"start": 100,
+			"end": 108,
+			"loc": {
+				"start": {
+					"line": 3,
+					"column": 10
+				},
+				"end": {
+					"line": 3,
+					"column": 18
+				}
+			}
+		},
+		{
+			"type": "Line",
+			"value": " Block comment after the `.` — stays on that side",
+			"start": 132,
+			"end": 183,
+			"loc": {
+				"start": {
+					"line": 5,
+					"column": 1
+				},
+				"end": {
+					"line": 5,
+					"column": 52
+				}
+			}
+		},
+		{
+			"type": "Block",
+			"value": " c2 ",
+			"start": 190,
+			"end": 198,
+			"loc": {
+				"start": {
+					"line": 6,
+					"column": 6
+				},
+				"end": {
+					"line": 6,
+					"column": 14
+				}
+			}
+		},
+		{
+			"type": "Line",
+			"value": " The other recognized variants take the same two gaps",
+			"start": 222,
+			"end": 277,
+			"loc": {
+				"start": {
+					"line": 8,
+					"column": 1
+				},
+				"end": {
+					"line": 8,
+					"column": 56
+				}
+			}
+		},
+		{
+			"type": "Block",
+			"value": " c3 ",
+			"start": 284,
+			"end": 292,
+			"loc": {
+				"start": {
+					"line": 9,
+					"column": 6
+				},
+				"end": {
+					"line": 9,
+					"column": 14
+				}
+			}
+		},
+		{
+			"type": "Block",
+			"value": " c4 ",
+			"start": 319,
+			"end": 327,
+			"loc": {
+				"start": {
+					"line": 10,
+					"column": 4
+				},
+				"end": {
+					"line": 10,
+					"column": 12
+				}
+			}
+		}
+	],
+	"instance": {
+		"type": "Script",
+		"start": 0,
+		"end": 358,
+		"context": "default",
+		"content": {
+			"type": "Program",
+			"start": 18,
+			"end": 349,
+			"loc": {
+				"start": {
+					"line": 1,
+					"column": 0
+				},
+				"end": {
+					"line": 11,
+					"column": 9
+				}
+			},
+			"body": [
+				{
+					"type": "ExpressionStatement",
+					"start": 91,
+					"end": 129,
+					"loc": {
+						"start": {
+							"line": 3,
+							"column": 1
+						},
+						"end": {
+							"line": 3,
+							"column": 39
+						}
+					},
+					"expression": {
+						"type": "CallExpression",
+						"start": 91,
+						"end": 128,
+						"loc": {
+							"start": {
+								"line": 3,
+								"column": 1
+							},
+							"end": {
+								"line": 3,
+								"column": 38
+							}
+						},
+						"callee": {
+							"type": "MemberExpression",
+							"start": 91,
+							"end": 113,
+							"loc": {
+								"start": {
+									"line": 3,
+									"column": 1
+								},
+								"end": {
+									"line": 3,
+									"column": 23
+								}
+							},
+							"object": {
+								"type": "Identifier",
+								"start": 91,
+								"end": 99,
+								"loc": {
+									"start": {
+										"line": 3,
+										"column": 1
+									},
+									"end": {
+										"line": 3,
+										"column": 9
+									}
+								},
+								"name": "describe",
+								"trailingComments": [
+									{
+										"type": "Block",
+										"value": " c1 ",
+										"start": 100,
+										"end": 108
+									}
+								]
+							},
+							"property": {
+								"type": "Identifier",
+								"start": 109,
+								"end": 113,
+								"loc": {
+									"start": {
+										"line": 3,
+										"column": 19
+									},
+									"end": {
+										"line": 3,
+										"column": 23
+									}
+								},
+								"name": "only"
+							},
+							"computed": false,
+							"optional": false
+						},
+						"arguments": [
+							{
+								"type": "Literal",
+								"start": 114,
+								"end": 117,
+								"loc": {
+									"start": {
+										"line": 3,
+										"column": 24
+									},
+									"end": {
+										"line": 3,
+										"column": 27
+									}
+								},
+								"value": "a",
+								"raw": "'a'"
+							},
+							{
+								"type": "ArrowFunctionExpression",
+								"start": 119,
+								"end": 127,
+								"loc": {
+									"start": {
+										"line": 3,
+										"column": 29
+									},
+									"end": {
+										"line": 3,
+										"column": 37
+									}
+								},
+								"id": null,
+								"expression": false,
+								"generator": false,
+								"async": false,
+								"params": [],
+								"body": {
+									"type": "BlockStatement",
+									"start": 125,
+									"end": 127,
+									"loc": {
+										"start": {
+											"line": 3,
+											"column": 35
+										},
+										"end": {
+											"line": 3,
+											"column": 37
+										}
+									},
+									"body": []
+								}
+							}
+						],
+						"optional": false
+					},
+					"leadingComments": [
+						{
+							"type": "Line",
+							"value": " Block comment before the `.` of a test-pattern chain — stays there",
+							"start": 20,
+							"end": 89
+						}
+					]
+				},
+				{
+					"type": "ExpressionStatement",
+					"start": 185,
+					"end": 219,
+					"loc": {
+						"start": {
+							"line": 6,
+							"column": 1
+						},
+						"end": {
+							"line": 6,
+							"column": 35
+						}
+					},
+					"expression": {
+						"type": "CallExpression",
+						"start": 185,
+						"end": 218,
+						"loc": {
+							"start": {
+								"line": 6,
+								"column": 1
+							},
+							"end": {
+								"line": 6,
+								"column": 34
+							}
+						},
+						"callee": {
+							"type": "MemberExpression",
+							"start": 185,
+							"end": 203,
+							"loc": {
+								"start": {
+									"line": 6,
+									"column": 1
+								},
+								"end": {
+									"line": 6,
+									"column": 19
+								}
+							},
+							"object": {
+								"type": "Identifier",
+								"start": 185,
+								"end": 189,
+								"loc": {
+									"start": {
+										"line": 6,
+										"column": 1
+									},
+									"end": {
+										"line": 6,
+										"column": 5
+									}
+								},
+								"name": "test"
+							},
+							"property": {
+								"type": "Identifier",
+								"start": 199,
+								"end": 203,
+								"loc": {
+									"start": {
+										"line": 6,
+										"column": 15
+									},
+									"end": {
+										"line": 6,
+										"column": 19
+									}
+								},
+								"name": "skip",
+								"leadingComments": [
+									{
+										"type": "Block",
+										"value": " c2 ",
+										"start": 190,
+										"end": 198
+									}
+								]
+							},
+							"computed": false,
+							"optional": false
+						},
+						"arguments": [
+							{
+								"type": "Literal",
+								"start": 204,
+								"end": 207,
+								"loc": {
+									"start": {
+										"line": 6,
+										"column": 20
+									},
+									"end": {
+										"line": 6,
+										"column": 23
+									}
+								},
+								"value": "b",
+								"raw": "'b'"
+							},
+							{
+								"type": "ArrowFunctionExpression",
+								"start": 209,
+								"end": 217,
+								"loc": {
+									"start": {
+										"line": 6,
+										"column": 25
+									},
+									"end": {
+										"line": 6,
+										"column": 33
+									}
+								},
+								"id": null,
+								"expression": false,
+								"generator": false,
+								"async": false,
+								"params": [],
+								"body": {
+									"type": "BlockStatement",
+									"start": 215,
+									"end": 217,
+									"loc": {
+										"start": {
+											"line": 6,
+											"column": 31
+										},
+										"end": {
+											"line": 6,
+											"column": 33
+										}
+									},
+									"body": []
+								}
+							}
+						],
+						"optional": false
+					},
+					"leadingComments": [
+						{
+							"type": "Line",
+							"value": " Block comment after the `.` — stays on that side",
+							"start": 132,
+							"end": 183
+						}
+					]
+				},
+				{
+					"type": "ExpressionStatement",
+					"start": 279,
+					"end": 314,
+					"loc": {
+						"start": {
+							"line": 9,
+							"column": 1
+						},
+						"end": {
+							"line": 9,
+							"column": 36
+						}
+					},
+					"expression": {
+						"type": "CallExpression",
+						"start": 279,
+						"end": 313,
+						"loc": {
+							"start": {
+								"line": 9,
+								"column": 1
+							},
+							"end": {
+								"line": 9,
+								"column": 35
+							}
+						},
+						"callee": {
+							"type": "MemberExpression",
+							"start": 279,
+							"end": 298,
+							"loc": {
+								"start": {
+									"line": 9,
+									"column": 1
+								},
+								"end": {
+									"line": 9,
+									"column": 20
+								}
+							},
+							"object": {
+								"type": "Identifier",
+								"start": 279,
+								"end": 283,
+								"loc": {
+									"start": {
+										"line": 9,
+										"column": 1
+									},
+									"end": {
+										"line": 9,
+										"column": 5
+									}
+								},
+								"name": "test"
+							},
+							"property": {
+								"type": "Identifier",
+								"start": 293,
+								"end": 298,
+								"loc": {
+									"start": {
+										"line": 9,
+										"column": 15
+									},
+									"end": {
+										"line": 9,
+										"column": 20
+									}
+								},
+								"name": "fixme",
+								"leadingComments": [
+									{
+										"type": "Block",
+										"value": " c3 ",
+										"start": 284,
+										"end": 292
+									}
+								]
+							},
+							"computed": false,
+							"optional": false
+						},
+						"arguments": [
+							{
+								"type": "Literal",
+								"start": 299,
+								"end": 302,
+								"loc": {
+									"start": {
+										"line": 9,
+										"column": 21
+									},
+									"end": {
+										"line": 9,
+										"column": 24
+									}
+								},
+								"value": "c",
+								"raw": "'c'"
+							},
+							{
+								"type": "ArrowFunctionExpression",
+								"start": 304,
+								"end": 312,
+								"loc": {
+									"start": {
+										"line": 9,
+										"column": 26
+									},
+									"end": {
+										"line": 9,
+										"column": 34
+									}
+								},
+								"id": null,
+								"expression": false,
+								"generator": false,
+								"async": false,
+								"params": [],
+								"body": {
+									"type": "BlockStatement",
+									"start": 310,
+									"end": 312,
+									"loc": {
+										"start": {
+											"line": 9,
+											"column": 32
+										},
+										"end": {
+											"line": 9,
+											"column": 34
+										}
+									},
+									"body": []
+								}
+							}
+						],
+						"optional": false
+					},
+					"leadingComments": [
+						{
+							"type": "Line",
+							"value": " The other recognized variants take the same two gaps",
+							"start": 222,
+							"end": 277
+						}
+					]
+				},
+				{
+					"type": "ExpressionStatement",
+					"start": 316,
+					"end": 348,
+					"loc": {
+						"start": {
+							"line": 10,
+							"column": 1
+						},
+						"end": {
+							"line": 10,
+							"column": 33
+						}
+					},
+					"expression": {
+						"type": "CallExpression",
+						"start": 316,
+						"end": 347,
+						"loc": {
+							"start": {
+								"line": 10,
+								"column": 1
+							},
+							"end": {
+								"line": 10,
+								"column": 32
+							}
+						},
+						"callee": {
+							"type": "MemberExpression",
+							"start": 316,
+							"end": 332,
+							"loc": {
+								"start": {
+									"line": 10,
+									"column": 1
+								},
+								"end": {
+									"line": 10,
+									"column": 17
+								}
+							},
+							"object": {
+								"type": "Identifier",
+								"start": 316,
+								"end": 318,
+								"loc": {
+									"start": {
+										"line": 10,
+										"column": 1
+									},
+									"end": {
+										"line": 10,
+										"column": 3
+									}
+								},
+								"name": "it",
+								"trailingComments": [
+									{
+										"type": "Block",
+										"value": " c4 ",
+										"start": 319,
+										"end": 327
+									}
+								]
+							},
+							"property": {
+								"type": "Identifier",
+								"start": 328,
+								"end": 332,
+								"loc": {
+									"start": {
+										"line": 10,
+										"column": 13
+									},
+									"end": {
+										"line": 10,
+										"column": 17
+									}
+								},
+								"name": "only"
+							},
+							"computed": false,
+							"optional": false
+						},
+						"arguments": [
+							{
+								"type": "Literal",
+								"start": 333,
+								"end": 336,
+								"loc": {
+									"start": {
+										"line": 10,
+										"column": 18
+									},
+									"end": {
+										"line": 10,
+										"column": 21
+									}
+								},
+								"value": "d",
+								"raw": "'d'"
+							},
+							{
+								"type": "ArrowFunctionExpression",
+								"start": 338,
+								"end": 346,
+								"loc": {
+									"start": {
+										"line": 10,
+										"column": 23
+									},
+									"end": {
+										"line": 10,
+										"column": 31
+									}
+								},
+								"id": null,
+								"expression": false,
+								"generator": false,
+								"async": false,
+								"params": [],
+								"body": {
+									"type": "BlockStatement",
+									"start": 344,
+									"end": 346,
+									"loc": {
+										"start": {
+											"line": 10,
+											"column": 29
+										},
+										"end": {
+											"line": 10,
+											"column": 31
+										}
+									},
+									"body": []
+								}
+							}
+						],
+						"optional": false
+					}
+				}
+			],
+			"sourceType": "module"
+		},
+		"attributes": [
+			{
+				"type": "Attribute",
+				"start": 8,
+				"end": 17,
+				"name": "lang",
+				"name_loc": {
+					"start": {
+						"line": 1,
+						"column": 8,
+						"character": 8
+					},
+					"end": {
+						"line": 1,
+						"column": 12,
+						"character": 12
+					}
+				},
+				"value": [
+					{
+						"start": 14,
+						"end": 16,
+						"type": "Text",
+						"raw": "ts",
+						"data": "ts"
+					}
+				]
+			}
+		]
+	}
+}
diff --git a/tests/fixtures/typescript/expressions/calls/test_function_dot_comment/input.svelte b/tests/fixtures/typescript/expressions/calls/test_function_dot_comment/input.svelte
new file mode 100644
index 000000000..dcdcac11a
--- /dev/null
+++ b/tests/fixtures/typescript/expressions/calls/test_function_dot_comment/input.svelte
@@ -0,0 +1,11 @@
+<script lang="ts">
+	// Block comment before the `.` of a test-pattern chain — stays there
+	describe /* c1 */.only('a', () => {});
+
+	// Block comment after the `.` — stays on that side
+	test./* c2 */ skip('b', () => {});
+
+	// The other recognized variants take the same two gaps
+	test./* c3 */ fixme('c', () => {});
+	it /* c4 */.only('d', () => {});
+</script>
diff --git a/tests/fixtures/typescript/expressions/destructuring/array_own_line_multiline_comment_expand/expected.json b/tests/fixtures/typescript/expressions/destructuring/array_own_line_multiline_comment_expand/expected.json
new file mode 100644
index 000000000..06d70583c
--- /dev/null
+++ b/tests/fixtures/typescript/expressions/destructuring/array_own_line_multiline_comment_expand/expected.json
@@ -0,0 +1,477 @@
+{
+	"css": null,
+	"js": [],
+	"start": 0,
+	"end": 327,
+	"type": "Root",
+	"fragment": {
+		"type": "Fragment",
+		"nodes": []
+	},
+	"options": null,
+	"comments": [
+		{
+			"type": "Line",
+			"value": " Own-line multiline block comment after the last element",
+			"start": 10,
+			"end": 68,
+			"loc": {
+				"start": {
+					"line": 2,
+					"column": 1
+				},
+				"end": {
+					"line": 2,
+					"column": 59
+				}
+			}
+		},
+		{
+			"type": "Block",
+			"value": " c1\nc2 ",
+			"start": 89,
+			"end": 100,
+			"loc": {
+				"start": {
+					"line": 6,
+					"column": 2
+				},
+				"end": {
+					"line": 7,
+					"column": 5
+				}
+			}
+		},
+		{
+			"type": "Line",
+			"value": " Own-line multiline block comment between elements",
+			"start": 113,
+			"end": 165,
+			"loc": {
+				"start": {
+					"line": 10,
+					"column": 1
+				},
+				"end": {
+					"line": 10,
+					"column": 53
+				}
+			}
+		},
+		{
+			"type": "Block",
+			"value": " c1\nc2 ",
+			"start": 183,
+			"end": 194,
+			"loc": {
+				"start": {
+					"line": 13,
+					"column": 2
+				},
+				"end": {
+					"line": 14,
+					"column": 5
+				}
+			}
+		},
+		{
+			"type": "Line",
+			"value": " Own-line multiline block comment before the first element",
+			"start": 212,
+			"end": 272,
+			"loc": {
+				"start": {
+					"line": 18,
+					"column": 1
+				},
+				"end": {
+					"line": 18,
+					"column": 61
+				}
+			}
+		},
+		{
+			"type": "Block",
+			"value": " c1\nc2 ",
+			"start": 284,
+			"end": 295,
+			"loc": {
+				"start": {
+					"line": 20,
+					"column": 2
+				},
+				"end": {
+					"line": 21,
+					"column": 5
+				}
+			}
+		}
+	],
+	"instance": {
+		"type": "Script",
+		"start": 0,
+		"end": 326,
+		"context": "default",
+		"content": {
+			"type": "Program",
+			"start": 8,
+			"end": 317,
+			"loc": {
+				"start": {
+					"line": 1,
+					"column": 0
+				},
+				"end": {
+					"line": 25,
+					"column": 9
+				}
+			},
+			"body": [
+				{
+					"type": "VariableDeclaration",
+					"start": 70,
+					"end": 110,
+					"loc": {
+						"start": {
+							"line": 3,
+							"column": 1
+						},
+						"end": {
+							"line": 8,
+							"column": 9
+						}
+					},
+					"declarations": [
+						{
+							"type": "VariableDeclarator",
+							"start": 76,
+							"end": 109,
+							"loc": {
+								"start": {
+									"line": 3,
+									"column": 7
+								},
+								"end": {
+									"line": 8,
+									"column": 8
+								}
+							},
+							"id": {
+								"type": "ArrayPattern",
+								"start": 76,
+								"end": 103,
+								"loc": {
+									"start": {
+										"line": 3,
+										"column": 7
+									},
+									"end": {
+										"line": 8,
+										"column": 2
+									}
+								},
+								"elements": [
+									{
+										"type": "Identifier",
+										"start": 80,
+										"end": 81,
+										"loc": {
+											"start": {
+												"line": 4,
+												"column": 2
+											},
+											"end": {
+												"line": 4,
+												"column": 3
+											}
+										},
+										"name": "a"
+									},
+									{
+										"type": "Identifier",
+										"start": 85,
+										"end": 86,
+										"loc": {
+											"start": {
+												"line": 5,
+												"column": 2
+											},
+											"end": {
+												"line": 5,
+												"column": 3
+											}
+										},
+										"name": "b"
+									}
+								]
+							},
+							"init": {
+								"type": "Identifier",
+								"start": 106,
+								"end": 109,
+								"loc": {
+									"start": {
+										"line": 8,
+										"column": 5
+									},
+									"end": {
+										"line": 8,
+										"column": 8
+									}
+								},
+								"name": "arr",
+								"leadingComments": [
+									{
+										"type": "Block",
+										"value": " c1\nc2 ",
+										"start": 89,
+										"end": 100
+									}
+								]
+							}
+						}
+					],
+					"kind": "const",
+					"leadingComments": [
+						{
+							"type": "Line",
+							"value": " Own-line multiline block comment after the last element",
+							"start": 10,
+							"end": 68
+						}
+					]
+				},
+				{
+					"type": "VariableDeclaration",
+					"start": 167,
+					"end": 209,
+					"loc": {
+						"start": {
+							"line": 11,
+							"column": 1
+						},
+						"end": {
+							"line": 16,
+							"column": 9
+						}
+					},
+					"declarations": [
+						{
+							"type": "VariableDeclarator",
+							"start": 173,
+							"end": 208,
+							"loc": {
+								"start": {
+									"line": 11,
+									"column": 7
+								},
+								"end": {
+									"line": 16,
+									"column": 8
+								}
+							},
+							"id": {
+								"type": "ArrayPattern",
+								"start": 173,
+								"end": 202,
+								"loc": {
+									"start": {
+										"line": 11,
+										"column": 7
+									},
+									"end": {
+										"line": 16,
+										"column": 2
+									}
+								},
+								"elements": [
+									{
+										"type": "Identifier",
+										"start": 177,
+										"end": 179,
+										"loc": {
+											"start": {
+												"line": 12,
+												"column": 2
+											},
+											"end": {
+												"line": 12,
+												"column": 4
+											}
+										},
+										"name": "a1"
+									},
+									{
+										"type": "Identifier",
+										"start": 197,
+										"end": 199,
+										"loc": {
+											"start": {
+												"line": 15,
+												"column": 2
+											},
+											"end": {
+												"line": 15,
+												"column": 4
+											}
+										},
+										"name": "b1",
+										"leadingComments": [
+											{
+												"type": "Block",
+												"value": " c1\nc2 ",
+												"start": 183,
+												"end": 194
+											}
+										]
+									}
+								]
+							},
+							"init": {
+								"type": "Identifier",
+								"start": 205,
+								"end": 208,
+								"loc": {
+									"start": {
+										"line": 16,
+										"column": 5
+									},
+									"end": {
+										"line": 16,
+										"column": 8
+									}
+								},
+								"name": "arr"
+							}
+						}
+					],
+					"kind": "const",
+					"leadingComments": [
+						{
+							"type": "Line",
+							"value": " Own-line multiline block comment between elements",
+							"start": 113,
+							"end": 165
+						}
+					]
+				},
+				{
+					"type": "VariableDeclaration",
+					"start": 274,
+					"end": 316,
+					"loc": {
+						"start": {
+							"line": 19,
+							"column": 1
+						},
+						"end": {
+							"line": 24,
+							"column": 9
+						}
+					},
+					"declarations": [
+						{
+							"type": "VariableDeclarator",
+							"start": 280,
+							"end": 315,
+							"loc": {
+								"start": {
+									"line": 19,
+									"column": 7
+								},
+								"end": {
+									"line": 24,
+									"column": 8
+								}
+							},
+							"id": {
+								"type": "ArrayPattern",
+								"start": 280,
+								"end": 309,
+								"loc": {
+									"start": {
+										"line": 19,
+										"column": 7
+									},
+									"end": {
+										"line": 24,
+										"column": 2
+									}
+								},
+								"elements": [
+									{
+										"type": "Identifier",
+										"start": 298,
+										"end": 300,
+										"loc": {
+											"start": {
+												"line": 22,
+												"column": 2
+											},
+											"end": {
+												"line": 22,
+												"column": 4
+											}
+										},
+										"name": "a2",
+										"leadingComments": [
+											{
+												"type": "Block",
+												"value": " c1\nc2 ",
+												"start": 284,
+												"end": 295
+											}
+										]
+									},
+									{
+										"type": "Identifier",
+										"start": 304,
+										"end": 306,
+										"loc": {
+											"start": {
+												"line": 23,
+												"column": 2
+											},
+											"end": {
+												"line": 23,
+												"column": 4
+											}
+										},
+										"name": "b2"
+									}
+								]
+							},
+							"init": {
+								"type": "Identifier",
+								"start": 312,
+								"end": 315,
+								"loc": {
+									"start": {
+										"line": 24,
+										"column": 5
+									},
+									"end": {
+										"line": 24,
+										"column": 8
+									}
+								},
+								"name": "arr"
+							}
+						}
+					],
+					"kind": "const",
+					"leadingComments": [
+						{
+							"type": "Line",
+							"value": " Own-line multiline block comment before the first element",
+							"start": 212,
+							"end": 272
+						}
+					]
+				}
+			],
+			"sourceType": "module"
+		},
+		"attributes": []
+	}
+}
diff --git a/tests/fixtures/typescript/expressions/destructuring/array_own_line_multiline_comment_expand/input.svelte b/tests/fixtures/typescript/expressions/destructuring/array_own_line_multiline_comment_expand/input.svelte
new file mode 100644
index 000000000..7dc09a5a0
--- /dev/null
+++ b/tests/fixtures/typescript/expressions/destructuring/array_own_line_multiline_comment_expand/input.svelte
@@ -0,0 +1,25 @@
+<script>
+	// Own-line multiline block comment after the last element
+	const [
+		a,
+		b
+		/* c1
+c2 */
+	] = arr;
+
+	// Own-line multiline block comment between elements
+	const [
+		a1,
+		/* c1
+c2 */
+		b1
+	] = arr;
+
+	// Own-line multiline block comment before the first element
+	const [
+		/* c1
+c2 */
+		a2,
+		b2
+	] = arr;
+</script>
diff --git a/tests/fixtures/typescript/modules/imports/equals_header_line_comment_prettier_divergence/README.md b/tests/fixtures/typescript/modules/imports/equals_header_line_comment_prettier_divergence/README.md
new file mode 100644
index 000000000..68c54aafe
--- /dev/null
+++ b/tests/fixtures/typescript/modules/imports/equals_header_line_comment_prettier_divergence/README.md
@@ -0,0 +1,34 @@
+# Divergence: import-equals header line comments (preserve, one indent level)
+
+A *line* comment in the gaps of the import-equals header. tsv keeps each where the author wrote it;
+prettier **relocates** them — `// c3` past the `=` to trail the whole statement, `// c4` down onto
+its own line, and `// c` in the `=`→module-reference gap onto the `require(` line.
+
+```ts
+// tsv (preserve)              // prettier (relocate)
+export // c1                   export // c1
+	import // c2               import // c2
+	A // c3                    A = require('./a'); // c3
+	= // c4                    // c4
+	require('./a');
+```
+
+The line-comment counterpart of [equals_header_comment](../equals_header_comment/) (the
+block-comment form, a *regular* fixture — prettier preserves four of the five header gaps, so there
+is no opinion to state there).
+
+Like [export_as_namespace_line_comment](../../exports/export_as_namespace_line_comment_prettier_divergence/),
+it pins the **rendering**: a header with several broken gaps continues at **one** indent level, not
+a staircase. These two headers are the only three-word ones, so no other keyword can show it.
+
+What this fixture pins that its `export as namespace` sibling **cannot**: the module reference is
+the one such tail that can break *internally*. Its own line breaks have to nest inside the
+continuation level the gap established — a reference sitting at one level with its contents at that
+same level, and its `)` a level *above* the `require(` it closes, would be wrong. So the gaps are
+emitted flat and the whole tail — reference included — is wrapped once.
+
+Prettier is **non-idempotent** on its own output here: a second pass moves `// c` off the `require(`
+line onto its own line, which is why `output_prettier.svelte` carries an `audit_signature.txt`.
+
+See [conformance_prettier.md §Comments inside a multi-word keyword](../../../../../../docs/conformance_prettier.md#comments-inside-a-multi-word-keyword)
+and [§Comment relocation](../../../../../../docs/conformance_prettier.md#comment-relocation).
diff --git a/tests/fixtures/typescript/modules/imports/equals_header_line_comment_prettier_divergence/audit_signature.txt b/tests/fixtures/typescript/modules/imports/equals_header_line_comment_prettier_divergence/audit_signature.txt
new file mode 100644
index 000000000..8b9f6fb5a
--- /dev/null
+++ b/tests/fixtures/typescript/modules/imports/equals_header_line_comment_prettier_divergence/audit_signature.txt
@@ -0,0 +1,27 @@
+# Auto-generated prettier chain signature. Do not edit manually.
+# Regenerate: deno task fixtures:update:formatted <pattern>
+#
+# Each %%PASS=N%% section is exactly prettier^N(output_prettier.<ext>).
+# This file exists when prettier is non-idempotent on output_prettier.* — it pins
+# the full chain so the audit recognizes the case and the validator catches drift.
+# See docs/fixture_overview.md (rule F4) and crates/tsv_debug/src/fixtures/audit_signature.rs.
+
+%%PASS=2 (fixed point)%%
+<script lang="ts">
+	// A line comment in each gap of the import-equals header — each stays where the
+	// author wrote it, and the whole header continues at ONE indent level
+	export // c1
+	import // c2
+	A = require('./a'); // c3
+	// c4
+
+	// The module reference continues one level down, and its own breaks nest inside
+	// that level — its contents one deeper than `require(`, its `)` back at the
+	// reference's own level
+	import B = require(
+		// c5
+		// c6
+		'./b' // c7
+		// c8
+	); // c9
+</script>
diff --git a/tests/fixtures/typescript/modules/imports/equals_header_line_comment_prettier_divergence/expected.json b/tests/fixtures/typescript/modules/imports/equals_header_line_comment_prettier_divergence/expected.json
new file mode 100644
index 000000000..b556133f1
--- /dev/null
+++ b/tests/fixtures/typescript/modules/imports/equals_header_line_comment_prettier_divergence/expected.json
@@ -0,0 +1,523 @@
+{
+	"css": null,
+	"js": [],
+	"start": 0,
+	"end": 510,
+	"type": "Root",
+	"fragment": {
+		"type": "Fragment",
+		"nodes": []
+	},
+	"options": null,
+	"comments": [
+		{
+			"type": "Line",
+			"value": " A line comment in each gap of the import-equals header — each stays where the",
+			"start": 20,
+			"end": 100,
+			"loc": {
+				"start": {
+					"line": 2,
+					"column": 1
+				},
+				"end": {
+					"line": 2,
+					"column": 81
+				}
+			}
+		},
+		{
+			"type": "Line",
+			"value": " author wrote it, and the whole header continues at ONE indent level",
+			"start": 102,
+			"end": 172,
+			"loc": {
+				"start": {
+					"line": 3,
+					"column": 1
+				},
+				"end": {
+					"line": 3,
+					"column": 71
+				}
+			}
+		},
+		{
+			"type": "Line",
+			"value": " c1",
+			"start": 181,
+			"end": 186,
+			"loc": {
+				"start": {
+					"line": 4,
+					"column": 8
+				},
+				"end": {
+					"line": 4,
+					"column": 13
+				}
+			}
+		},
+		{
+			"type": "Line",
+			"value": " c2",
+			"start": 196,
+			"end": 201,
+			"loc": {
+				"start": {
+					"line": 5,
+					"column": 9
+				},
+				"end": {
+					"line": 5,
+					"column": 14
+				}
+			}
+		},
+		{
+			"type": "Line",
+			"value": " c3",
+			"start": 206,
+			"end": 211,
+			"loc": {
+				"start": {
+					"line": 6,
+					"column": 4
+				},
+				"end": {
+					"line": 6,
+					"column": 9
+				}
+			}
+		},
+		{
+			"type": "Line",
+			"value": " c4",
+			"start": 216,
+			"end": 221,
+			"loc": {
+				"start": {
+					"line": 7,
+					"column": 4
+				},
+				"end": {
+					"line": 7,
+					"column": 9
+				}
+			}
+		},
+		{
+			"type": "Line",
+			"value": " The module reference continues one level down, and its own breaks nest inside",
+			"start": 242,
+			"end": 322,
+			"loc": {
+				"start": {
+					"line": 10,
+					"column": 1
+				},
+				"end": {
+					"line": 10,
+					"column": 81
+				}
+			}
+		},
+		{
+			"type": "Line",
+			"value": " that level — its contents one deeper than `require(`, its `)` back at the",
+			"start": 324,
+			"end": 400,
+			"loc": {
+				"start": {
+					"line": 11,
+					"column": 1
+				},
+				"end": {
+					"line": 11,
+					"column": 77
+				}
+			}
+		},
+		{
+			"type": "Line",
+			"value": " reference's own level",
+			"start": 402,
+			"end": 426,
+			"loc": {
+				"start": {
+					"line": 12,
+					"column": 1
+				},
+				"end": {
+					"line": 12,
+					"column": 25
+				}
+			}
+		},
+		{
+			"type": "Line",
+			"value": " c5",
+			"start": 439,
+			"end": 444,
+			"loc": {
+				"start": {
+					"line": 13,
+					"column": 12
+				},
+				"end": {
+					"line": 13,
+					"column": 17
+				}
+			}
+		},
+		{
+			"type": "Line",
+			"value": " c6",
+			"start": 459,
+			"end": 464,
+			"loc": {
+				"start": {
+					"line": 15,
+					"column": 3
+				},
+				"end": {
+					"line": 15,
+					"column": 8
+				}
+			}
+		},
+		{
+			"type": "Line",
+			"value": " c7",
+			"start": 474,
+			"end": 479,
+			"loc": {
+				"start": {
+					"line": 16,
+					"column": 9
+				},
+				"end": {
+					"line": 16,
+					"column": 14
+				}
+			}
+		},
+		{
+			"type": "Line",
+			"value": " c8",
+			"start": 483,
+			"end": 488,
+			"loc": {
+				"start": {
+					"line": 17,
+					"column": 3
+				},
+				"end": {
+					"line": 17,
+					"column": 8
+				}
+			}
+		},
+		{
+			"type": "Line",
+			"value": " c9",
+			"start": 494,
+			"end": 499,
+			"loc": {
+				"start": {
+					"line": 18,
+					"column": 5
+				},
+				"end": {
+					"line": 18,
+					"column": 10
+				}
+			}
+		}
+	],
+	"instance": {
+		"type": "Script",
+		"start": 0,
+		"end": 509,
+		"context": "default",
+		"content": {
+			"type": "Program",
+			"start": 18,
+			"end": 500,
+			"loc": {
+				"start": {
+					"line": 1,
+					"column": 0
+				},
+				"end": {
+					"line": 19,
+					"column": 9
+				}
+			},
+			"body": [
+				{
+					"type": "TSImportEqualsDeclaration",
+					"start": 174,
+					"end": 239,
+					"loc": {
+						"start": {
+							"line": 4,
+							"column": 1
+						},
+						"end": {
+							"line": 8,
+							"column": 17
+						}
+					},
+					"importKind": "value",
+					"isExport": true,
+					"id": {
+						"type": "Identifier",
+						"start": 204,
+						"end": 205,
+						"loc": {
+							"start": {
+								"line": 6,
+								"column": 2
+							},
+							"end": {
+								"line": 6,
+								"column": 3
+							}
+						},
+						"name": "A",
+						"leadingComments": [
+							{
+								"type": "Line",
+								"value": " c1",
+								"start": 181,
+								"end": 186
+							},
+							{
+								"type": "Line",
+								"value": " c2",
+								"start": 196,
+								"end": 201
+							}
+						],
+						"trailingComments": [
+							{
+								"type": "Line",
+								"value": " c3",
+								"start": 206,
+								"end": 211
+							}
+						]
+					},
+					"moduleReference": {
+						"type": "TSExternalModuleReference",
+						"start": 224,
+						"end": 238,
+						"loc": {
+							"start": {
+								"line": 8,
+								"column": 2
+							},
+							"end": {
+								"line": 8,
+								"column": 16
+							}
+						},
+						"expression": {
+							"type": "Literal",
+							"start": 232,
+							"end": 237,
+							"loc": {
+								"start": {
+									"line": 8,
+									"column": 10
+								},
+								"end": {
+									"line": 8,
+									"column": 15
+								}
+							},
+							"value": "./a",
+							"raw": "'./a'"
+						},
+						"leadingComments": [
+							{
+								"type": "Line",
+								"value": " c4",
+								"start": 216,
+								"end": 221
+							}
+						]
+					},
+					"leadingComments": [
+						{
+							"type": "Line",
+							"value": " A line comment in each gap of the import-equals header — each stays where the",
+							"start": 20,
+							"end": 100
+						},
+						{
+							"type": "Line",
+							"value": " author wrote it, and the whole header continues at ONE indent level",
+							"start": 102,
+							"end": 172
+						}
+					]
+				},
+				{
+					"type": "TSImportEqualsDeclaration",
+					"start": 428,
+					"end": 493,
+					"loc": {
+						"start": {
+							"line": 13,
+							"column": 1
+						},
+						"end": {
+							"line": 18,
+							"column": 4
+						}
+					},
+					"importKind": "value",
+					"isExport": false,
+					"id": {
+						"type": "Identifier",
+						"start": 435,
+						"end": 436,
+						"loc": {
+							"start": {
+								"line": 13,
+								"column": 8
+							},
+							"end": {
+								"line": 13,
+								"column": 9
+							}
+						},
+						"name": "B"
+					},
+					"moduleReference": {
+						"type": "TSExternalModuleReference",
+						"start": 447,
+						"end": 492,
+						"loc": {
+							"start": {
+								"line": 14,
+								"column": 2
+							},
+							"end": {
+								"line": 18,
+								"column": 3
+							}
+						},
+						"expression": {
+							"type": "Literal",
+							"start": 468,
+							"end": 473,
+							"loc": {
+								"start": {
+									"line": 16,
+									"column": 3
+								},
+								"end": {
+									"line": 16,
+									"column": 8
+								}
+							},
+							"value": "./b",
+							"raw": "'./b'",
+							"leadingComments": [
+								{
+									"type": "Line",
+									"value": " c6",
+									"start": 459,
+									"end": 464
+								}
+							],
+							"trailingComments": [
+								{
+									"type": "Line",
+									"value": " c7",
+									"start": 474,
+									"end": 479
+								}
+							]
+						},
+						"leadingComments": [
+							{
+								"type": "Line",
+								"value": " c5",
+								"start": 439,
+								"end": 444
+							}
+						]
+					},
+					"leadingComments": [
+						{
+							"type": "Line",
+							"value": " The module reference continues one level down, and its own breaks nest inside",
+							"start": 242,
+							"end": 322
+						},
+						{
+							"type": "Line",
+							"value": " that level — its contents one deeper than `require(`, its `)` back at the",
+							"start": 324,
+							"end": 400
+						},
+						{
+							"type": "Line",
+							"value": " reference's own level",
+							"start": 402,
+							"end": 426
+						}
+					],
+					"trailingComments": [
+						{
+							"type": "Line",
+							"value": " c8",
+							"start": 483,
+							"end": 488
+						},
+						{
+							"type": "Line",
+							"value": " c9",
+							"start": 494,
+							"end": 499
+						}
+					]
+				}
+			],
+			"sourceType": "module"
+		},
+		"attributes": [
+			{
+				"type": "Attribute",
+				"start": 8,
+				"end": 17,
+				"name": "lang",
+				"name_loc": {
+					"start": {
+						"line": 1,
+						"column": 8,
+						"character": 8
+					},
+					"end": {
+						"line": 1,
+						"column": 12,
+						"character": 12
+					}
+				},
+				"value": [
+					{
+						"start": 14,
+						"end": 16,
+						"type": "Text",
+						"raw": "ts",
+						"data": "ts"
+					}
+				]
+			}
+		]
+	}
+}
diff --git a/tests/fixtures/typescript/modules/imports/equals_header_line_comment_prettier_divergence/input.svelte b/tests/fixtures/typescript/modules/imports/equals_header_line_comment_prettier_divergence/input.svelte
new file mode 100644
index 000000000..d2fdc480a
--- /dev/null
+++ b/tests/fixtures/typescript/modules/imports/equals_header_line_comment_prettier_divergence/input.svelte
@@ -0,0 +1,19 @@
+<script lang="ts">
+	// A line comment in each gap of the import-equals header — each stays where the
+	// author wrote it, and the whole header continues at ONE indent level
+	export // c1
+		import // c2
+		A // c3
+		= // c4
+		require('./a');
+
+	// The module reference continues one level down, and its own breaks nest inside
+	// that level — its contents one deeper than `require(`, its `)` back at the
+	// reference's own level
+	import B = // c5
+		require(
+			// c6
+			'./b' // c7
+			// c8
+		); // c9
+</script>
diff --git a/tests/fixtures/typescript/modules/imports/equals_header_line_comment_prettier_divergence/output_prettier.svelte b/tests/fixtures/typescript/modules/imports/equals_header_line_comment_prettier_divergence/output_prettier.svelte
new file mode 100644
index 000000000..c0ba94ce0
--- /dev/null
+++ b/tests/fixtures/typescript/modules/imports/equals_header_line_comment_prettier_divergence/output_prettier.svelte
@@ -0,0 +1,17 @@
+<script lang="ts">
+	// A line comment in each gap of the import-equals header — each stays where the
+	// author wrote it, and the whole header continues at ONE indent level
+	export // c1
+	import // c2
+	A = require('./a'); // c3
+	// c4
+
+	// The module reference continues one level down, and its own breaks nest inside
+	// that level — its contents one deeper than `require(`, its `)` back at the
+	// reference's own level
+	import B = require( // c5
+		// c6
+		'./b' // c7
+		// c8
+	); // c9
+</script>
diff --git a/tests/fixtures/typescript/modules/imports/equals_require_paren_comment/expected.json b/tests/fixtures/typescript/modules/imports/equals_require_paren_comment/expected.json
new file mode 100644
index 000000000..9104e1d93
--- /dev/null
+++ b/tests/fixtures/typescript/modules/imports/equals_require_paren_comment/expected.json
@@ -0,0 +1,315 @@
+{
+	"css": null,
+	"js": [],
+	"start": 0,
+	"end": 255,
+	"type": "Root",
+	"fragment": {
+		"type": "Fragment",
+		"nodes": []
+	},
+	"options": null,
+	"comments": [
+		{
+			"type": "Line",
+			"value": " Block comment inside `require(` — hugs the paren, keeps its space on the literal's side",
+			"start": 20,
+			"end": 110,
+			"loc": {
+				"start": {
+					"line": 2,
+					"column": 1
+				},
+				"end": {
+					"line": 2,
+					"column": 91
+				}
+			}
+		},
+		{
+			"type": "Block",
+			"value": " c1 ",
+			"start": 131,
+			"end": 139,
+			"loc": {
+				"start": {
+					"line": 3,
+					"column": 20
+				},
+				"end": {
+					"line": 3,
+					"column": 28
+				}
+			}
+		},
+		{
+			"type": "Line",
+			"value": " Two comments in the same gap keep their order",
+			"start": 150,
+			"end": 198,
+			"loc": {
+				"start": {
+					"line": 5,
+					"column": 1
+				},
+				"end": {
+					"line": 5,
+					"column": 49
+				}
+			}
+		},
+		{
+			"type": "Block",
+			"value": " c2 ",
+			"start": 219,
+			"end": 227,
+			"loc": {
+				"start": {
+					"line": 6,
+					"column": 20
+				},
+				"end": {
+					"line": 6,
+					"column": 28
+				}
+			}
+		},
+		{
+			"type": "Block",
+			"value": " c3 ",
+			"start": 228,
+			"end": 236,
+			"loc": {
+				"start": {
+					"line": 6,
+					"column": 29
+				},
+				"end": {
+					"line": 6,
+					"column": 37
+				}
+			}
+		}
+	],
+	"instance": {
+		"type": "Script",
+		"start": 0,
+		"end": 254,
+		"context": "default",
+		"content": {
+			"type": "Program",
+			"start": 18,
+			"end": 245,
+			"loc": {
+				"start": {
+					"line": 1,
+					"column": 0
+				},
+				"end": {
+					"line": 7,
+					"column": 9
+				}
+			},
+			"body": [
+				{
+					"type": "TSImportEqualsDeclaration",
+					"start": 112,
+					"end": 147,
+					"loc": {
+						"start": {
+							"line": 3,
+							"column": 1
+						},
+						"end": {
+							"line": 3,
+							"column": 36
+						}
+					},
+					"importKind": "value",
+					"isExport": false,
+					"id": {
+						"type": "Identifier",
+						"start": 119,
+						"end": 120,
+						"loc": {
+							"start": {
+								"line": 3,
+								"column": 8
+							},
+							"end": {
+								"line": 3,
+								"column": 9
+							}
+						},
+						"name": "A"
+					},
+					"moduleReference": {
+						"type": "TSExternalModuleReference",
+						"start": 123,
+						"end": 146,
+						"loc": {
+							"start": {
+								"line": 3,
+								"column": 12
+							},
+							"end": {
+								"line": 3,
+								"column": 35
+							}
+						},
+						"expression": {
+							"type": "Literal",
+							"start": 140,
+							"end": 145,
+							"loc": {
+								"start": {
+									"line": 3,
+									"column": 29
+								},
+								"end": {
+									"line": 3,
+									"column": 34
+								}
+							},
+							"value": "./a",
+							"raw": "'./a'",
+							"leadingComments": [
+								{
+									"type": "Block",
+									"value": " c1 ",
+									"start": 131,
+									"end": 139
+								}
+							]
+						}
+					},
+					"leadingComments": [
+						{
+							"type": "Line",
+							"value": " Block comment inside `require(` — hugs the paren, keeps its space on the literal's side",
+							"start": 20,
+							"end": 110
+						}
+					]
+				},
+				{
+					"type": "TSImportEqualsDeclaration",
+					"start": 200,
+					"end": 244,
+					"loc": {
+						"start": {
+							"line": 6,
+							"column": 1
+						},
+						"end": {
+							"line": 6,
+							"column": 45
+						}
+					},
+					"importKind": "value",
+					"isExport": false,
+					"id": {
+						"type": "Identifier",
+						"start": 207,
+						"end": 208,
+						"loc": {
+							"start": {
+								"line": 6,
+								"column": 8
+							},
+							"end": {
+								"line": 6,
+								"column": 9
+							}
+						},
+						"name": "B"
+					},
+					"moduleReference": {
+						"type": "TSExternalModuleReference",
+						"start": 211,
+						"end": 243,
+						"loc": {
+							"start": {
+								"line": 6,
+								"column": 12
+							},
+							"end": {
+								"line": 6,
+								"column": 44
+							}
+						},
+						"expression": {
+							"type": "Literal",
+							"start": 237,
+							"end": 242,
+							"loc": {
+								"start": {
+									"line": 6,
+									"column": 38
+								},
+								"end": {
+									"line": 6,
+									"column": 43
+								}
+							},
+							"value": "./b",
+							"raw": "'./b'",
+							"leadingComments": [
+								{
+									"type": "Block",
+									"value": " c2 ",
+									"start": 219,
+									"end": 227
+								},
+								{
+									"type": "Block",
+									"value": " c3 ",
+									"start": 228,
+									"end": 236
+								}
+							]
+						}
+					},
+					"leadingComments": [
+						{
+							"type": "Line",
+							"value": " Two comments in the same gap keep their order",
+							"start": 150,
+							"end": 198
+						}
+					]
+				}
+			],
+			"sourceType": "module"
+		},
+		"attributes": [
+			{
+				"type": "Attribute",
+				"start": 8,
+				"end": 17,
+				"name": "lang",
+				"name_loc": {
+					"start": {
+						"line": 1,
+						"column": 8,
+						"character": 8
+					},
+					"end": {
+						"line": 1,
+						"column": 12,
+						"character": 12
+					}
+				},
+				"value": [
+					{
+						"start": 14,
+						"end": 16,
+						"type": "Text",
+						"raw": "ts",
+						"data": "ts"
+					}
+				]
+			}
+		]
+	}
+}
diff --git a/tests/fixtures/typescript/modules/imports/equals_require_paren_comment/input.svelte b/tests/fixtures/typescript/modules/imports/equals_require_paren_comment/input.svelte
new file mode 100644
index 000000000..2030660cd
--- /dev/null
+++ b/tests/fixtures/typescript/modules/imports/equals_require_paren_comment/input.svelte
@@ -0,0 +1,7 @@
+<script lang="ts">
+	// Block comment inside `require(` — hugs the paren, keeps its space on the literal's side
+	import A = require(/* c1 */ './a');
+
+	// Two comments in the same gap keep their order
+	import B = require(/* c2 */ /* c3 */ './b');
+</script>
diff --git a/tests/fixtures/typescript/modules/imports/equals_require_paren_comment/unformatted_before_paren.svelte b/tests/fixtures/typescript/modules/imports/equals_require_paren_comment/unformatted_before_paren.svelte
new file mode 100644
index 000000000..903847064
--- /dev/null
+++ b/tests/fixtures/typescript/modules/imports/equals_require_paren_comment/unformatted_before_paren.svelte
@@ -0,0 +1,7 @@
+<script lang="ts">
+	// Block comment inside `require(` — hugs the paren, keeps its space on the literal's side
+	import A = require /* c1 */ ('./a');
+
+	// Two comments in the same gap keep their order
+	import B = require /* c2 */ (/* c3 */ './b');
+</script>
diff --git a/tests/fixtures/typescript/types/qualified_name_dot_gap_comments/expected.json b/tests/fixtures/typescript/types/qualified_name_dot_gap_comments/expected.json
new file mode 100644
index 000000000..bba4ee7c6
--- /dev/null
+++ b/tests/fixtures/typescript/types/qualified_name_dot_gap_comments/expected.json
@@ -0,0 +1,863 @@
+{
+	"css": null,
+	"js": [],
+	"start": 0,
+	"end": 459,
+	"type": "Root",
+	"fragment": {
+		"type": "Fragment",
+		"nodes": []
+	},
+	"options": null,
+	"comments": [
+		{
+			"type": "Line",
+			"value": " Block comment before the `.` — stays there, hugging the dot",
+			"start": 20,
+			"end": 82,
+			"loc": {
+				"start": {
+					"line": 2,
+					"column": 1
+				},
+				"end": {
+					"line": 2,
+					"column": 63
+				}
+			}
+		},
+		{
+			"type": "Block",
+			"value": " c1 ",
+			"start": 96,
+			"end": 104,
+			"loc": {
+				"start": {
+					"line": 3,
+					"column": 13
+				},
+				"end": {
+					"line": 3,
+					"column": 21
+				}
+			}
+		},
+		{
+			"type": "Line",
+			"value": " Block comment after the `.` — stays on that side",
+			"start": 113,
+			"end": 164,
+			"loc": {
+				"start": {
+					"line": 5,
+					"column": 1
+				},
+				"end": {
+					"line": 5,
+					"column": 52
+				}
+			}
+		},
+		{
+			"type": "Block",
+			"value": " c2 ",
+			"start": 178,
+			"end": 186,
+			"loc": {
+				"start": {
+					"line": 6,
+					"column": 13
+				},
+				"end": {
+					"line": 6,
+					"column": 21
+				}
+			}
+		},
+		{
+			"type": "Line",
+			"value": " Both gaps in a deeper chain",
+			"start": 195,
+			"end": 225,
+			"loc": {
+				"start": {
+					"line": 8,
+					"column": 1
+				},
+				"end": {
+					"line": 8,
+					"column": 31
+				}
+			}
+		},
+		{
+			"type": "Block",
+			"value": " c3 ",
+			"start": 240,
+			"end": 248,
+			"loc": {
+				"start": {
+					"line": 9,
+					"column": 14
+				},
+				"end": {
+					"line": 9,
+					"column": 22
+				}
+			}
+		},
+		{
+			"type": "Block",
+			"value": " c4 ",
+			"start": 251,
+			"end": 259,
+			"loc": {
+				"start": {
+					"line": 9,
+					"column": 25
+				},
+				"end": {
+					"line": 9,
+					"column": 33
+				}
+			}
+		},
+		{
+			"type": "Line",
+			"value": " Interface heritage shares the qualified-name printer",
+			"start": 268,
+			"end": 323,
+			"loc": {
+				"start": {
+					"line": 11,
+					"column": 1
+				},
+				"end": {
+					"line": 11,
+					"column": 56
+				}
+			}
+		},
+		{
+			"type": "Block",
+			"value": " c5 ",
+			"start": 354,
+			"end": 362,
+			"loc": {
+				"start": {
+					"line": 12,
+					"column": 30
+				},
+				"end": {
+					"line": 12,
+					"column": 38
+				}
+			}
+		},
+		{
+			"type": "Line",
+			"value": " So does an import-equals module reference",
+			"start": 373,
+			"end": 417,
+			"loc": {
+				"start": {
+					"line": 14,
+					"column": 1
+				},
+				"end": {
+					"line": 14,
+					"column": 45
+				}
+			}
+		},
+		{
+			"type": "Block",
+			"value": " c6 ",
+			"start": 435,
+			"end": 443,
+			"loc": {
+				"start": {
+					"line": 15,
+					"column": 17
+				},
+				"end": {
+					"line": 15,
+					"column": 25
+				}
+			}
+		}
+	],
+	"instance": {
+		"type": "Script",
+		"start": 0,
+		"end": 458,
+		"context": "default",
+		"content": {
+			"type": "Program",
+			"start": 18,
+			"end": 449,
+			"loc": {
+				"start": {
+					"line": 1,
+					"column": 0
+				},
+				"end": {
+					"line": 16,
+					"column": 9
+				}
+			},
+			"body": [
+				{
+					"type": "TSTypeAliasDeclaration",
+					"start": 84,
+					"end": 110,
+					"loc": {
+						"start": {
+							"line": 3,
+							"column": 1
+						},
+						"end": {
+							"line": 3,
+							"column": 27
+						}
+					},
+					"id": {
+						"type": "Identifier",
+						"start": 89,
+						"end": 90,
+						"loc": {
+							"start": {
+								"line": 3,
+								"column": 6
+							},
+							"end": {
+								"line": 3,
+								"column": 7
+							}
+						},
+						"name": "A"
+					},
+					"typeAnnotation": {
+						"type": "TSTypeReference",
+						"start": 93,
+						"end": 109,
+						"loc": {
+							"start": {
+								"line": 3,
+								"column": 10
+							},
+							"end": {
+								"line": 3,
+								"column": 26
+							}
+						},
+						"typeName": {
+							"type": "TSQualifiedName",
+							"start": 93,
+							"end": 109,
+							"loc": {
+								"start": {
+									"line": 3,
+									"column": 10
+								},
+								"end": {
+									"line": 3,
+									"column": 26
+								}
+							},
+							"left": {
+								"type": "Identifier",
+								"start": 93,
+								"end": 95,
+								"loc": {
+									"start": {
+										"line": 3,
+										"column": 10
+									},
+									"end": {
+										"line": 3,
+										"column": 12
+									}
+								},
+								"name": "ns",
+								"trailingComments": [
+									{
+										"type": "Block",
+										"value": " c1 ",
+										"start": 96,
+										"end": 104
+									}
+								]
+							},
+							"right": {
+								"type": "Identifier",
+								"start": 105,
+								"end": 109,
+								"loc": {
+									"start": {
+										"line": 3,
+										"column": 22
+									},
+									"end": {
+										"line": 3,
+										"column": 26
+									}
+								},
+								"name": "Type"
+							}
+						}
+					},
+					"leadingComments": [
+						{
+							"type": "Line",
+							"value": " Block comment before the `.` — stays there, hugging the dot",
+							"start": 20,
+							"end": 82
+						}
+					]
+				},
+				{
+					"type": "TSTypeAliasDeclaration",
+					"start": 166,
+					"end": 192,
+					"loc": {
+						"start": {
+							"line": 6,
+							"column": 1
+						},
+						"end": {
+							"line": 6,
+							"column": 27
+						}
+					},
+					"id": {
+						"type": "Identifier",
+						"start": 171,
+						"end": 172,
+						"loc": {
+							"start": {
+								"line": 6,
+								"column": 6
+							},
+							"end": {
+								"line": 6,
+								"column": 7
+							}
+						},
+						"name": "B"
+					},
+					"typeAnnotation": {
+						"type": "TSTypeReference",
+						"start": 175,
+						"end": 191,
+						"loc": {
+							"start": {
+								"line": 6,
+								"column": 10
+							},
+							"end": {
+								"line": 6,
+								"column": 26
+							}
+						},
+						"typeName": {
+							"type": "TSQualifiedName",
+							"start": 175,
+							"end": 191,
+							"loc": {
+								"start": {
+									"line": 6,
+									"column": 10
+								},
+								"end": {
+									"line": 6,
+									"column": 26
+								}
+							},
+							"left": {
+								"type": "Identifier",
+								"start": 175,
+								"end": 177,
+								"loc": {
+									"start": {
+										"line": 6,
+										"column": 10
+									},
+									"end": {
+										"line": 6,
+										"column": 12
+									}
+								},
+								"name": "ns"
+							},
+							"right": {
+								"type": "Identifier",
+								"start": 187,
+								"end": 191,
+								"loc": {
+									"start": {
+										"line": 6,
+										"column": 22
+									},
+									"end": {
+										"line": 6,
+										"column": 26
+									}
+								},
+								"name": "Type",
+								"leadingComments": [
+									{
+										"type": "Block",
+										"value": " c2 ",
+										"start": 178,
+										"end": 186
+									}
+								]
+							}
+						}
+					},
+					"leadingComments": [
+						{
+							"type": "Line",
+							"value": " Block comment after the `.` — stays on that side",
+							"start": 113,
+							"end": 164
+						}
+					]
+				},
+				{
+					"type": "TSTypeAliasDeclaration",
+					"start": 227,
+					"end": 265,
+					"loc": {
+						"start": {
+							"line": 9,
+							"column": 1
+						},
+						"end": {
+							"line": 9,
+							"column": 39
+						}
+					},
+					"id": {
+						"type": "Identifier",
+						"start": 232,
+						"end": 233,
+						"loc": {
+							"start": {
+								"line": 9,
+								"column": 6
+							},
+							"end": {
+								"line": 9,
+								"column": 7
+							}
+						},
+						"name": "C"
+					},
+					"typeAnnotation": {
+						"type": "TSTypeReference",
+						"start": 236,
+						"end": 264,
+						"loc": {
+							"start": {
+								"line": 9,
+								"column": 10
+							},
+							"end": {
+								"line": 9,
+								"column": 38
+							}
+						},
+						"typeName": {
+							"type": "TSQualifiedName",
+							"start": 236,
+							"end": 264,
+							"loc": {
+								"start": {
+									"line": 9,
+									"column": 10
+								},
+								"end": {
+									"line": 9,
+									"column": 38
+								}
+							},
+							"left": {
+								"type": "TSQualifiedName",
+								"start": 236,
+								"end": 250,
+								"loc": {
+									"start": {
+										"line": 9,
+										"column": 10
+									},
+									"end": {
+										"line": 9,
+										"column": 24
+									}
+								},
+								"left": {
+									"type": "TSQualifiedName",
+									"start": 236,
+									"end": 239,
+									"loc": {
+										"start": {
+											"line": 9,
+											"column": 10
+										},
+										"end": {
+											"line": 9,
+											"column": 13
+										}
+									},
+									"left": {
+										"type": "Identifier",
+										"start": 236,
+										"end": 237,
+										"loc": {
+											"start": {
+												"line": 9,
+												"column": 10
+											},
+											"end": {
+												"line": 9,
+												"column": 11
+											}
+										},
+										"name": "a"
+									},
+									"right": {
+										"type": "Identifier",
+										"start": 238,
+										"end": 239,
+										"loc": {
+											"start": {
+												"line": 9,
+												"column": 12
+											},
+											"end": {
+												"line": 9,
+												"column": 13
+											}
+										},
+										"name": "b"
+									},
+									"trailingComments": [
+										{
+											"type": "Block",
+											"value": " c3 ",
+											"start": 240,
+											"end": 248
+										}
+									]
+								},
+								"right": {
+									"type": "Identifier",
+									"start": 249,
+									"end": 250,
+									"loc": {
+										"start": {
+											"line": 9,
+											"column": 23
+										},
+										"end": {
+											"line": 9,
+											"column": 24
+										}
+									},
+									"name": "c"
+								}
+							},
+							"right": {
+								"type": "Identifier",
+								"start": 260,
+								"end": 264,
+								"loc": {
+									"start": {
+										"line": 9,
+										"column": 34
+									},
+									"end": {
+										"line": 9,
+										"column": 38
+									}
+								},
+								"name": "Type",
+								"leadingComments": [
+									{
+										"type": "Block",
+										"value": " c4 ",
+										"start": 251,
+										"end": 259
+									}
+								]
+							}
+						}
+					},
+					"leadingComments": [
+						{
+							"type": "Line",
+							"value": " Both gaps in a deeper chain",
+							"start": 195,
+							"end": 225
+						}
+					]
+				},
+				{
+					"type": "TSInterfaceDeclaration",
+					"start": 325,
+					"end": 370,
+					"loc": {
+						"start": {
+							"line": 12,
+							"column": 1
+						},
+						"end": {
+							"line": 12,
+							"column": 46
+						}
+					},
+					"id": {
+						"type": "Identifier",
+						"start": 335,
+						"end": 342,
+						"loc": {
+							"start": {
+								"line": 12,
+								"column": 11
+							},
+							"end": {
+								"line": 12,
+								"column": 18
+							}
+						},
+						"name": "Extends"
+					},
+					"extends": [
+						{
+							"type": "TSExpressionWithTypeArguments",
+							"start": 351,
+							"end": 367,
+							"loc": {
+								"start": {
+									"line": 12,
+									"column": 27
+								},
+								"end": {
+									"line": 12,
+									"column": 43
+								}
+							},
+							"expression": {
+								"type": "TSQualifiedName",
+								"start": 351,
+								"end": 367,
+								"loc": {
+									"start": {
+										"line": 12,
+										"column": 27
+									},
+									"end": {
+										"line": 12,
+										"column": 43
+									}
+								},
+								"left": {
+									"type": "Identifier",
+									"start": 351,
+									"end": 353,
+									"loc": {
+										"start": {
+											"line": 12,
+											"column": 27
+										},
+										"end": {
+											"line": 12,
+											"column": 29
+										}
+									},
+									"name": "ns"
+								},
+								"right": {
+									"type": "Identifier",
+									"start": 363,
+									"end": 367,
+									"loc": {
+										"start": {
+											"line": 12,
+											"column": 39
+										},
+										"end": {
+											"line": 12,
+											"column": 43
+										}
+									},
+									"name": "Base",
+									"leadingComments": [
+										{
+											"type": "Block",
+											"value": " c5 ",
+											"start": 354,
+											"end": 362
+										}
+									]
+								}
+							}
+						}
+					],
+					"body": {
+						"type": "TSInterfaceBody",
+						"start": 368,
+						"end": 370,
+						"loc": {
+							"start": {
+								"line": 12,
+								"column": 44
+							},
+							"end": {
+								"line": 12,
+								"column": 46
+							}
+						},
+						"body": []
+					},
+					"leadingComments": [
+						{
+							"type": "Line",
+							"value": " Interface heritage shares the qualified-name printer",
+							"start": 268,
+							"end": 323
+						}
+					]
+				},
+				{
+					"type": "TSImportEqualsDeclaration",
+					"start": 419,
+					"end": 448,
+					"loc": {
+						"start": {
+							"line": 15,
+							"column": 1
+						},
+						"end": {
+							"line": 15,
+							"column": 30
+						}
+					},
+					"importKind": "value",
+					"isExport": false,
+					"id": {
+						"type": "Identifier",
+						"start": 426,
+						"end": 429,
+						"loc": {
+							"start": {
+								"line": 15,
+								"column": 8
+							},
+							"end": {
+								"line": 15,
+								"column": 11
+							}
+						},
+						"name": "Ref"
+					},
+					"moduleReference": {
+						"type": "TSQualifiedName",
+						"start": 432,
+						"end": 447,
+						"loc": {
+							"start": {
+								"line": 15,
+								"column": 14
+							},
+							"end": {
+								"line": 15,
+								"column": 29
+							}
+						},
+						"left": {
+							"type": "Identifier",
+							"start": 432,
+							"end": 434,
+							"loc": {
+								"start": {
+									"line": 15,
+									"column": 14
+								},
+								"end": {
+									"line": 15,
+									"column": 16
+								}
+							},
+							"name": "ns"
+						},
+						"right": {
+							"type": "Identifier",
+							"start": 444,
+							"end": 447,
+							"loc": {
+								"start": {
+									"line": 15,
+									"column": 26
+								},
+								"end": {
+									"line": 15,
+									"column": 29
+								}
+							},
+							"name": "Sub",
+							"leadingComments": [
+								{
+									"type": "Block",
+									"value": " c6 ",
+									"start": 435,
+									"end": 443
+								}
+							]
+						}
+					},
+					"leadingComments": [
+						{
+							"type": "Line",
+							"value": " So does an import-equals module reference",
+							"start": 373,
+							"end": 417
+						}
+					]
+				}
+			],
+			"sourceType": "module"
+		},
+		"attributes": [
+			{
+				"type": "Attribute",
+				"start": 8,
+				"end": 17,
+				"name": "lang",
+				"name_loc": {
+					"start": {
+						"line": 1,
+						"column": 8,
+						"character": 8
+					},
+					"end": {
+						"line": 1,
+						"column": 12,
+						"character": 12
+					}
+				},
+				"value": [
+					{
+						"start": 14,
+						"end": 16,
+						"type": "Text",
+						"raw": "ts",
+						"data": "ts"
+					}
+				]
+			}
+		]
+	}
+}
diff --git a/tests/fixtures/typescript/types/qualified_name_dot_gap_comments/input.svelte b/tests/fixtures/typescript/types/qualified_name_dot_gap_comments/input.svelte
new file mode 100644
index 000000000..9b3875a42
--- /dev/null
+++ b/tests/fixtures/typescript/types/qualified_name_dot_gap_comments/input.svelte
@@ -0,0 +1,16 @@
+<script lang="ts">
+	// Block comment before the `.` — stays there, hugging the dot
+	type A = ns /* c1 */.Type;
+
+	// Block comment after the `.` — stays on that side
+	type B = ns./* c2 */ Type;
+
+	// Both gaps in a deeper chain
+	type C = a.b /* c3 */.c./* c4 */ Type;
+
+	// Interface heritage shares the qualified-name printer
+	interface Extends extends ns./* c5 */ Base {}
+
+	// So does an import-equals module reference
+	import Ref = ns./* c6 */ Sub;
+</script>
diff --git a/tests/fixtures/typescript/types/qualified_name_dot_gap_line_comment_prettier_divergence/README.md b/tests/fixtures/typescript/types/qualified_name_dot_gap_line_comment_prettier_divergence/README.md
new file mode 100644
index 000000000..d46ccf739
--- /dev/null
+++ b/tests/fixtures/typescript/types/qualified_name_dot_gap_line_comment_prettier_divergence/README.md
@@ -0,0 +1,31 @@
+# Divergence: qualified-name dot-gap line comments (preserve)
+
+A *line* comment in either gap around a qualified name's `.` (`ns // c⏎.Type`, `ns. // c⏎Type`).
+tsv keeps it where the author wrote it and continues the rest of the name one level down; prettier
+**relocates** it past the `;`, where it no longer reads as being about the name at all.
+
+```ts
+// tsv (preserve)          // prettier (relocate)
+let a: ns // c1            let a: ns.Type; // c1
+	.Type;
+```
+
+The qualified-name twin of
+[meta_property/dot_gap_line_comment](../../expressions/misc/meta_property/dot_gap_line_comment_prettier_divergence/):
+same shape (`name` `.` `name`), same two gaps, same rule — and, before the fix, the same bug. Both
+route through one printer, so neither can drift.
+
+Block comments in these gaps are **not** a divergence: prettier keeps each on its authored side of
+the dot, and so does tsv — pinned by the regular sibling
+[qualified_name_dot_gap_comments](../qualified_name_dot_gap_comments/).
+
+The type alias is the one nested shape: a breaking right-hand side goes below the `=` (prettier's
+own convention for a multiline RHS — a broken union takes the same form), so the name's `+1`
+continuation nests inside that, not against the statement. The annotation and heritage cases show
+the rule flat. Prettier isn't an oracle for any of it — it relocates the comment out of the name
+first, and on the heritage case leaves `.Base` sitting level with the `extends` it belongs to.
+
+See [conformance_prettier.md §Comment relocation](../../../../../docs/conformance_prettier.md#comment-relocation)
+and [§Comments inside a multi-word keyword](../../../../../docs/conformance_prettier.md#comments-inside-a-multi-word-keyword)
+(the punctuator-joined member of that class — the reason its usual detector, a `d.text` literal with
+an *interior* space, cannot see it: the joining literal is `"."`).
diff --git a/tests/fixtures/typescript/types/qualified_name_dot_gap_line_comment_prettier_divergence/expected.json b/tests/fixtures/typescript/types/qualified_name_dot_gap_line_comment_prettier_divergence/expected.json
new file mode 100644
index 000000000..ab07a23d9
--- /dev/null
+++ b/tests/fixtures/typescript/types/qualified_name_dot_gap_line_comment_prettier_divergence/expected.json
@@ -0,0 +1,761 @@
+{
+	"css": null,
+	"js": [],
+	"start": 0,
+	"end": 480,
+	"type": "Root",
+	"fragment": {
+		"type": "Fragment",
+		"nodes": []
+	},
+	"options": null,
+	"comments": [
+		{
+			"type": "Line",
+			"value": " A line comment before the `.` — stays there, and the rest of the name continues",
+			"start": 20,
+			"end": 102,
+			"loc": {
+				"start": {
+					"line": 2,
+					"column": 1
+				},
+				"end": {
+					"line": 2,
+					"column": 83
+				}
+			}
+		},
+		{
+			"type": "Line",
+			"value": " one level down",
+			"start": 104,
+			"end": 121,
+			"loc": {
+				"start": {
+					"line": 3,
+					"column": 1
+				},
+				"end": {
+					"line": 3,
+					"column": 18
+				}
+			}
+		},
+		{
+			"type": "Line",
+			"value": " c1",
+			"start": 133,
+			"end": 138,
+			"loc": {
+				"start": {
+					"line": 4,
+					"column": 11
+				},
+				"end": {
+					"line": 4,
+					"column": 16
+				}
+			}
+		},
+		{
+			"type": "Line",
+			"value": " The gap on the other side of the dot",
+			"start": 150,
+			"end": 189,
+			"loc": {
+				"start": {
+					"line": 7,
+					"column": 1
+				},
+				"end": {
+					"line": 7,
+					"column": 40
+				}
+			}
+		},
+		{
+			"type": "Line",
+			"value": " c2",
+			"start": 202,
+			"end": 207,
+			"loc": {
+				"start": {
+					"line": 8,
+					"column": 12
+				},
+				"end": {
+					"line": 8,
+					"column": 17
+				}
+			}
+		},
+		{
+			"type": "Line",
+			"value": " Interface heritage shares the qualified-name printer",
+			"start": 218,
+			"end": 273,
+			"loc": {
+				"start": {
+					"line": 11,
+					"column": 1
+				},
+				"end": {
+					"line": 11,
+					"column": 56
+				}
+			}
+		},
+		{
+			"type": "Line",
+			"value": " c3",
+			"start": 304,
+			"end": 309,
+			"loc": {
+				"start": {
+					"line": 12,
+					"column": 30
+				},
+				"end": {
+					"line": 12,
+					"column": 35
+				}
+			}
+		},
+		{
+			"type": "Line",
+			"value": " A type alias puts a breaking right-hand side below the `=`, so the name's own",
+			"start": 323,
+			"end": 403,
+			"loc": {
+				"start": {
+					"line": 15,
+					"column": 1
+				},
+				"end": {
+					"line": 15,
+					"column": 81
+				}
+			}
+		},
+		{
+			"type": "Line",
+			"value": " continuation nests inside that",
+			"start": 405,
+			"end": 438,
+			"loc": {
+				"start": {
+					"line": 16,
+					"column": 1
+				},
+				"end": {
+					"line": 16,
+					"column": 34
+				}
+			}
+		},
+		{
+			"type": "Line",
+			"value": " c4",
+			"start": 454,
+			"end": 459,
+			"loc": {
+				"start": {
+					"line": 18,
+					"column": 5
+				},
+				"end": {
+					"line": 18,
+					"column": 10
+				}
+			}
+		}
+	],
+	"instance": {
+		"type": "Script",
+		"start": 0,
+		"end": 479,
+		"context": "default",
+		"content": {
+			"type": "Program",
+			"start": 18,
+			"end": 470,
+			"loc": {
+				"start": {
+					"line": 1,
+					"column": 0
+				},
+				"end": {
+					"line": 20,
+					"column": 9
+				}
+			},
+			"body": [
+				{
+					"type": "VariableDeclaration",
+					"start": 123,
+					"end": 147,
+					"loc": {
+						"start": {
+							"line": 4,
+							"column": 1
+						},
+						"end": {
+							"line": 5,
+							"column": 8
+						}
+					},
+					"declarations": [
+						{
+							"type": "VariableDeclarator",
+							"start": 127,
+							"end": 146,
+							"loc": {
+								"start": {
+									"line": 4,
+									"column": 5
+								},
+								"end": {
+									"line": 5,
+									"column": 7
+								}
+							},
+							"id": {
+								"type": "Identifier",
+								"start": 127,
+								"end": 146,
+								"loc": {
+									"start": {
+										"line": 4,
+										"column": 5
+									},
+									"end": {
+										"line": 5,
+										"column": 7
+									}
+								},
+								"name": "a",
+								"typeAnnotation": {
+									"type": "TSTypeAnnotation",
+									"start": 128,
+									"end": 146,
+									"loc": {
+										"start": {
+											"line": 4,
+											"column": 6
+										},
+										"end": {
+											"line": 5,
+											"column": 7
+										}
+									},
+									"typeAnnotation": {
+										"type": "TSTypeReference",
+										"start": 130,
+										"end": 146,
+										"loc": {
+											"start": {
+												"line": 4,
+												"column": 8
+											},
+											"end": {
+												"line": 5,
+												"column": 7
+											}
+										},
+										"typeName": {
+											"type": "TSQualifiedName",
+											"start": 130,
+											"end": 146,
+											"loc": {
+												"start": {
+													"line": 4,
+													"column": 8
+												},
+												"end": {
+													"line": 5,
+													"column": 7
+												}
+											},
+											"left": {
+												"type": "Identifier",
+												"start": 130,
+												"end": 132,
+												"loc": {
+													"start": {
+														"line": 4,
+														"column": 8
+													},
+													"end": {
+														"line": 4,
+														"column": 10
+													}
+												},
+												"name": "ns",
+												"trailingComments": [
+													{
+														"type": "Line",
+														"value": " c1",
+														"start": 133,
+														"end": 138
+													}
+												]
+											},
+											"right": {
+												"type": "Identifier",
+												"start": 142,
+												"end": 146,
+												"loc": {
+													"start": {
+														"line": 5,
+														"column": 3
+													},
+													"end": {
+														"line": 5,
+														"column": 7
+													}
+												},
+												"name": "Type"
+											}
+										}
+									}
+								}
+							},
+							"init": null
+						}
+					],
+					"kind": "let",
+					"leadingComments": [
+						{
+							"type": "Line",
+							"value": " A line comment before the `.` — stays there, and the rest of the name continues",
+							"start": 20,
+							"end": 102
+						},
+						{
+							"type": "Line",
+							"value": " one level down",
+							"start": 104,
+							"end": 121
+						}
+					]
+				},
+				{
+					"type": "VariableDeclaration",
+					"start": 191,
+					"end": 215,
+					"loc": {
+						"start": {
+							"line": 8,
+							"column": 1
+						},
+						"end": {
+							"line": 9,
+							"column": 7
+						}
+					},
+					"declarations": [
+						{
+							"type": "VariableDeclarator",
+							"start": 195,
+							"end": 214,
+							"loc": {
+								"start": {
+									"line": 8,
+									"column": 5
+								},
+								"end": {
+									"line": 9,
+									"column": 6
+								}
+							},
+							"id": {
+								"type": "Identifier",
+								"start": 195,
+								"end": 214,
+								"loc": {
+									"start": {
+										"line": 8,
+										"column": 5
+									},
+									"end": {
+										"line": 9,
+										"column": 6
+									}
+								},
+								"name": "b",
+								"typeAnnotation": {
+									"type": "TSTypeAnnotation",
+									"start": 196,
+									"end": 214,
+									"loc": {
+										"start": {
+											"line": 8,
+											"column": 6
+										},
+										"end": {
+											"line": 9,
+											"column": 6
+										}
+									},
+									"typeAnnotation": {
+										"type": "TSTypeReference",
+										"start": 198,
+										"end": 214,
+										"loc": {
+											"start": {
+												"line": 8,
+												"column": 8
+											},
+											"end": {
+												"line": 9,
+												"column": 6
+											}
+										},
+										"typeName": {
+											"type": "TSQualifiedName",
+											"start": 198,
+											"end": 214,
+											"loc": {
+												"start": {
+													"line": 8,
+													"column": 8
+												},
+												"end": {
+													"line": 9,
+													"column": 6
+												}
+											},
+											"left": {
+												"type": "Identifier",
+												"start": 198,
+												"end": 200,
+												"loc": {
+													"start": {
+														"line": 8,
+														"column": 8
+													},
+													"end": {
+														"line": 8,
+														"column": 10
+													}
+												},
+												"name": "ns"
+											},
+											"right": {
+												"type": "Identifier",
+												"start": 210,
+												"end": 214,
+												"loc": {
+													"start": {
+														"line": 9,
+														"column": 2
+													},
+													"end": {
+														"line": 9,
+														"column": 6
+													}
+												},
+												"name": "Type",
+												"leadingComments": [
+													{
+														"type": "Line",
+														"value": " c2",
+														"start": 202,
+														"end": 207
+													}
+												]
+											}
+										}
+									}
+								}
+							},
+							"init": null
+						}
+					],
+					"kind": "let",
+					"leadingComments": [
+						{
+							"type": "Line",
+							"value": " The gap on the other side of the dot",
+							"start": 150,
+							"end": 189
+						}
+					]
+				},
+				{
+					"type": "TSInterfaceDeclaration",
+					"start": 275,
+					"end": 320,
+					"loc": {
+						"start": {
+							"line": 12,
+							"column": 1
+						},
+						"end": {
+							"line": 13,
+							"column": 10
+						}
+					},
+					"id": {
+						"type": "Identifier",
+						"start": 285,
+						"end": 292,
+						"loc": {
+							"start": {
+								"line": 12,
+								"column": 11
+							},
+							"end": {
+								"line": 12,
+								"column": 18
+							}
+						},
+						"name": "Extends"
+					},
+					"extends": [
+						{
+							"type": "TSExpressionWithTypeArguments",
+							"start": 301,
+							"end": 317,
+							"loc": {
+								"start": {
+									"line": 12,
+									"column": 27
+								},
+								"end": {
+									"line": 13,
+									"column": 7
+								}
+							},
+							"expression": {
+								"type": "TSQualifiedName",
+								"start": 301,
+								"end": 317,
+								"loc": {
+									"start": {
+										"line": 12,
+										"column": 27
+									},
+									"end": {
+										"line": 13,
+										"column": 7
+									}
+								},
+								"left": {
+									"type": "Identifier",
+									"start": 301,
+									"end": 303,
+									"loc": {
+										"start": {
+											"line": 12,
+											"column": 27
+										},
+										"end": {
+											"line": 12,
+											"column": 29
+										}
+									},
+									"name": "ns",
+									"trailingComments": [
+										{
+											"type": "Line",
+											"value": " c3",
+											"start": 304,
+											"end": 309
+										}
+									]
+								},
+								"right": {
+									"type": "Identifier",
+									"start": 313,
+									"end": 317,
+									"loc": {
+										"start": {
+											"line": 13,
+											"column": 3
+										},
+										"end": {
+											"line": 13,
+											"column": 7
+										}
+									},
+									"name": "Base"
+								}
+							}
+						}
+					],
+					"body": {
+						"type": "TSInterfaceBody",
+						"start": 318,
+						"end": 320,
+						"loc": {
+							"start": {
+								"line": 13,
+								"column": 8
+							},
+							"end": {
+								"line": 13,
+								"column": 10
+							}
+						},
+						"body": []
+					},
+					"leadingComments": [
+						{
+							"type": "Line",
+							"value": " Interface heritage shares the qualified-name printer",
+							"start": 218,
+							"end": 273
+						}
+					]
+				},
+				{
+					"type": "TSTypeAliasDeclaration",
+					"start": 440,
+					"end": 469,
+					"loc": {
+						"start": {
+							"line": 17,
+							"column": 1
+						},
+						"end": {
+							"line": 19,
+							"column": 9
+						}
+					},
+					"id": {
+						"type": "Identifier",
+						"start": 445,
+						"end": 446,
+						"loc": {
+							"start": {
+								"line": 17,
+								"column": 6
+							},
+							"end": {
+								"line": 17,
+								"column": 7
+							}
+						},
+						"name": "A"
+					},
+					"typeAnnotation": {
+						"type": "TSTypeReference",
+						"start": 451,
+						"end": 468,
+						"loc": {
+							"start": {
+								"line": 18,
+								"column": 2
+							},
+							"end": {
+								"line": 19,
+								"column": 8
+							}
+						},
+						"typeName": {
+							"type": "TSQualifiedName",
+							"start": 451,
+							"end": 468,
+							"loc": {
+								"start": {
+									"line": 18,
+									"column": 2
+								},
+								"end": {
+									"line": 19,
+									"column": 8
+								}
+							},
+							"left": {
+								"type": "Identifier",
+								"start": 451,
+								"end": 453,
+								"loc": {
+									"start": {
+										"line": 18,
+										"column": 2
+									},
+									"end": {
+										"line": 18,
+										"column": 4
+									}
+								},
+								"name": "ns",
+								"trailingComments": [
+									{
+										"type": "Line",
+										"value": " c4",
+										"start": 454,
+										"end": 459
+									}
+								]
+							},
+							"right": {
+								"type": "Identifier",
+								"start": 464,
+								"end": 468,
+								"loc": {
+									"start": {
+										"line": 19,
+										"column": 4
+									},
+									"end": {
+										"line": 19,
+										"column": 8
+									}
+								},
+								"name": "Type"
+							}
+						}
+					},
+					"leadingComments": [
+						{
+							"type": "Line",
+							"value": " A type alias puts a breaking right-hand side below the `=`, so the name's own",
+							"start": 323,
+							"end": 403
+						},
+						{
+							"type": "Line",
+							"value": " continuation nests inside that",
+							"start": 405,
+							"end": 438
+						}
+					]
+				}
+			],
+			"sourceType": "module"
+		},
+		"attributes": [
+			{
+				"type": "Attribute",
+				"start": 8,
+				"end": 17,
+				"name": "lang",
+				"name_loc": {
+					"start": {
+						"line": 1,
+						"column": 8,
+						"character": 8
+					},
+					"end": {
+						"line": 1,
+						"column": 12,
+						"character": 12
+					}
+				},
+				"value": [
+					{
+						"start": 14,
+						"end": 16,
+						"type": "Text",
+						"raw": "ts",
+						"data": "ts"
+					}
+				]
+			}
+		]
+	}
+}
diff --git a/tests/fixtures/typescript/types/qualified_name_dot_gap_line_comment_prettier_divergence/input.svelte b/tests/fixtures/typescript/types/qualified_name_dot_gap_line_comment_prettier_divergence/input.svelte
new file mode 100644
index 000000000..337f05108
--- /dev/null
+++ b/tests/fixtures/typescript/types/qualified_name_dot_gap_line_comment_prettier_divergence/input.svelte
@@ -0,0 +1,20 @@
+<script lang="ts">
+	// A line comment before the `.` — stays there, and the rest of the name continues
+	// one level down
+	let a: ns // c1
+		.Type;
+
+	// The gap on the other side of the dot
+	let b: ns. // c2
+		Type;
+
+	// Interface heritage shares the qualified-name printer
+	interface Extends extends ns // c3
+		.Base {}
+
+	// A type alias puts a breaking right-hand side below the `=`, so the name's own
+	// continuation nests inside that
+	type A =
+		ns // c4
+			.Type;
+</script>
diff --git a/tests/fixtures/typescript/types/qualified_name_dot_gap_line_comment_prettier_divergence/output_prettier.svelte b/tests/fixtures/typescript/types/qualified_name_dot_gap_line_comment_prettier_divergence/output_prettier.svelte
new file mode 100644
index 000000000..084d49444
--- /dev/null
+++ b/tests/fixtures/typescript/types/qualified_name_dot_gap_line_comment_prettier_divergence/output_prettier.svelte
@@ -0,0 +1,17 @@
+<script lang="ts">
+	// A line comment before the `.` — stays there, and the rest of the name continues
+	// one level down
+	let a: ns.Type; // c1
+
+	// The gap on the other side of the dot
+	let b: ns.Type; // c2
+
+	// Interface heritage shares the qualified-name printer
+	interface Extends
+		extends ns // c3
+		.Base {}
+
+	// A type alias puts a breaking right-hand side below the `=`, so the name's own
+	// continuation nests inside that
+	type A = ns.Type; // c4
+</script>
diff --git a/tests/import_phase.rs b/tests/import_phase.rs
index eccd621d5..bff454eca 100644
--- a/tests/import_phase.rs
+++ b/tests/import_phase.rs
@@ -129,3 +129,20 @@ fn static_import_source_keyword_binding_rejected() {
     assert_ours_rejects("<script lang=\"ts\">\n\timport source from from 'x';\n</script>\n");
     assert_ours_stable("<script lang=\"ts\">\n\timport source source from 'x';\n</script>\n");
 }
+
+/// A comment in either gap around the phase dot survives.
+///
+/// `import.source` / `import.defer` are a dotted pair (`import` `.` `source`), so both
+/// gaps are positions an author can comment in. Emitting the pair as one fixed text
+/// (`"import.source("`) scans neither and drops what's there — the punctuator-joined
+/// member of the multi-word-keyword class (`docs/conformance_prettier.md` §Comments
+/// inside a multi-word keyword). Prettier preserves these, so the "no divergence on the
+/// dynamic forms" claim in that doc depends on tsv preserving them too; there is no
+/// fixture to pin it with, because acorn rejects the syntax outright.
+#[test]
+fn dynamic_import_phase_dot_gap_comments_stable() {
+    assert_ours_stable("<script lang=\"ts\">\n\timport /* c */.source('x');\n</script>\n");
+    assert_ours_stable("<script lang=\"ts\">\n\timport./* c */ source('x');\n</script>\n");
+    assert_ours_stable("<script lang=\"ts\">\n\timport /* c */.defer('x');\n</script>\n");
+    assert_ours_stable("<script lang=\"ts\">\n\timport./* c */ defer('x');\n</script>\n");
+}