diff --git a/CLAUDE.md b/CLAUDE.md
index 90e1790..80634c1 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -409,6 +409,7 @@ If the fix is bounded (one inline construct, one or two lines of lookahead), it'
   The operator **requires** the DISPLAY annotation to be accurate (captured dumps); it is suppressed inside `<pre>`/`<code>`/`<textarea>`.
 - `simplifyHtml` drops **technical-noise `<meta name>`** values from the frontmatter via a denylist (`isNoiseMetaName` in `SimplifyHtml.kt`: `viewport`, `generator`, `theme-color`, `robots`, `msapplication-*`, `apple-*`, `*-verification`, …).
   A denylist (not an allowlist) is deliberate so unknown-but-useful names (`og:*`, `article:*`, custom) survive; extend the denylist as new noise names appear.
+  Value-shaped noise (single-page-app state, issue #82) belongs in `isApplicationStateMeta`, not in the name list.
   `renderDumpMarkdown` (Gradle task, `RenderDumpMarkdown.kt` in jvmTest) runs the full `transformHtmlToMarkdown` pipeline over every dump to `build/renderedMarkdown/<name>.md` — the canonical way to regenerate the per-dump golden strings (`dumps/OpenjurTest`, `dumps/HackerNewsTest`) after a pipeline change.
 - A `Regex` used with `matches()` in `commonMain` must be **explicitly anchored** (`^(?:a|b)$`) when it contains a top-level alternation: Kotlin/JS resolves `matches` through the leftmost `find`, so the first branch wins on a *prefix* and the whole-input check fails (`0x1F` matched `[-+]?[0-9]+|0x[0-9a-fA-F]+` as `0`; a full timestamp matched the date-only branch) — JVM backtracks across the branches and never shows it.
   The YAML scalar typing in `markanywhere-yaml` hit exactly this: green on `jvmTest`, red on `jsBrowserTest`. Dev builds run the JS tests for `yaml`/`parse`/`render`/`html`, so a JVM-only test run is not enough evidence for a regex change.
@@ -416,6 +417,8 @@ If the fix is bounded (one inline construct, one or two lines of lookahead), it'
   Repeat a character class instead (`[0-9_]*`) and check what the group expressed by hand (`YamlScalarType.kt`).
 - Facts of the HTML standard needed by more than one of `parse` / `render` / `html` — HTML whitespace (`isHtmlWhitespace` / `isHtmlBlank`), void and raw text elements, `Mark.classList` — live in the leaf module `markanywhere-html-spec` (depends only on `api`), never in `markanywhere-api` (which describes only the event model) and never as private copies.
   Only spec facts go there, not project policy (e.g. which tags render as blocks in Markdown); the parser's `isFlankWhitespace` is deliberately a different set (CommonMark "Unicode whitespace", which includes NBSP).
+- kotlinx `Json.parseToJsonElement` accepts a **bare word as a value** even with `isLenient = false` (`[[Wiki]]`, `{"a": tru}` parse; only keys must be quoted), so "it parses as JSON" is not evidence that a value is serialised data.
+  `ApplicationStateMeta.kt` checks the parsed tree with `isStrictJson` before judging a `<meta>` value as state — otherwise bracketed prose like `[foo, [bar]]` was dropped as a nested array.
 - `MutableMap.putIfAbsent` is **JVM-only** — not in the common stdlib, so it can't be used in `commonMain`.
   For first-wins ("put only if key absent") semantics across all KMP targets, prefer **`getOrPutIfMissing(key) { value }`** (Kotlin 2.4, `@ExperimentalStdlibApi`): it computes & stores the default *only when the key is genuinely absent*.
   Do NOT reach for plain `getOrPut` as the `putIfAbsent` replacement — it (and its explicit alias `getOrPutIfNull`) also recompute when the stored value is **null**, conflating "missing" with "null" (the footgun [KEEP-0457](https://github.com/Kotlin/KEEP/blob/main/proposals/stdlib/KEEP-0457-alternative-behavior-for-map-getOrElse.md) fixes).
@@ -557,9 +560,11 @@ If the fix is bounded (one inline construct, one or two lines of lookahead), it'
   Key typing is not value typing: go-yaml v2 decodes a **top-level** front matter key into a string but a nested one as `interface{}`, so `y:` must stay plain at the top level (it was once rewritten to `"y":`) and be quoted below it (`isTypedPlainKey`).
   The writer's plain-key rule (`isIdentifierKey`) and the detector share their character rules in `YamlKeyLine.kt`, and `YamlWriterTest` "should write every key as a line the front matter detector accepts" pins the two — widen one without the other and every document whose *first* entry has such a key silently loses its front matter on re-parse.
   **DIVERGENCE (no round-trip)**: a `frontmatter` whose root is a **sequence** (top-level `item`s) renders as `---\n- a\n…`, which line 2 rejects — Markdown reads `---` + `- a` as a thematic break + list, and no front matter consumer (Jekyll, Hugo, `wrapInHtmlDocument`) accepts a non-mapping — so the shape is pinned as such in `FrontMatterRoundTripTest` rather than widened into detection.
-- `wrapInHtmlDocument` and `ensureFrontmatterTitle` read the front matter by **depth** (a direct child `entry` is depth 1 / 2 respectively, counted from the `frontmatter` mark): only top-level scalar entries become `<meta>`/`<title>`, only a top-level `entry key=title` counts as an existing title.
-  Neither contains any YAML parsing — that was the ~300-line `Frontmatter.kt` codec this representation replaced; do not reintroduce a text-level reader.
-  The two must agree on what a *usable* title is, because `wrapInHtmlDocument` skips a `type=null` entry and emits an empty `<title>` for a blank one: `ensureFrontmatterTitle` therefore treats a top-level `title` with blank text or `type=null` (a bare `title:` line) as missing and **replaces it in place** with the derived one (a `title` holding nested marks is left alone — replacing it would lose content), and it holds any blank text seen *before* the first `h1` so a synthesized `frontmatter` is the **first** event, the only position `wrapInHtmlDocument` reads it from.
+- `wrapInHtmlDocument` and `ensureFrontmatterTitle` read the front matter through **one** reader, `FrontMatterEntryReader`, and must agree on which title entry is read and what a usable one is — hand-rolled copies of the reader in each operator drifted apart once and let a leading `title:` hide a later `Title: Real`, so the derived `h1` title displaced a real one.
+  Do not reintroduce a text-level YAML reader (the ~300-line `Frontmatter.kt` this replaced) or a private copy of the entry reader.
+  Duplicate keys deliberately resolve differently per direction (`simplifyHtml` first `<meta>` wins as in HTML, `wrapInHtmlDocument` later entry wins as in Psych/PyYAML): each side emits one entry per name, so neither sees the other's duplicates — "aligning" them once made `wrapInHtmlDocument` show a title no front matter reader shows.
+  `ensureFrontmatterTitle` never leaves duplicate title entries rather than reordering them for later-wins readers, because js-yaml (gray-matter: Eleventy, Astro, Gatsby) rejects a duplicate key and loses the whole front matter.
+  The one exception is a nested title entry (localized titles): it is content, so a usable variant beside it is kept as found rather than collapsing the two into one.
 
 ## Test conventions
 
diff --git a/README.md b/README.md
index 68148bd..402de9c 100644
--- a/README.md
+++ b/README.md
@@ -85,7 +85,10 @@ Will print:
 
 ### Wrapping parsed Markdown in a complete HTML document
 
-`wrapInHtmlDocument()` (in `markanywhere-html`) wraps the event stream in an `html`/`head`/`body` structure, populating the `head` from a leading front matter block: `title` becomes `<title>`, `lang` becomes the `<html lang>` attribute, and every other flat key becomes a `<meta name content>` — the exact inverse of `simplifyHtml`'s `<head>`-to-front-matter extraction, so the two round-trip.
+`wrapInHtmlDocument()` (in `markanywhere-html`) wraps the event stream in an `html`/`head`/`body` structure, populating the `head` from a leading front matter block: `title` becomes `<title>`, `lang` becomes the `<html lang>` attribute, and every other flat key becomes a `<meta name content>` — the inverse of `simplifyHtml`'s `<head>`-to-front-matter extraction.
+Keys are read ASCII case-insensitively, as HTML reads `<meta>` names: a `Title` key is the title.
+Of duplicate keys the later non-blank one wins, as front matter readers (Jekyll, PyYAML) resolve them, except that the lowercase spelling beats a variant in another letter case — `simplifyHtml` instead keeps the first of duplicate `<meta>` names, as HTML does.
+The two round-trip up to what they normalise or discard as carrying nothing for a reader: blank, nested and null values, technical noise names (`viewport`, `robots`, …), and application state (a JSON object, an opaque over-long blob) are dropped, case-variant keys are merged, `title` and `lang` come back spelled in lowercase, the title's whitespace is collapsed as `document.title` reads it, and a typed scalar comes back as a string.
 
 ```kotlin
 val document = """
diff --git a/markanywhere-html-spec/README.md b/markanywhere-html-spec/README.md
index 36075d2..7c4d66a 100644
--- a/markanywhere-html-spec/README.md
+++ b/markanywhere-html-spec/README.md
@@ -11,6 +11,8 @@ so code that reads a semantic event stream carrying HTML attributes can use it w
 |---------------------------------------------------|------------------------------------------------------------------------------------------------|
 | `HTML_WHITESPACE_CHARS`, `Char.isHtmlWhitespace()` | HTML "ASCII whitespace": TAB, LF, FF, CR, SPACE — not NBSP, which HTML treats as content      |
 | `String.isHtmlBlank()`                            | Empty or HTML whitespace only                                                                  |
+| `String.stripAndCollapseHtmlWhitespace()`         | Trimmed of HTML whitespace, inner runs collapsed to one space, as `document.title` reads it     |
+| `Char.asciiLowercase()`, `String.asciiLowercase()` | ASCII lowercase: only `A`–`Z` fold, as HTML compares names "ASCII case-insensitively"          |
 | `HTML_VOID_ELEMENTS`                              | Elements with no content and no closing tag, including the obsolete `keygen` and `param`       |
 | `HTML_RAW_TEXT_ELEMENTS`                          | `script` and `style`, whose content is neither escaped nor parsed as markup                    |
 | `SemanticEvent.Mark.classList`                    | The distinct class names of a mark's `class` attribute, like the DOM's `classList`             |
diff --git a/markanywhere-html-spec/api/markanywhere-html-spec.api b/markanywhere-html-spec/api/markanywhere-html-spec.api
index b778a16..9cb4fbe 100644
--- a/markanywhere-html-spec/api/markanywhere-html-spec.api
+++ b/markanywhere-html-spec/api/markanywhere-html-spec.api
@@ -1,3 +1,8 @@
+public final class com/xemantic/markanywhere/html/spec/AsciiCaseKt {
+	public static final fun asciiLowercase (C)C
+	public static final fun asciiLowercase (Ljava/lang/String;)Ljava/lang/String;
+}
+
 public final class com/xemantic/markanywhere/html/spec/HtmlElementsKt {
 	public static final fun getHTML_RAW_TEXT_ELEMENTS ()Ljava/util/Set;
 	public static final fun getHTML_VOID_ELEMENTS ()Ljava/util/Set;
@@ -6,6 +11,7 @@ public final class com/xemantic/markanywhere/html/spec/HtmlElementsKt {
 public final class com/xemantic/markanywhere/html/spec/HtmlWhitespaceKt {
 	public static final fun isHtmlBlank (Ljava/lang/String;)Z
 	public static final fun isHtmlWhitespace (C)Z
+	public static final fun stripAndCollapseHtmlWhitespace (Ljava/lang/String;)Ljava/lang/String;
 }
 
 public final class com/xemantic/markanywhere/html/spec/MarkClassListKt {
diff --git a/markanywhere-html-spec/src/commonMain/kotlin/AsciiCase.kt b/markanywhere-html-spec/src/commonMain/kotlin/AsciiCase.kt
new file mode 100644
index 0000000..c5757e1
--- /dev/null
+++ b/markanywhere-html-spec/src/commonMain/kotlin/AsciiCase.kt
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2026 Kazimierz Pogoda / Xemantic
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.xemantic.markanywhere.html.spec
+
+/**
+ * This character with an ASCII upper alpha (`A`–`Z`) replaced by its lowercase
+ * counterpart — the WHATWG Infra "ASCII lowercase", the folding HTML applies
+ * wherever it matches names "ASCII case-insensitively" (element names,
+ * `<meta name>`, URL schemes).
+ *
+ * Deliberately narrower than [Char.lowercaseChar]: every other character,
+ * including non-ASCII letters, is returned unchanged.
+ */
+public fun Char.asciiLowercase(): Char =
+    if (this in 'A'..'Z') this + ('a' - 'A') else this
+
+/**
+ * This string with every ASCII upper alpha replaced by its lowercase
+ * counterpart (see [Char.asciiLowercase]) — unlike [String.lowercase], which
+ * folds some non-ASCII letters into ASCII ones: `"\u212Aey".lowercase()`
+ * (a Kelvin sign `K`, U+212A) is `"key"`, while this leaves it unchanged, so
+ * it never matches a `key` name.
+ */
+public fun String.asciiLowercase(): String =
+    if (none { it in 'A'..'Z' }) this else CharArray(length) { this[it].asciiLowercase() }.concatToString()
diff --git a/markanywhere-html-spec/src/commonMain/kotlin/HtmlWhitespace.kt b/markanywhere-html-spec/src/commonMain/kotlin/HtmlWhitespace.kt
index b5b0a80..33a1b97 100644
--- a/markanywhere-html-spec/src/commonMain/kotlin/HtmlWhitespace.kt
+++ b/markanywhere-html-spec/src/commonMain/kotlin/HtmlWhitespace.kt
@@ -41,3 +41,22 @@ public fun Char.isHtmlWhitespace(): Boolean = this in HTML_WHITESPACE_CHARS
  * whitespace.
  */
 public fun String.isHtmlBlank(): Boolean = all { it.isHtmlWhitespace() }
+
+/**
+ * This string with leading and trailing [HTML whitespace][isHtmlWhitespace]
+ * removed and every inner run of it replaced by a single space — the WHATWG
+ * Infra "strip and collapse ASCII whitespace", the normalisation behind
+ * `document.title`. NBSP is content and stays.
+ */
+public fun String.stripAndCollapseHtmlWhitespace(): String = buildString(length) {
+    var pendingSpace = false
+    for (c in this@stripAndCollapseHtmlWhitespace) {
+        if (c.isHtmlWhitespace()) {
+            pendingSpace = isNotEmpty()
+        } else {
+            if (pendingSpace) append(' ')
+            pendingSpace = false
+            append(c)
+        }
+    }
+}
diff --git a/markanywhere-html-spec/src/commonTest/kotlin/AsciiCaseTest.kt b/markanywhere-html-spec/src/commonTest/kotlin/AsciiCaseTest.kt
new file mode 100644
index 0000000..de3098e
--- /dev/null
+++ b/markanywhere-html-spec/src/commonTest/kotlin/AsciiCaseTest.kt
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2026 Kazimierz Pogoda / Xemantic
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+package com.xemantic.markanywhere.html.spec
+
+import com.xemantic.kotlin.test.assert
+import com.xemantic.kotlin.test.sameAs
+import kotlin.test.Test
+
+class AsciiCaseTest {
+
+    @Test
+    fun `should lowercase ASCII upper alphas only`() {
+        // when
+        val lowered = "Og:TITLE-1_x".asciiLowercase()
+
+        // then
+        lowered sameAs "og:title-1_x"
+    }
+
+    @Test
+    fun `should leave non-ASCII letters unchanged`() {
+        // when — Unicode case folding would map these
+        val dotless = "TıTLE".asciiLowercase()
+        val umlaut = "ÄRGER".asciiLowercase()
+        val kelvin = 'K'.asciiLowercase()
+
+        // then
+        dotless sameAs "tıtle"
+        umlaut sameAs "Ärger"
+        assert(kelvin == 'K')
+    }
+
+    @Test
+    fun `should not fold a Kelvin sign into an ASCII k as lowercase does`() {
+        // given
+        val kelvinKey = "\u212Aey"
+
+        // when
+        val lowered = kelvinKey.asciiLowercase()
+
+        // then
+        kelvinKey.lowercase() sameAs "key"
+        lowered sameAs kelvinKey
+    }
+}
diff --git a/markanywhere-html-spec/src/commonTest/kotlin/HtmlWhitespaceTest.kt b/markanywhere-html-spec/src/commonTest/kotlin/HtmlWhitespaceTest.kt
index f50bf3a..06d0f4e 100644
--- a/markanywhere-html-spec/src/commonTest/kotlin/HtmlWhitespaceTest.kt
+++ b/markanywhere-html-spec/src/commonTest/kotlin/HtmlWhitespaceTest.kt
@@ -17,6 +17,7 @@
 package com.xemantic.markanywhere.html.spec
 
 import com.xemantic.kotlin.test.assert
+import com.xemantic.kotlin.test.sameAs
 import kotlin.test.Test
 
 class HtmlWhitespaceTest {
@@ -70,4 +71,31 @@ class HtmlWhitespaceTest {
         assert(!"text".isHtmlBlank())
     }
 
-}
\ No newline at end of file
+    @Test
+    fun `should strip and collapse HTML whitespace`() {
+        // when
+        val result = "\n  Foo\t\r\n  Bar \u000C".stripAndCollapseHtmlWhitespace()
+
+        // then
+        result sameAs "Foo Bar"
+    }
+
+    @Test
+    fun `should keep NBSP when stripping and collapsing HTML whitespace`() {
+        // when
+        val result = "\u00A0 a  \u00A0b ".stripAndCollapseHtmlWhitespace()
+
+        // then
+        result sameAs "\u00A0 a \u00A0b"
+    }
+
+    @Test
+    fun `should strip and collapse a blank string to empty`() {
+        // when
+        val result = " \t\n".stripAndCollapseHtmlWhitespace()
+
+        // then
+        result sameAs ""
+    }
+
+}
diff --git a/markanywhere-html/build.gradle.kts b/markanywhere-html/build.gradle.kts
index e59d11d..ac41366 100644
--- a/markanywhere-html/build.gradle.kts
+++ b/markanywhere-html/build.gradle.kts
@@ -41,7 +41,9 @@ kotlin {
                 api(project(":markanywhere-transform"))
                 implementation(project(":markanywhere-dump"))
                 implementation(project(":markanywhere-html-spec"))
+                implementation(project(":markanywhere-yaml"))
                 api(libs.kotlinx.coroutines.core)
+                implementation(libs.kotlinx.serialization.json)
                 implementation(libs.xemantic.kotlin.core)
             }
         }
diff --git a/markanywhere-html/src/commonMain/kotlin/ApplicationStateMeta.kt b/markanywhere-html/src/commonMain/kotlin/ApplicationStateMeta.kt
new file mode 100644
index 0000000..53313e6
--- /dev/null
+++ b/markanywhere-html/src/commonMain/kotlin/ApplicationStateMeta.kt
@@ -0,0 +1,315 @@
+/*
+ * Copyright 2026 Kazimierz Pogoda / Xemantic
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.xemantic.markanywhere.html
+
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonNull
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.jsonPrimitive
+
+// Single-page apps use `<meta>` as a transport for application state
+// (LinkedIn: `__init`, `spark/hash-includes`, Ember's percent-encoded
+// `<app>/config/environment`, … — 95% of a page's Markdown, issue #82). A
+// name denylist cannot keep up with names private to each site's framework,
+// so this judges the *value*, which is what tells metadata apart from state.
+// A percent-encoded value's structure is judged by what it decodes to — undoing
+// the encoding as many times over as it was applied, and inside a JSON string
+// too — so encoding state does not hide it, nor do invisible chars (a byte
+// order mark, NBSP) at its edges or those of a JSON string within:
+// - a value that parses as a JSON object. Parsing, not a look at the first
+//   and last char, is what keeps human text that merely starts with a
+//   bracket (`[Solved] …`, `{Draft} …`, `[2024] Annual report [PDF]`) —
+//   parsing as strict JSON, since the parser takes a bare word for a value
+//   and would read `[[Wiki]]` as a nested array;
+// - a JSON array holding an object or a nested array. A flat list of
+//   scalars — an empty one included — is metadata a person writes
+//   (`keywords`, `article:tag`, `citation_volume`), whether a bare word in it
+//   reads as a string, a number, a flag or `null`;
+// - a JSON string whose content is itself state by these rules — state
+//   serialised twice, a common single-page-app double encoding — whether
+//   it stands alone or as an element of an array;
+// - a value longer than [MAX_META_VALUE_LENGTH] that does not read as text —
+//   the backstop for opaque blobs of any other shape (base64, hash lists,
+//   truncated JSON), which a long abstract in prose is not. It judges the
+//   value as it will be written, so a percent-encoded one by its escapes,
+//   never by what they decode to. A flat JSON array is measured by its
+//   elements joined, not the quotes and commas serialising them — its length
+//   as well as whether it reads as text — so it is judged as the same list
+//   written plainly would be: a long list of words is kept, a long list of
+//   hashes is not, and one whose elements fit under the cap is short.
+// Past [MAX_PARSED_LENGTH] nothing is decoded or parsed: a value is state
+// unless it reads as text, as written, and does not open like encoded state
+// (a JSON object, array or string, a percent escape) — no page writes
+// metadata that long, and a page-controlled value must not cost a tree many
+// times its size.
+internal fun isApplicationStateMeta(content: String): Boolean {
+    val written = content.trimInvisible()
+    return when {
+        written.length <= MAX_META_VALUE_LENGTH -> written.isStructuralState()
+        written.length <= MAX_PARSED_LENGTH -> when {
+            written.isFlatArray() -> written.isLongFlatArrayState()
+            // decoded and parsed only once it reads as text, so a blob is
+            // dropped unparsed
+            else -> !written.readsAsText() || written.isStructuralState()
+        }
+        // never parsed: opening like encoded state is state enough
+        else -> !written.readsAsText() || written.opensLikeEncodedState()
+    }
+}
+
+// Whether this value opens the way a value [isStructuralState] parses does:
+// like a JSON object, array or string, or with a percent escape.
+private fun String.opensLikeEncodedState(): Boolean = firstOrNull()?.let { it in "{[\"%" } == true
+
+// Real metadata is short: `description` / `og:description` rarely exceed 300
+// characters. Past this, a value must read as text to be kept.
+private const val MAX_META_VALUE_LENGTH = 4096
+
+// Past this, even a flat array is not parsed to be read by its words: its
+// tree would cost many times the value's size, for a list no page writes.
+private const val MAX_PARSED_LENGTH = 16 * MAX_META_VALUE_LENGTH
+
+// Whether this value, percent-decoded when it is encoded, parses as state.
+private fun String.isStructuralState(): Boolean {
+    val decoded = percentDecodedOrNull(MAX_DECODING_DEPTH)
+    val json = (decoded?.value ?: this).parseJsonCandidateOrNull() ?: return false
+    return json.isState(decoded?.layersLeft ?: MAX_DECODING_DEPTH)
+}
+
+// A raw array none of whose elements is an object or an array.
+private fun String.isFlatArray(): Boolean = firstOrNull() == '[' && !hasNestedElement()
+
+// An over-long flat array: state if it parses as state, a blob if it does not
+// parse and does not read as text, and otherwise judged by its elements
+// joined, as the same list written plainly would be.
+private fun String.isLongFlatArrayState(): Boolean {
+    val json = parseJsonOrNull() as? JsonArray ?: return !readsAsText()
+    if (json.isState(MAX_DECODING_DEPTH)) return true
+    val text = json.joinToString(" ") { it.jsonPrimitive.content }
+    return text.length > MAX_META_VALUE_LENGTH && !text.readsAsText()
+}
+
+// Whether this (raw, possibly malformed) array holds an object or an array
+// — a bracket past the opening one outside a JSON string — found by a scan,
+// without parsing.
+private fun String.hasNestedElement(): Boolean {
+    var inString = false
+    var escaped = false
+    for (i in 1 until length) {
+        val c = this[i]
+        when {
+            escaped -> escaped = false
+            inString -> when (c) {
+                '\\' -> escaped = true
+                '"' -> inString = false
+            }
+            c == '"' -> inString = true
+            c == '{' || c == '[' -> return true
+        }
+    }
+    return false
+}
+
+// How many layers of encoding — percent-encoding and JSON strings, one budget
+// for both — are undone, one within another, to find state. Real double
+// encodings take two or three; the bound keeps a crafted value from costing
+// a pass over itself per layer.
+private const val MAX_DECODING_DEPTH = 8
+
+// Only a value opening like a JSON object, array or string is parsed, and
+// only strict JSON counts ([isStrictJson]).
+private fun String.parseJsonCandidateOrNull(): JsonElement? {
+    val first = firstOrNull()
+    return if (first == '{' || first == '[' || first == '"') {
+        parseJsonOrNull()?.takeIf { it.isStrictJson() }
+    } else null
+}
+
+// Whether every scalar in this tree is a JSON value — a string, a number,
+// `true`, `false` or `null` — and not a bare word, which the parser accepts
+// even when not lenient (keys it does require quoted). Walked with a stack
+// of its own, as a crafted value nests deeper than the call stack reaches.
+private fun JsonElement.isStrictJson(): Boolean {
+    val pending = ArrayDeque<JsonElement>()
+    pending.addLast(this)
+    while (pending.isNotEmpty()) {
+        when (val element = pending.removeLast()) {
+            is JsonObject -> pending.addAll(element.values)
+            is JsonArray -> pending.addAll(element)
+            is JsonPrimitive -> if (!element.isString
+                && element.content != "true"
+                && element.content != "false"
+                && element !is JsonNull
+                && !JSON_NUMBER.matches(element.content)
+            ) return false
+        }
+    }
+    return true
+}
+
+private val JSON_NUMBER = Regex("^-?(?:0|[1-9][0-9]*)(?:\\.[0-9]+)?(?:[eE][-+]?[0-9]+)?$")
+
+// Recursion unwraps one JSON string per level, `layers` bounding the
+// layers of encoding still to be undone ([MAX_DECODING_DEPTH]).
+private fun JsonElement.isState(layers: Int): Boolean = when (this) {
+    is JsonObject -> true
+    is JsonArray -> any { it !is JsonPrimitive || it.isEncodedState(layers) }
+    is JsonPrimitive -> isEncodedState(layers)
+}
+
+// A JSON string whose content — percent-decoded, when it is encoded — is
+// state.
+private fun JsonElement.isEncodedState(layers: Int): Boolean {
+    if (this !is JsonPrimitive || !isString || layers == 0) return false
+    val content = content.trimInvisible()
+    val decoded = content.percentDecodedOrNull(layers - 1)
+    return (decoded?.value ?: content).parseJsonCandidateOrNull()
+        ?.isState(decoded?.layersLeft ?: (layers - 1)) == true
+}
+
+// Text is made of words: at least half the chars are letters (hex and
+// number lists are mostly digits), a combining mark counting as one, since
+// scripts like Devanagari and vowel-marked Arabic write vowels as marks; and
+// at least one char in sixteen breaks a word — whitespace, a list separator
+// (`,` `;`, so `a,b,c` keywords count), a path separator (`/`, so a list of
+// URLs counts — base64 holds one in 64 chars, too few), or a letter of a
+// script written without spaces ([isUnspacedScriptLetter] — base64 and hex
+// never contain one; a Latin, Greek or Cyrillic letter, accented or not,
+// breaks no word) — sparse enough for a list of long compound words, while the
+// punctuation of serialised data (quotes, brackets, `=`, `|`, `\`) stays
+// rare.
+// Chars are counted as code points: a surrogate pair, which the common stdlib
+// cannot classify, counts once, judged by its plane.
+private fun String.readsAsText(): Boolean {
+    var chars = 0
+    var letters = 0
+    var wordBreaks = 0
+    var dataPunctuation = 0
+    var i = 0
+    while (i < length) {
+        val c = this[i]
+        chars++
+        val low = getOrNull(i + 1)
+        if (c.isHighSurrogate() && low != null && low.isLowSurrogate()) {
+            when (supplementaryCodePoint(c, low)) {
+                // the CJK ideograph extensions: letters of a script written
+                // without spaces
+                in 0x20000..0x3FFFF -> { letters++; wordBreaks++ }
+                // historic scripts and styled mathematical letters, written
+                // with spaces
+                in 0x10000..0x1DFFF -> letters++
+                // emoji, other symbols, private use: no letter, so a blob
+                // encoded as emoji does not read as text
+                else -> {}
+            }
+            i += 2
+            continue
+        }
+        if (c.isLetter() || c.category in COMBINING_MARKS) letters++
+        if (c.isWhitespace() || c == ',' || c == ';' || c == '/' || c.isUnspacedScriptLetter()) wordBreaks++
+        else if (c in DATA_PUNCTUATION) dataPunctuation++
+        i++
+    }
+    return letters * 2 >= chars && wordBreaks * 16 >= chars && dataPunctuation * 20 < chars
+}
+
+// The code point a surrogate pair encodes.
+private fun supplementaryCodePoint(high: Char, low: Char): Int =
+    0x10000 + ((high.code - 0xD800) shl 10) + (low.code - 0xDC00)
+
+// Whether this is a letter of a script written without spaces between words:
+// Thai, Lao, Tibetan, Myanmar, Khmer, Japanese kana, Bopomofo, the CJK
+// ideographs and Yi. (A supplementary-plane char, which the common stdlib
+// cannot classify, is judged by its plane in [readsAsText] directly.)
+private fun Char.isUnspacedScriptLetter(): Boolean =
+    isLetter() && UNSPACED_SCRIPT_RANGES.any { code in it }
+
+private val UNSPACED_SCRIPT_RANGES = listOf(
+    0x0E00..0x0FFF, // Thai, Lao, Tibetan
+    0x1000..0x109F, // Myanmar
+    0x1780..0x17FF, // Khmer
+    0x3040..0x31FF, // Hiragana, Katakana, Bopomofo, Katakana extensions
+    0x3400..0x4DBF, // CJK Extension A
+    0x4E00..0xA4CF, // CJK Unified Ideographs, Yi
+    0xF900..0xFAFF, // CJK Compatibility Ideographs
+    0xFF66..0xFF9F, // halfwidth Katakana
+)
+
+private val COMBINING_MARKS = setOf(
+    CharCategory.NON_SPACING_MARK,
+    CharCategory.COMBINING_SPACING_MARK,
+)
+
+private const val DATA_PUNCTUATION = "{}[]\"<>=|\\"
+
+// Never throws: the value is page-controlled, and a malformed one is simply
+// not JSON, whatever the parser reports it with.
+private fun String.parseJsonOrNull(): JsonElement? = try {
+    Json.parseToJsonElement(this)
+} catch (_: Exception) {
+    null
+}
+
+// A value with some layers of its encoding undone, and how many more may be.
+private class Decoded(val value: String, val layersLeft: Int)
+
+// This value with its percent-encoding undone — as many times over as it was
+// applied, up to `layers` times — and invisible chars trimmed from its
+// edges, or null when it is not percent-encoded: it does not open with an
+// escape, its first decoding fails, or no layer may be undone.
+private fun String.percentDecodedOrNull(layers: Int): Decoded? {
+    var value = this
+    var left = layers
+    while (left > 0 && value.firstOrNull() == '%') {
+        value = value.percentDecodedOnceOrNull()?.trimInvisible() ?: break
+        left--
+    }
+    return if (left == layers) null else Decoded(value, left)
+}
+
+// Decodes `%XX` escapes as UTF-8, or null when the value is not
+// percent-encoded text (a malformed escape, a raw non-ASCII char).
+private fun String.percentDecodedOnceOrNull(): String? {
+    val bytes = ByteArray(length)
+    var size = 0
+    var i = 0
+    while (i < length) {
+        val c = this[i]
+        if (c == '%') {
+            val high = getOrNull(i + 1)?.asciiHexDigitOrNull() ?: return null
+            val low = getOrNull(i + 2)?.asciiHexDigitOrNull() ?: return null
+            bytes[size++] = (high * 16 + low).toByte()
+            i += 3
+        } else {
+            if (c.code > 0x7F) return null
+            bytes[size++] = c.code.toByte()
+            i++
+        }
+    }
+    return bytes.decodeToString(0, size)
+}
+
+// Unlike [Char.digitToIntOrNull], which also takes non-ASCII Unicode digits.
+private fun Char.asciiHexDigitOrNull(): Int? = when (this) {
+    in '0'..'9' -> this - '0'
+    in 'a'..'f' -> this - 'a' + 10
+    in 'A'..'F' -> this - 'A' + 10
+    else -> null
+}
diff --git a/markanywhere-html/src/commonMain/kotlin/EnsureFrontmatterTitle.kt b/markanywhere-html/src/commonMain/kotlin/EnsureFrontmatterTitle.kt
index 3276735..04a8b0c 100644
--- a/markanywhere-html/src/commonMain/kotlin/EnsureFrontmatterTitle.kt
+++ b/markanywhere-html/src/commonMain/kotlin/EnsureFrontmatterTitle.kt
@@ -18,32 +18,77 @@ package com.xemantic.markanywhere.html
 
 import com.xemantic.markanywhere.SemanticEvent
 import com.xemantic.markanywhere.flow.semanticEvents
+import com.xemantic.markanywhere.html.spec.asciiLowercase
+import com.xemantic.markanywhere.html.spec.isHtmlBlank
 import kotlinx.coroutines.flow.Flow
 
 /**
  * Ensures the stream starts with a `frontmatter` mark defining a `title`,
  * deriving a missing title from the first `h1`.
  *
- * A stream whose leading `frontmatter` already holds a usable top-level
- * `entry` with `key="title"` — one with non-blank text, or one holding a
- * nested structure — passes through untouched. Otherwise the frontmatter is
- * held back and the title is derived from the very first `h1` following it
- * (only blank text may intervene): the `h1` subtree's flattened text —
- * its text events plus the `alt` of every `img` mark, in document order,
- * the way an accessible name is computed from content — trimmed, internal
- * whitespace collapsed to single spaces — becomes the `title`, injected as
- * the first `entry` of the frontmatter (or put in
- * place of a `title` entry that is blank or `null`, such as a bare `title:`
- * line), and only then the frontmatter and the buffered `h1` are emitted,
- * in source order. When no frontmatter exists at all, one carrying just the
- * derived `title` is synthesized as the **first** event — ahead of any
- * blank text that preceded the `h1`, since [wrapInHtmlDocument] reads only
- * a frontmatter that opens the stream.
+ * The frontmatter judged is the one [wrapInHtmlDocument] reads: an untagged
+ * `frontmatter` mark opening the stream, text of HTML whitespace before it
+ * being insignificant — the frontmatter is emitted ahead of that text, so it
+ * opens the stream as Markdown front matter must; one anywhere else, or a
+ * tagged one, is ordinary content. Its title entries are its top-level
+ * `entry` marks with `key="title"` in any ASCII letter case, and one holding
+ * scalar text with visible content is usable — entries holding a nested
+ * structure, an empty collection, `null` or blank text are not, as there.
+ * A verbatim line defining a title key (a YAML shape outside the parsed
+ * subset, such as a multi-line quoted scalar) is a title entry too, one whose
+ * value only the front matter readers know. Each title entry spans the
+ * indented verbatim lines continuing it, so dropping one drops them too,
+ * rather than leaving them to continue the entry before it.
  *
- * When no title can be derived — the first non-blank event after the
- * frontmatter is not an `h1`, the `h1` yields no text, or the stream ends —
- * everything held is flushed unchanged: a stream without a leading `h1`
- * passes through untouched and no empty frontmatter is fabricated.
+ * Whenever a title comes out, the frontmatter holds exactly one title entry,
+ * spelled `title`: every front matter reader then reads the same title —
+ * whether it matches keys case-sensitively (Jekyll) or not, keeps the later
+ * of duplicate keys (Psych, PyYAML) or rejects them (js-yaml) — and it is the
+ * one [wrapInHtmlDocument] reads. It comes out in one of two ways:
+ *
+ * - **A usable title entry exists**: the one [wrapInHtmlDocument] picks is
+ *   respelled `title` in place, and every other title entry is dropped.
+ * - **None exists**: the frontmatter is held back and the title is derived
+ *   from the very first `h1` following it, only text showing nothing
+ *   (whitespace, an NBSP, a zero-width char) intervening. The `h1` subtree's
+ *   flattened text — its text events plus the `alt` of every `img` mark, in
+ *   document order, the way an accessible name is computed from content —
+ *   normalized as [normalizeTitle] reads a `<title>` becomes the `title`, and
+ *   only then are the frontmatter and the buffered `h1` emitted, in source
+ *   order. The derived entry takes the place of the first title entry, every
+ *   other one dropped, or is injected as the first `entry` of a frontmatter
+ *   without any. When no frontmatter exists at all, one carrying just the
+ *   derived `title` is synthesized as the **first** event, ahead of any text
+ *   that preceded the `h1`.
+ *
+ * Two shapes are left without a title:
+ *
+ * - A title entry holding a nested structure (localized titles, say) or kept
+ *   as a verbatim line is no title for [wrapInHtmlDocument], but it is
+ *   content: no title is derived and no title entry respelled. Of the other title entries only the usable
+ *   one [wrapInHtmlDocument] picks is kept, as spelled, so readers may
+ *   disagree on the title as they did on the input; the empty ones (`null`,
+ *   blank, an empty collection) carry nothing, and another usable one would
+ *   be a duplicate key, which makes js-yaml reject the whole front matter.
+ *   A frontmatter whose root is a sequence (top-level `item` marks) has no
+ *   place for a title entry and passes through unchanged.
+ * - When no title can be derived — the first event after the frontmatter
+ *   that shows something is not an `h1`, the `h1` yields no text, or the
+ *   stream ends — everything held is flushed unchanged but for the title
+ *   entries dropped as above.
+ *
+ * A frontmatter left empty, by dropping its title entries or as it came, is
+ * dropped too (it would render as two thematic breaks), so no empty
+ * frontmatter is ever emitted. Nor is a title entry dropped from the front
+ * of a frontmatter where that would leave a verbatim line (one outside the
+ * YAML subset) first — front matter detection needs a key there, so the
+ * block would parse back as a thematic break and a paragraph: the title
+ * entry kept moves into the first title entry's place instead, or, none
+ * being kept, the first one stays.
+ *
+ * A frontmatter or `h1` the stream ends inside (a broken upstream contract)
+ * is judged all the same, an entry left open included, and emitted closed,
+ * so the output stays balanced.
  *
  * Buffering is bounded to the frontmatter subtree plus one `h1` subtree —
  * everything after the decision point is forwarded as it arrives.
@@ -55,22 +100,22 @@ public fun Flow<SemanticEvent>.ensureFrontmatterTitle(): Flow<SemanticEvent> = s
     // the held frontmatter subtree (mark + body events + unmark); null when
     // no frontmatter was present and a default one is to be synthesized
     var frontmatterEvents: MutableList<SemanticEvent>? = null
-    var frontmatterDepth = 0
-    var hasTitle = false
-
-    // the span of a top-level `title` entry that carries no usable title
-    // (blank text, `type=null`) within `frontmatterEvents`, replaced by the
-    // derived entry on commit; `titleStart` < 0 when there is none
-    var titleStart = -1
-    var titleEnd = -1
-    // the top-level title entry currently open: its text, and whether it
-    // holds nested marks (then it is kept as is, whatever its text)
-    var inTitleEntry = false
-    var titleHasChildren = false
-    val titleText = StringBuilder()
-
-    // blank text held before the first h1 (ahead of the frontmatter, or
-    // between it and the h1), replayed in source order on commit
+
+    // the top-level title entries (in any letter case) within
+    // `frontmatterEvents`, in source order, their spans indexing it
+    val titleSlots = mutableListOf<FrontMatterEntry>()
+    // the one of them wrapInHtmlDocument reads the title from, if any
+    var read: FrontMatterEntry? = null
+    val reader = FrontMatterEntryReader { entry ->
+        if (entry.key.asciiLowercase() == "title") {
+            titleSlots += entry
+            if (entry.readOver(read?.key)) read = entry
+        }
+    }
+
+    // text showing nothing held before the first h1 (ahead of the
+    // frontmatter, or between it and the h1), replayed in source order on
+    // commit
     val blanks = mutableListOf<SemanticEvent>()
 
     // the h1 subtree, buffered between its mark and balanced unmark so the
@@ -84,48 +129,153 @@ public fun Flow<SemanticEvent>.ensureFrontmatterTitle(): Flow<SemanticEvent> = s
         blanks.clear()
     }
 
-    suspend fun flushHeld() {
-        frontmatterEvents?.let { emit(it) }
+    // the held events of this slot, as they came
+    fun FrontMatterEntry.events(): List<SemanticEvent> = frontmatterEvents!!.subList(start, end + 1)
+
+    // the held frontmatter's body — `prepended` first, the span of each slot
+    // in `rewrite` (in source order, as `titleSlots` is) replaced by its
+    // events (none drops the entry)
+    fun heldBody(
+        rewrite: Map<FrontMatterEntry, List<SemanticEvent>>,
+        prepended: List<SemanticEvent>
+    ): List<SemanticEvent> = buildList {
+        val held = frontmatterEvents!!
+        addAll(prepended)
+        var next = 1
+        for ((slot, events) in rewrite) {
+            addAll(held.subList(next, slot.start))
+            addAll(events)
+            next = slot.end + 1
+        }
+        addAll(held.subList(next, held.size))
+    }
+
+    // Whether the held frontmatter's body, rewritten as [heldBody] would,
+    // opens with a verbatim line: text, past any of HTML whitespace, ahead of
+    // the first entry — found without building the body.
+    fun opensWithVerbatimLine(
+        rewrite: Map<FrontMatterEntry, List<SemanticEvent>>,
+        prepended: List<SemanticEvent>
+    ): Boolean {
+        if (prepended.isNotEmpty()) return false
+        val held = frontmatterEvents!!
+        val slots = rewrite.keys.associateBy { it.start }
+        var i = 1
+        while (i < held.size) {
+            val slot = slots[i]
+            if (slot != null) {
+                val events = rewrite.getValue(slot)
+                if (events.isNotEmpty()) return events.first() is Text
+                i = slot.end + 1
+                continue
+            }
+            val event = held[i]
+            if (!(event is Text && event.text.isHtmlBlank())) return event is Text
+            i++
+        }
+        return false
+    }
+
+    // `rewrite` keeping the first title slot: the one scalar title entry it
+    // keeps elsewhere moves there, or, keeping none, the slot stays as it
+    // came
+    fun keepingFirstSlot(
+        rewrite: Map<FrontMatterEntry, List<SemanticEvent>>
+    ): Map<FrontMatterEntry, List<SemanticEvent>> {
+        val first = titleSlots.first()
+        val kept = rewrite.entries.firstOrNull { (slot, events) ->
+            slot != first && !slot.isUnreadable && events.isNotEmpty()
+        }
+        return rewrite.mapValues { (slot, events) ->
+            when (slot) {
+                first -> kept?.value ?: first.events()
+                kept?.key -> emptyList()
+                else -> events
+            }
+        }
+    }
+
+    // emits the held frontmatter rewritten as [heldBody] does, then the
+    // blanks held with it. Dropping leading title entries must not leave a
+    // verbatim line (one outside the YAML subset) first: front matter
+    // detection needs a key on the line after the `---`, so the block would
+    // parse back as a thematic break and a paragraph — the first title slot
+    // is kept then ([keepingFirstSlot]). A frontmatter left empty, by the
+    // rewrite or as it came, is dropped: it would render as a `---` pair,
+    // which parses back as two thematic breaks.
+    suspend fun flushHeld(
+        rewrite: Map<FrontMatterEntry, List<SemanticEvent>> = emptyMap(),
+        prepended: List<SemanticEvent> = emptyList()
+    ) {
+        frontmatterEvents?.let { held ->
+            val leavesVerbatimLineFirst = opensWithVerbatimLine(rewrite, prepended)
+                && !opensWithVerbatimLine(emptyMap(), emptyList())
+            val body = heldBody(if (leavesVerbatimLineFirst) keepingFirstSlot(rewrite) else rewrite, prepended)
+            val empty = body.none {
+                it is Mark || (it is Text && !it.text.isHtmlBlank())
+            }
+            if (!empty) {
+                emit((listOf(held.first()) + body).closed())
+            }
+        }
         frontmatterEvents = null
         flushBlanks()
     }
 
-    suspend fun emitTitleEntry(title: String) {
-        "entry"("key" to "title") { +title }
+    // emits the held frontmatter with `entry` in place of `slot`, every
+    // other title entry dropped
+    suspend fun flushWithSingleTitle(slot: FrontMatterEntry, entry: List<SemanticEvent>) {
+        flushHeld(titleSlots.associateWith { if (it == slot) entry else emptyList() })
+    }
+
+    // emits the held frontmatter keeping, of its title entries, only the
+    // unreadable ones and the one wrapInHtmlDocument reads: the empty ones
+    // carry nothing, and another usable one would be a duplicate key
+    suspend fun flushWithReadTitleOnly() {
+        flushHeld(
+            titleSlots.associateWith {
+                if (it.isUnreadable || it == read) it.events() else emptyList()
+            }
+        )
     }
 
     suspend fun commitHeading() {
-        val title = headingText.toString().trim().replace(WHITESPACE_RUN, " ")
-        val held = frontmatterEvents
-        if (title.isEmpty()) {
-            flushHeld()
-        } else if (held == null) {
-            "frontmatter" {
-                emitTitleEntry(title)
+        val title = headingText.toString().normalizeTitle()
+        val slot = titleSlots.firstOrNull()
+        when {
+            !isMetadataValue(title) -> flushWithReadTitleOnly()
+            frontmatterEvents == null -> {
+                "frontmatter" {
+                    emit(titleEntry(title))
+                }
+                flushBlanks()
             }
-            flushBlanks()
-        } else if (titleStart >= 0) {
-            // replay the original frontmatter verbatim, with the derived
-            // entry in place of the unusable title entry
-            frontmatterEvents = null
-            emit(held.subList(0, titleStart))
-            emitTitleEntry(title)
-            emit(held.subList(titleEnd + 1, held.size))
-            flushBlanks()
-        } else {
-            // replay the original frontmatter verbatim, with a single title
-            // entry prepended to its content
-            frontmatterEvents = null
-            emit(held.first())
-            emitTitleEntry(title)
-            emit(held.subList(1, held.size))
-            flushBlanks()
+            slot == null -> flushHeld(prepended = titleEntry(title))
+            else -> flushWithSingleTitle(slot, titleEntry(title))
         }
-        emit(headingEvents)
+        emit(headingEvents.closed())
         headingEvents.clear()
         state = PassThrough
     }
 
+    // decides, once the frontmatter closes, whether it holds a usable title
+    suspend fun judgeFrontmatter() {
+        val usable = read
+        state = when {
+            // a nested or verbatim title is content, not ours to replace or
+            // drop; a sequence has no place for a title entry
+            titleSlots.any { it.isUnreadable } || reader.isSequence -> {
+                flushWithReadTitleOnly()
+                PassThrough
+            }
+            usable != null -> {
+                flushWithSingleTitle(usable, respelled(usable.events()))
+                PassThrough
+            }
+            else -> AwaitingHeading
+        }
+    }
+
     fun startHeading(event: SemanticEvent) {
         headingEvents += event
         headingDepth = 1
@@ -135,18 +285,16 @@ public fun Flow<SemanticEvent>.ensureFrontmatterTitle(): Flow<SemanticEvent> = s
     collect { event ->
         when (state) {
             AtStart -> when {
-                event is Mark && event.name == "frontmatter" -> {
-                    // a frontmatter is only ever the first event, but keep
-                    // whatever preceded it in source order
-                    flushBlanks()
+                // only a frontmatter opening the stream (but for HTML
+                // whitespace text) is the page's metadata; anywhere else it
+                // is content
+                event.opensFrontmatter(blanks) -> {
                     frontmatterEvents = mutableListOf(event)
-                    frontmatterDepth = 1
-                    hasTitle = false
-                    titleStart = -1
+                    reader.read(event)
                     state = InFrontmatter
                 }
                 event is Mark && event.name == "h1" -> startHeading(event)
-                event is Text && event.text.isBlank() -> blanks += event
+                event.showsNothing() -> blanks += event
                 else -> {
                     flushBlanks()
                     emit(event)
@@ -154,48 +302,14 @@ public fun Flow<SemanticEvent>.ensureFrontmatterTitle(): Flow<SemanticEvent> = s
                 }
             }
             InFrontmatter -> {
-                val events = frontmatterEvents!!
-                events += event
-                when (event) {
-                    is Mark -> {
-                        frontmatterDepth++
-                        if (frontmatterDepth == 2) {
-                            // a top-level entry (a direct child)
-                            inTitleEntry = event.name == "entry" && event["key"] == "title"
-                            if (inTitleEntry) {
-                                titleHasChildren = false
-                                titleText.clear()
-                                titleStart = events.lastIndex
-                            }
-                        } else if (inTitleEntry) {
-                            titleHasChildren = true
-                        }
-                    }
-                    is Text -> if (inTitleEntry && frontmatterDepth == 2) titleText.append(event.text)
-                    is Unmark -> when (--frontmatterDepth) {
-                        1 -> if (inTitleEntry) {
-                            inTitleEntry = false
-                            if (titleHasChildren || titleText.isNotBlank()) {
-                                hasTitle = true
-                                titleStart = -1
-                            } else {
-                                titleEnd = events.lastIndex
-                            }
-                        }
-                        0 -> if (hasTitle) {
-                            flushHeld()
-                            state = PassThrough
-                        } else {
-                            state = AwaitingHeading
-                        }
-                    }
-                }
+                frontmatterEvents!! += event
+                if (reader.read(event)) judgeFrontmatter()
             }
             AwaitingHeading -> when (event) {
-                is Text if event.text.isBlank() -> blanks += event
+                is Text if event.showsNothing() -> blanks += event
                 is Mark if event.name == "h1" -> startHeading(event)
                 else -> {
-                    flushHeld()
+                    flushWithReadTitleOnly()
                     emit(event)
                     state = PassThrough
                 }
@@ -222,17 +336,60 @@ public fun Flow<SemanticEvent>.ensureFrontmatterTitle(): Flow<SemanticEvent> = s
         }
     }
 
-    // an unclosed h1 (broken upstream contract) still commits so no buffered
-    // events are lost; otherwise flush whatever is still held
-    if (state == InHeading) {
-        commitHeading()
-    } else {
-        flushHeld()
+    // an unclosed frontmatter or h1 (broken upstream contract) is still
+    // committed so no buffered events are lost; otherwise flush whatever is
+    // still held
+    when (state) {
+        // judged like a closed one, an entry left open included, as
+        // wrapInHtmlDocument reads it
+        InFrontmatter -> {
+            reader.finish()
+            judgeFrontmatter()
+            if (state == AwaitingHeading) flushWithReadTitleOnly()
+        }
+        InHeading -> commitHeading()
+        AwaitingHeading -> flushWithReadTitleOnly()
+        else -> flushHeld()
+    }
+}
+
+// Whether this event is text a reader sees nothing of — the one test of
+// blankness around the h1, the one a title is judged by ([isMetadataValue]).
+// Which text may precede a frontmatter is a different, HTML question
+// ([mayPrecedeFrontmatter]).
+private fun SemanticEvent.showsNothing(): Boolean = this is Text && !isMetadataValue(text)
+
+// Whether this title entry holds a title [wrapInHtmlDocument] cannot read,
+// though front matter readers do: a nested structure or a verbatim line.
+private val FrontMatterEntry.isUnreadable: Boolean get() = hasChildren || isVerbatim
+
+// These events with an unmark appended for every mark left open, innermost
+// first.
+private fun List<SemanticEvent>.closed(): List<SemanticEvent> {
+    val open = ArrayDeque<SemanticEvent.Mark>()
+    for (event in this) when (event) {
+        is Mark -> open.addLast(event)
+        is Unmark -> open.removeLastOrNull()
+        else -> {}
     }
+    return if (open.isEmpty()) this
+    else this + open.reversed().map { SemanticEvent.Unmark(it.name, it.isTagged) }
 }
 
 private enum class State {
     AtStart, InFrontmatter, AwaitingHeading, InHeading, PassThrough
 }
 
-private val WHITESPACE_RUN = Regex("""\s+""")
+// A top-level front matter `title` entry holding the scalar `value`.
+private fun titleEntry(value: String): List<SemanticEvent> = listOf(
+    SemanticEvent.Mark("entry", attributes = mapOf("key" to "title")),
+    SemanticEvent.Text(value),
+    SemanticEvent.Unmark("entry")
+)
+
+// An entry's events with its key spelled `title`.
+private fun respelled(entry: List<SemanticEvent>): List<SemanticEvent> {
+    val mark = entry.first() as Mark
+    return if (mark["key"] == "title") entry
+    else listOf(mark.copy(attributes = mark.attributes + ("key" to "title"))) + entry.drop(1)
+}
diff --git a/markanywhere-html/src/commonMain/kotlin/FrontMatterEntryReader.kt b/markanywhere-html/src/commonMain/kotlin/FrontMatterEntryReader.kt
new file mode 100644
index 0000000..11f21c3
--- /dev/null
+++ b/markanywhere-html/src/commonMain/kotlin/FrontMatterEntryReader.kt
@@ -0,0 +1,196 @@
+/*
+ * Copyright 2026 Kazimierz Pogoda / Xemantic
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.xemantic.markanywhere.html
+
+import com.xemantic.markanywhere.SemanticEvent
+import com.xemantic.markanywhere.html.spec.isHtmlBlank
+import com.xemantic.markanywhere.yaml.yamlKeyLineKeyOrNull
+
+// Whether this event opens the frontmatter that is the page's metadata, the
+// `preceding` events being all the stream held before it: an untagged
+// `frontmatter` mark, nothing but [insignificant][mayPrecedeFrontmatter]
+// text ahead of it. The one rule wrapInHtmlDocument reads the head by and
+// ensureFrontmatterTitle judges the title by — anywhere else a frontmatter
+// is content.
+internal fun SemanticEvent.opensFrontmatter(preceding: List<SemanticEvent>): Boolean =
+    isFrontmatterMark() && preceding.all { it.mayPrecedeFrontmatter() }
+
+// Whether this is the mark of a frontmatter that is metadata wherever it
+// stands first: an untagged `frontmatter` mark (a tagged one is content).
+internal fun SemanticEvent.isFrontmatterMark(): Boolean =
+    this is Mark && !isTagged && name == "frontmatter"
+
+// Whether this event may come ahead of the frontmatter without keeping it
+// from opening the stream: text of HTML whitespace (an NBSP is content).
+internal fun SemanticEvent.mayPrecedeFrontmatter(): Boolean = this is Text && text.isHtmlBlank()
+
+// A top-level front matter `entry`: its key as spelled, `type`, text, whether
+// it holds nested marks, and the span of its events among those read — the
+// indented verbatim lines continuing it included, so dropping the span drops
+// them too, rather than leaving them to continue the entry before it. An
+// entry whose value is unknown is [isVerbatim], never head metadata, yet it
+// holds the key for readers: a verbatim line defining a key (one outside the
+// YAML subset, such as a multi-line quoted scalar), an entry continued by
+// indented verbatim lines (readers join them into the value), and one
+// holding indented verbatim lines under a bare `key:`.
+internal class FrontMatterEntry(
+    val key: String,
+    val type: String?,
+    val text: String,
+    val hasChildren: Boolean,
+    val isVerbatim: Boolean,
+    val start: Int,
+    val end: Int
+) {
+
+    // Whether it holds head metadata: scalar text with visible content —
+    // not a nested structure, an empty collection, `null`, blank text or a
+    // verbatim line.
+    val isHeadMetadata: Boolean =
+        !hasChildren && !isVerbatim && isScalarEntryType(type) && isMetadataValue(text)
+
+}
+
+// Reads the top-level entries of a `frontmatter` subtree, reporting each to
+// `onEntry` once its span is known: when the next top-level entry or verbatim
+// line opens, or the frontmatter closes. The one reader of front matter as
+// head metadata — wrapInHtmlDocument turns the entries into `<head>`,
+// ensureFrontmatterTitle judges the title entries among them, and the two
+// must agree on both.
+internal class FrontMatterEntryReader(
+    private val onEntry: (FrontMatterEntry) -> Unit
+) {
+
+    // 1 inside the frontmatter, 2 inside a top-level entry
+    private var depth = 0
+    private var index = -1
+    private var open: SemanticEvent.Mark? = null
+    private var openStart = 0
+    private var openHasChildren = false
+    private var openIsVerbatim = false
+    private val openText = StringBuilder()
+
+    // the last top-level entry read, held until its span is known
+    private var pending: FrontMatterEntry? = null
+
+    // Whether the root is a sequence: a top-level `item` was read.
+    var isSequence: Boolean = false
+        private set
+
+    // Reads the next event of the subtree, the frontmatter mark first; true
+    // once the frontmatter's own unmark is read.
+    fun read(event: SemanticEvent): Boolean {
+        index++
+        when (event) {
+            is Mark -> {
+                depth++
+                if (depth == 2) {
+                    reportPending()
+                    if (event.name == "item") isSequence = true
+                    open = if (event.name == "entry" && event["key"] != null) event else null
+                    openStart = index
+                    openHasChildren = false
+                    openIsVerbatim = false
+                    openText.clear()
+                } else if (depth > 2) {
+                    openHasChildren = true
+                }
+            }
+            is Text -> when (depth) {
+                1 -> readVerbatimLine(event.text)
+                2 -> {
+                    // the YAML parser strips a scalar's indentation, never
+                    // a verbatim line's, which also keeps its `\n`
+                    if (event.text.startsWithIndentation() && event.text.endsWith('\n')) {
+                        openIsVerbatim = true
+                    }
+                    openText.append(event.text)
+                }
+            }
+            is Unmark -> {
+                if (--depth == 1) closeEntry()
+                if (depth == 0) {
+                    reportPending()
+                    return true
+                }
+            }
+        }
+        return false
+    }
+
+    // Reports an entry left open by a frontmatter that never closed (a broken
+    // upstream contract) — its text is complete by then.
+    fun finish() {
+        closeEntry()
+        reportPending()
+    }
+
+    // A verbatim line (text outside any entry, as the YAML parser emits a
+    // line outside its subset): an indented one continues the entry before
+    // it, one at the margin ends it, and defines an entry itself when it
+    // opens with a key. A blank line decides nothing.
+    private fun readVerbatimLine(text: String) {
+        if (text.isHtmlBlank()) return
+        val entry = pending
+        if (text.startsWithIndentation()) {
+            if (entry != null) pending = entry.continuedTo(index)
+            return
+        }
+        reportPending()
+        pending = yamlKeyLineKeyOrNull(text.substringBefore('\n'))?.let { key ->
+            FrontMatterEntry(
+                key = key,
+                type = null,
+                text = "",
+                hasChildren = false,
+                isVerbatim = true,
+                start = index,
+                end = index
+            )
+        }
+    }
+
+    private fun closeEntry() {
+        open?.let {
+            open = null
+            pending = FrontMatterEntry(
+                key = it["key"]!!,
+                type = it["type"],
+                text = openText.toString(),
+                hasChildren = openHasChildren,
+                isVerbatim = openIsVerbatim,
+                start = openStart,
+                end = index
+            )
+        }
+    }
+
+    private fun reportPending() {
+        pending?.let {
+            pending = null
+            onEntry(it)
+        }
+    }
+
+}
+
+// The entry continued by the verbatim line ending at [end]: its value is
+// no longer known.
+private fun FrontMatterEntry.continuedTo(end: Int) =
+    FrontMatterEntry(key, type, text, hasChildren, isVerbatim = true, start, end)
+
+private fun String.startsWithIndentation() = startsWith(' ') || startsWith('\t')
diff --git a/markanywhere-html/src/commonMain/kotlin/HeadMetadata.kt b/markanywhere-html/src/commonMain/kotlin/HeadMetadata.kt
new file mode 100644
index 0000000..5000c05
--- /dev/null
+++ b/markanywhere-html/src/commonMain/kotlin/HeadMetadata.kt
@@ -0,0 +1,154 @@
+/*
+ * Copyright 2026 Kazimierz Pogoda / Xemantic
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.xemantic.markanywhere.html
+
+import com.xemantic.markanywhere.html.spec.asciiLowercase
+import com.xemantic.markanywhere.html.spec.stripAndCollapseHtmlWhitespace
+
+// The keys wrapInHtmlDocument turns into `<title>` and `<html lang>` rather
+// than a `<meta>`, spelled as it reads them.
+internal val HEAD_KEYS = setOf("title", "lang")
+
+// The front matter `entry` types whose text is meaningful as head metadata
+// (`null` and the empty collections are not); an entry without a `type` is a
+// string.
+private val SCALAR_ENTRY_TYPES = setOf("bool", "int", "float", "timestamp")
+
+// Whether an `entry` of this `type` holds a scalar that is head metadata —
+// the rule wrapInHtmlDocument reads entries by and ensureFrontmatterTitle
+// judges title entries by.
+internal fun isScalarEntryType(type: String?): Boolean =
+    type == null || type in SCALAR_ENTRY_TYPES
+
+// Whether a value carries anything for a reader: a char that shows.
+internal fun isMetadataValue(value: String): Boolean = value.any { !it.isInvisible() }
+
+// Whitespace (NBSP included), a control char (a next line char, a C0
+// control), an invisible format char such as a zero-width space or a byte
+// order mark, or a letter or symbol that renders blank ([BLANK_GLYPHS]).
+private fun Char.isInvisible(): Boolean =
+    isWhitespace() || category == CONTROL || category == FORMAT || this in BLANK_GLYPHS
+
+// Letters and symbols with no visible glyph — the Hangul fillers (choseong,
+// jungseong, compatibility, halfwidth) and the blank Braille pattern: being no
+// whitespace or format char, they are the common trick for a name that shows
+// nothing.
+private const val BLANK_GLYPHS = "\u115F\u1160\u3164\uFFA0\u2800"
+
+// This value with the chars [isMetadataValue] finds invisible trimmed from
+// its edges.
+internal fun String.trimInvisible(): String = trim { it.isInvisible() }
+
+// A title as `document.title` reads a `<title>` — HTML whitespace stripped
+// and collapsed — with any other invisible char at its edges (the NBSP
+// padding an icon often leaves, a byte order mark) trimmed too: inside, NBSP
+// is content and stays, at an edge it only forces the title into quotes.
+// A bidi control ([BIDI_CONTROLS]) is kept at an edge as well: invisible, yet
+// it is what keeps the punctuation of a right-to-left title on its side.
+// Whitespace that breaks a line (a vertical tab, a line or paragraph
+// separator, a next line char) collapses like HTML whitespace, as a title is
+// one line.
+internal fun String.normalizeTitle(): String =
+    CharArray(length) { if (this[it] in LINE_BREAKING_WHITESPACE) ' ' else this[it] }
+        .concatToString()
+        .stripAndCollapseHtmlWhitespace()
+        .trim { it.isInvisible() && it !in BIDI_CONTROLS }
+
+private const val LINE_BREAKING_WHITESPACE = "\u000B\u0085\u2028\u2029"
+
+// The bidi marks, embeddings, overrides and isolates: the Arabic letter mark,
+// the left-to-right and right-to-left marks, U+202A..U+202E and
+// U+2066..U+2069.
+private const val BIDI_CONTROLS =
+    "\u061C\u200E\u200F\u202A\u202B\u202C\u202D\u202E\u2066\u2067\u2068\u2069"
+
+// A language tag as `<html lang>` carries it: HTML strips its whitespace, and
+// any other invisible char at its edges (a byte order mark, a zero-width
+// space) is trimmed too — no valid BCP 47 tag holds one.
+internal fun String.normalizeLang(): String = trimInvisible()
+
+// Whether a front matter entry spelled `candidate` supersedes an earlier one
+// of the same name spelled `existing`, as front matter readers resolve a
+// duplicate key: the later one wins (Psych — Jekyll's — and PyYAML), except
+// that the lowercase spelling, the one a case-sensitive reader such as Jekyll
+// looks up for `title`, beats a variant wherever it occurs.
+internal fun frontMatterKeySupersedes(existing: String, candidate: String): Boolean {
+    val name = candidate.asciiLowercase()
+    return candidate == name || existing != name
+}
+
+// Whether a front matter reader reads this entry's value over that of an
+// earlier entry of the same name spelled `existingKey`, if any: it must be
+// head metadata ([FrontMatterEntry.isHeadMetadata]), and must then
+// [supersede][frontMatterKeySupersedes] the earlier one.
+internal fun FrontMatterEntry.readOver(existingKey: String?): Boolean =
+    isHeadMetadata && (existingKey == null || frontMatterKeySupersedes(existingKey, key))
+
+// A metadata entry: its name, spelled as where its value was read, and the
+// value.
+internal data class MetadataEntry(val key: String, val value: String)
+
+// The `<head>` metadata a front matter holds, in insertion order and keyed
+// the way HTML reads `<meta>` names: ASCII case-insensitively (HTML §4.2.5).
+// A blank value carries nothing for a reader, so it is never added, and
+// cannot shadow a variant holding one. Duplicates resolve the way readers of
+// the format they were read from resolve them — [simplifyHtml] reads HTML,
+// [wrapInHtmlDocument] YAML. The two policies need not agree for the two to
+// stay inverses: each emits a single entry per name.
+internal class HeadMetadata {
+
+    private val entries = LinkedHashMap<String, MetadataEntry>()
+
+    val values: Collection<MetadataEntry> get() = entries.values
+
+    fun isNotEmpty(): Boolean = entries.isNotEmpty()
+
+    // Every lookup takes a name as spelled; folding it is this class's job.
+    operator fun contains(name: String): Boolean = name.asciiLowercase() in entries
+
+    operator fun get(name: String): MetadataEntry? = entries[name.asciiLowercase()]
+
+    // Whether [addFromHtml] would add this `<meta>`: it carries something
+    // for a reader and, the first of duplicate elements being the one a
+    // query finds, no earlier one of its name, in any letter case, was added.
+    // Lets a caller skip judging a value that would not be added anyway.
+    fun acceptsFromHtml(key: String, value: String): Boolean =
+        key !in this && isMetadataValue(value)
+
+    // Adds a `<meta>` read from HTML when it [acceptsFromHtml] — the first
+    // occurrence of a name wins, spelling and value.
+    fun addFromHtml(key: String, value: String) {
+        if (acceptsFromHtml(key, value)) entries[key.asciiLowercase()] = MetadataEntry(key, value)
+    }
+
+    // Adds a front matter entry the way its readers resolve a duplicate key
+    // ([readOver], the rule ensureFrontmatterTitle picks the title entry by).
+    // The name keeps the position of its first occurrence.
+    fun addFromFrontMatter(entry: FrontMatterEntry) {
+        val name = entry.key.asciiLowercase()
+        if (entry.readOver(entries[name]?.key)) {
+            entries[name] = MetadataEntry(entry.key, entry.text)
+        }
+    }
+
+    // Sets the entry whether or not its name is present, keeping the position
+    // of an existing one.
+    operator fun set(key: String, value: String) {
+        entries[key.asciiLowercase()] = MetadataEntry(key, value)
+    }
+
+}
diff --git a/markanywhere-html/src/commonMain/kotlin/HtmlWhitespaceNormalization.kt b/markanywhere-html/src/commonMain/kotlin/HtmlWhitespaceNormalization.kt
index d7c616f..fbbac15 100644
--- a/markanywhere-html/src/commonMain/kotlin/HtmlWhitespaceNormalization.kt
+++ b/markanywhere-html/src/commonMain/kotlin/HtmlWhitespaceNormalization.kt
@@ -21,6 +21,7 @@ import com.xemantic.markanywhere.dump.AccessibilityAnnotations
 import com.xemantic.markanywhere.flow.mergeAdjacentText
 import com.xemantic.markanywhere.html.spec.isHtmlBlank
 import com.xemantic.markanywhere.html.spec.isHtmlWhitespace
+import com.xemantic.markanywhere.html.spec.stripAndCollapseHtmlWhitespace
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.flow
 
@@ -109,7 +110,7 @@ public fun Flow<SemanticEvent>.dropHtmlStructuralWhitespace(): Flow<SemanticEven
                     // content, dropped at a block boundary).
                     if (event.text.first().isHtmlWhitespace()) pending = true
                     resolvePending(rightQualifies = true)
-                    emit(SemanticEvent.Text(event.text.collapseWhitespace()))
+                    emit(SemanticEvent.Text(event.text.stripAndCollapseHtmlWhitespace()))
                     leftQualifies = true
                     pending = event.text.last().isHtmlWhitespace()
                 }
@@ -149,24 +150,6 @@ public fun Flow<SemanticEvent>.dropHtmlStructuralWhitespace(): Flow<SemanticEven
     // End-of-stream (a block boundary): any trailing whitespace run is dropped.
 }.mergeAdjacentText()
 
-// Collapses every run of ASCII whitespace to a single space and trims the ends —
-// the caller re-attaches a separating space via the block/inline gate when one
-// is warranted. Non-ASCII spaces (NBSP ` `, narrow NBSP, en/em space, …)
-// are content, not structural whitespace: HTML never collapses them, so they
-// pass through verbatim (e.g. legal citations like `§ 823`).
-private fun String.collapseWhitespace(): String = buildString {
-    var inWhitespace = false
-    for (c in this@collapseWhitespace) {
-        if (c.isHtmlWhitespace()) {
-            inWhitespace = true
-        } else {
-            if (isNotEmpty() && inWhitespace) append(' ')
-            inWhitespace = false
-            append(c)
-        }
-    }
-}
-
 // Opens a whitespace-preserving region, whose watermark covers the whole
 // subtree — so a `code` nested in a `pre` needs no rule of its own.
 //
diff --git a/markanywhere-html/src/commonMain/kotlin/SimplifyHtml.kt b/markanywhere-html/src/commonMain/kotlin/SimplifyHtml.kt
index 94e578e..a0c2184 100644
--- a/markanywhere-html/src/commonMain/kotlin/SimplifyHtml.kt
+++ b/markanywhere-html/src/commonMain/kotlin/SimplifyHtml.kt
@@ -18,6 +18,7 @@ package com.xemantic.markanywhere.html
 
 import com.xemantic.markanywhere.SemanticEvent
 import com.xemantic.markanywhere.dump.AccessibilityAnnotations
+import com.xemantic.markanywhere.html.spec.asciiLowercase
 import com.xemantic.markanywhere.transform.MatcherScope
 import com.xemantic.markanywhere.transform.transform
 import kotlinx.coroutines.flow.Flow
@@ -129,10 +130,27 @@ import kotlinx.coroutines.flow.Flow
  * and emitted as a single synthetic `frontmatter` mark holding one `entry`
  * (`key` attribute, value as text) per item — the parser's structured front
  * matter vocabulary — just before `<body>` content streams through. Technical meta
- * names that carry no content signal (rendering hints, crawler / verification
- * directives, platform tile metadata — see [isNoiseMetaName]) are dropped so
- * they don't inflate the frontmatter. If `<head>` is absent or yields no
- * metadata, no frontmatter mark is emitted.
+ * names that carry no content signal (rendering hints such as `viewport` and
+ * `theme-color`, crawler / verification directives such as `robots` and
+ * `*-verification`, platform tile metadata such as `msapplication-*` and
+ * `apple-*`) are dropped so they don't inflate the frontmatter, and so are a
+ * value with nothing visible in it (whitespace, NBSP included, or invisible
+ * format chars such as a zero-width space — `<html lang>` too) and
+ * application state that single-page apps ship in `<meta>` — structured JSON
+ * (raw, percent-encoded or serialised into a JSON string) and opaque blobs
+ * over 4096 chars that do not read as text. Meta names are
+ * ASCII case-insensitive, so of several names differing only in letter case
+ * the first one (spelling and value) wins, as HTML resolves duplicate
+ * `<meta>` elements — unlike [wrapInHtmlDocument], which resolves duplicate
+ * front matter keys as YAML readers do; a
+ * `lang` meta is spelled `lang` and yields to `<html lang>`, the document's
+ * actual language. Those discarded values and merged
+ * names are what does not survive a [wrapInHtmlDocument] round-trip. When
+ * `<head>` holds several `<title>`s, the first non-blank one wins, over a
+ * `<meta name="title">` (in any letter case) too, with its whitespace
+ * stripped and collapsed as `document.title` does and any non-breaking space
+ * at its edges trimmed. If `<head>` is absent or
+ * yields no metadata, no frontmatter mark is emitted.
  *
  * Matcher registration is grouped: per-tag explicit matchers come first
  * (so they win the `firstOrNull` race), then a small number of
@@ -163,8 +181,18 @@ public fun Flow<SemanticEvent>.simplifyHtml(
     svgMode: SvgMode = SvgMode.RESOLVE,
 ): Flow<SemanticEvent> = transform {
 
-    val metadata = mutableMapOf<String, String>()
+    // A value that tells a reader nothing is never added — judged by
+    // `isMetadataValue`, not HTML whitespace: rendered, an NBSP-only or
+    // zero-width value is as empty as a blank one. `ensureFrontmatterTitle`
+    // judges a title the same way, so a title kept here is never replaced
+    // there.
+    val metadata = HeadMetadata()
     val titleText = StringBuilder()
+    // The first non-blank `<title>` wins, over a `<meta name="title">` too —
+    // unlike `document.title`, which takes the first `<title>` even when
+    // blank, since a blank title tells the reader nothing. Overwriting a meta
+    // title keeps the entry where the first candidate appeared.
+    var titleFromElement = false
 
     // Attribute map kept on a preserved element: its own [names] whitelist, the
     // ARIA name/state keep-set, and any caller-requested [keepAttributes]. An
@@ -237,7 +265,7 @@ public fun Flow<SemanticEvent>.simplifyHtml(
     // --- metadata extraction (explicit per-tag) -------------------------
 
     match("html") { event ->
-        event["lang"]?.let { metadata["lang"] = it }
+        event["lang"]?.let { metadata.addFromHtml("lang", it.normalizeLang()) }
         children()
     }
 
@@ -248,7 +276,7 @@ public fun Flow<SemanticEvent>.simplifyHtml(
         afterClose {
             if (metadata.isNotEmpty()) {
                 "frontmatter" {
-                    for ((key, value) in metadata) {
+                    for ((key, value) in metadata.values) {
                         "entry"("key" to key) { +value }
                     }
                 }
@@ -257,12 +285,17 @@ public fun Flow<SemanticEvent>.simplifyHtml(
     }
 
     match("title") {
-        // Capture the title's text into metadata; the mark itself is dropped.
+        // Capture the title's text as a candidate; the mark itself is dropped.
+        // A page can carry several <title>s (e.g. after a client-side
+        // navigation), so each is collected on its own.
+        titleText.clear()
         children(mode = "titleText")
         afterClose {
-            val trimmed = titleText.toString().trim()
-            if (trimmed.isNotEmpty()) {
-                metadata["title"] = trimmed
+            // as `document.title` reads it, edges trimmed (normalizeTitle)
+            val title = titleText.toString().normalizeTitle()
+            if (!titleFromElement && isMetadataValue(title)) {
+                metadata["title"] = title
+                titleFromElement = true
             }
         }
     }
@@ -270,8 +303,22 @@ public fun Flow<SemanticEvent>.simplifyHtml(
     match("meta") { event ->
         val name = event["name"]
         val content = event["content"]
-        if (name != null && content != null && !isNoiseMetaName(name)) {
-            metadata[name] = content
+        // cheapest checks first, so the JSON parse runs only for a meta
+        // that would otherwise be added
+        if (name != null && content != null && metadata.acceptsFromHtml(name, content)) {
+            val normalizedName = name.asciiLowercase()
+            if (!isNoiseMetaName(normalizedName) && !isApplicationStateMeta(content)) {
+                val value = when (normalizedName) {
+                    // as a <title> element's text reads
+                    "title" -> content.normalizeTitle()
+                    // as <html lang> is read above
+                    "lang" -> content.normalizeLang()
+                    else -> content
+                }
+                // the keys wrapInHtmlDocument turns back into <title> and
+                // <html lang> are spelled as it reads them
+                metadata.addFromHtml(if (normalizedName in HEAD_KEYS) normalizedName else name, value)
+            }
         }
     }
 
@@ -681,14 +728,13 @@ private val ARIA_KEEP = arrayOf(
 // directives, and platform tile metadata. Dropped from the extracted metadata.
 // A denylist (rather than an allowlist) keeps unknown-but-possibly-useful names
 // — `description`, `keywords`, `author`, `og:*`, `article:*`, … — by default.
-private fun isNoiseMetaName(name: String): Boolean {
-    val n = name.lowercase()
-    return n in NOISE_META_NAMES
-            || NOISE_META_PREFIXES.any { n.startsWith(it) }
-            || n.endsWith("-verification")
-            || n.endsWith("-verify")
-            || n.startsWith("verify-")
-}
+// Takes the name already ASCII-lowercased.
+private fun isNoiseMetaName(normalizedName: String): Boolean =
+    normalizedName in NOISE_META_NAMES
+            || NOISE_META_PREFIXES.any { normalizedName.startsWith(it) }
+            || normalizedName.endsWith("-verification")
+            || normalizedName.endsWith("-verify")
+            || normalizedName.startsWith("verify-")
 
 private val NOISE_META_NAMES = setOf(
     "viewport", "referrer", "generator", "theme-color", "color-scheme",
diff --git a/markanywhere-html/src/commonMain/kotlin/WrapInHtmlDocument.kt b/markanywhere-html/src/commonMain/kotlin/WrapInHtmlDocument.kt
index de751ff..191162b 100644
--- a/markanywhere-html/src/commonMain/kotlin/WrapInHtmlDocument.kt
+++ b/markanywhere-html/src/commonMain/kotlin/WrapInHtmlDocument.kt
@@ -18,6 +18,7 @@ package com.xemantic.markanywhere.html
 
 import com.xemantic.markanywhere.SemanticEvent
 import com.xemantic.markanywhere.flow.semanticEvents
+import com.xemantic.markanywhere.html.spec.asciiLowercase
 import kotlinx.coroutines.flow.Flow
 
 /**
@@ -26,111 +27,112 @@ import kotlinx.coroutines.flow.Flow
  *
  * A **leading** `frontmatter` block (the untagged mark the parser emits for
  * YAML `---` front matter, holding `entry` marks) feeds the `head` — the
- * inverse of [simplifyHtml]'s head-to-frontmatter extraction, so the two
- * round-trip:
+ * inverse of [simplifyHtml]'s head-to-frontmatter extraction:
  *
- * - the `title` entry becomes `<title>`
- * - the `lang` entry becomes the `lang` attribute on `<html>`
+ * - the `title` entry, normalized as [simplifyHtml] reads a `<title>`,
+ *   becomes `<title>`
+ * - the `lang` entry, its HTML whitespace and any other invisible char at
+ *   its edges stripped, becomes the `lang` attribute on `<html>`
  * - every other top-level scalar entry becomes a void `<meta name content>`
  *
  * Only top-level scalar entries are interpreted — exactly the shape
- * [simplifyHtml] produces. A nested mapping or sequence, a null value, and
- * verbatim text are skipped (never an error); a later duplicate key wins.
- * A `frontmatter` mark appearing anywhere past the first event is ordinary
- * content and flows into `body` verbatim.
+ * [simplifyHtml] produces. A nested mapping or sequence, a null value, a
+ * blank value and verbatim text are skipped (never an error). Keys are read
+ * the way HTML reads `<meta>` names, ASCII case-insensitively — a `Title`
+ * entry is the title. Of duplicate keys the later one wins, as front matter
+ * readers (Jekyll, PyYAML) resolve them, except that a key spelled in
+ * lowercase — the spelling a case-sensitive reader looks up — beats a
+ * variant in another letter case wherever it occurs; the winner keeps the
+ * position of the first duplicate.
  *
- * Only the frontmatter subtree is read ahead (bounded); without one the
- * document opening is emitted on the first event and body content streams
- * through untouched. All synthetic marks are untagged, consistent with the
- * parser's `frontmatter` mark and [simplifyHtml] output. An empty input
- * stream still yields the full document skeleton.
+ * Passing the result back through [simplifyHtml] restores the front matter
+ * except for what either side normalises or discards: skipped entries
+ * (above) and values [simplifyHtml] drops (noise names such as `viewport`,
+ * application state such as a JSON object or an opaque over-long blob) are
+ * gone, case-variant duplicates are merged, the `title` and `lang` keys come
+ * back spelled in lowercase, the title and `lang` normalized as above, and a
+ * typed scalar comes back as a string.
+ *
+ * Text of HTML whitespace ahead of the frontmatter is insignificant — it is
+ * moved to the start of `body` (a non-breaking space is content, as
+ * everywhere in HTML, and opens the body instead), as
+ * [ensureFrontmatterTitle] moves it after the frontmatter. A `frontmatter`
+ * mark appearing past any other event is ordinary content and flows into
+ * `body` verbatim.
+ *
+ * Only leading whitespace text and the frontmatter subtree are read ahead
+ * (bounded); body content streams through untouched. Holding the leading
+ * whitespace delays nothing a reader would see — it renders as nothing, and
+ * so does the skeleton opened ahead of it — while opening the document on it
+ * would push a frontmatter following it into `body`. All synthetic marks are
+ * untagged, consistent with the parser's `frontmatter` mark and
+ * [simplifyHtml] output. An empty input stream still yields the full
+ * document skeleton.
  */
 public fun Flow<SemanticEvent>.wrapInHtmlDocument(): Flow<SemanticEvent> = semanticEvents {
 
     var opened = false
-    var collectingFrontmatter = false
-    // nesting depth inside the frontmatter: 1 while inside a top-level entry
-    var depth = 0
-    // the top-level entry being read, null when it is not a scalar to keep
-    var entryKey: String? = null
-    val entryText = StringBuilder()
-    val metadata = LinkedHashMap<String, String>()
+    val metadata = HeadMetadata()
+    // reads the frontmatter while it is being collected
+    var frontmatter: FrontMatterEntryReader? = null
+    // blank text ahead of the frontmatter, replayed at the start of `body`
+    val blanks = mutableListOf<SemanticEvent>()
 
     // `head` and its subtree are lexically scoped, so the paired `"name" { }`
     // builder fits; `html` and `body` close only at end-of-stream, so their
     // unmark cannot come from a builder block — explicit mark/unmark instead.
     suspend fun openDocument() {
         opened = true
-        collectingFrontmatter = false
+        frontmatter = null
         mark(
             "html",
             attributes = metadata["lang"]
-                ?.let { mapOf("lang" to it) }
+                // trimmed, as simplifyHtml reads it
+                ?.let { mapOf("lang" to it.value.normalizeLang()) }
                 ?: emptyMap()
         )
         "head" {
-            metadata["title"]?.let { title ->
+            metadata["title"]?.let {
                 "title" {
-                    +title
+                    // as simplifyHtml reads a <title>
+                    +it.value.normalizeTitle()
                 }
             }
-            for ((key, value) in metadata) {
-                if (key == "title" || key == "lang") continue
+            for ((key, value) in metadata.values) {
+                if (key.asciiLowercase() in HEAD_KEYS) continue
                 "meta"("name" to key, "content" to value) {}
             }
         }
         mark("body")
+        emit(blanks)
+        blanks.clear()
     }
 
     collect { event ->
+        val reader = frontmatter
         when {
-            collectingFrontmatter -> when (event) {
-                is Mark -> {
-                    depth++
-                    if (depth == 1) {
-                        val type = event["type"]
-                        entryKey = if (
-                            event.name == "entry" && (type == null || type in SCALAR_TYPES)
-                        ) event["key"] else null
-                        entryText.clear()
-                    } else {
-                        entryKey = null // a nested mark: not a scalar
-                    }
+            reader != null -> if (reader.read(event)) openDocument()
+            // `blanks` only ever holds text that may precede a frontmatter,
+            // so the mark alone decides whether it opens the stream
+            !opened -> when {
+                event.isFrontmatterMark() -> {
+                    frontmatter = FrontMatterEntryReader(metadata::addFromFrontMatter).also { it.read(event) }
                 }
-                is Text -> if (depth == 1) entryText.append(event.text)
-                is Unmark -> if (depth == 0) {
+                event.mayPrecedeFrontmatter() -> blanks += event
+                else -> {
                     openDocument()
-                } else {
-                    if (depth == 1) {
-                        entryKey?.let { metadata[it] = entryText.toString() }
-                        entryKey = null
-                    }
-                    depth--
+                    emit(event)
                 }
             }
-            !opened -> if (
-                event is Mark && !event.isTagged && event.name == "frontmatter"
-            ) {
-                collectingFrontmatter = true
-            } else {
-                openDocument()
-                emit(event)
-            }
             else -> emit(event)
         }
     }
 
     // An unclosed frontmatter at end of stream (broken upstream contract) is
-    // still used, including an entry left open — its text is complete by
-    // then; an empty stream yields the bare skeleton.
-    if (collectingFrontmatter && depth == 1) {
-        entryKey?.let { metadata[it] = entryText.toString() }
-    }
+    // still used, including an entry left open; an empty stream yields the
+    // bare skeleton.
+    frontmatter?.finish()
     if (!opened) openDocument()
     unmark("body")
     unmark("html")
 }
-
-// Scalar `type`s whose text is meaningful as a `<meta content>` (`null` and
-// the empty collections are not).
-private val SCALAR_TYPES = setOf("bool", "int", "float", "timestamp")
diff --git a/markanywhere-html/src/commonTest/kotlin/EnsureFrontmatterTitleTest.kt b/markanywhere-html/src/commonTest/kotlin/EnsureFrontmatterTitleTest.kt
index 967a81c..cb56deb 100644
--- a/markanywhere-html/src/commonTest/kotlin/EnsureFrontmatterTitleTest.kt
+++ b/markanywhere-html/src/commonTest/kotlin/EnsureFrontmatterTitleTest.kt
@@ -17,6 +17,7 @@
 package com.xemantic.markanywhere.html
 
 import com.xemantic.kotlin.test.sameAs
+import com.xemantic.markanywhere.SemanticEvent
 import com.xemantic.markanywhere.flow.semanticEvents
 import com.xemantic.markanywhere.parse.parse
 import com.xemantic.markanywhere.render.renderMarkdown
@@ -216,6 +217,43 @@ class EnsureFrontmatterTitleTest {
         }
     }
 
+    @Test
+    fun `should keep a non-breaking space inside the derived title trimming the edges`() = runTest {
+        // given — NBSP inside is content, not HTML whitespace, as for a
+        // <title> read by simplifyHtml; at the edges (typically after an
+        // icon) it is padding, which would only force the title into quotes
+        val input = semanticEvents {
+            "h1" { +"\u00A0Foo\u00A0Bar\u00A0\n" }
+        }
+
+        // when
+        val output = input.ensureFrontmatterTitle()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"Foo\u00A0Bar" }
+            }
+            "h1" { +"\u00A0Foo\u00A0Bar\u00A0\n" }
+        }
+    }
+
+    @Test
+    fun `should not derive a title from a heading of non-breaking spaces`() = runTest {
+        // given
+        val input = semanticEvents {
+            "h1" { +"\u00A0\u00A0" }
+        }
+
+        // when
+        val output = input.ensureFrontmatterTitle()
+
+        // then
+        output sameAs semanticEvents {
+            "h1" { +"\u00A0\u00A0" }
+        }
+    }
+
     @Test
     fun `should not mistake a nested title entry for a top-level one`() = runTest {
         // given — only a direct child `entry key=title` counts
@@ -533,15 +571,113 @@ class EnsureFrontmatterTitleTest {
     }
 
     @Test
-    fun `should keep a title entry holding a nested structure`() = runTest {
-        // given — not a usable title, but replacing it would lose content
+    fun `should respell a title entry in another letter case as title`() = runTest {
+        // given — wrapInHtmlDocument reads a `Title` key as the title, but
+        // front matter readers matching keys case-sensitively (Jekyll) do not
+        val input = semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "Title") { +"My Page" }
+            }
+            "h1" { +"Heading" }
+        }
+
+        // when
+        val output = input.ensureFrontmatterTitle()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"My Page" }
+            }
+            "h1" { +"Heading" }
+        }
+    }
+
+    @Test
+    fun `should replace a blank title entry in any letter case with the derived title`() = runTest {
+        // given
+        val input = semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "TITLE") { +" " }
+                "entry"("key" to "author") { +"Alice" }
+            }
+            "h1" { +"Hello" }
+        }
+
+        // when
+        val output = input.ensureFrontmatterTitle()
+
+        // then — replaced in place, spelled as every reader reads it
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"Hello" }
+                "entry"("key" to "author") { +"Alice" }
+            }
+            "h1" { +"Hello" }
+        }
+    }
+
+    @Test
+    fun `should respell a usable title variant following a blank title entry dropping the blank one`() = runTest {
+        // given — wrapInHtmlDocument skips a blank entry, as simplifyHtml
+        // never extracts one, and reads the later variant, while a
+        // case-sensitive reader (Jekyll, Hugo) reads only the blank `title`
+        val input = semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +" " }
+                "entry"("key" to "Title") { +"Later" }
+            }
+            "h1" { +"Hello" }
+        }
+
+        // when
+        val output = input.ensureFrontmatterTitle()
+
+        // then — the blank entry carried nothing for either reader
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"Later" }
+            }
+            "h1" { +"Hello" }
+        }
+    }
+
+    @Test
+    fun `should drop a blank title variant following a usable title entry`() = runTest {
+        // given
+        val input = semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"Foo" }
+                "entry"("key" to "TITLE") { }
+            }
+            "h1" { +"Hello" }
+        }
+
+        // when
+        val output = input.ensureFrontmatterTitle()
+
+        // then — a single title entry, which no reader can take for another
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"Foo" }
+            }
+            "h1" { +"Hello" }
+        }
+    }
+
+    @Test
+    fun `should keep a title entry holding a nested structure instead of deriving a title`() = runTest {
+        // given — no reader shows a mapping as the page title, but replacing
+        // it would delete the author's content (localized titles, say)
         val input = semanticEvents {
             "frontmatter" {
                 "entry"("key" to "title") {
                     "entry"("key" to "en") { +"Hello" }
+                    "entry"("key" to "de") { +"Hallo" }
                 }
+                "entry"("key" to "author") { +"Alice" }
             }
-            "h1" { +"Hello" }
+            "h1" { +"Heading" }
         }
 
         // when
@@ -552,9 +688,930 @@ class EnsureFrontmatterTitleTest {
             "frontmatter" {
                 "entry"("key" to "title") {
                     "entry"("key" to "en") { +"Hello" }
+                    "entry"("key" to "de") { +"Hallo" }
                 }
+                "entry"("key" to "author") { +"Alice" }
             }
-            "h1" { +"Hello" }
+            "h1" { +"Heading" }
+        }
+    }
+
+    @Test
+    fun `should keep a nested title entry beside a usable title variant`() = runTest {
+        // given — the variant is what wrapInHtmlDocument reads, but keeping a
+        // single title entry would delete the localized titles
+        val input = semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") {
+                    "entry"("key" to "en") { +"Hello" }
+                    "entry"("key" to "de") { +"Hallo" }
+                }
+                "entry"("key" to "Title") { +"Hello" }
+                "entry"("key" to "TITLE") { +" " }
+            }
+            "h1" { +"Heading" }
+        }
+
+        // when
+        val output = input.ensureFrontmatterTitle()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") {
+                    "entry"("key" to "en") { +"Hello" }
+                    "entry"("key" to "de") { +"Hallo" }
+                }
+                "entry"("key" to "Title") { +"Hello" }
+            }
+            "h1" { +"Heading" }
+        }
+    }
+
+
+    @Test
+    fun `should keep only the title variant wrapInHtmlDocument reads beside a nested title entry`() = runTest {
+        // given — two variants spelled alike are a duplicate key, which makes
+        // js-yaml reject the whole front matter
+        val input = semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "Title") {
+                    "entry"("key" to "en") { +"Hello" }
+                }
+                "entry"("key" to "title") { +"First" }
+                "entry"("key" to "title") { +"Second" }
+            }
+            "h1" { +"Heading" }
+        }
+
+        // when
+        val output = input.ensureFrontmatterTitle()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "Title") {
+                    "entry"("key" to "en") { +"Hello" }
+                }
+                "entry"("key" to "title") { +"Second" }
+            }
+            "h1" { +"Heading" }
+        }
+    }
+
+    @Test
+    fun `should not add a title entry to a frontmatter whose root is a sequence`() = runTest {
+        // given — a title entry beside the items would make the root neither
+        // a mapping nor a sequence, which no YAML reader loads
+        val input = semanticEvents {
+            "frontmatter" {
+                "item" { +"a" }
+                "item" { +"b" }
+            }
+            "h1" { +"Heading" }
+        }
+
+        // when
+        val output = input.ensureFrontmatterTitle()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "item" { +"a" }
+                "item" { +"b" }
+            }
+            "h1" { +"Heading" }
+        }
+    }
+
+    @Test
+    fun `should respell a title variant following a null title entry dropping the null one`() = runTest {
+        // given — wrapInHtmlDocument skips the null entry and reads the
+        // variant after it as the title
+        val input = semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title", "type" to "null") { }
+                "entry"("key" to "Title") { +"Real" }
+            }
+            "h1" { +"Heading" }
+        }
+
+        // when
+        val output = input.ensureFrontmatterTitle()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"Real" }
+            }
+            "h1" { +"Heading" }
+        }
+    }
+
+    @Test
+    fun `should keep a title variant following a null title entry in the head`() = runTest {
+        // given
+        val input = semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title", "type" to "null") { }
+                "entry"("key" to "Title") { +"Real" }
+            }
+            "h1" { +"Heading" }
+        }
+
+        // when
+        val output = input.ensureFrontmatterTitle().wrapInHtmlDocument()
+
+        // then
+        output sameAs semanticEvents {
+            "html" {
+                "head" {
+                    "title" { +"Real" }
+                }
+                "body" {
+                    "h1" { +"Heading" }
+                }
+            }
+        }
+    }
+
+    @Test
+    fun `should keep a nested title entry dropping a blank variant following it`() = runTest {
+        // given — the blank variant carries nothing, the nested entry does
+        val input = semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") {
+                    "entry"("key" to "en") { +"Hello" }
+                }
+                "entry"("key" to "Title") { }
+            }
+            "h1" { +"Heading" }
+        }
+
+        // when
+        val output = input.ensureFrontmatterTitle()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") {
+                    "entry"("key" to "en") { +"Hello" }
+                }
+            }
+            "h1" { +"Heading" }
+        }
+    }
+
+    @Test
+    fun `should keep a nested title entry dropping a null variant following it`() = runTest {
+        // given
+        val input = semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") {
+                    "entry"("key" to "en") { +"Hello" }
+                }
+                "entry"("key" to "Title", "type" to "null") { }
+            }
+            "h1" { +"Heading" }
+        }
+
+        // when
+        val output = input.ensureFrontmatterTitle()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") {
+                    "entry"("key" to "en") { +"Hello" }
+                }
+            }
+            "h1" { +"Heading" }
+        }
+    }
+
+    @Test
+    fun `should replace a title entry holding an empty collection with the derived title`() = runTest {
+        // given — `title: []`
+        val input = semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title", "type" to "seq") { }
+            }
+            "h1" { +"Heading" }
+        }
+
+        // when
+        val output = input.ensureFrontmatterTitle()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"Heading" }
+            }
+            "h1" { +"Heading" }
+        }
+    }
+
+    @Test
+    fun `should put the derived title in the first of several empty title entries`() = runTest {
+        // given — `Title: ""` then `title:`
+        val input = semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "Title") { }
+                "entry"("key" to "author") { +"Alice" }
+                "entry"("key" to "title", "type" to "null") { }
+            }
+            "h1" { +"Heading" }
+        }
+
+        // when
+        val output = input.ensureFrontmatterTitle()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"Heading" }
+                "entry"("key" to "author") { +"Alice" }
+            }
+            "h1" { +"Heading" }
+        }
+    }
+
+    @Test
+    fun `should replace an unreadable title variant with the derived title`() = runTest {
+        // given — `Title: []`, which wrapInHtmlDocument skips; a `title`
+        // entry beside it would duplicate the key for a reader folding case
+        val input = semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "Title", "type" to "seq") { }
+            }
+            "h1" { +"Heading" }
+        }
+
+        // when
+        val output = input.ensureFrontmatterTitle()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"Heading" }
+            }
+            "h1" { +"Heading" }
+        }
+    }
+
+    @Test
+    fun `should move a frontmatter preceded by blank text ahead of it`() = runTest {
+        // given — blank text before the first element is insignificant, and
+        // renderMarkdown drops it, but wrapInHtmlDocument reads only a
+        // frontmatter opening the stream
+        val input = semanticEvents {
+            +"\n"
+            "frontmatter" {
+                "entry"("key" to "author") { +"Alice" }
+            }
+            "h1" { +"Heading" }
+        }
+
+        // when
+        val output = input.ensureFrontmatterTitle()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"Heading" }
+                "entry"("key" to "author") { +"Alice" }
+            }
+            +"\n"
+            "h1" { +"Heading" }
+        }
+    }
+
+    @Test
+    fun `should put the title of a frontmatter preceded by blank text into the head`() = runTest {
+        // given
+        val input = semanticEvents {
+            +"\n"
+            "frontmatter" {
+                "entry"("key" to "title") { +"Page" }
+            }
+            "h1" { +"Heading" }
+        }
+
+        // when
+        val output = input.ensureFrontmatterTitle().wrapInHtmlDocument()
+
+        // then
+        output sameAs semanticEvents {
+            "html" {
+                "head" {
+                    "title" { +"Page" }
+                }
+                "body" {
+                    +"\n"
+                    "h1" { +"Heading" }
+                }
+            }
+        }
+    }
+
+    @Test
+    fun `should drop a blank title entry following a usable one`() = runTest {
+        // given — a front matter reader keeps the later duplicate, so the
+        // blank entry would hide the title wrapInHtmlDocument reads
+        val input = semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"Real" }
+                "entry"("key" to "author") { +"Alice" }
+                "entry"("key" to "title") { }
+            }
+            "h1" { +"Heading" }
+        }
+
+        // when
+        val output = input.ensureFrontmatterTitle()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"Real" }
+                "entry"("key" to "author") { +"Alice" }
+            }
+            "h1" { +"Heading" }
+        }
+    }
+
+    @Test
+    fun `should drop an unreadable title entry following a usable one`() = runTest {
+        // given — `title: Real` then `title: []`: a later-wins reader would
+        // read the collection, and js-yaml rejects the duplicate key outright
+        val input = semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"Real" }
+                "entry"("key" to "author") { +"Alice" }
+                "entry"("key" to "title", "type" to "seq") { }
+                "entry"("key" to "tags") { +"x" }
+            }
+            "p" { +"Body." }
+        }
+
+        // when
+        val output = input.ensureFrontmatterTitle()
+
+        // then — decided without an h1, as a usable title needs none
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"Real" }
+                "entry"("key" to "author") { +"Alice" }
+                "entry"("key" to "tags") { +"x" }
+            }
+            "p" { +"Body." }
+        }
+    }
+
+    @Test
+    fun `should keep only the title variant wrapInHtmlDocument reads`() = runTest {
+        // given
+        val input = semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "Title") { +"First" }
+                "entry"("key" to "TITLE") { +"Last" }
+            }
+            "h1" { +"Heading" }
+        }
+
+        // when
+        val output = input.ensureFrontmatterTitle()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"Last" }
+            }
+            "h1" { +"Heading" }
+        }
+    }
+
+    @Test
+    fun `should drop every other empty title entry when deriving the title`() = runTest {
+        // given — a front matter reader keeps the later `title:`, which
+        // would hide the derived title in the first slot
+        val input = semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { }
+                "entry"("key" to "author") { +"Alice" }
+                "entry"("key" to "title", "type" to "null") { }
+            }
+            "h1" { +"Heading" }
+        }
+
+        // when
+        val output = input.ensureFrontmatterTitle()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"Heading" }
+                "entry"("key" to "author") { +"Alice" }
+            }
+            "h1" { +"Heading" }
+        }
+    }
+
+    @Test
+    fun `should keep a later nested title entry dropping an earlier null one`() = runTest {
+        // given — `title:` then `title: {en: Hello}`; js-yaml would reject
+        // the duplicate key, and only the null one carries nothing
+        val input = semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title", "type" to "null") { }
+                "entry"("key" to "author") { +"Alice" }
+                "entry"("key" to "title") {
+                    "entry"("key" to "en") { +"Hello" }
+                }
+            }
+            "h1" { +"Heading" }
+        }
+
+        // when
+        val output = input.ensureFrontmatterTitle()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "author") { +"Alice" }
+                "entry"("key" to "title") {
+                    "entry"("key" to "en") { +"Hello" }
+                }
+            }
+            "h1" { +"Heading" }
+        }
+    }
+
+    @Test
+    fun `should trim invisible format chars at the edges of the derived title`() = runTest {
+        // given
+        val input = semanticEvents {
+            "h1" { +"\u200BHeading\uFEFF" }
+        }
+
+        // when
+        val output = input.ensureFrontmatterTitle()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"Heading" }
+            }
+            "h1" { +"\u200BHeading\uFEFF" }
+        }
+    }
+
+    @Test
+    fun `should not derive a title from an invisible h1`() = runTest {
+        // given — a zero-width space shows nothing
+        val input = semanticEvents {
+            "h1" { +"\u200B" }
+        }
+
+        // when
+        val output = input.ensureFrontmatterTitle()
+
+        // then
+        output sameAs semanticEvents {
+            "h1" { +"\u200B" }
+        }
+    }
+
+    @Test
+    fun `should treat a zero-width title entry as blank`() = runTest {
+        // given
+        val input = semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"\u200B" }
+            }
+            "h1" { +"Heading" }
+        }
+
+        // when
+        val output = input.ensureFrontmatterTitle()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"Heading" }
+            }
+            "h1" { +"Heading" }
+        }
+    }
+
+    @Test
+    fun `should treat a title entry of blank-rendering letters as blank`() = runTest {
+        // given — a Hangul filler is a letter, yet shows nothing
+        val input = semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"\u3164" }
+            }
+            "h1" { +"Heading" }
+        }
+
+        // when
+        val output = input.ensureFrontmatterTitle()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"Heading" }
+            }
+            "h1" { +"Heading" }
+        }
+    }
+
+    @Test
+    fun `should keep a non-breaking space before the frontmatter as content`() = runTest {
+        // given — NBSP is content in HTML, so the frontmatter does not open
+        // the stream
+        val input = semanticEvents {
+            +"\u00A0"
+            "frontmatter" {
+                "entry"("key" to "author") { +"Alice" }
+            }
+            "h1" { +"Heading" }
+        }
+
+        // when
+        val output = input.ensureFrontmatterTitle()
+
+        // then
+        output sameAs semanticEvents {
+            +"\u00A0"
+            "frontmatter" {
+                "entry"("key" to "author") { +"Alice" }
+            }
+            "h1" { +"Heading" }
+        }
+    }
+
+    @Test
+    fun `should derive a title past a non-breaking space before the h1`() = runTest {
+        // given — an `&nbsp;` spacer only stops a frontmatter following it
+        // from opening the stream; a synthesized one goes first anyway
+        val input = semanticEvents {
+            +"\u00A0"
+            "h1" { +"Hello" }
+        }
+
+        // when
+        val output = input.ensureFrontmatterTitle()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"Hello" }
+            }
+            +"\u00A0"
+            "h1" { +"Hello" }
+        }
+    }
+
+    @Test
+    fun `should derive a title past a non-breaking space between the frontmatter and the h1`() = runTest {
+        // given
+        val input = semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "author") { +"Alice" }
+            }
+            +"\u00A0"
+            "h1" { +"Hello" }
+        }
+
+        // when
+        val output = input.ensureFrontmatterTitle()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"Hello" }
+                "entry"("key" to "author") { +"Alice" }
+            }
+            +"\u00A0"
+            "h1" { +"Hello" }
+        }
+    }
+
+    @Test
+    fun `should drop empty title entries when the h1 yields no title`() = runTest {
+        // given — duplicate keys make js-yaml reject the whole front matter
+        val input = semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title", "type" to "null") { }
+                "entry"("key" to "author") { +"Alice" }
+                "entry"("key" to "title") { }
+            }
+            "h1" { }
+        }
+
+        // when
+        val output = input.ensureFrontmatterTitle()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "author") { +"Alice" }
+            }
+            "h1" { }
+        }
+    }
+
+    @Test
+    fun `should drop empty title entries when no h1 follows`() = runTest {
+        // given
+        val input = semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title", "type" to "null") { }
+                "entry"("key" to "Title") { }
+                "entry"("key" to "author") { +"Alice" }
+            }
+            "p" { +"Body." }
+        }
+
+        // when
+        val output = input.ensureFrontmatterTitle()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "author") { +"Alice" }
+            }
+            "p" { +"Body." }
+        }
+    }
+
+    @Test
+    fun `should drop a frontmatter left empty by dropping its empty title entries`() = runTest {
+        // given — an empty frontmatter renders as `---` twice, which parses
+        // back as two thematic breaks
+        val input = semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title", "type" to "null") { }
+                "entry"("key" to "Title") { }
+            }
+            "p" { +"Body." }
+        }
+
+        // when
+        val output = input.ensureFrontmatterTitle()
+
+        // then
+        output sameAs semanticEvents {
+            "p" { +"Body." }
+        }
+    }
+
+
+    @Test
+    fun `should drop a frontmatter arriving empty when no title can be derived`() = runTest {
+        // given — it renders as `---` twice all the same, which parses back
+        // as two thematic breaks
+        val input = semanticEvents {
+            "frontmatter" {
+                +"\n"
+            }
+            "p" { +"Body." }
+        }
+
+        // when
+        val output = input.ensureFrontmatterTitle()
+
+        // then
+        output sameAs semanticEvents {
+            "p" { +"Body." }
+        }
+    }
+
+    @Test
+    fun `should round-trip Markdown whose front matter holds only a null title`() = runTest {
+        // given
+        val markdown = "---\ntitle:\n---\n\nBody."
+
+        // when
+        val output = flowOf(markdown).parse().ensureFrontmatterTitle().renderMarkdown()
+
+        // then
+        output sameAs "Body."
+    }
+
+    @Test
+    fun `should keep a leading empty title entry that a verbatim line follows`() = runTest {
+        // given — dropping the entry would make the verbatim line the first
+        // one, which front matter detection rejects: the block would parse
+        // back as a thematic break and a paragraph
+        val markdown = "---\ntitle:\nfoo bar baz\nx: y\n---\n\nBody."
+
+        // when
+        val output = flowOf(markdown).parse().ensureFrontmatterTitle().renderMarkdown()
+
+        // then
+        output sameAs markdown
+    }
+
+    @Test
+    fun `should move a usable title variant ahead of a verbatim line following a dropped empty title`() = runTest {
+        // given
+        val markdown = "---\ntitle:\nfoo bar baz\nTitle: Real\n---\n\nBody."
+
+        // when
+        val output = flowOf(markdown).parse().ensureFrontmatterTitle().renderMarkdown()
+
+        // then
+        output sameAs "---\ntitle: Real\nfoo bar baz\n---\n\nBody."
+    }
+
+    @Test
+    fun `should keep a frontmatter led by empty title entries and a verbatim line a front matter on re-parse`() = runTest {
+        // given
+        val markdown = "---\ntitle: \"\"\nTitle:\n? complex\nx: y\n---\n\nBody."
+
+        // when
+        val output = flowOf(markdown).parse().ensureFrontmatterTitle().renderMarkdown()
+
+        // then
+        output sameAs "---\ntitle: \"\"\n? complex\nx: y\n---\n\nBody."
+    }
+
+    @Test
+    fun `should derive no title beside a title line outside the YAML subset`() = runTest {
+        // given — the multi-line quoted title comes through as verbatim lines,
+        // yet readers read it: deriving one would make a duplicate key
+        val markdown = "---\ntitle: \"A long\n  title\"\nx: y\n---\n\n# Heading"
+
+        // when
+        val output = flowOf(markdown).parse().ensureFrontmatterTitle().renderMarkdown()
+
+        // then
+        output sameAs markdown
+    }
+
+    @Test
+    fun `should keep a title variant continued on indented lines as content`() = runTest {
+        // given — readers join the continuation lines into the value, which
+        // the YAML subset keeps verbatim, so the variant's title is unknown
+        val markdown = "---\nfoo: a\nTitle: x\n  cont\n  more\ntitle: Real\n---\n\nBody."
+
+        // when
+        val output = flowOf(markdown).parse().ensureFrontmatterTitle().renderMarkdown()
+
+        // then
+        output sameAs markdown
+    }
+
+    @Test
+    fun `should keep the continuation lines of a verbatim line after a title entry`() = runTest {
+        // given — the indented line continues the verbatim line, not the
+        // title entry dropped before it
+        val markdown = "---\nfoo: a\nTitle:\nbar: [a:, b]\n  x\n---\n\nBody."
+
+        // when
+        val output = flowOf(markdown).parse().ensureFrontmatterTitle().renderMarkdown()
+
+        // then
+        output sameAs "---\nfoo: a\nbar: [a:, b]\n  x\n---\n\nBody."
+    }
+
+    @Test
+    fun `should treat a title entry of control chars as blank`() = runTest {
+        // given — a next line char or a C0 control shows nothing, and the
+        // title read back from `<title>` would be empty
+        val input = semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"\u0085\u0001" }
+            }
+            "h1" { +"Heading" }
+        }
+
+        // when
+        val output = input.ensureFrontmatterTitle()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"Heading" }
+            }
+            "h1" { +"Heading" }
+        }
+    }
+
+    @Test
+    fun `should judge the title entries of a frontmatter the stream ends inside`() = runTest {
+        // given — a broken upstream contract: neither the last entry nor the
+        // frontmatter is closed, yet wrapInHtmlDocument reads the open entry.
+        // Built from raw events on purpose: the balanced builders cannot
+        // express an unclosed mark.
+        val input = flowOf(
+            SemanticEvent.Mark(name = "frontmatter", isTagged = false),
+            SemanticEvent.Mark(name = "entry", isTagged = false, attributes = mapOf("key" to "title", "type" to "null")),
+            SemanticEvent.Unmark(name = "entry", isTagged = false),
+            SemanticEvent.Mark(name = "entry", isTagged = false, attributes = mapOf("key" to "Title")),
+            SemanticEvent.Text("Hello"),
+        )
+
+        // when
+        val output = input.ensureFrontmatterTitle()
+
+        // then — closed, so the stream stays balanced
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"Hello" }
+            }
+        }
+    }
+
+    @Test
+    fun `should close an h1 the stream ends inside`() = runTest {
+        // given — a broken upstream contract; built from raw events on
+        // purpose, as the balanced builders cannot express an unclosed mark
+        val input = flowOf(
+            SemanticEvent.Mark(name = "h1", isTagged = false),
+            SemanticEvent.Mark(name = "em", isTagged = false),
+            SemanticEvent.Text("Hello"),
+        )
+
+        // when
+        val output = input.ensureFrontmatterTitle()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"Hello" }
+            }
+            "h1" {
+                "em" { +"Hello" }
+            }
+        }
+    }
+
+    @Test
+    fun `should derive a title past invisible format chars before the h1`() = runTest {
+        // given — a byte order mark or a zero-width space shows nothing, as
+        // in a title
+        val input = semanticEvents {
+            +"\uFEFF"
+            +"\u200B"
+            "h1" { +"Hello" }
+        }
+
+        // when
+        val output = input.ensureFrontmatterTitle()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"Hello" }
+            }
+            +"\uFEFF"
+            +"\u200B"
+            "h1" { +"Hello" }
+        }
+    }
+
+    @Test
+    fun `should collapse line-breaking whitespace in the derived title`() = runTest {
+        // given — a line or paragraph separator, a vertical tab or a next
+        // line char pasted into a heading would break the title's line
+        val input = semanticEvents {
+            "h1" { +"Foo\u2028Bar\u000BBaz\u2029\u0085Qux" }
+        }
+
+        // when
+        val output = input.ensureFrontmatterTitle()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"Foo Bar Baz Qux" }
+            }
+            "h1" { +"Foo\u2028Bar\u000BBaz\u2029\u0085Qux" }
+        }
+    }
+
+    @Test
+    fun `should treat a tagged frontmatter as content`() = runTest {
+        // given — a literal `<frontmatter>` tag, not front matter
+        val input = semanticEvents {
+            tag("frontmatter") {
+                "entry"("key" to "author") { +"Alice" }
+            }
+            "h1" { +"Heading" }
+        }
+
+        // when
+        val output = input.ensureFrontmatterTitle()
+
+        // then
+        output sameAs semanticEvents {
+            tag("frontmatter") {
+                "entry"("key" to "author") { +"Alice" }
+            }
+            "h1" { +"Heading" }
         }
     }
 
diff --git a/markanywhere-html/src/commonTest/kotlin/SimplifyHtmlTest.kt b/markanywhere-html/src/commonTest/kotlin/SimplifyHtmlTest.kt
index f711d90..da02b29 100644
--- a/markanywhere-html/src/commonTest/kotlin/SimplifyHtmlTest.kt
+++ b/markanywhere-html/src/commonTest/kotlin/SimplifyHtmlTest.kt
@@ -838,6 +838,1393 @@ class SimplifyHtmlTest {
         }
     }
 
+    @Test
+    fun `should drop application-state meta values from frontmatter`() = runTest {
+        // given — single-page-app state serialised into <meta content>, the
+        // shapes that swamped LinkedIn's front matter (issue #82)
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "meta"("name" to "__init", "content" to "{\"a\":1}") { }
+                    "meta"("name" to "storage-inventory", "content" to "  [[1,2],[3]]") { }
+                    "meta"("name" to "como-err", "content" to "[{\"x\":1}]") { }
+                    "meta"("name" to "empty-object", "content" to "{}") { }
+                    "meta"("name" to "feed/config/environment", "content" to "%7B%22x%22%3A1%7D") { }
+                    "meta"("name" to "jam/config/environment", "content" to "%7b%7d") { }
+                    "meta"("name" to "spaced", "content" to "%5B%20%7B%22a%22%3A1%7D%20%5D") { }
+                    "meta"("name" to "description", "content" to "Save {50%} today") { }
+                }
+                "body" { "p" { +"text" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then — only a value that *is* a JSON object, or an array that is
+        // not a flat list of scalars, raw or percent-encoded, marks state
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "description") { +"Save {50%} today" }
+            }
+            "p" { +"text" }
+        }
+    }
+
+    @Test
+    fun `should keep meta values opening with a bracketed or braced tag`() = runTest {
+        // given — human-readable prefixes, not JSON objects or arrays, even
+        // when the value also ends with a bracket
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "meta"("name" to "description", "content" to "[Solved] How to fix X") { }
+                    "meta"("name" to "og:title", "content" to "[PDF] Annual report") { }
+                    "meta"("name" to "abstract", "content" to "[1] Introduction") { }
+                    "meta"("name" to "twitter:title", "content" to "[2024] Annual report [PDF]") { }
+                    "meta"("name" to "summary", "content" to "[1] Intro, see [2]") { }
+                    "meta"("name" to "og:description", "content" to "{Kotlin} Multiplatform guide") { }
+                    "meta"("name" to "subject", "content" to "%5BDraft%5D notes") { }
+                }
+                "body" { "p" { +"text" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "description") { +"[Solved] How to fix X" }
+                "entry"("key" to "og:title") { +"[PDF] Annual report" }
+                "entry"("key" to "abstract") { +"[1] Introduction" }
+                "entry"("key" to "twitter:title") { +"[2024] Annual report [PDF]" }
+                "entry"("key" to "summary") { +"[1] Intro, see [2]" }
+                "entry"("key" to "og:description") { +"{Kotlin} Multiplatform guide" }
+                "entry"("key" to "subject") { +"%5BDraft%5D notes" }
+            }
+            "p" { +"text" }
+        }
+    }
+
+    @Test
+    fun `should drop meta values longer than the cap unless they read as text`() = runTest {
+        // given — past the cap only prose survives: a long abstract, in a
+        // script written with spaces or without
+        val abstract = "Background: we study the effect of X on Y. ".repeat(110)
+        val cjkAbstract = "本研究では大規模言語モデルの挙動を分析した。".repeat(200)
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "meta"("name" to "blob", "content" to "x".repeat(4097)) { }
+                    "meta"("name" to "hashes", "content" to "0123456789abcdef, ".repeat(300)) { }
+                    "meta"("name" to "truncated-json", "content" to "{\"id\": 1, \"tags\": [\"a\", \"b\"], ".repeat(150)) { }
+                    "meta"("name" to "short-blob", "content" to "y".repeat(4096)) { }
+                    "meta"("name" to "citation_abstract", "content" to abstract) { }
+                    "meta"("name" to "dc.description", "content" to cjkAbstract) { }
+                }
+                "body" { "p" { +"text" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "short-blob") { +"y".repeat(4096) }
+                "entry"("key" to "citation_abstract") { +abstract }
+                "entry"("key" to "dc.description") { +cjkAbstract }
+            }
+            "p" { +"text" }
+        }
+    }
+
+    @Test
+    fun `should drop JSON state serialised into a JSON string`() = runTest {
+        // given — a single-page-app double encoding, and one nested deeper;
+        // a quoted phrase and a JSON string of words stay metadata
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "meta"("name" to "app-state", "content" to "\"{\\\"user\\\":{\\\"id\\\":1}}\"") { }
+                    "meta"("name" to "app-state-2", "content" to "\"\\\"[{\\\\\\\"id\\\\\\\":1}]\\\"\"") { }
+                    "meta"("name" to "description", "content" to "\"Hello\" world") { }
+                    "meta"("name" to "subject", "content" to "\"{Draft} notes\"") { }
+                }
+                "body" { "p" { +"text" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "description") { +"\"Hello\" world" }
+                "entry"("key" to "subject") { +"\"{Draft} notes\"" }
+            }
+            "p" { +"text" }
+        }
+    }
+
+    @Test
+    fun `should drop state percent-encoded inside a JSON string or more than once`() = runTest {
+        // given — encoding state once more, in either layer, must not hide it
+        val state = "{\"modulePrefix\":\"app\"}"
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "meta"("name" to "app/config", "content" to "\"${state.percentEncoded()}\"") { }
+                    "meta"("name" to "app/config-2", "content" to state.percentEncoded().percentEncoded()) { }
+                    "meta"("name" to "subject", "content" to "\"50%25 off\"") { }
+                }
+                "body" { "p" { +"text" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "subject") { +"\"50%25 off\"" }
+            }
+            "p" { +"text" }
+        }
+    }
+
+    @Test
+    fun `should drop state with invisible chars at its edges`() = runTest {
+        // given — a byte order mark, NBSP or zero-width space carries nothing
+        // for a reader, so it must not hide the JSON behind it
+        val state = "{\"user\":{\"id\":1}}"
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "meta"("name" to "init", "content" to "\uFEFF$state") { }
+                    "meta"("name" to "init-2", "content" to "\u00A0$state\u200B") { }
+                    "meta"("name" to "init-3", "content" to "\"\uFEFF${state.replace("\"", "\\\"")}\"") { }
+                }
+                "body" { "p" { +"text" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "p" { +"text" }
+        }
+    }
+
+    @Test
+    fun `should undo at most eight layers of encoding in all`() = runTest {
+        // given — JSON-string and percent layers alternating count against one
+        // budget, so a value past it costs no more passes and is kept
+        val state = "{\"a\":1}"
+        fun String.jsonString() = "\"" + replace("\\", "\\\\").replace("\"", "\\\"") + "\""
+        val eight = (1..4).fold(state) { value, _ -> value.jsonString().percentEncoded() }
+        val nine = eight.jsonString()
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "meta"("name" to "eight", "content" to eight) { }
+                    "meta"("name" to "nine", "content" to nine) { }
+                }
+                "body" { "p" { +"text" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "nine") { +nine }
+            }
+            "p" { +"text" }
+        }
+    }
+
+    @Test
+    fun `should keep long text written in supplementary-plane letters or emoji`() = runTest {
+        // given — each of these letters and emoji is a UTF-16 surrogate pair
+        val extensionB = "\uD840\uDC00\uD840\uDC01\uD840\uDC02。".repeat(700)
+        val emoji = "Party \uD83C\uDF89\uD83C\uDF89\uD83C\uDF89\uD83C\uDF89 time! ".repeat(200)
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "meta"("name" to "description", "content" to extensionB) { }
+                    "meta"("name" to "og:description", "content" to emoji) { }
+                }
+                "body" { "p" { +"text" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "description") { +extensionB }
+                "entry"("key" to "og:description") { +emoji }
+            }
+            "p" { +"text" }
+        }
+    }
+
+    @Test
+    fun `should drop a long unspaced run of letters of a script written with spaces`() = runTest {
+        // given — Latin, Greek and Cyrillic are written with spaces, so a
+        // letter of theirs breaks no word, accented or not; Thai is not, so a
+        // long Thai text without spaces is kept
+        val latin = "àéîõüçñ".repeat(700)
+        val greek = "αβγδεζη".repeat(700)
+        val cyrillic = "абвгдеж".repeat(700)
+        val thai = "ภาษาไทยเขียนติดกันโดยไม่เว้นวรรค".repeat(150)
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "meta"("name" to "latin", "content" to latin) { }
+                    "meta"("name" to "greek", "content" to greek) { }
+                    "meta"("name" to "cyrillic", "content" to cyrillic) { }
+                    "meta"("name" to "description", "content" to thai) { }
+                }
+                "body" { "p" { +"text" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "description") { +thai }
+            }
+            "p" { +"text" }
+        }
+    }
+
+    @Test
+    fun `should keep long text in scripts writing vowels as combining marks`() = runTest {
+        // given — Devanagari matras and viramas, and Arabic harakat, are marks
+        // (Mn / Mc), not letters: under half of these chars are letters
+        val hindi = "किन्तु प्रत्येक व्यक्ति की स्वतन्त्रता सुनिश्चित है। ".repeat(100)
+        val arabic = "بِسْمِ ٱللَّٰهِ ٱلرَّحْمَٰنِ ٱلرَّحِيمِ ".repeat(150)
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "meta"("name" to "description", "content" to hindi) { }
+                    "meta"("name" to "og:description", "content" to arabic) { }
+                }
+                "body" { "p" { +"text" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "description") { +hindi }
+                "entry"("key" to "og:description") { +arabic }
+            }
+            "p" { +"text" }
+        }
+    }
+
+    @Test
+    fun `should drop a JSON array of JSON-encoded state`() = runTest {
+        // given — each element is state serialised into a string, as the
+        // same payload unwrapped to a bare JSON string would be
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "meta"("name" to "app-state", "content" to "[\"{\\\"id\\\":1,\\\"token\\\":\\\"x\\\"}\", \"{\\\"id\\\":2}\"]") { }
+                    "meta"("name" to "keywords", "content" to "[\"{Draft}\", \"notes\"]") { }
+                }
+                "body" { "p" { +"text" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "keywords") { +"[\"{Draft}\", \"notes\"]" }
+            }
+            "p" { +"text" }
+        }
+    }
+
+    @Test
+    fun `should keep long comma-separated keyword lists`() = runTest {
+        // given — list separators break words as spaces do, and long compound
+        // words keep a list sparse in breaks; a list of hashes stays dropped
+        val compact = (1..600).joinToString(",") { "tag$it" }
+        val german = List(100) { "Bundesverfassungsgericht, Rechtsprechung" }.joinToString(", ")
+        val semicolons = List(160) { "Verwaltungsgerichtsbarkeit" }.joinToString("; ")
+        val hashes = (1..300).joinToString(",") { "0123456789abcdef" }
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "meta"("name" to "keywords", "content" to compact) { }
+                    "meta"("name" to "news_keywords", "content" to german) { }
+                    "meta"("name" to "subject", "content" to semicolons) { }
+                    "meta"("name" to "hashes", "content" to hashes) { }
+                }
+                "body" { "p" { +"text" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "keywords") { +compact }
+                "entry"("key" to "news_keywords") { +german }
+                "entry"("key" to "subject") { +semicolons }
+            }
+            "p" { +"text" }
+        }
+    }
+
+    @Test
+    fun `should keep a long list of URLs`() = runTest {
+        // given — path separators break a URL into words; base64, which
+        // holds a slash only now and then, stays dropped
+        val urls = (1..150).joinToString(" ") { "https://www.example.org/reference/article-$it" }
+        val base64 = "QUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVo/abc+".repeat(120)
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "meta"("name" to "citation_references", "content" to urls) { }
+                    "meta"("name" to "blob", "content" to base64) { }
+                }
+                "body" { "p" { +"text" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "citation_references") { +urls }
+            }
+            "p" { +"text" }
+        }
+    }
+
+    @Test
+    fun `should judge a long flat JSON array by its words and not its quotes and commas`() = runTest {
+        // given — both past the cap; the quotes and commas serialising the
+        // words are not the punctuation of state, a list of hashes still is
+        val words = (1..600).joinToString(",", "[", "]") { "\"tag$it\"" }
+        val hashes = (1..300).joinToString(",", "[", "]") { "\"0123456789abcdef\"" }
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "meta"("name" to "keywords", "content" to words) { }
+                    "meta"("name" to "hashes", "content" to hashes) { }
+                }
+                "body" { "p" { +"text" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "keywords") { +words }
+            }
+            "p" { +"text" }
+        }
+    }
+
+    @Test
+    fun `should measure a flat JSON array by its elements as the same list written plainly`() = runTest {
+        // given — over the cap as written, under it once the quotes and
+        // commas are gone: short, as the same hashes written plainly are
+        val jsonHashes = (1..380).joinToString(",", "[", "]") { "\"a1b2c3d4\"" }
+        val plainHashes = (1..380).joinToString(" ") { "a1b2c3d4" }
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "meta"("name" to "json-hashes", "content" to jsonHashes) { }
+                    "meta"("name" to "plain-hashes", "content" to plainHashes) { }
+                }
+                "body" { "p" { +"text" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "json-hashes") { +jsonHashes }
+                "entry"("key" to "plain-hashes") { +plainHashes }
+            }
+            "p" { +"text" }
+        }
+    }
+
+
+    @Test
+    fun `should judge a flat JSON array too long to parse as written`() = runTest {
+        // given — words, but far past anything metadata holds: parsing it
+        // would cost many times its size, so its quotes and commas count
+        val words = (1..10000).joinToString(",", "[", "]") { "\"lorem\"" }
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "meta"("name" to "keywords", "content" to words) { }
+                }
+                "body" { "p" { +"text" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "p" { +"text" }
+        }
+    }
+
+    @Test
+    fun `should drop a long array holding a nested element unless it reads as text`() = runTest {
+        // given — state if it parses, a blob if it does not; neither is text
+        val state = (1..600).joinToString(",", "[", "]") { "[$it,$it]" }
+        val truncated = state.dropLast(1)
+        // the nested element need not come first
+        val late = (1..600).joinToString(",", "[\"x\",", "]") { "{\"id\":$it}" }
+        val lateTruncated = late.dropLast(1)
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "meta"("name" to "state", "content" to state) { }
+                    "meta"("name" to "truncated", "content" to truncated) { }
+                    "meta"("name" to "late", "content" to late) { }
+                    "meta"("name" to "late-truncated", "content" to lateTruncated) { }
+                }
+                "body" { "p" { +"text" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "p" { +"text" }
+        }
+    }
+
+    @Test
+    fun `should judge the length of a percent-encoded value as it is written`() = runTest {
+        // given — a value is written to the front matter still encoded, so
+        // prose whose escapes run past the cap is as opaque there as a blob,
+        // while a short encoded value is kept
+        val longProse = "本研究では大規模言語モデルの挙動を分析した。".repeat(30).percentEncoded()
+        val shortProse = "本研究では大規模言語モデルの挙動を分析した。".percentEncoded()
+        val blob = ("A" + "x".repeat(5000)).percentEncoded()
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "meta"("name" to "description", "content" to longProse) { }
+                    "meta"("name" to "blob", "content" to blob) { }
+                    "meta"("name" to "abstract", "content" to shortProse) { }
+                }
+                "body" { "p" { +"text" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "abstract") { +shortProse }
+            }
+            "p" { +"text" }
+        }
+    }
+
+    @Test
+    fun `should drop a long JSON object even when its content reads as text`() = runTest {
+        // given — an over-long value that reads as text is still parsed, so
+        // state wrapping prose is not kept for its prose
+        val prose = "A study of how language models behave in long dialogues. ".repeat(100)
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "meta"("name" to "state", "content" to "{\"text\": \"$prose\"}") { }
+                    "meta"("name" to "description", "content" to prose) { }
+                }
+                "body" { "p" { +"text" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "description") { +prose }
+            }
+            "p" { +"text" }
+        }
+    }
+
+    @Test
+    fun `should drop a value too long to parse opening like JSON without parsing it`() = runTest {
+        // given — far past anything metadata holds, a value opening like a
+        // JSON object, array or string, or a percent escape is judged by
+        // that alone, so no page-controlled value is parsed whatever its size;
+        // plain prose that long is still kept
+        val prose = "A study of how language models behave in long dialogues. ".repeat(1200)
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "meta"("name" to "quoted", "content" to "\"$prose\"") { }
+                    "meta"("name" to "state", "content" to "{\"text\": \"$prose\"}") { }
+                    "meta"("name" to "description", "content" to prose) { }
+                }
+                "body" { "p" { +"text" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "description") { +prose }
+            }
+            "p" { +"text" }
+        }
+    }
+
+    @Test
+    fun `should keep bracketed human text holding a nested bracket`() = runTest {
+        // given — a bare word is no JSON value, so these are no nested JSON
+        // arrays however leniently a parser reads them
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "meta"("name" to "keywords", "content" to "[foo, [bar]]") { }
+                    "meta"("name" to "description", "content" to "[[Wiki]]") { }
+                    "meta"("name" to "state", "content" to "[[\"a\", 1, true, null, -2.5e3]]") { }
+                }
+                "body" { "p" { +"text" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "keywords") { +"[foo, [bar]]" }
+                "entry"("key" to "description") { +"[[Wiki]]" }
+            }
+            "p" { +"text" }
+        }
+    }
+
+    @Test
+    fun `should drop a long value made of emoji`() = runTest {
+        // given — an emoji is no letter, so a blob encoded as emoji does not
+        // read as text, while styled letters of the supplementary planes and
+        // CJK Extension B ideographs do
+        val emoji = "\uD83D\uDE00\uD83D\uDC4D\uD83C\uDF89 ".repeat(1500)
+        val styled = "\uD835\uDC07\uD835\uDC1E\uD835\uDC25\uD835\uDC25\uD835\uDC28 ".repeat(1000)
+        val cjk = "\uD840\uDC00\uD840\uDC01\uD840\uDC02".repeat(1500)
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "meta"("name" to "state", "content" to emoji) { }
+                    "meta"("name" to "description", "content" to styled) { }
+                    "meta"("name" to "abstract", "content" to cjk) { }
+                }
+                "body" { "p" { +"text" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "description") { +styled }
+                "entry"("key" to "abstract") { +cjk }
+            }
+            "p" { +"text" }
+        }
+    }
+
+    @Test
+    fun `should not decode a percent escape made of non-ASCII digits`() = runTest {
+        // given — an Arabic-Indic seven is no hex digit, so this is not a
+        // percent-encoded JSON object but text
+        val value = "%\u0667B%22a%22%3A1%7D"
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "meta"("name" to "config", "content" to value) { }
+                }
+                "body" { "p" { +"text" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "config") { +value }
+            }
+            "p" { +"text" }
+        }
+    }
+
+    @Test
+    fun `should keep malformed JSON-looking meta values as text without throwing`() = runTest {
+        // given — page-controlled input the JSON parser rejects in any way
+        val malformed = listOf(
+            "[\"\\u12\"]",
+            "{\"a\":\"\\",
+            "[1e99999999999999999999]",
+            "[".repeat(2000) + "]".repeat(1999),
+            "{\"a\":\"\u0000\"",
+        )
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    malformed.forEachIndexed { i, value ->
+                        "meta"("name" to "m$i", "content" to value) { }
+                    }
+                }
+                "body" { "p" { +"text" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                malformed.forEachIndexed { i, value ->
+                    "entry"("key" to "m$i") { +value }
+                }
+            }
+            "p" { +"text" }
+        }
+    }
+
+    @Test
+    fun `should drop blank meta values from frontmatter`() = runTest {
+        // given — an NBSP-only value tells a reader as little as a blank one
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "meta"("name" to "keywords", "content" to "") { }
+                    "meta"("name" to "abstract", "content" to " \t\n") { }
+                    "meta"("name" to "separator", "content" to "\u00A0") { }
+                    "meta"("name" to "section/topic", "content" to "Politics") { }
+                    "meta"("name" to "description", "content" to "A doc") { }
+                    "meta"("name" to "og:title", "content" to "Hello") { }
+                    "meta"("name" to "author", "content" to "Alice") { }
+                    "meta"("name" to "article:published_time", "content" to "2026-09-27T10:00:00Z") { }
+                }
+                "body" { "p" { +"text" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then — ordinary metadata survives, a `/` in the name included
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "section/topic") { +"Politics" }
+                "entry"("key" to "description") { +"A doc" }
+                "entry"("key" to "og:title") { +"Hello" }
+                "entry"("key" to "author") { +"Alice" }
+                "entry"("key" to "article:published_time") { +"2026-09-27T10:00:00Z" }
+            }
+            "p" { +"text" }
+        }
+    }
+
+    @Test
+    fun `should skip a blank html lang in favour of a lang meta`() = runTest {
+        // given
+        val input = semanticEvents(tagged = true) {
+            "html"("lang" to " ") {
+                "head" {
+                    "meta"("name" to "lang", "content" to "de") { }
+                }
+                "body" { "p" { +"x" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "lang") { +"de" }
+            }
+            "p" { +"x" }
+        }
+    }
+
+
+    @Test
+    fun `should trim invisible chars around the html lang`() = runTest {
+        // given
+        val input = semanticEvents(tagged = true) {
+            "html"("lang" to "\uFEFFen\u200B") {
+                "head" { }
+                "body" { "p" { +"text" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "lang") { +"en" }
+            }
+            "p" { +"text" }
+        }
+    }
+
+    @Test
+    fun `should trim invisible chars around a lang meta`() = runTest {
+        // given
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "meta"("name" to "lang", "content" to "\u200Bde\uFEFF") { }
+                }
+                "body" { "p" { +"text" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "lang") { +"de" }
+            }
+            "p" { +"text" }
+        }
+    }
+
+    @Test
+    fun `should trim HTML whitespace around the html lang`() = runTest {
+        // given
+        val input = semanticEvents(tagged = true) {
+            "html"("lang" to " en\n") {
+                "head" { }
+                "body" { "p" { +"x" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "lang") { +"en" }
+            }
+            "p" { +"x" }
+        }
+    }
+
+    @Test
+    fun `should trim HTML whitespace around a lang meta`() = runTest {
+        // given
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "meta"("name" to "LANG", "content" to "\tde\n") { }
+                }
+                "body" { "p" { +"x" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "lang") { +"de" }
+            }
+            "p" { +"x" }
+        }
+    }
+
+    @Test
+    fun `should prefer html lang over a lang meta in any letter case`() = runTest {
+        // given — the document language is the root element's attribute
+        val input = semanticEvents(tagged = true) {
+            "html"("lang" to "en") {
+                "head" {
+                    "meta"("name" to "Lang", "content" to "de") { }
+                    "meta"("name" to "lang", "content" to "fr") { }
+                }
+                "body" { "p" { +"x" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "lang") { +"en" }
+            }
+            "p" { +"x" }
+        }
+    }
+
+    @Test
+    fun `should spell a lang meta in any letter case as the lang key`() = runTest {
+        // given — without <html lang> the meta is the only language there is,
+        // and the front matter says so in the key wrapInHtmlDocument reads
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "meta"("name" to "LANG", "content" to "de") { }
+                }
+                "body" { "p" { +"x" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "lang") { +"de" }
+            }
+            "p" { +"x" }
+        }
+    }
+
+    @Test
+    fun `should keep the first non-blank title when head holds several`() = runTest {
+        // given — e.g. after a client-side navigation (issue #82)
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "title" { +"  " }
+                    "title" { +"A" }
+                    "title" { +"B" }
+                }
+                "body" { "p" { +"x" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then — not "AB", not "B"
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"A" }
+            }
+            "p" { +"x" }
+        }
+    }
+
+    @Test
+    fun `should prefer the title element over a title meta preceding it`() = runTest {
+        // given
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "meta"("name" to "title", "content" to "SEO blurb") { }
+                    "title" { +"Actual Page" }
+                }
+                "body" { "p" { +"x" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"Actual Page" }
+            }
+            "p" { +"x" }
+        }
+    }
+
+    @Test
+    fun `should prefer the title element over a title meta following it`() = runTest {
+        // given
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "title" { +"Actual Page" }
+                    "meta"("name" to "title", "content" to "SEO blurb") { }
+                }
+                "body" { "p" { +"x" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"Actual Page" }
+            }
+            "p" { +"x" }
+        }
+    }
+
+    @Test
+    fun `should prefer the title element over a title meta in any letter case`() = runTest {
+        // given — meta names are matched case-insensitively (HTML §4.2.5)
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "meta"("name" to "Title", "content" to "SEO blurb") { }
+                    "title" { +"Actual Page" }
+                    "meta"("name" to "TITLE", "content" to "Other blurb") { }
+                    "meta"("name" to "author", "content" to "Alice") { }
+                }
+                "body" { "p" { +"x" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then — a single title, at the position of the first candidate
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"Actual Page" }
+                "entry"("key" to "author") { +"Alice" }
+            }
+            "p" { +"x" }
+        }
+    }
+
+    @Test
+    fun `should keep the first non-blank title meta when there is no title element`() = runTest {
+        // given
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "meta"("name" to "author", "content" to "Alice") { }
+                    "meta"("name" to "title", "content" to "First") { }
+                    "meta"("name" to "Title", "content" to "Second") { }
+                }
+                "body" { "p" { +"x" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "author") { +"Alice" }
+                "entry"("key" to "title") { +"First" }
+            }
+            "p" { +"x" }
+        }
+    }
+
+    @Test
+    fun `should keep the bidi marks at the edges of a title`() = runTest {
+        // given — a right-to-left title ends in a right-to-left mark on
+        // purpose, keeping its punctuation on the right side; an isolate
+        // likewise opens the title of an embedded direction
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "title" { +" \uFEFF\u05E9\u05DC\u05D5\u05DD!\u200F " }
+                    "meta"("name" to "og:title", "content" to "\u2067\u05E9\u05DC\u05D5\u05DD\u2069") { }
+                }
+                "body" { "p" { +"x" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"\u05E9\u05DC\u05D5\u05DD!\u200F" }
+                "entry"("key" to "og:title") { +"\u2067\u05E9\u05DC\u05D5\u05DD\u2069" }
+            }
+            "p" { +"x" }
+        }
+    }
+
+    @Test
+    fun `should trim invisible format chars at the edges of a title`() = runTest {
+        // given — a byte order mark and a zero-width space show nothing, at
+        // an edge they would only force the title into quotes
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "title" { +"\uFEFFMy\u200BPage\u200B" }
+                    "meta"("name" to "Title", "content" to "\u200BIgnored") { }
+                }
+                "body" { "p" { +"x" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"My\u200BPage" }
+            }
+            "p" { +"x" }
+        }
+    }
+
+    @Test
+    fun `should keep non-breaking spaces inside a title trimming the edges`() = runTest {
+        // given — NBSP inside is content, not HTML whitespace, like in a meta
+        // value; at the edges it is padding, which would only force the
+        // title into quotes
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "title" { +" \u00A0Page\u00A0One\u00A0\n" }
+                    "title" { +"Later" }
+                }
+                "body" { "p" { +"x" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"Page\u00A0One" }
+            }
+            "p" { +"x" }
+        }
+    }
+
+    @Test
+    fun `should keep a flat JSON list of scalars in frontmatter`() = runTest {
+        // given — a list a person writes, not serialised state — an empty
+        // one, one percent-encoded, and one whose bare words JSON would read
+        // as flags or `null` included
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "meta"("name" to "keywords", "content" to "[\"Kotlin\",\"Multiplatform\"]") { }
+                    "meta"("name" to "article:tag", "content" to "[\"politics\"]") { }
+                    "meta"("name" to "citation_volume", "content" to "[2024]") { }
+                    "meta"("name" to "chapters", "content" to "[1, 2, 3]") { }
+                    "meta"("name" to "label", "content" to "[PDF]") { }
+                    "meta"("name" to "none", "content" to "[]") { }
+                    "meta"("name" to "none-spaced", "content" to "[ ]") { }
+                    "meta"("name" to "encoded", "content" to "%5B%22a%22%5D") { }
+                    "meta"("name" to "nothing", "content" to "[null]") { }
+                    "meta"("name" to "answer", "content" to "[true]") { }
+                    "meta"("name" to "options", "content" to "[true, false]") { }
+                    "meta"("name" to "encoded-flag", "content" to "%5Btrue%5D") { }
+                }
+                "body" { "p" { +"text" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "keywords") { +"[\"Kotlin\",\"Multiplatform\"]" }
+                "entry"("key" to "article:tag") { +"[\"politics\"]" }
+                "entry"("key" to "citation_volume") { +"[2024]" }
+                "entry"("key" to "chapters") { +"[1, 2, 3]" }
+                "entry"("key" to "label") { +"[PDF]" }
+                "entry"("key" to "none") { +"[]" }
+                "entry"("key" to "none-spaced") { +"[ ]" }
+                "entry"("key" to "encoded") { +"%5B%22a%22%5D" }
+                "entry"("key" to "nothing") { +"[null]" }
+                "entry"("key" to "answer") { +"[true]" }
+                "entry"("key" to "options") { +"[true, false]" }
+                "entry"("key" to "encoded-flag") { +"%5Btrue%5D" }
+            }
+            "p" { +"text" }
+        }
+    }
+
+    @Test
+    fun `should drop a malformed-JSON-looking value only when it parses`() = runTest {
+        // given — not JSON, so kept as text: trailing commas, crossed brackets
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "meta"("name" to "a", "content" to "[1,]") { }
+                    "meta"("name" to "b", "content" to "{\"a\":1,}") { }
+                    "meta"("name" to "c", "content" to "[}") { }
+                    "meta"("name" to "d", "content" to "{draft}") { }
+                }
+                "body" { "p" { +"text" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "a") { +"[1,]" }
+                "entry"("key" to "b") { +"{\"a\":1,}" }
+                "entry"("key" to "c") { +"[}" }
+                "entry"("key" to "d") { +"{draft}" }
+            }
+            "p" { +"text" }
+        }
+    }
+
+    @Test
+    fun `should skip a title of non-breaking spaces only`() = runTest {
+        // given — blank as ensureFrontmatterTitle judges it, which would
+        // otherwise replace it and lose the later title
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "title" { +"\u00A0\u00A0" }
+                    "title" { +"Real Page" }
+                    "meta"("name" to "title", "content" to "\u00A0") { }
+                }
+                "body" { "p" { +"x" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"Real Page" }
+            }
+            "p" { +"x" }
+        }
+    }
+
+    @Test
+    fun `should skip a title of invisible format chars only`() = runTest {
+        // given — a zero-width space or a byte order mark is not whitespace,
+        // yet shows nothing
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "title" { +"\u200B" }
+                    "meta"("name" to "title", "content" to "Real Page") { }
+                    "meta"("name" to "description", "content" to "\uFEFF\u200B") { }
+                }
+                "body" { "p" { +"x" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"Real Page" }
+            }
+            "p" { +"x" }
+        }
+    }
+
+    @Test
+    fun `should skip a title of blank-rendering letters only`() = runTest {
+        // given — a Hangul filler or a blank Braille pattern is a letter or a
+        // symbol, yet shows nothing: the common trick for a blank name
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "title" { +"\u3164" }
+                    "meta"("name" to "title", "content" to "Real Page") { }
+                    "meta"("name" to "description", "content" to "\u115F\u1160\uFFA0\u2800") { }
+                }
+                "body" { "p" { +"x" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"Real Page" }
+            }
+            "p" { +"x" }
+        }
+    }
+
+    @Test
+    fun `should strip and collapse a title meta like a title element`() = runTest {
+        // given
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "meta"("name" to "title", "content" to "  SEO\n    blurb\n") { }
+                }
+                "body" { "p" { +"x" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"SEO blurb" }
+            }
+            "p" { +"x" }
+        }
+    }
+
+    @Test
+    fun `should keep the first of meta names differing only in letter case`() = runTest {
+        // given — meta names are ASCII case-insensitive (HTML §4.2.5)
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "meta"("name" to "Description", "content" to "First") { }
+                    "meta"("name" to "author", "content" to "Alice") { }
+                    "meta"("name" to "description", "content" to "Second") { }
+                    "meta"("name" to "AUTHOR", "content" to "Bob") { }
+                }
+                "body" { "p" { +"x" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "Description") { +"First" }
+                "entry"("key" to "author") { +"Alice" }
+            }
+            "p" { +"x" }
+        }
+    }
+
+    @Test
+    fun `should fold only ASCII letter case in meta names`() = runTest {
+        // given — a dotless ı is not an i, whatever Unicode case folding says
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "title" { +"Page" }
+                    "meta"("name" to "t\u0131tle", "content" to "Other") { }
+                }
+                "body" { "p" { +"x" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"Page" }
+                "entry"("key" to "t\u0131tle") { +"Other" }
+            }
+            "p" { +"x" }
+        }
+    }
+
+    @Test
+    fun `should fall back to a title meta when no title element is present`() = runTest {
+        // given
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "meta"("name" to "title", "content" to "SEO blurb") { }
+                }
+                "body" { "p" { +"x" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"SEO blurb" }
+            }
+            "p" { +"x" }
+        }
+    }
+
     @Test
     fun `should not emit frontmatter when head yields no metadata`() = runTest {
         // given
@@ -910,6 +2297,31 @@ class SimplifyHtmlTest {
         }
     }
 
+    @Test
+    fun `should collapse whitespace inside a pretty-printed title`() = runTest {
+        // given — like document.title, which strips and collapses ASCII
+        // whitespace; the NBSP is content and stays
+        val input = semanticEvents(tagged = true) {
+            "html" {
+                "head" {
+                    "title" { +"\n    Foo\n    Bar\u00A0\u00A0Baz\n  " }
+                }
+                "body" { "p" { +"x" } }
+            }
+        }
+
+        // when
+        val output = input.simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"Foo Bar\u00A0\u00A0Baz" }
+            }
+            "p" { +"x" }
+        }
+    }
+
     @Test
     fun `should drop marks nested inside title and keep only their text`() = runTest {
         // given
@@ -1531,3 +2943,8 @@ class SimplifyHtmlTest {
     }
 
 }
+
+// Every byte as a `%XX` escape of its UTF-8 encoding.
+private fun String.percentEncoded(): String = encodeToByteArray().joinToString("") {
+    "%" + (it.toInt() and 0xFF).toString(16).uppercase().padStart(2, '0')
+}
diff --git a/markanywhere-html/src/commonTest/kotlin/WrapInHtmlDocumentTest.kt b/markanywhere-html/src/commonTest/kotlin/WrapInHtmlDocumentTest.kt
index 35ffade..4235749 100644
--- a/markanywhere-html/src/commonTest/kotlin/WrapInHtmlDocumentTest.kt
+++ b/markanywhere-html/src/commonTest/kotlin/WrapInHtmlDocumentTest.kt
@@ -33,7 +33,7 @@ import kotlin.test.Test
  * `entry` marks) feeds the `head`: the `title` entry becomes `<title>`,
  * `lang` becomes the `<html lang>` attribute, every other top-level scalar
  * entry becomes a `<meta name content>` — the inverse of `simplifyHtml`'s
- * head-to-frontmatter extraction.
+ * head-to-frontmatter extraction, minus the values it discards.
  */
 class WrapInHtmlDocumentTest {
 
@@ -103,13 +103,91 @@ class WrapInHtmlDocumentTest {
         }
     }
 
+    @Test
+    fun `should trim HTML whitespace around the lang`() = runTest {
+        // given — as simplifyHtml trims it on the way in (text that opens
+        // with indentation and ends with a newline would read as a verbatim
+        // line of unknown value)
+        val input = semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "lang") { +"\n en " }
+            }
+            "p" { +"Body." }
+        }
+
+        // when
+        val output = input.wrapInHtmlDocument()
+
+        // then
+        output sameAs semanticEvents {
+            "html"("lang" to "en") {
+                "head" { }
+                "body" {
+                    "p" { +"Body." }
+                }
+            }
+        }
+    }
+
+    @Test
+    fun `should trim invisible chars around the lang`() = runTest {
+        // given — a byte order mark or a zero-width space makes no valid
+        // language tag, as they are trimmed from a title
+        val input = semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "lang") { +"\uFEFFen\u200B" }
+            }
+            "p" { +"Body." }
+        }
+
+        // when
+        val output = input.wrapInHtmlDocument()
+
+        // then
+        output sameAs semanticEvents {
+            "html"("lang" to "en") {
+                "head" { }
+                "body" {
+                    "p" { +"Body." }
+                }
+            }
+        }
+    }
+
+    @Test
+    fun `should normalize the title as simplifyHtml reads it`() = runTest {
+        // given — invisible chars at the edges, a line separator inside
+        val input = semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"\uFEFF Foo\u2028Bar  baz " }
+            }
+            "p" { +"Body." }
+        }
+
+        // when
+        val output = input.wrapInHtmlDocument()
+
+        // then
+        output sameAs semanticEvents {
+            "html" {
+                "head" {
+                    "title" { +"Foo Bar baz" }
+                }
+                "body" {
+                    "p" { +"Body." }
+                }
+            }
+        }
+    }
+
     @Test
     fun `should use scalar text verbatim including decoded quoting`() = runTest {
-        // given — the parser has already decoded the YAML; the value carries a
-        // colon, quotes and a newline as plain text
+        // given — the parser has already decoded the YAML; the values carry a
+        // colon, quotes and a newline as plain text (a title is one line)
         val input = semanticEvents {
             "frontmatter" {
-                "entry"("key" to "title") { +"He said: \"hi\"\nBye" }
+                "entry"("key" to "title") { +"He said: \"hi\"" }
+                "entry"("key" to "description") { +"Hello\nBye" }
                 "entry"("key" to "og:image") { +"https://example.com/img.png" }
             }
         }
@@ -121,7 +199,8 @@ class WrapInHtmlDocumentTest {
         output sameAs semanticEvents {
             "html" {
                 "head" {
-                    "title" { +"He said: \"hi\"\nBye" }
+                    "title" { +"He said: \"hi\"" }
+                    "meta"("name" to "description", "content" to "Hello\nBye") { }
                     "meta"("name" to "og:image", "content" to "https://example.com/img.png") { }
                 }
                 "body" { }
@@ -130,8 +209,8 @@ class WrapInHtmlDocumentTest {
     }
 
     @Test
-    fun `should include typed scalars and skip nested null and verbatim content`() = runTest {
-        // given — only a top-level scalar is representable as head metadata
+    fun `should include typed scalars and skip nested null blank and verbatim content`() = runTest {
+        // given — only a top-level non-blank scalar is head metadata
         val input = semanticEvents {
             "frontmatter" {
                 "entry"("key" to "title") { +"Hello" }
@@ -159,7 +238,6 @@ class WrapInHtmlDocumentTest {
                 "head" {
                     "title" { +"Hello" }
                     "meta"("name" to "year", "content" to "2026") { }
-                    "meta"("name" to "blank", "content" to "") { }
                 }
                 "body" { }
             }
@@ -167,8 +245,8 @@ class WrapInHtmlDocumentTest {
     }
 
     @Test
-    fun `should let a later duplicate key win`() = runTest {
-        // given
+    fun `should let the last of duplicate keys win as front matter readers do`() = runTest {
+        // given — Psych (Jekyll) and PyYAML keep the later duplicate
         val input = semanticEvents {
             "frontmatter" {
                 "entry"("key" to "author") { +"Alice" }
@@ -190,6 +268,59 @@ class WrapInHtmlDocumentTest {
         }
     }
 
+    @Test
+    fun `should read the title front matter readers read of duplicate title keys`() = runTest {
+        // given
+        val document = flowOf(
+            """
+            ---
+            title: Draft
+            author: Alice
+            title: Final
+            ---
+            """.trimIndent()
+        )
+
+        // when
+        val output = document.parse().wrapInHtmlDocument()
+
+        // then
+        output sameAs semanticEvents {
+            "html" {
+                "head" {
+                    "title" { +"Final" }
+                    "meta"("name" to "author", "content" to "Alice") { }
+                }
+                "body" { }
+            }
+        }
+    }
+
+    @Test
+    fun `should prefer the lowercase spelling of a key over a later variant`() = runTest {
+        // given — a case-sensitive reader (Jekyll) looks up `title`, whatever
+        // follows it in another letter case
+        val input = semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"Real" }
+                "entry"("key" to "Title") { +"Variant" }
+            }
+        }
+
+        // when
+        val output = input.wrapInHtmlDocument()
+
+        // then
+        output sameAs semanticEvents {
+            "html" {
+                "head" {
+                    "title" { +"Real" }
+                }
+                "body" { }
+            }
+        }
+    }
+
     @Test
     fun `should pass a mid-stream frontmatter block through into body`() = runTest {
         // given — only a *leading* frontmatter feeds the head; anywhere else it
@@ -218,6 +349,62 @@ class WrapInHtmlDocumentTest {
         }
     }
 
+    @Test
+    fun `should read a frontmatter preceded by blank text into the head`() = runTest {
+        // given — blank text is insignificant, as for ensureFrontmatterTitle
+        val input = semanticEvents {
+            +"\n"
+            "frontmatter" {
+                "entry"("key" to "title") { +"Page" }
+            }
+            "p" { +"Body." }
+        }
+
+        // when
+        val output = input.wrapInHtmlDocument()
+
+        // then
+        output sameAs semanticEvents {
+            "html" {
+                "head" {
+                    "title" { +"Page" }
+                }
+                "body" {
+                    +"\n"
+                    "p" { +"Body." }
+                }
+            }
+        }
+    }
+
+    @Test
+    fun `should treat a frontmatter preceded by a non-breaking space as content`() = runTest {
+        // given — NBSP is content in HTML, so the frontmatter does not open
+        // the stream
+        val input = semanticEvents {
+            +"\u00A0"
+            "frontmatter" {
+                "entry"("key" to "title") { +"Page" }
+            }
+        }
+
+        // when
+        val output = input.wrapInHtmlDocument()
+
+        // then
+        output sameAs semanticEvents {
+            "html" {
+                "head" { }
+                "body" {
+                    +"\u00A0"
+                    "frontmatter" {
+                        "entry"("key" to "title") { +"Page" }
+                    }
+                }
+            }
+        }
+    }
+
     @Test
     fun `should wrap parsed Markdown in a complete HTML document`() = runTest {
         // given
@@ -251,6 +438,79 @@ class WrapInHtmlDocumentTest {
         """.trimIndent()
     }
 
+    @Test
+    fun `should read no value from an entry continued on indented lines`() = runTest {
+        // given — readers join the continuation lines into the value, which
+        // the YAML subset keeps verbatim, so the first line alone is not it
+        val markdown = """
+            ---
+            title: A long
+              title
+            description: first
+              second
+            author: Alice
+            ---
+            Body.
+        """.trimIndent()
+
+        // when
+        val html = flowOf(markdown)
+            .parse()
+            .wrapInHtmlDocument()
+            .renderHtml()
+
+        // then
+        html sameAsHtml """
+            <html>
+              <head>
+                <meta name="author" content="Alice"/>
+              </head>
+              <body>
+                <p>
+                  Body.
+                </p>
+              </body>
+            </html>
+        """.trimIndent()
+    }
+
+    @Test
+    fun `should read no value from indented verbatim lines under a bare key`() = runTest {
+        // given — the lines are outside the YAML subset, kept verbatim with
+        // their indentation, and readers disagree on what they hold
+        val markdown = """
+            ---
+            title:
+              [a:, b]
+            description:
+              first line
+              second
+            author: Alice
+            ---
+            Body.
+        """.trimIndent()
+
+        // when
+        val html = flowOf(markdown)
+            .parse()
+            .wrapInHtmlDocument()
+            .renderHtml()
+
+        // then
+        html sameAsHtml """
+            <html>
+              <head>
+                <meta name="author" content="Alice"/>
+              </head>
+              <body>
+                <p>
+                  Body.
+                </p>
+              </body>
+            </html>
+        """.trimIndent()
+    }
+
     @Test
     fun `should reconstruct head metadata extracted by simplifyHtml`() = runTest {
         // given — a captured (tagged) HTML document whose head simplifyHtml
@@ -285,6 +545,194 @@ class WrapInHtmlDocumentTest {
         }
     }
 
+    @Test
+    fun `should round-trip through simplifyHtml except the values it discards`() = runTest {
+        // given — simplifyHtml keeps no blank value and no application state
+        // (a JSON object or array, or an over-long blob), so those entries do
+        // not come back; text that merely looks bracketed does
+        val input = semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"Page" }
+                "entry"("key" to "summary") { +"{draft} notes" }
+                "entry"("key" to "keywords") { }
+                "entry"("key" to "state") { +"{\"a\":1}" }
+                "entry"("key" to "blob") { +"x".repeat(4097) }
+            }
+            "p" { +"Hi" }
+        }
+
+        // when
+        val output = input.wrapInHtmlDocument().simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"Page" }
+                "entry"("key" to "summary") { +"{draft} notes" }
+            }
+            "p" { +"Hi" }
+        }
+    }
+
+    @Test
+    fun `should read keys ASCII case-insensitively like meta names`() = runTest {
+        // given — a key differing only in letter case is a duplicate, and
+        // its lowercase spelling wins, at the position of the first one
+        val input = semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "Title") { +"My Page" }
+                "entry"("key" to "LANG") { +"de" }
+                "entry"("key" to "Author") { +"Alice" }
+                "entry"("key" to "description") { +"A doc" }
+                "entry"("key" to "author") { +"Bob" }
+            }
+        }
+
+        // when
+        val output = input.wrapInHtmlDocument()
+
+        // then
+        output sameAs semanticEvents {
+            "html"("lang" to "de") {
+                "head" {
+                    "title" { +"My Page" }
+                    "meta"("name" to "author", "content" to "Bob") { }
+                    "meta"("name" to "description", "content" to "A doc") { }
+                }
+                "body" { }
+            }
+        }
+    }
+
+    @Test
+    fun `should not let a blank key hide a later variant differing in letter case`() = runTest {
+        // given — simplifyHtml never extracts a blank value, so a blank key
+        // must not win the duplicate policy either, or the round-trip loses
+        // the real value
+        val input = semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "description") { +"" }
+                "entry"("key" to "Description") { +"A real summary" }
+                "entry"("key" to "lang") { +" " }
+                "entry"("key" to "Lang") { +"de" }
+                "entry"("key" to "title") { }
+                "entry"("key" to "Title") { +"Page" }
+            }
+        }
+
+        // when
+        val output = input.wrapInHtmlDocument()
+
+        // then
+        output sameAs semanticEvents {
+            "html"("lang" to "de") {
+                "head" {
+                    "title" { +"Page" }
+                    "meta"("name" to "Description", "content" to "A real summary") { }
+                }
+                "body" { }
+            }
+        }
+    }
+
+    @Test
+    fun `should keep a later non-blank variant of a blank key on a round-trip through simplifyHtml`() = runTest {
+        // given
+        val input = semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "description") { +"" }
+                "entry"("key" to "Description") { +"A real summary" }
+            }
+        }
+
+        // when
+        val output = input.wrapInHtmlDocument().simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "Description") { +"A real summary" }
+            }
+        }
+    }
+
+    @Test
+    fun `should keep a title key in any letter case on a round-trip through ensureFrontmatterTitle and simplifyHtml`() = runTest {
+        // given — the H1 must not displace the `Title` entry
+        val input = semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "Title") { +"My Page" }
+            }
+            "h1" { +"Heading" }
+        }
+
+        // when
+        val output = input.ensureFrontmatterTitle().wrapInHtmlDocument().simplifyHtml()
+
+        // then
+        output sameAs semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"My Page" }
+            }
+            "h1" { +"Heading" }
+        }
+    }
+
+    @Test
+    fun `should agree with ensureFrontmatterTitle when a later title variant is blank`() = runTest {
+        // given — the usable first title is kept by ensureFrontmatterTitle,
+        // so the blank variant after it must not blank the <title>
+        val input = semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { +"Foo" }
+                "entry"("key" to "Title") { }
+            }
+            "h1" { +"Heading" }
+        }
+
+        // when
+        val output = input.ensureFrontmatterTitle().wrapInHtmlDocument()
+
+        // then
+        output sameAs semanticEvents {
+            "html" {
+                "head" {
+                    "title" { +"Foo" }
+                }
+                "body" {
+                    "h1" { +"Heading" }
+                }
+            }
+        }
+    }
+
+    @Test
+    fun `should agree with ensureFrontmatterTitle when the first title variant is blank`() = runTest {
+        // given — both skip the blank first title, so the later usable
+        // variant is the title and the heading does not displace it
+        val input = semanticEvents {
+            "frontmatter" {
+                "entry"("key" to "title") { }
+                "entry"("key" to "Title") { +"Foo" }
+            }
+            "h1" { +"Heading" }
+        }
+
+        // when
+        val output = input.ensureFrontmatterTitle().wrapInHtmlDocument()
+
+        // then
+        output sameAs semanticEvents {
+            "html" {
+                "head" {
+                    "title" { +"Foo" }
+                }
+                "body" {
+                    "h1" { +"Heading" }
+                }
+            }
+        }
+    }
 
     @Test
     fun `should use an entry left open when the stream ends inside the frontmatter`() = runTest {
diff --git a/markanywhere-html/src/commonTest/kotlin/dumps/W3cValidatorNoRefsTest.kt b/markanywhere-html/src/commonTest/kotlin/dumps/W3cValidatorNoRefsTest.kt
index aac5bf5..33b4e23 100644
--- a/markanywhere-html/src/commonTest/kotlin/dumps/W3cValidatorNoRefsTest.kt
+++ b/markanywhere-html/src/commonTest/kotlin/dumps/W3cValidatorNoRefsTest.kt
@@ -51,7 +51,7 @@ class W3cValidatorNoRefsTest {
         markdown sameAsMarkdown """
             ---
             lang: en
-            title: Ready to check  - Nu Html Checker
+            title: Ready to check - Nu Html Checker
             ---
             
             # [Nu Html Checker](.)
diff --git a/markanywhere-html/src/commonTest/kotlin/dumps/W3cValidatorRefsTest.kt b/markanywhere-html/src/commonTest/kotlin/dumps/W3cValidatorRefsTest.kt
index 878b978..9188872 100644
--- a/markanywhere-html/src/commonTest/kotlin/dumps/W3cValidatorRefsTest.kt
+++ b/markanywhere-html/src/commonTest/kotlin/dumps/W3cValidatorRefsTest.kt
@@ -53,7 +53,7 @@ class W3cValidatorRefsTest {
         markdown sameAsMarkdown """
             ---
             lang: en
-            title: Ready to check  - Nu Html Checker
+            title: Ready to check - Nu Html Checker
             ---
             
             # [Nu Html Checker](ref:1:.)
diff --git a/markanywhere-parse/src/commonMain/kotlin/AutolinkCollector.kt b/markanywhere-parse/src/commonMain/kotlin/AutolinkCollector.kt
index 714d80e..809346b 100644
--- a/markanywhere-parse/src/commonMain/kotlin/AutolinkCollector.kt
+++ b/markanywhere-parse/src/commonMain/kotlin/AutolinkCollector.kt
@@ -17,6 +17,7 @@
 package com.xemantic.markanywhere.parse
 
 import com.xemantic.markanywhere.SemanticEvent
+import com.xemantic.markanywhere.html.spec.asciiLowercase
 import com.xemantic.markanywhere.html.spec.isHtmlWhitespace
 import com.xemantic.markanywhere.parse.AutolinkCollector.Companion.SUPPRESS_NAMES
 import kotlinx.coroutines.flow.FlowCollector
@@ -616,11 +617,8 @@ private fun String.regionMatchesAsciiCi(
         val a = this[thisOffset + i]
         val b = other[otherOffset + i]
         if (a == b) continue
-        if (a.foldAsciiLower() == b.foldAsciiLower()) continue
+        if (a.asciiLowercase() == b.asciiLowercase()) continue
         return false
     }
     return true
 }
-
-private fun Char.foldAsciiLower(): Char =
-    if (this in 'A'..'Z') (this.code or 0x20).toChar() else this
diff --git a/markanywhere-yaml/api/markanywhere-yaml.api b/markanywhere-yaml/api/markanywhere-yaml.api
index 9d5e9ae..5b6ab85 100644
--- a/markanywhere-yaml/api/markanywhere-yaml.api
+++ b/markanywhere-yaml/api/markanywhere-yaml.api
@@ -1,5 +1,6 @@
 public final class com/xemantic/markanywhere/yaml/YamlKeyLineKt {
 	public static final fun isYamlKeyLine (Ljava/lang/String;)Z
+	public static final fun yamlKeyLineKeyOrNull (Ljava/lang/String;)Ljava/lang/String;
 }
 
 public final class com/xemantic/markanywhere/yaml/YamlKt {
diff --git a/markanywhere-yaml/src/commonMain/kotlin/YamlKeyLine.kt b/markanywhere-yaml/src/commonMain/kotlin/YamlKeyLine.kt
index 89bdedc..1623f01 100644
--- a/markanywhere-yaml/src/commonMain/kotlin/YamlKeyLine.kt
+++ b/markanywhere-yaml/src/commonMain/kotlin/YamlKeyLine.kt
@@ -32,19 +32,32 @@ package com.xemantic.markanywhere.yaml
  * A manual scan rather than a regex: `\p{L}` classes are not portable
  * across the Kotlin/JS and Kotlin/Native regex engines.
  */
-public fun isYamlKeyLine(line: String): Boolean {
-    if (line.isEmpty()) return false
+public fun isYamlKeyLine(line: String): Boolean = yamlKeyLineKeyOrNull(line) != null
+
+/**
+ * The key of [line] when it is a YAML block mapping key line by the rule of
+ * [isYamlKeyLine] — a quoted key decoded — or null when it is not one.
+ *
+ * Lets a consumer of a front matter line kept verbatim (one outside the
+ * subset `YamlParser` parses) still tell which key it defines.
+ */
+public fun yamlKeyLineKeyOrNull(line: String): String? {
+    if (line.isEmpty()) return null
     val first = line[0]
-    var i = if (first == '"' || first == '\'') {
-        scanQuoted(line)?.second ?: return false
+    val key: String
+    var i: Int
+    if (first == '"' || first == '\'') {
+        val (content, end) = scanQuoted(line) ?: return null
+        key = content
+        i = end
     } else {
-        if (!isIdentifierKeyStart(first)) return false
-        var j = 1
-        while (j < line.length && isIdentifierKeyChar(line[j])) j++
-        j
+        if (!isIdentifierKeyStart(first)) return null
+        i = 1
+        while (i < line.length && isIdentifierKeyChar(line[i])) i++
+        key = line.substring(0, i)
     }
     while (i < line.length && line[i] == ' ') i++
-    return i < line.length && line.isMappingColonAt(i)
+    return if (i < line.length && line.isMappingColonAt(i)) key else null
 }
 
 // A key [YamlWriter] may write plain: identifier-shaped, so it passes
diff --git a/markanywhere-yaml/src/commonTest/kotlin/YamlKeyLineTest.kt b/markanywhere-yaml/src/commonTest/kotlin/YamlKeyLineTest.kt
index f03d9fd..3f0628c 100644
--- a/markanywhere-yaml/src/commonTest/kotlin/YamlKeyLineTest.kt
+++ b/markanywhere-yaml/src/commonTest/kotlin/YamlKeyLineTest.kt
@@ -17,6 +17,7 @@
 package com.xemantic.markanywhere.yaml
 
 import com.xemantic.kotlin.test.assert
+import com.xemantic.kotlin.test.sameAs
 import kotlin.test.Test
 
 /**
@@ -51,4 +52,19 @@ class YamlKeyLineTest {
         // then
         for (line in lines) assert(!isYamlKeyLine(line))
     }
+
+    @Test
+    fun `should read the key of a mapping key line`() {
+        // when
+        val plain = yamlKeyLineKeyOrNull("title: \"A long")
+        val doubleQuoted = yamlKeyLineKeyOrNull("\"og:\\u0074itle\" : x")
+        val singleQuoted = yamlKeyLineKeyOrNull("'it''s':")
+        val none = yamlKeyLineKeyOrNull("title:x")
+
+        // then
+        plain sameAs "title"
+        doubleQuoted sameAs "og:title"
+        singleQuoted sameAs "it's"
+        assert(none == null)
+    }
 }