@@ -436,6 +436,7 @@ BENCH_FILTER=zzz BENCH_LIMIT=10 deno task bench:deno:run
 - swc — parse-only TS/JS on both surfaces (its own AST dialect, so oxc-class payload disclosure; `decorators` must be enabled explicitly; goal axis `isModule`)
 - postcss — parse-only CSS (the parser behind prettier's CSS printer; the only kind available, since no Rust CSS parser exposes an AST to JS)
 - rsvelte's Svelte **parser** via its N-API addon — two `parse/svelte` rows: plain (mechanism-matched to tsv's default parse row; payload Svelte's own sparse-`loc` wire) and `skipExpressionLoc` (named for its option, since that reduction is not tsv's); the first third-party engine on that surface
+- markup_fmt (`markup-fmt-wasm`, Svelte only) — dprint's Svelte plugin, composed with the dprint and malva plugins for the embedded script, style and expressions; a **coverage-only** row, since it rejects valid real Svelte and a timed row would remove those files from every row's timed set. See ./docs/benchmarks.md §Coverage-only rows.
 - `rsvelte-fmt` (Svelte only) — a **coverage-only** row (accept rate, no timing: no in-process API, and a per-file subprocess row would rank process spawn, not format work); its end-to-end CLI numbers live in the separate hyperfine comparison on tsv.fuz.dev. See ./docs/benchmarks.md §Coverage-only rows.
 
 Results: `benches/js/results/report.<runtime>.{json,md}` (committed; every row carries a `runtime` field) + the combined `report.{json,md}`. Publish to tsv.fuz.dev: `npm run update-benchmarks` in ../tsv.fuz.dev. See ./benches/js/CLAUDE.md.
 
@@ -1103,7 +1103,7 @@ detector, not the raw cv). ⚠ A longer `BENCH_DURATION` is NOT the answer to an
 drifting row's mean keeps moving with n, and at most sample counts the cleaner erases the
 disclosure entirely — re-run the runtime, and read the raw fields.
 
-**Null timing is not exclusive to a coverage-only report:** a coverage-only ROW (`rsvelte-fmt`)
+**Null timing is not exclusive to a coverage-only report:** a coverage-only ROW (`rsvelte-fmt`, `markup-fmt-wasm`)
 carries null stats inside an otherwise fully-timed perf report, identifiable by
 `files_iterated: null` — timed on nothing, rather than on the group's intersection. A consumer
 reading `entries[]` as speeds must skip a row with null `ops_per_second`, not treat it as a zero.
@@ -1209,7 +1209,11 @@ not drift — each surface registers its own subset):
   there (`rows_missing_from_payload_tiers`).
 
 All three WARN rather than throw: an absent row understates a table, where a stale
-`SURFACE_DISCLOSURES` sentence asserts something false.
+`SURFACE_DISCLOSURES` sentence asserts something false. One registry check at the same site
+THROWS: a coverage-only row with no `COVERAGE_ONLY_REASONS` entry
+(`coverage_only_rows_missing_reason`) — the report would otherwise publish an untimed name it
+cannot explain, and failing at pre-flight costs nothing where failing at report time would throw
+away a finished run.
 
 A **fourth** row list in the same module is deliberately unchecked: the curated payload-matched
 lines in `generate_summary_report` (`tsv` vs `oxc-parser`, and the rest). Its
@@ -1587,7 +1591,7 @@ benches/js/
     ├── format_config_probe.ts # Behavioral "did the pinned layout config LAND" check —
     │                      # one probe source + grading arm PER LANGUAGE, shared by prettier
     │                      # (the baseline) and every format impl (biome, oxfmt, dprint,
-    │                      # malva); unit-tested by format_config_probe_test.ts
+    │                      # malva, markup_fmt); unit-tested by format_config_probe_test.ts
     ├── gate_counts.ts     # Pinned gate counts — see ../../docs/gate_counts.md
     ├── harvest_stamp.ts   # Harvest freshness stamps (checkout ids + pins + view entry lists) + the HARVEST_STAMPS table
     ├── implementations.ts # Implementation registry (branches native FFI vs N-API by runtime)
@@ -1616,6 +1620,8 @@ benches/js/
     │                      # a binding still emitting `loc` can't be timed as the span-only
     │                      # default; unit-tested by locations_probe_test.ts
     ├── malva.ts           # malva WASM wrapper (CSS only; dprint's CSS plugin, shared formatter host)
+    ├── markup.ts          # markup_fmt WASM wrapper (Svelte only; dprint's Svelte plugin composed with
+    │                      # the dprint + malva plugins in one host context; COVERAGE-ONLY, never timed)
     ├── napi.ts            # process.dlopen bindings (NapiImplementation — Node/Bun native)
     ├── oxc.ts             # OXC native wrappers (oxc-parser + oxfmt)
     ├── oxc_wasm.ts        # OXC WASM wrapper (oxc-parser via wasm32-wasi; per-runtime entry)
 
@@ -89,6 +89,7 @@ import {
 } from './lib/perf_omit.ts';
 import {
 	type CoverageBySource,
+	coverage_only_rows_missing_reason,
 	rows_missing_from_comparisons,
 	rows_missing_from_display_order,
 	rows_missing_from_payload_tiers,
@@ -442,6 +443,22 @@ if (untiered_rows.length > 0) {
 	);
 }
 
+// Each coverage-only row's published reason (`report.ts` `COVERAGE_ONLY_REASONS`),
+// asked of every operation's cells. FATAL, unlike the three warnings above: the
+// report refuses an unexplained untimed name, and asking here fails the run before
+// anything is timed instead of after.
+const unexplained_rows = coverage_only_rows_missing_reason(
+	OPERATIONS.flatMap((operation) => get_defined_cells(impls, operation, TASK_OPTIONS))
+);
+if (unexplained_rows.length > 0) {
+	throw new Error(
+		`${unexplained_rows.join(', ')} — coverage-only with no entry in report.ts ` +
+			`COVERAGE_ONLY_REASONS, so the report could not say why ${
+				unexplained_rows.length === 1 ? 'it is' : 'they are'
+			} not timed`
+	);
+}
+
 //
 // Pre-flight state
 //
 
@@ -70,6 +70,7 @@ const LABELS = {
 	yuku_parser_napi: 'yuku-parser (napi)',
 	yuku_parser_wasm: 'yuku-parser (wasm)',
 	malva_wasm: 'malva (wasm)',
+	markup_wasm: 'markup_fmt (wasm)',
 	rsvelte_fmt_native: 'rsvelte-fmt (binary)',
 	rsvelte_parse_napi: 'rsvelte compiler (napi)',
 	swc_napi: 'swc (napi)'
@@ -392,6 +393,19 @@ export async function collect_binary_sizes(
 		);
 	}
 
+	// markup_fmt — dprint's Svelte (markup) plugin wasm, alone. Its row formats a
+	// component with the dprint and malva plugins beside it (each sized above), so
+	// formatting Svelte this way loads all three; this row is the markup layer.
+	if (impls.markup) {
+		await push_resolved(
+			staged,
+			LABELS.markup_wasm,
+			'wasm',
+			[`${node_modules}/dprint-plugin-markup`],
+			'.wasm'
+		);
+	}
+
 	// rsvelte's N-API addon — the artifact behind the `rsvelte-parse` rows, and like
 	// `rsvelte-fmt (binary)` NOT scope-matched to a tsv build: it carries the whole
 	// compiler plus `svelte2tsx`, HMR diffing and a resolver, where the rows measure
 
@@ -22,7 +22,8 @@
  * `ts,tsx,js,jsx,mjs,cjs,mts,cts` and rejects CSS/Svelte outright (verified), so
  * unlike `oxfmt`/`biome` this contributes no css or svelte row. dprint's CSS plugin
  * is a separate Wasm plugin with a row of its own over this same formatter host —
- * see `lib/malva.ts`; its HTML plugin stays unwired, since it does not format Svelte.
+ * see `lib/malva.ts` — and its markup plugin backs the Svelte row, composed with this
+ * plugin and malva — see `lib/markup.ts`.
  */
 
 import { readFile } from 'node:fs/promises';
@@ -35,6 +36,28 @@ import type { DprintVersions } from './versions.ts';
 // `init()` (see there) so a load-time crash can't escape the registry's skip.
 import type { Formatter } from '@dprint/formatter';
 
+/**
+ * dprint's GLOBAL config, shared by every dprint-hosted row (`dprint-wasm`,
+ * `malva-wasm`, `markup-fmt-wasm`): the prettier/tsv layout targets — width 100,
+ * tabs — so every format row does the same layout work. At dprint's defaults the
+ * rows would wrap different amounts of code and the ratios would conflate config
+ * with engine speed. See docs/benchmarks.md §Fairness caveats.
+ */
+export const DPRINT_GLOBAL_CONFIG = { lineWidth: 100, indentWidth: 2, useTabs: true } as const;
+
+/**
+ * `@dprint/typescript`'s plugin config — shared with `lib/markup.ts`, whose Svelte
+ * row formats each embedded `<script>` and template expression through this same
+ * plugin. `trailingCommas` fans out to the 12 per-construct keys
+ * (`arguments.trailingCommas`, `arrayExpression.…`, …). `preferSingle` (not
+ * `alwaysSingle`) is the faithful analogue of prettier's `singleQuote: true`,
+ * which still switches quotes to avoid escaping.
+ */
+export const DPRINT_TYPESCRIPT_CONFIG = {
+	quoteStyle: 'preferSingle',
+	trailingCommas: 'never'
+} as const;
+
 /**
  * dprint implementation using the `dprint-plugin-typescript` Wasm plugin.
  *
@@ -65,19 +88,8 @@ export class DprintImplementation extends BaseImplementation {
 		const { createFromBuffer } = await import('@dprint/formatter');
 		this._formatter = createFromBuffer(await readFile(getPath()));
 
-		// Match the prettier/tsv config — tabs, line width 100, single quotes, no
-		// trailing commas — so every format row does the same layout work (at
-		// dprint's defaults the rows wrap different amounts of code and the ratios
-		// conflate config with engine speed). See docs/benchmarks.md §Fairness caveats.
-		// `lineWidth`/`indentWidth`/`useTabs` are dprint GLOBAL config; the quote and
-		// trailing-comma keys are plugin config (`trailingCommas` fans out to the 12
-		// per-construct keys — `arguments.trailingCommas`, `arrayExpression.…`, …).
-		// `preferSingle` (not `alwaysSingle`) is the faithful analogue of prettier's
-		// `singleQuote: true`, which still switches quotes to avoid escaping.
-		this._formatter.setConfig(
-			{ lineWidth: 100, indentWidth: 2, useTabs: true },
-			{ quoteStyle: 'preferSingle', trailingCommas: 'never' }
-		);
+		// the pinned layout targets — see `DPRINT_GLOBAL_CONFIG` / `DPRINT_TYPESCRIPT_CONFIG`
+		this._formatter.setConfig(DPRINT_GLOBAL_CONFIG, DPRINT_TYPESCRIPT_CONFIG);
 
 		// Assert the config actually LANDED. dprint reports an unrecognized key as
 		// a diagnostic rather than throwing (verified: a bogus key yields
 
@@ -1,15 +1,15 @@
 /**
  * The shared "did the pinned layout config actually LAND" probe, run by every
- * formatter wrapper: the prettier baseline, biome, oxfmt, dprint and malva.
+ * formatter wrapper: the prettier baseline, biome, oxfmt, dprint, malva and markup_fmt.
  *
  * Every formatter here is pinned to tsv's layout targets — width 100, tabs, single
  * quotes, no trailing commas — so each row wraps and rewrites the same amount of
  * code and a ratio measures the engine rather than the config (see
  * docs/benchmarks.md §Fairness caveats). Two of the four timed format opponents
  * have a channel that says so when a key stops being recognized, and two do not:
  * `lib/dprint.ts` and `lib/malva.ts` fail init on a non-empty
- * `getConfigDiagnostics()`, while biome's `applyConfiguration` and oxfmt's
- * per-call options bag each accept an unknown key SILENTLY and fall back to their
+ * `getConfigDiagnostics()` (as does the coverage-only `lib/markup.ts`), while
+ * biome's `applyConfiguration` and oxfmt's per-call options bag each accept an unknown key SILENTLY and fall back to their
  * own defaults — measured: biome drops to width 80 + double quotes + trailing
  * commas, oxfmt to spaces + double quotes + trailing commas. A renamed key there
  * would leave the row wrapping a different amount of code with nothing anywhere in
 
@@ -33,6 +33,7 @@ import { YukuImplementation } from './yuku.ts';
 import { BiomeImplementation } from './biome.ts';
 import { DprintImplementation } from './dprint.ts';
 import { MalvaImplementation } from './malva.ts';
+import { MarkupImplementation } from './markup.ts';
 import { PostcssImplementation } from './postcss.ts';
 import { RsvelteImplementation } from './rsvelte.ts';
 import { RsvelteParseImplementation } from './rsvelte_parse.ts';
@@ -126,6 +127,12 @@ export interface ImplementationSet {
 	dprint: DprintImplementation | undefined;
 	/** malva (via WASM; dprint's CSS plugin) - format only; undefined if not available */
 	malva: MalvaImplementation | undefined;
+	/**
+	 * markup_fmt (via WASM; dprint's Svelte plugin, composed with dprint's TS and CSS
+	 * plugins) - format only, Svelte; undefined if not available. Coverage-only: it
+	 * rejects valid real Svelte, so it is never timed (see `get_benchmark_tasks`).
+	 */
+	markup: MarkupImplementation | undefined;
 	/** postcss - parse only, CSS; undefined if not available */
 	postcss: PostcssImplementation | undefined;
 	/**
@@ -195,16 +202,17 @@ export interface InitOptions {
 }
 
 // Deliberately NOT surface-scoped: every impl initializes on every run, including
-// the format-only ones (biome, dprint, malva, rsvelte-fmt) on the parse-only
-// conformance surface, where they back no row. Gating init on `OPERATIONS` is the
-// obvious saving and it isn't worth taking — measured, the four cost ~233 ms total
-// (biome 187, dprint 23, malva 9, rsvelte-fmt 14) against a multi-minute run, and
-// two disclosures read the LIVE set rather than `complete`: `collect_binary_sizes`
-// gates each artifact on `impls.<key>`, so a skipped impl silently drops its row
-// from the published BINARY SIZES table (a catalog of what is on disk, which the
-// surface's operation list has no business thinning), and `get_alternative_versions`
-// feeds the report's `Versions:` line from the same set. The cost of the saving is a
-// thinner published report; the cost of not taking it is a fifth of a second.
+// the format-only ones (biome, dprint, malva, markup_fmt, rsvelte-fmt) on the
+// parse-only conformance surface, where they back no row. Gating init on
+// `OPERATIONS` is the obvious saving and it isn't worth taking — measured, the five
+// cost under 300 ms total (biome 187, markup_fmt ~50, dprint 23, rsvelte-fmt 14,
+// malva 9) against a multi-minute run, and two disclosures read the LIVE set rather
+// than `complete`: `collect_binary_sizes` gates each artifact on `impls.<key>`, so
+// a skipped impl silently drops its row from the published BINARY SIZES table (a
+// catalog of what is on disk, which the surface's operation list has no business
+// thinning), and `get_alternative_versions` feeds the report's `Versions:` line
+// from the same set. The cost of the saving is a
+// thinner published report; the cost of not taking it is under a third of a second.
 
 /**
  * Initialize one REQUIRED implementation, rethrowing when it can't load.
@@ -364,6 +372,7 @@ export async function init_implementations(
 		biome,
 		dprint,
 		malva,
+		markup,
 		rsvelte,
 		rsvelte_parse,
 		swc,
@@ -383,6 +392,12 @@ export async function init_implementations(
 	const biome_impl = await optional(biome, 'biome', 'Biome (WASM)', 'Biome');
 	const dprint_impl = await optional(dprint, 'dprint', 'dprint (WASM)', 'dprint');
 	const malva_impl = await optional(malva, 'malva', 'malva (WASM, CSS)', 'malva');
+	const markup_impl = await optional(
+		markup,
+		'markup',
+		'markup_fmt (WASM, Svelte, coverage-only)',
+		'markup_fmt'
+	);
 	const rsvelte_impl = await optional(
 		rsvelte,
 		'rsvelte',
@@ -428,6 +443,7 @@ export async function init_implementations(
 		biome: biome_impl,
 		dprint: dprint_impl,
 		malva: malva_impl,
+		markup: markup_impl,
 		postcss: postcss_impl,
 		rsvelte: rsvelte_impl,
 		rsvelte_parse: rsvelte_parse_impl,
@@ -462,6 +478,7 @@ function construct_implementations(versions: AllVersions): ConstructedImplementa
 		biome: new BiomeImplementation(versions.biome),
 		dprint: new DprintImplementation(versions.dprint),
 		malva: new MalvaImplementation(versions.malva),
+		markup: new MarkupImplementation(versions.markup),
 		postcss: new PostcssImplementation(versions.postcss),
 		rsvelte: new RsvelteImplementation(versions.rsvelte),
 		// A different package from rsvelte-fmt above — the N-API addon, which unlike
@@ -547,9 +564,13 @@ export interface BenchmarkTask {
 	/** Whether this benchmark runs async */
 	is_async: boolean;
 	/**
-	 * Measure this impl's pre-flight coverage but never TIME it. Set for an impl
-	 * with no in-process API, where a timed row would be dominated by process
-	 * spawn rather than format work (`rsvelte-fmt` — see `lib/rsvelte.ts`).
+	 * Measure this impl's pre-flight coverage but never TIME it. Set where a timed
+	 * row would mislead: an impl with no in-process API, whose timed row would be
+	 * dominated by process spawn rather than format work (`rsvelte-fmt` — see
+	 * `lib/rsvelte.ts`), and an impl that rejects valid real code, whose timed row
+	 * would remove every file it rejects from every row's timed set
+	 * (`markup-fmt-wasm` — see `lib/markup.ts`). Each one's reason is published
+	 * beside its accept rate (`report.ts` `COVERAGE_ONLY_REASONS`).
 	 *
 	 * The bench honors this in four places, and all four are load-bearing: the
 	 * pre-flight (`bench_preflight.ts`) plans no timed row for the task, keeps it
@@ -877,7 +898,8 @@ export function get_benchmark_tasks(
 		// No native peer exists to add here: none of the Rust CSS tools considered
 		// exposes a parse call to JS (lightningcss hands a tree to its `visitor` only
 		// mid-transform, biome's js-api exposes no parse, malva is a formatter, oxc has
-		// no CSS parse binding). See lib/postcss.ts.
+		// no CSS parse binding, `@swc/css` exposes only minify/transform). See
+		// lib/postcss.ts.
 		add(
 			'postcss',
 			impls.postcss?.supports_parse_language(language),
@@ -949,6 +971,24 @@ export function get_benchmark_tasks(
 			impls.malva!.format(source, language)
 		);
 
+		// markup_fmt (Svelte only) — dprint's Svelte plugin, composed with the
+		// dprint and malva plugins for the embedded code (see lib/markup.ts) —
+		// COVERAGE-ONLY. It rejects valid Svelte the real corpus holds (markup inside
+		// a template literal in an attribute expression, `{…}` inside a quoted
+		// `style`), a large share of the perf corpus's Svelte bytes. A timed row would
+		// need a `PERF_OMITS` entry per file, and each would leave EVERY row's timed
+		// set, so adding it would reshape every published Svelte number. Measured for
+		// what it accepts instead; time it once upstream accepts the corpus. See
+		// docs/benchmarks.md §Coverage-only rows.
+		add(
+			'markup',
+			impls.markup?.supports_format_language(language),
+			'markup-fmt-wasm',
+			'markup',
+			(source) => impls.markup!.format(source, language),
+			{ coverage_only: true }
+		);
+
 		// rsvelte-fmt (Svelte only) — COVERAGE-ONLY. It ships no in-process format
 		// API in any package (the sibling N-API addon is the compiler), so this task
 		// spawns a process per file: measured on ~5 KB of Svelte the spawn floor
@@ -1012,6 +1052,8 @@ export function get_defined_rows(
 /** One cell this surface defines: a row in one language. */
 export interface DefinedCell extends DefinedRow {
 	language: Language;
+	/** `BenchmarkTask.coverage_only` — measured for coverage, never timed. */
+	coverage_only: boolean;
 }
 
 /**
@@ -1028,7 +1070,8 @@ export function get_defined_cells(
 		get_benchmark_tasks(impls.complete, operation, language, options).map((task) => ({
 			name: task.name,
 			impl: task.impl,
-			language
+			language,
+			coverage_only: task.coverage_only === true
 		}))
 	);
 }
@@ -1085,6 +1128,8 @@ export function get_alternative_versions(
 		dprint: impls.dprint?.versions.typescript,
 		// Same reasoning as dprint: the CSS plugin, not the shared host.
 		malva: impls.malva?.versions.malva,
+		// The markup plugin; its embedded TS and CSS are the dprint and malva versions above.
+		markup: impls.markup?.versions.markup,
 		postcss: impls.postcss?.versions.postcss,
 		rsvelte_fmt: impls.rsvelte?.versions.fmt,
 		// Two facts, both reported: the addon's own version, and the upstream Svelte