diff --git a/.gitignore b/.gitignore
index defcf74..6a0b1d5 100644
--- a/.gitignore
+++ b/.gitignore
@@ -23,3 +23,7 @@ package-lock.json
 
 # Non-Claude agent worktrees (created per CLAUDE.md isolation rules)
 .worktrees/
+
+# Raw prettyhtml.com capture — third-party copyrighted JS/CSS/HTML, local reference only.
+# Clean-room behavior specs live in planning/*.md; the raw files never get committed.
+planning/captures/
diff --git a/CLAUDE.md b/CLAUDE.md
index 72d227a..585bbd1 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -63,7 +63,13 @@ Each tool lives in its own directory with a consistent pattern:
 
 ### Current Tools
 
-- **`/formatter/`** — HTML Formatter & Tidy. Pipeline: tokenize → indent (two-stage) → tidy → compress. Tidy dropdown is organized into three groups: **Formatting** (lowercase/sort/quote — our extras), **Cleaning (prettyhtml.com)** (the 10 options 1-for-1 with prettyhtml.com — Inline styles, Classes & IDs, Empty tags, Tags with 1 space, Successive spaces, Comments, Tag attributes, To plain text, AI Watermarks, Smart &nbsp;s; first 6 ON by default), and **Extras** (data-attrs, span-unwrap, strip-stray-line-breaks, etc.). Literal ports of `removeTagAttributes`, `aiWatermarkFixer`, and `smartNbsps` live in `formatter/app.mjs` (ES module). `normalizeStrayBreaks` (same module) runs as a pre-pass before `tidy()` to strip `<br>` residue between/around block elements and inside empty blocks (default-ON Extras option `opt-stray-breaks`), replicating prettyhtml.com's TinyMCE normalization layer without a DOM round-trip; tests in `formatter/tests/stray-breaks.test.mjs`. Tests in `formatter/tests/*.test.mjs` run via `npm test` (uses `linkedom` as DOMParser shim in Node). Options in `localStorage` key `htmlTidy_options`. See `planning/2026-05-27-prettyhtml-parity.md` for the algorithm snapshot / insurance documentation, and `planning/2026-06-24-stray-line-break-normalization-{design,plan}.md` for the stray-break feature.
+- **`/formatter/`** — HTML Formatter & Tidy. All logic lives in `formatter/app.mjs` (an ES module; there is no `app.js` here). Buttons: Indent (two-stage), Tidy, Compress.
+  - **Tidy runs through `runTidyPipeline(html, opts)`**, ordered to match prettyhtml.com's `convertText()`: stray-break normalization → whitespace pre-pass → script/style strip → to-plain-text (**first**, as theirs is) → nbsp collapse (option 5) → inter-tag gap joins → `tidy()` → nested-empty fixpoint → block-newline separation → looped whitespace post-pass → tag-attributes → AI-watermarks → smart-punctuation straightening → smart-nbsps → final cleanup. `replaceUntilStable()` mirrors their `helyettesit()` replace-to-idempotence semantics.
+  - **prettyhtml.com is two layers**: a TinyMCE DOM round-trip, then the string cleaners behind the ten checkboxes. We have no round-trip, so several default-ON **Extras** stand in for layer 1 — `opt-stray-breaks`, `opt-block-newlines`, `opt-nested-empties`, `opt-docs-residue`. Reasoning about their cleaners in isolation gives the wrong answer about what their site outputs; always check end-to-end.
+  - Dropdown groups: **Formatting** (lowercase/sort/quote), **Cleaning (prettyhtml.com)** (the 10 options 1-for-1; first 6 ON by default), **Extras** (block newlines, nested empties, Google Docs residue, script/style strip, straighten smart punctuation, stray line breaks, data-attrs, span-unwrap).
+  - **Deliberate divergences** (documented in `app.mjs` above the pipeline): E — options 1/2 parse attributes structurally rather than doing double-quote-only string surgery; G — empty-tag removal exempts `td/th/script/style/media` and requires matching tag names; H — one-space-tag removal accepts `&#160;`; N — curly quotes are accepted as attribute delimiters, which is what makes HTML pasted out of Google Docs survive.
+  - Tests in `formatter/tests/*.test.mjs` via `npm test` (`linkedom` as DOMParser shim). `parity.test.mjs` runs the pipeline against `tests/fixtures/prettyhtml-golden.json` — black-box input/output pairs captured from the live site; a fixture with an `ours` field is a recorded deliberate divergence. Options persist in `localStorage` key `htmlTidy_options`.
+  - Docs: `planning/2026-09-03-prettyhtml-complete-capture.md` is the current clean-room spec (supersedes most of `planning/2026-05-27-prettyhtml-parity.md`); `planning/2026-06-24-stray-line-break-normalization-{design,plan}.md` covers stray breaks. The raw third-party capture lives in gitignored `planning/captures/` and must never be committed.
 - **`/og-image/`** — OG Image Preview. Platform specs in `platforms.json`. Optional Cloudflare Worker CORS proxy in `functions/fetch-meta.js`. Fallback proxies for CORS.
 
 ### Suggested Tools System
diff --git a/README.md b/README.md
index 89dd27c..0d0c110 100644
--- a/README.md
+++ b/README.md
@@ -70,7 +70,8 @@ Beautify, format, and clean up messy or minified HTML instantly.
 └── formatter/                  # HTML Formatter & Tidy
     ├── index.html
     ├── styles.css
-    └── app.js
+    ├── app.mjs                 # ES module — pipeline, cleaners, DOM wiring
+    └── tests/                  # node --test, linkedom DOMParser shim
 ```
 
 Each tool is self-contained in its own directory with its own `index.html`, making it easy to develop, test, and deploy independently.
diff --git a/eslint.config.js b/eslint.config.js
index 859875d..e09b808 100644
--- a/eslint.config.js
+++ b/eslint.config.js
@@ -41,6 +41,15 @@ module.exports = [
       },
     },
   },
+  {
+    files: ['formatter/tests/**/*.mjs'],
+    languageOptions: {
+      sourceType: 'module',
+      globals: {
+        ...globals.node,
+      },
+    },
+  },
   {
     files: ['og-image/functions/**/*.js'],
     languageOptions: {
@@ -51,6 +60,8 @@ module.exports = [
     },
   },
   {
-    ignores: ['node_modules/'],
+    // planning/captures/ holds the raw third-party prettyhtml.com capture. It is
+    // gitignored reference material, not our source — never lint or ship it.
+    ignores: ['node_modules/', 'planning/captures/'],
   },
 ];
diff --git a/formatter/app.mjs b/formatter/app.mjs
index a930794..b90e39d 100644
--- a/formatter/app.mjs
+++ b/formatter/app.mjs
@@ -67,25 +67,66 @@ const BLOCK_ELEMENTS = new Set([
   'td', 'th', 'dl', 'dt', 'dd', 'form', 'fieldset', 'address', 'pre',
 ]);
 
+/**
+ * Curly quotes accepted as attribute delimiters.
+ *
+ * Word processors (Google Docs especially) autocorrect straight quotes to curly
+ * ones even when the text is HTML *source*, so pasted markup routinely arrives as
+ * `class=“hero lede”`. Treating those as delimiters is a robustness fix, not a
+ * parity concern: prettyhtml.com's TinyMCE mis-parses the same input (it reads the
+ * value as unquoted and truncates at the first space) and only looks clean because
+ * its classes/IDs option then deletes the wreckage. Ours has no such backstop, so
+ * without this the invented attribute survives into the output.
+ *
+ * Each opener maps to the set of characters that may close it — a pair is accepted
+ * in either orientation, since autocorrect sometimes emits two openers or two
+ * closers when it guesses the word boundary wrong.
+ *
+ * Known limitation, deliberate: a value that mixes delimiter styles
+ * (`class=“hero lede"`) is NOT recognized and still falls to the bare-value path.
+ * Autocorrect converts both quotes of a pair, so this shape has not been observed
+ * in real input — and the obvious fix costs more than it buys. Letting a straight
+ * quote close a curly-opened value would truncate `alt=“He said "hi" to me”`, and
+ * letting a curly close a straight-opened one would truncate
+ * `alt="He said “hi” to me"` — quoted prose inside an attribute, which is both
+ * common and exactly what a word processor produces. Those two cases parse
+ * correctly today and are covered by tests; keep it that way unless a real
+ * mixed-delimiter sample turns up.
+ */
+const QUOTE_CLOSERS = {
+  '"': '"',
+  "'": "'",
+  '\u201C': '\u201D\u201C',
+  '\u201D': '\u201D\u201C',
+  '\u2018': '\u2019\u2018',
+  '\u2019': '\u2019\u2018',
+};
+
 /**
  * Parse an HTML attribute string into an array of {name, value, quote} objects.
  */
-function parseAttributes(attrString) {
+export function parseAttributes(attrString) {
   const attrs = [];
   if (!attrString || !attrString.trim()) return attrs;
 
-  // Regex matches: name="value", name='value', name=value, or bare name
-  const re = /([^\s=]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|(\S+)))?/g;
+  // Regex matches: name="value", name='value', name=“value”, name=‘value’,
+  // name=value, or bare name. Curly-delimited values are normalized to straight
+  // quotes here so every downstream rebuild path emits valid HTML.
+  const re = /([^\s=]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|[\u201C\u201D]([^\u201C\u201D]*)[\u201C\u201D]|[\u2018\u2019]([^\u2018\u2019]*)[\u2018\u2019]|(\S+)))?/g;
   let match;
   while ((match = re.exec(attrString)) !== null) {
     const name = match[1];
     const value = match[2] !== undefined ? match[2]
                 : match[3] !== undefined ? match[3]
                 : match[4] !== undefined ? match[4]
+                : match[5] !== undefined ? match[5]
+                : match[6] !== undefined ? match[6]
                 : null;
     const quote = match[2] !== undefined ? '"'
                : match[3] !== undefined ? "'"
-               : match[4] !== undefined ? ''
+               : match[4] !== undefined ? '"'
+               : match[5] !== undefined ? "'"
+               : match[6] !== undefined ? ''
                : null;
     attrs.push({ name, value, quote });
   }
@@ -96,7 +137,7 @@ function parseAttributes(attrString) {
  * Tokenize an HTML string into an array of tokens.
  * Each token has: { type, raw, tagName?, attributes?, content? }
  */
-function tokenize(html) {
+export function tokenize(html) {
   const tokens = [];
   let pos = 0;
   const len = html.length;
@@ -224,9 +265,14 @@ function findTagEnd(html, pos) {
   const len = html.length;
   while (i < len) {
     const ch = html[i];
-    if (ch === '"' || ch === "'") {
-      // Skip quoted attribute value
-      const closeQuote = html.indexOf(ch, i + 1);
+    const closers = QUOTE_CLOSERS[ch];
+    if (closers) {
+      // Skip a quoted attribute value so a '>' inside it doesn't truncate the tag.
+      // Curly delimiters close on either member of their pair (see QUOTE_CLOSERS).
+      let closeQuote = -1;
+      for (let j = i + 1; j < len; j++) {
+        if (closers.includes(html[j])) { closeQuote = j; break; }
+      }
       if (closeQuote === -1) return -1;
       i = closeQuote + 1;
     } else if (ch === '>') {
@@ -284,7 +330,7 @@ function rebuildTag(token) {
  * @param {number} stage - 1 = block elements only, 2 = all elements
  * @returns {string} Indented HTML
  */
-function indent(html, opts, stage) {
+export function indent(html, opts, stage) {
   const tokens = tokenize(html);
   const lines = [];
   let indentLevel = 0;
@@ -406,6 +452,32 @@ function isBooleanAttr(name) {
   return booleans.has(name.toLowerCase());
 }
 
+/**
+ * True if an attribute is removed by the current options.
+ *
+ * Single source of truth for two call sites that must agree: buildTidyTag, which
+ * decides what to emit, and the unwrapSpans check, which decides whether a <span>
+ * has anything left worth keeping. They were duplicated, and adding the Google
+ * Docs residue rules to one and not the other left a span whose only attribute
+ * was residue un-unwrapped while that same attribute got stripped. At shipped
+ * defaults the opt-nested-empties fixpoint hid it by catching the span on a
+ * second pass; with that Extra off, a stray <span> survived.
+ */
+function isDroppedAttr(name, value, opts) {
+  const an = name.toLowerCase();
+  if (opts.removeStyles && (an === 'style' || an === 'valign' || an === 'align')) return true;
+  if (opts.removeClassesIds && (an === 'class' || an === 'id')) return true;
+  if (opts.removeDataAttrs && an.startsWith('data-')) return true;
+  if (opts.docsResidue) {
+    const lowerValue = (value || '').toLowerCase();
+    if (an === 'role' && lowerValue === 'presentation') return true;
+    if (an === 'aria-level') return true;
+    if (an === 'dir' && lowerValue === 'ltr') return true;
+  }
+  if (opts.removeEmptyAttrs && value === '' && !isBooleanAttr(an)) return true;
+  return false;
+}
+
 /**
  * Build a tidied tag string, applying cleaning options to attributes.
  */
@@ -417,11 +489,10 @@ function buildTidyTag(tagName, attrs, selfClose, opts) {
     let value = attr.value;
     let quote = attr.quote;
 
-    const lowerAttrName = attrName.toLowerCase();
-    if (opts.removeStyles && (lowerAttrName === 'style' || lowerAttrName === 'valign' || lowerAttrName === 'align')) return null;
-    if (opts.removeClassesIds && (lowerAttrName === 'class' || lowerAttrName === 'id')) return null;
-    if (opts.removeDataAttrs && lowerAttrName.startsWith('data-')) return null;
-    if (opts.removeEmptyAttrs && value === '' && !isBooleanAttr(attrName)) return null;
+    // Google Docs residue is part of this: TinyMCE drops role/aria-level for
+    // prettyhtml.com at layer 1; we have no layer 1, so the option covers them
+    // explicitly. dir="ltr" survives on their site — deliberately better than parity.
+    if (isDroppedAttr(attrName, value, opts)) return null;
 
     if (opts.quoteAttrs && value !== null && quote !== '"' && quote !== "'") {
       quote = '"';
@@ -453,12 +524,16 @@ function buildTidyTag(tagName, attrs, selfClose, opts) {
  * Tidy tokenized HTML — applies cleaning without changing whitespace.
  * Returns { output, fixCount, tagCount }.
  */
-function tidy(html, opts) {
+export function tidy(html, opts) {
   const tokens = tokenize(html);
   const parts = [];
   let fixCount = 0;
   let tagCount = 0;
   let unwrappedSpanDepth = 0;
+  // One entry per open <b>: true if it was unwrapped as a Google Docs container.
+  // A plain stack rather than a depth counter, so a real nested <b> keeps its
+  // own closing tag instead of consuming the wrapper's.
+  const boldStack = [];
 
   for (let i = 0; i < tokens.length; i++) {
     const token = tokens[i];
@@ -495,7 +570,7 @@ function tidy(html, opts) {
         const canRemove = !VOID_ELEMENTS.has(lowerName) &&
             !['script', 'style', 'iframe', 'canvas', 'video', 'audio', 'td', 'th'].includes(lowerName);
 
-        // Case 1: <tag></tag> — directly empty
+        // Case 1: <tag></tag> — directly empty. prettyhtml option 3 (uresTagotTorul).
         if (canRemove && opts.removeEmptyTags && nextToken &&
             nextToken.type === TokenType.CLOSE_TAG &&
             nextToken.tagName.toLowerCase() === lowerName) {
@@ -504,12 +579,29 @@ function tidy(html, opts) {
           break;
         }
 
-        // Case 2: <tag>&nbsp;</tag> — contains only &nbsp; / whitespace
-        if (canRemove && opts.removeOneSpaceTags && nextToken && nextToken.type === TokenType.TEXT) {
-          const stripped = nextToken.content.replace(/&nbsp;/g, '').trim();
+        // Case 2: <tag>\n</tag> — a single newline. Also option 3, via
+        // csakEnteresTagotTorul; it used to be lumped in with the one-space
+        // option below, which put it behind the wrong checkbox (divergence F).
+        // Whitespace runs have already been collapsed by the pre-pass, and a
+        // space-only tag reaches Case 1 through option 3's "> <" join.
+        if (canRemove && opts.removeEmptyTags && nextToken &&
+            nextToken.type === TokenType.TEXT && nextToken.content === '\n') {
+          const closeToken = tokens[i + 2];
+          if (closeToken && closeToken.type === TokenType.CLOSE_TAG &&
+              closeToken.tagName.toLowerCase() === lowerName) {
+            fixCount++;
+            i += 2;
+            break;
+          }
+        }
+
+        // Case 3: <tag>&nbsp;</tag> — option 4 (csakEgyNbspTagotTorul). Theirs
+        // matches the named entity only; we accept the numeric spelling too
+        // (divergence H, a deliberate improvement).
+        if (canRemove && opts.removeOneSpaceTags && nextToken && nextToken.type === TokenType.TEXT &&
+            NBSP_SPELLINGS.includes(nextToken.content)) {
           const closeToken = tokens[i + 2];
-          if (!stripped &&
-              closeToken && closeToken.type === TokenType.CLOSE_TAG &&
+          if (closeToken && closeToken.type === TokenType.CLOSE_TAG &&
               closeToken.tagName.toLowerCase() === lowerName) {
             fixCount++;
             i += 2;
@@ -517,16 +609,23 @@ function tidy(html, opts) {
           }
         }
 
+        // Google Docs wraps a whole paste in <b id="docs-internal-guid-…"> with
+        // font-weight:normal. It is a transparent container, not bold — unwrap it.
+        if (lowerName === 'b') {
+          const idAttr = (token.attributes || []).find(a => a.name.toLowerCase() === 'id');
+          const isDocsWrapper = Boolean(opts.docsResidue && idAttr && idAttr.value &&
+            idAttr.value.startsWith('docs-internal-guid'));
+          boldStack.push(isDocsWrapper);
+          if (isDocsWrapper) {
+            fixCount++;
+            break;
+          }
+        }
+
         // Unwrap empty spans
         if (opts.unwrapSpans && lowerName === 'span') {
-          const remainingAttrs = (token.attributes || []).filter(attr => {
-            const an = (opts.lowercaseAttrs ? attr.name.toLowerCase() : attr.name).toLowerCase();
-            if (opts.removeStyles && (an === 'style' || an === 'valign' || an === 'align')) return false;
-            if (opts.removeClassesIds && (an === 'class' || an === 'id')) return false;
-            if (opts.removeDataAttrs && an.startsWith('data-')) return false;
-            if (opts.removeEmptyAttrs && attr.value === '' && !isBooleanAttr(an)) return false;
-            return true;
-          });
+          const remainingAttrs = (token.attributes || [])
+            .filter(attr => !isDroppedAttr(attr.name, attr.value, opts));
           if (remainingAttrs.length === 0) {
             fixCount++;
             unwrappedSpanDepth++;
@@ -552,6 +651,10 @@ function tidy(html, opts) {
           break;
         }
 
+        if (lowerName === 'b' && boldStack.length > 0 && boldStack.pop()) {
+          break;
+        }
+
         parts.push(`</${closeTagName}>`);
         break;
       }
@@ -563,22 +666,9 @@ function tidy(html, opts) {
       }
 
       case TokenType.TEXT: {
-        if (token.preserveWhitespace) {
-          parts.push(token.content);
-          break;
-        }
-
-        let text = token.content;
-        if (opts.trimWhitespace) {
-          text = text.replace(/\s+/g, ' ');
-          // Only fully trim if the result is all whitespace
-          if (!text.trim()) {
-            // Preserve a single space between inline elements
-            parts.push(' ');
-            break;
-          }
-        }
-        parts.push(text);
+        // Pass through untouched. Whitespace normalization belongs to the
+        // pipeline's pre/post-passes, not to any option (divergence C).
+        parts.push(token.content);
         break;
       }
     }
@@ -594,7 +684,7 @@ function tidy(html, opts) {
 // COMPRESS — Strip all unnecessary whitespace (formerly minify)
 // ============================================================
 
-function compress(html) {
+export function compress(html) {
   const tokens = tokenize(html);
   const parts = [];
 
@@ -719,13 +809,18 @@ export function removeAllTagAttributes(text) {
 export function toPlainText(text) {
   const SENTINEL = '\x00COMMENT\x00';  // NUL-bracketed sentinel — won't collide with real content
   const comments = [];
-  // Save comments, replace each with the sentinel
+  // Save comments, replace each with the sentinel. Theirs sentinels only the
+  // "<!--" opener, which leaves the comment with no "<" for the tag machine to
+  // latch onto — same effect, stated more directly.
   let t = text.replace(/<!--[\s\S]*?-->/g, m => {
     comments.push(m);
     return SENTINEL;
   });
-  // Strip all remaining tags
-  t = t.replace(/<[^>]*>/g, '');
+  // Replace each remaining tag with a single space. Theirs collapses every tag
+  // to "<>" and then substitutes " ", so "a<br/>b" becomes "a b", not "ab"
+  // (divergence D). The doubled spaces this leaves are collapsed by the
+  // pipeline's post-pass.
+  t = t.replace(/<[^>]*>/g, ' ');
   // Restore comments in order
   t = t.replace(new RegExp(SENTINEL, 'g'), () => comments.shift());
   return t;
@@ -939,6 +1034,18 @@ export function normalizeStrayBreaks(html) {
         continue;
       }
       if (!hasDirectText[pIdx]) { i++; continue; } // empty block -> drop the <br>
+
+      // A <br> with nothing but whitespace between it and its block's closing
+      // tag is filler, not a line break — it renders nothing. TinyMCE drops
+      // these for prettyhtml.com at layer 1; without that layer we do it here.
+      let k = i + 1;
+      while (k < n && tokens[k].type === TokenType.TEXT &&
+             parentBlock[k] === pIdx && tokens[k].content.trim() === '') k++;
+      if (k < n && isBlockClose(tokens[k]) &&
+          tokens[k].tagName.toLowerCase() === tokens[pIdx].tagName.toLowerCase()) {
+        i++;
+        continue;
+      }
       // else: real line break inside text — keep it
     }
     out.push(t.raw);
@@ -947,6 +1054,265 @@ export function normalizeStrayBreaks(html) {
   return out.join('');
 }
 
+// ============================================================
+// TIDY PIPELINE — the order and scaffolding of prettyhtml.com convertText()
+//
+// Their engine is two layers. Layer 1 is a TinyMCE round-trip that normalizes
+// the DOM before any cleaner runs; layer 2 is the string cleaners behind the
+// ten checkboxes. We have no layer 1, so a few things TinyMCE does for them are
+// handled here by default-ON Extras options instead (normalizeStrayBreaks,
+// opt-nested-empties, opt-docs-residue). Reasoning about their cleaners in
+// isolation gives the wrong answer about what the site actually outputs — see
+// planning/2026-09-03-prettyhtml-complete-capture.md.
+//
+// Deliberate divergences, kept because ours is better:
+//   E — options 1/2 parse attributes structurally; theirs does double-quote-only
+//       string surgery, so style='x' or class=“x” slip past it.
+//   G — canRemove exempts td/th/script/style/media; theirs deletes <td></td> and
+//       does not even check that tag names match (<b></i> gets removed).
+//   H — one-space-tag removal accepts &#160; as well as &nbsp;.
+//   N — curly quotes are accepted as attribute delimiters (see QUOTE_CLOSERS).
+//
+// Known cost of parity: the whitespace passes are string-level and run outside
+// the tokenizer, so like theirs they do not preserve <pre>/<textarea> indentation.
+// ============================================================
+
+/** Both spellings of a non-breaking space entity. Theirs only knows the first. */
+const NBSP_SPELLINGS = ['&nbsp;', '&#160;'];
+
+/** Guard against a replacement that can never reach a fixed point. */
+const REPLACE_STABLE_LIMIT = 1000;
+
+/**
+ * Replace every occurrence of a literal substring, repeating until the text
+ * stops changing. Mirrors their `helyettesit(from, to)`, whose looping is what
+ * makes single-pair replacements like "  " -> " " collapse runs of any length.
+ */
+export function replaceUntilStable(text, from, to) {
+  if (!from) return text;
+  // A replacement whose output still contains its own pattern can never reach a
+  // fixed point, and each round makes the string longer — looping would exhaust
+  // memory, not just spin. One pass is the only sane reading of that request.
+  if (to.includes(from)) return text.split(from).join(to);
+
+  let out = text;
+  for (let i = 0; i < REPLACE_STABLE_LIMIT; i++) {
+    const next = out.split(from).join(to);
+    if (next === out) return out;
+    out = next;
+  }
+  return out;
+}
+
+/** Unconditional pre-pass, run before any option is consulted. */
+function normalizeWhitespacePrepass(text) {
+  let t = text;
+  t = replaceUntilStable(t, '\t', '');
+  t = replaceUntilStable(t, '  ', ' ');
+  t = replaceUntilStable(t, ' \n', '\n');
+  t = replaceUntilStable(t, '\t\n', '\n');   // dead after the tab strip; kept for fidelity
+  t = replaceUntilStable(t, '\n\n', '\n');
+  t = replaceUntilStable(t, '  ', ' ');
+  return t;
+}
+
+/**
+ * Post-pass, re-run until a full round changes nothing. Theirs sums the
+ * replacement counts and loops while the total is positive, which is the same
+ * condition expressed differently.
+ */
+function postPassLoop(text) {
+  let t = text;
+  for (let i = 0; i < REPLACE_STABLE_LIMIT; i++) {
+    const before = t;
+    t = replaceUntilStable(t, '  ', ' ');
+    t = replaceUntilStable(t, ' >', '>');
+    t = replaceUntilStable(t, '\t', '');
+    t = replaceUntilStable(t, '  ', ' ');
+    t = replaceUntilStable(t, '&nbsp;\n', '\n');
+    t = replaceUntilStable(t, ' \n', '\n');
+    t = replaceUntilStable(t, '\n\n', '\n');
+    if (t === before) return t;
+  }
+  return t;
+}
+
+/** Final cleanup, after the attribute/watermark/nbsp options have run. */
+function finalCleanup(text) {
+  let t = text;
+  t = replaceUntilStable(t, ' \n', '\n');
+  t = replaceUntilStable(t, '\t\n', '\n');
+  t = replaceUntilStable(t, '\n\n', '\n');
+  t = replaceUntilStable(t, '  ', ' ');
+  return t;
+}
+
+/**
+ * Remove <script> and <style> blocks. Unconditional on their site (with a popup
+ * announcing it); here it rides a visible Extras checkbox so it can be turned off.
+ * Theirs deletes between the markers and then removes the "<script</script>"
+ * residue, which composes to deleting the whole block.
+ */
+function stripScriptStyleBlocks(text) {
+  return text
+    .replace(/<script\b[\s\S]*?<\/script>/gi, '')
+    .replace(/<style\b[\s\S]*?<\/style>/gi, '');
+}
+
+/**
+ * Option 5, "Successive spaces". Despite the label it only touches non-breaking
+ * space entities — literal whitespace runs are collapsed by the unconditional
+ * passes instead. Measured live: "a&nbsp;b" survives, "a&nbsp;&nbsp;b" -> "a b".
+ */
+function collapseNbspRuns(text) {
+  let t = text;
+  for (const a of NBSP_SPELLINGS) {
+    for (const b of NBSP_SPELLINGS) t = replaceUntilStable(t, a + b, ' ');
+  }
+  for (const a of NBSP_SPELLINGS) {
+    t = replaceUntilStable(t, a + ' ', ' ');
+    t = replaceUntilStable(t, ' ' + a, ' ');
+  }
+  return t;
+}
+
+/**
+ * The inter-tag gap normalizations that belong to options 4 and 3 respectively.
+ * They run on the raw string, before tokenizing, because their whole job is to
+ * turn "<p> </p>" into the "<p></p>" that the empty-tag machine can then see.
+ */
+function normalizeTagGaps(text, opts) {
+  let t = text;
+  if (opts.removeOneSpaceTags) {
+    t = replaceUntilStable(t, '> &nbsp;<', '>&nbsp;<');
+    t = replaceUntilStable(t, '>&nbsp; <', '>&nbsp;<');
+  }
+  if (opts.removeEmptyTags) {
+    t = replaceUntilStable(t, '> <', '><');
+    t = replaceUntilStable(t, '> \n', '>\n');
+  }
+  return t;
+}
+
+/**
+ * Straighten literal curly punctuation in text content — the character-level
+ * counterpart of option 9, which only knows the entity and mojibake spellings.
+ * Default OFF: curly quotes in prose are legitimate typography, and this is
+ * deliberately kept out of option 9 itself so the ten stay byte-faithful.
+ */
+export function straightenSmartPunctuation(text) {
+  return text
+    .replace(/\u2013/g, ' - ')
+    .replace(/\u2014/g, ' - ')
+    .replace(/[\u201C\u201D]/g, '"')
+    .replace(/[\u2018\u2019]/g, "'")
+    .replace(/\u2026/g, '...');
+}
+
+/**
+ * Put every block-level element on its own line, with no indentation.
+ *
+ * This is what TinyMCE's getContent() does for prettyhtml.com at layer 1, and
+ * it accounts for most of the visible difference between their output and ours:
+ * they hand back line-delimited blocks, we handed back one long line. Measured
+ * live — a block's open tag starts a line, its close tag starts a line only when
+ * the block has block children, and inline content stays put. Expressed as two
+ * boundary rules that produce exactly that, letting the post-pass tidy up the
+ * blank lines and stray spaces they leave behind.
+ *
+ * Option 3's "> \n" normalization and newline-only-tag machine exist because their
+ * layer 1 emits these newlines before any cleaner runs. Ours emits them after, so
+ * those two fire on already-formatted input rather than on our own output.
+ *
+ * Deliberately NOT replicated from TinyMCE: <b> to <strong> rewriting, implied
+ * <tbody> insertion, wrapping loose text in <p>, and alt="" injection. Those are
+ * editor semantics, not cleanup (divergence K).
+ */
+export function separateBlockElements(html) {
+  const tokens = tokenize(html);
+  const parts = [];
+
+  // True if the output so far ends a line — skipping empty pushes.
+  const atLineStart = () => {
+    for (let i = parts.length - 1; i >= 0; i--) {
+      if (parts[i] === '') continue;
+      return parts[i].endsWith('\n');
+    }
+    return true;
+  };
+
+  for (const token of tokens) {
+    const isBlock = token.tagName && BLOCK_ELEMENTS.has(token.tagName.toLowerCase());
+
+    if (isBlock && token.type === TokenType.OPEN_TAG) {
+      if (!atLineStart()) parts.push('\n');
+      parts.push(token.raw);
+    } else if (isBlock && token.type === TokenType.CLOSE_TAG) {
+      parts.push(token.raw, '\n');
+    } else {
+      parts.push(token.raw);
+    }
+  }
+
+  return parts.join('').replace(/\n+$/, '');
+}
+
+/**
+ * Run the full Tidy pipeline, ordered to match convertText().
+ * @param {string} html - Raw HTML string
+ * @param {object} opts - Option flags (see getTidyOptions)
+ * @returns {{output: string, fixCount: number, tagCount: number}}
+ */
+export function runTidyPipeline(html, opts) {
+  let text = opts.strayBreaks ? normalizeStrayBreaks(html) : html;
+
+  text = normalizeWhitespacePrepass(text);
+
+  if (opts.stripScripts) text = stripScriptStyleBlocks(text);
+
+  // Option 8 runs first on their site, before every other option.
+  if (opts.plainText) text = toPlainText(text);
+
+  // Options 1 and 2 are applied structurally inside tidy(); option 5 is a
+  // string pass, and their dispatch runs it between the two.
+  if (opts.trimWhitespace) text = collapseNbspRuns(text);
+
+  text = normalizeTagGaps(text, opts);
+  let result = tidy(text, opts);
+  const tagCount = result.tagCount;
+  let fixCount = result.fixCount;
+
+  // Their option dispatch runs once, so a nested empty pair leaves the outer tag
+  // behind. Layer 1 hides that for them: TinyMCE rewrites <div><p></p></div> as
+  // <div>&nbsp;</div>, which option 4 then eats. Looping is how a pure tokenizer
+  // reaches the same end-to-end output, so this is layer-1 compensation rather
+  // than optional polish — the same category as normalizeStrayBreaks.
+  if (opts.nestedEmpties) {
+    for (let i = 0; i < REPLACE_STABLE_LIMIT; i++) {
+      const before = result.output;
+      result = tidy(normalizeTagGaps(before, opts), opts);
+      fixCount += result.fixCount;
+      if (result.output === before) break;
+    }
+  }
+
+  // Block separation runs after the cleaners, not before. TinyMCE does this at
+  // layer 1 for them, but emitting the newlines up front would feed the empty-tag
+  // machine "<div>\n</div>" instead of the "<div></div>" it needs to match, and
+  // would leave a leading newline behind wherever an unwrapped container had been.
+  text = opts.blockNewlines ? separateBlockElements(result.output) : result.output;
+
+  text = postPassLoop(text);
+
+  if (opts.tagAttributes) text = removeAllTagAttributes(text);
+  if (opts.aiWatermarks) text = removeAiWatermarks(text);
+  if (opts.straightenQuotes) text = straightenSmartPunctuation(text);
+  if (opts.smartNbsps) text = smartNbsps(text);
+
+  return { output: finalCleanup(text), fixCount, tagCount };
+}
+
+
 // ============================================================
 // OPTIONS — Separated into indent and tidy option readers
 // ============================================================
@@ -972,11 +1338,20 @@ function getTidyOptions() {
     removeEmptyTags: document.getElementById('opt-empty-tags').checked,
     removeOneSpaceTags: document.getElementById('opt-one-space-tags').checked,
     trimWhitespace: document.getElementById('opt-trim-whitespace').checked,
-    newlineBeforeClose: document.getElementById('opt-newline-before-close').checked,
     removeStyles: document.getElementById('opt-remove-styles').checked,
     removeClassesIds: document.getElementById('opt-classes-ids').checked,
     removeDataAttrs: document.getElementById('opt-remove-data-attrs').checked,
     unwrapSpans: document.getElementById('opt-unwrap-spans').checked,
+    tagAttributes: document.getElementById('opt-tag-attributes').checked,
+    plainText: document.getElementById('opt-plain-text').checked,
+    aiWatermarks: document.getElementById('opt-ai-watermarks').checked,
+    smartNbsps: document.getElementById('opt-smart-nbsps').checked,
+    strayBreaks: document.getElementById('opt-stray-breaks').checked,
+    stripScripts: document.getElementById('opt-strip-scripts').checked,
+    blockNewlines: document.getElementById('opt-block-newlines').checked,
+    nestedEmpties: document.getElementById('opt-nested-empties').checked,
+    docsResidue: document.getElementById('opt-docs-residue').checked,
+    straightenQuotes: document.getElementById('opt-straighten-quotes').checked,
   };
 }
 
@@ -991,9 +1366,11 @@ const TIDY_CHECKBOX_IDS = [
   'opt-sort-attrs', 'opt-lowercase-tags', 'opt-lowercase-attrs',
   'opt-remove-empty-attrs', 'opt-fix-self-closing', 'opt-unquoted-to-quoted',
   'opt-remove-comments', 'opt-empty-tags', 'opt-one-space-tags', 'opt-trim-whitespace',
-  'opt-newline-before-close', 'opt-remove-styles', 'opt-classes-ids',
+  'opt-remove-styles', 'opt-classes-ids',
   'opt-remove-data-attrs', 'opt-unwrap-spans', 'opt-tag-attributes',
   'opt-plain-text', 'opt-ai-watermarks', 'opt-smart-nbsps', 'opt-stray-breaks',
+  'opt-strip-scripts', 'opt-nested-empties', 'opt-docs-residue', 'opt-straighten-quotes',
+  'opt-block-newlines',
 ];
 
 function saveTidyOptions() {
@@ -1312,23 +1689,7 @@ function init() {
     hideError();
     try {
       pushUndo();
-      var opts = getTidyOptions();
-      var normalized = document.getElementById('opt-stray-breaks').checked
-        ? normalizeStrayBreaks(html)
-        : html;
-      var result = tidy(normalized, opts);
-      if (document.getElementById('opt-tag-attributes').checked) {
-        result.output = removeAllTagAttributes(result.output);
-      }
-      if (document.getElementById('opt-plain-text').checked) {
-        result.output = toPlainText(result.output);
-      }
-      if (document.getElementById('opt-ai-watermarks').checked) {
-        result.output = removeAiWatermarks(result.output);
-      }
-      if (document.getElementById('opt-smart-nbsps').checked) {
-        result.output = smartNbsps(result.output);
-      }
+      var result = runTidyPipeline(html, getTidyOptions());
       updateEditors(result.output);
       resetIndentStage();
       updateStats(html, result.output, result.tagCount, result.fixCount);
diff --git a/formatter/index.html b/formatter/index.html
index 48bef3c..b39fa18 100644
--- a/formatter/index.html
+++ b/formatter/index.html
@@ -226,8 +226,24 @@ <h1>HTML Formatter &amp; Tidy</h1>
                 <span title="Removes &lt;br&gt; between or around block elements and inside otherwise-empty blocks; keeps line breaks inside text.">Strip stray line breaks</span>
               </label>
               <label class="option-checkbox">
-                <input type="checkbox" id="opt-newline-before-close">
-                <span>Newline before closing &gt;</span>
+                <input type="checkbox" id="opt-block-newlines" checked>
+                <span title="Puts each block-level element on its own line, matching what prettyhtml.com's editor layer does before it cleans.">Block elements on their own lines</span>
+              </label>
+              <label class="option-checkbox">
+                <input type="checkbox" id="opt-nested-empties" checked>
+                <span title="Repeats empty-tag removal until nothing changes, so &lt;div&gt;&lt;p&gt;&lt;/p&gt;&lt;/div&gt; clears completely.">Remove nested empty tags</span>
+              </label>
+              <label class="option-checkbox">
+                <input type="checkbox" id="opt-docs-residue" checked>
+                <span title="Strips Google Docs paste residue: role=&quot;presentation&quot;, aria-level, dir=&quot;ltr&quot;, and the docs-internal-guid &lt;b&gt; wrapper.">Remove Google Docs residue</span>
+              </label>
+              <label class="option-checkbox">
+                <input type="checkbox" id="opt-strip-scripts" checked>
+                <span title="Removes &lt;script&gt; and &lt;style&gt; blocks entirely.">Remove scripts &amp; style blocks</span>
+              </label>
+              <label class="option-checkbox">
+                <input type="checkbox" id="opt-straighten-quotes">
+                <span title="Turns curly quotes, dashes and ellipses in text into their plain ASCII equivalents. Off by default — smart punctuation in prose is usually intentional.">Straighten smart punctuation</span>
               </label>
               <label class="option-checkbox">
                 <input type="checkbox" id="opt-remove-data-attrs">
diff --git a/formatter/tests/curly-quotes.test.mjs b/formatter/tests/curly-quotes.test.mjs
new file mode 100644
index 0000000..36d7b5e
--- /dev/null
+++ b/formatter/tests/curly-quotes.test.mjs
@@ -0,0 +1,128 @@
+import { test, assert } from './helpers.mjs';
+import { parseAttributes, tokenize, runTidyPipeline, straightenSmartPunctuation } from '../app.mjs';
+
+// Divergence N. Google Docs autocorrects straight quotes to curly ones even when
+// the text is HTML source, so markup copied out of a Doc arrives as
+// class=“hero lede”. Before this fix parseAttributes read the value as unquoted,
+// stopped at the space, and invented a bare attribute named 'lede”' that no
+// cleaner matched — so it survived into the output.
+
+const DEFAULTS = {
+  lowercaseTags: true, lowercaseAttrs: true, sortAttrs: false,
+  removeEmptyAttrs: false, fixSelfClosing: true, quoteAttrs: true,
+  removeStyles: true, removeClassesIds: true, removeEmptyTags: true,
+  removeOneSpaceTags: true, trimWhitespace: true, removeComments: true,
+  tagAttributes: false, plainText: false, aiWatermarks: false, smartNbsps: false,
+  strayBreaks: true, nestedEmpties: true, docsResidue: true, stripScripts: true,
+  blockNewlines: true, straightenQuotes: false,
+  removeDataAttrs: false, unwrapSpans: true,
+};
+const withOpts = (over) => ({ ...DEFAULTS, ...over });
+
+// --- parseAttributes ---
+
+test('curly double quotes delimit a multi-word value', () => {
+  assert.deepEqual(parseAttributes('class=“hero lede”'),
+    [{ name: 'class', value: 'hero lede', quote: '"' }]);
+});
+
+test('curly single quotes delimit a value', () => {
+  assert.deepEqual(parseAttributes('class=‘hero’'),
+    [{ name: 'class', value: 'hero', quote: "'" }]);
+});
+
+test('two opening curly quotes still delimit, since autocorrect guesses wrong', () => {
+  assert.deepEqual(parseAttributes('class=“hero“'),
+    [{ name: 'class', value: 'hero', quote: '"' }]);
+});
+
+test('straight quotes are unaffected', () => {
+  assert.deepEqual(parseAttributes('class="hero lede"'),
+    [{ name: 'class', value: 'hero lede', quote: '"' }]);
+});
+
+test('mixed straight and curly attributes in one tag', () => {
+  assert.deepEqual(parseAttributes('id="a" class=“b c” data-x=‘d’'), [
+    { name: 'id', value: 'a', quote: '"' },
+    { name: 'class', value: 'b c', quote: '"' },
+    { name: 'data-x', value: 'd', quote: "'" },
+  ]);
+});
+
+test('no phantom attribute is invented from the tail of a curly value', () => {
+  const attrs = parseAttributes('class=“hero lede”');
+  assert.equal(attrs.length, 1);
+  assert.equal(attrs.some(a => a.name.includes('”')), false);
+});
+
+// --- findTagEnd, via tokenize ---
+
+test('a ">" inside a curly-quoted value does not truncate the tag', () => {
+  const tokens = tokenize('<p class=“a > b”>Hi</p>');
+  assert.equal(tokens[0].tagName, 'p');
+  assert.deepEqual(tokens[0].attributes, [{ name: 'class', value: 'a > b', quote: '"' }]);
+  assert.equal(tokens[1].content, 'Hi');
+});
+
+test('an unterminated curly quote does not swallow the document', () => {
+  const tokens = tokenize('<p class=“broken>Hi</p>');
+  assert.equal(tokens.map(t => t.raw).join(''), '<p class=“broken>Hi</p>');
+});
+
+// --- end to end: the reported symptom ---
+
+test('a curly-quoted class is removed, not passed through mangled', () => {
+  assert.equal(runTidyPipeline('<p class=“hero lede”>Hi</p>', DEFAULTS).output, '<p>Hi</p>');
+});
+
+test('a curly-quoted value that is kept is rebuilt with straight quotes', () => {
+  const opts = withOpts({ removeClassesIds: false, blockNewlines: false });
+  assert.equal(runTidyPipeline('<p class=“hero lede”>Hi</p>', opts).output,
+    '<p class="hero lede">Hi</p>');
+});
+
+test('curly quotes in prose are left alone by the attribute fix', () => {
+  const opts = withOpts({ blockNewlines: false });
+  assert.equal(runTidyPipeline('<p>It’s a “big” day</p>', opts).output,
+    '<p>It’s a “big” day</p>');
+});
+
+// --- opt-straighten-quotes, default OFF ---
+
+test('straightenSmartPunctuation maps curly punctuation to ASCII', () => {
+  assert.equal(straightenSmartPunctuation('It’s a “big” day…'), 'It\'s a "big" day...');
+});
+
+test('straightenSmartPunctuation mirrors option 9 on dashes', () => {
+  // Option 9 maps &ndash;/&mdash; to ' - ', spaces included, so a dash that was
+  // already spaced ends up doubled. The pipeline post-pass collapses the runs.
+  assert.equal(straightenSmartPunctuation('a – b — c'), 'a  -  b  -  c');
+});
+
+test('the pipeline collapses the spacing that dash straightening leaves', () => {
+  const opts = withOpts({ straightenQuotes: true, blockNewlines: false });
+  assert.equal(runTidyPipeline('<p>a – b</p>', opts).output, '<p>a - b</p>');
+});
+
+test('the Extra is off by default, so prose typography survives', () => {
+  const opts = withOpts({ blockNewlines: false });
+  assert.equal(runTidyPipeline('<p>“hi”</p>', opts).output, '<p>“hi”</p>');
+});
+
+test('the Extra straightens prose when turned on', () => {
+  const opts = withOpts({ straightenQuotes: true, blockNewlines: false });
+  assert.equal(runTidyPipeline('<p>“hi”</p>', opts).output, '<p>"hi"</p>');
+});
+
+// Why mixed delimiters are deliberately not supported: the fix would regress
+// these two, which are more common than mixed delimiters and parse correctly now.
+
+test('a straight-quoted value may contain curly prose quotes', () => {
+  assert.deepEqual(parseAttributes('alt="He said “hi” to me"'),
+    [{ name: 'alt', value: 'He said “hi” to me', quote: '"' }]);
+});
+
+test('a curly-quoted value may contain straight quotes', () => {
+  assert.deepEqual(parseAttributes('alt=“He said "hi" to me”'),
+    [{ name: 'alt', value: 'He said "hi" to me', quote: '"' }]);
+});
diff --git a/formatter/tests/docs-residue.test.mjs b/formatter/tests/docs-residue.test.mjs
new file mode 100644
index 0000000..76a30f0
--- /dev/null
+++ b/formatter/tests/docs-residue.test.mjs
@@ -0,0 +1,108 @@
+import { test, assert } from './helpers.mjs';
+import { runTidyPipeline } from '../app.mjs';
+
+// Issue #22. Measured live on 2026-09-03: prettyhtml.com returns
+//   <p dir="ltr"><span>Hello</span></p>
+// for a Google Docs paste. Their TinyMCE layer strips role/aria-level and the
+// docs-internal-guid <b> wrapper before any option runs; dir="ltr" survives even
+// on their site. We have no such layer, so opt-docs-residue covers both the
+// layer-1 compensation and the better-than-parity dir strip.
+
+const DEFAULTS = {
+  lowercaseTags: true, lowercaseAttrs: true, sortAttrs: false,
+  removeEmptyAttrs: false, fixSelfClosing: true, quoteAttrs: true,
+  removeStyles: true, removeClassesIds: true, removeEmptyTags: true,
+  removeOneSpaceTags: true, trimWhitespace: true, removeComments: true,
+  tagAttributes: false, plainText: false, aiWatermarks: false, smartNbsps: false,
+  strayBreaks: true, nestedEmpties: true, docsResidue: true, stripScripts: true,
+  blockNewlines: true, straightenQuotes: false,
+  removeDataAttrs: false, unwrapSpans: true,
+};
+const withOpts = (over) => ({ ...DEFAULTS, ...over });
+
+const DOCS_PASTE =
+  '<b style="font-weight:normal" id="docs-internal-guid-abc123">' +
+  '<p dir="ltr" role="presentation"><span style="font-size:11pt">Hello</span></p>' +
+  '<h2 dir="ltr" aria-level="2"><span style="font-weight:700">Head</span></h2></b>';
+
+test('a Google Docs paste comes out clean with the Extra on', () => {
+  assert.equal(runTidyPipeline(DOCS_PASTE, DEFAULTS).output, '<p>Hello</p>\n<h2>Head</h2>');
+});
+
+test('the Extra off leaves the residue in place', () => {
+  const out = runTidyPipeline(DOCS_PASTE, withOpts({ docsResidue: false })).output;
+  assert.match(out, /dir="ltr"/);
+  assert.match(out, /role="presentation"/);
+  assert.match(out, /aria-level="2"/);
+});
+
+test('role="presentation" is stripped but other roles are kept', () => {
+  const opts = withOpts({ blockNewlines: false });
+  assert.equal(runTidyPipeline('<p role="presentation">a</p>', opts).output, '<p>a</p>');
+  assert.equal(runTidyPipeline('<p role="navigation">a</p>', opts).output, '<p role="navigation">a</p>');
+});
+
+test('dir="ltr" is stripped but dir="rtl" is kept', () => {
+  const opts = withOpts({ blockNewlines: false });
+  assert.equal(runTidyPipeline('<p dir="ltr">a</p>', opts).output, '<p>a</p>');
+  assert.equal(runTidyPipeline('<p dir="rtl">a</p>', opts).output, '<p dir="rtl">a</p>');
+});
+
+test('the docs-internal-guid wrapper is unwrapped, keeping its children', () => {
+  const opts = withOpts({ blockNewlines: false, removeClassesIds: false });
+  assert.equal(
+    runTidyPipeline('<b id="docs-internal-guid-x"><p>a</p></b>', opts).output,
+    '<p>a</p>');
+});
+
+test('a real <b> is left alone', () => {
+  const opts = withOpts({ blockNewlines: false });
+  assert.equal(runTidyPipeline('<p>a <b>bold</b> c</p>', opts).output, '<p>a <b>bold</b> c</p>');
+});
+
+test('a real <b> nested inside the wrapper keeps its own closing tag', () => {
+  const opts = withOpts({ blockNewlines: false, removeClassesIds: false });
+  assert.equal(
+    runTidyPipeline('<b id="docs-internal-guid-x"><p>a <b>real</b> c</p></b>', opts).output,
+    '<p>a <b>real</b> c</p>');
+});
+
+test('residue attribute values are matched case-insensitively', () => {
+  // role= was compared case-sensitively while dir= was lowercased first, so a
+  // differently-cased role slipped through where a dir would not.
+  const opts = withOpts({ blockNewlines: false });
+  assert.equal(runTidyPipeline('<p role="Presentation">a</p>', opts).output, '<p>a</p>');
+  assert.equal(runTidyPipeline('<p dir="LTR">a</p>', opts).output, '<p>a</p>');
+});
+
+// A span whose only attribute is Docs residue must unwrap, the same as one whose
+// only attribute is an inline style. buildTidyTag and the unwrapSpans check share
+// isDroppedAttr so the two cannot disagree again. Regression guard: assert with
+// the nested-empties fixpoint OFF, since that loop otherwise masks the bug by
+// catching the emptied span on a second pass.
+const noFixpoint = withOpts({ nestedEmpties: false, blockNewlines: false });
+
+test('a span holding only role="presentation" is unwrapped', () => {
+  assert.equal(runTidyPipeline('<p><span role="presentation">x</span></p>', noFixpoint).output,
+    '<p>x</p>');
+});
+
+test('a span holding only dir="ltr" is unwrapped', () => {
+  assert.equal(runTidyPipeline('<p><span dir="ltr">x</span></p>', noFixpoint).output, '<p>x</p>');
+});
+
+test('a span holding only aria-level is unwrapped', () => {
+  assert.equal(runTidyPipeline('<p><span aria-level="2">x</span></p>', noFixpoint).output,
+    '<p>x</p>');
+});
+
+test('a span with a surviving attribute is still kept', () => {
+  assert.equal(runTidyPipeline('<p><span dir="rtl">x</span></p>', noFixpoint).output,
+    '<p><span dir="rtl">x</span></p>');
+});
+
+test('residue unwrapping respects the docs-residue toggle', () => {
+  const off = withOpts({ nestedEmpties: false, blockNewlines: false, docsResidue: false });
+  assert.equal(runTidyPipeline('<p><span dir="ltr">x</span></p>', off).output,
+    '<p><span dir="ltr">x</span></p>');
+});
diff --git a/formatter/tests/fixtures/prettyhtml-golden.json b/formatter/tests/fixtures/prettyhtml-golden.json
new file mode 100644
index 0000000..de09421
--- /dev/null
+++ b/formatter/tests/fixtures/prettyhtml-golden.json
@@ -0,0 +1,194 @@
+{
+  "_meta": {
+    "captured": "2026-09-03; option dispatch re-verified live 2026-09-04",
+    "source": "prettyhtml.com, driven live in-browser via chrome-devtools MCP",
+    "technique": "window.text = input; <primitive>(); read window.text — for primitive fixtures. tinymce.get('vizualisEditor').setContent(input); convertText(); read window.text — for pipeline fixtures.",
+    "legal": "Black-box input/output observations only. No third-party source is reproduced here. The raw capture lives in planning/captures/ and is gitignored.",
+    "optDefaults": {
+      "1": 1,
+      "2": 1,
+      "3": 1,
+      "4": 1,
+      "5": 1,
+      "6": 1,
+      "7": 0,
+      "8": 0,
+      "9": 0,
+      "10": 0,
+      "14": 0
+    },
+    "layerNote": "'layer1' is the TinyMCE round-trip alone (setContent then getContent, before any cleaner runs). 'output' is the full convertText pipeline. Our port has no layer 1, so a fixture whose work happens in layer1 must be matched by an Extras compensation, not by a layer-2 cleaner.",
+    "oursNote": "'output' is what prettyhtml.com produces. Where we deliberately differ, 'ours' records our own expected output and 'oursNote' says why. A fixture with no 'ours' must match theirs byte for byte at shipped defaults."
+  },
+  "primitives": [
+    {
+      "id": "empty-nested-single-pass",
+      "divergence": "B",
+      "fn": "uresTagotTorul",
+      "input": "<div><p></p></div>",
+      "output": "<div></div>",
+      "note": "Single linear pass. The outer div is not revisited after the inner pair is deleted."
+    },
+    {
+      "id": "empty-nested-called-twice",
+      "divergence": "B",
+      "fn": "uresTagotTorul x2",
+      "input": "<div><p></p></div>",
+      "output": "",
+      "note": "Proves cascading is a real behavior change, not a no-op. convertText calls it once."
+    },
+    {
+      "id": "empty-nested-deeper",
+      "divergence": "B",
+      "fn": "uresTagotTorul",
+      "input": "<section><div><p></p></div></section>",
+      "output": "<section><div></div></section>",
+      "note": "Only the innermost pair is removed per pass."
+    },
+    {
+      "id": "empty-mismatched-names",
+      "fn": "uresTagotTorul",
+      "input": "<b></i>",
+      "output": "",
+      "note": "Tag names are never compared. Deliberate divergence G — our canRemove is stricter."
+    },
+    {
+      "id": "empty-mismatched-block",
+      "fn": "uresTagotTorul",
+      "input": "<div></span>",
+      "output": "",
+      "note": "Same quirk, block-level."
+    },
+    {
+      "id": "one-space-named-entity",
+      "divergence": "H",
+      "fn": "csakEgyNbspTagotTorul",
+      "input": "<p>&nbsp;</p>",
+      "output": "",
+      "note": "Named entity matched char-by-char."
+    },
+    {
+      "id": "one-space-numeric-entity",
+      "divergence": "H",
+      "fn": "csakEgyNbspTagotTorul",
+      "input": "<p>&#160;</p>",
+      "output": "<p>&#160;</p>",
+      "note": "Numeric form is NOT matched. Our handling both forms is an improvement, not parity."
+    },
+    {
+      "id": "opt5-collapses-nbsp",
+      "divergence": "C",
+      "fn": "option 5 replacement set",
+      "input": "a&nbsp;&nbsp;b",
+      "output": "a b",
+      "note": "Option 5 is entirely about non-breaking-space entities."
+    },
+    {
+      "id": "opt5-ignores-whitespace",
+      "divergence": "C",
+      "fn": "option 5 replacement set",
+      "input": "a     b",
+      "output": "a     b",
+      "note": "Option 5 does NOT touch literal whitespace runs. Ours does the opposite. Literal runs are collapsed by the unconditional pre/post-pass instead."
+    },
+    {
+      "id": "plaintext-substitutes-space",
+      "divergence": "D",
+      "fn": "option 8 replacement set",
+      "input": "a<br/>b",
+      "output": "a b",
+      "note": "One space per removed tag. We used to delete the tag outright, yielding 'ab'; fixed alongside this fixture, and plain-text.test.mjs now asserts the space-substituting behavior recorded here."
+    },
+    {
+      "id": "helyettesit-is-fixpoint",
+      "fn": "helyettesit('  ', ' ')",
+      "input": "a          b",
+      "output": "a b",
+      "note": "String-pattern replace looped to idempotence, so a run of any length collapses."
+    }
+  ],
+  "pipeline": [
+    {
+      "id": "curly-quoted-attribute",
+      "divergence": "N",
+      "input": "<p class=“hero lede”>Hi</p>",
+      "layer1": "<p class=\"&ldquo;hero\">Hi</p>",
+      "output": "<p>Hi</p>",
+      "note": "TinyMCE parses the curly-quoted value as unquoted, terminating at the space; 'lede”' is dropped entirely and the opening curly quote is entity-encoded into the value. Option 2 (default ON) then removes the mangled class, so their user-visible output is clean. Ours invents a bare attribute named 'lede”' that no cleaner matches, so it survives into output. Target for our fix: match this output."
+    },
+    {
+      "id": "curly-quoted-attribute-with-gt",
+      "divergence": "N",
+      "input": "<p class=“a > b”>Hi</p>",
+      "layer1": "<p class=\"&ldquo;a\">b&rdquo;&gt;Hi</p>",
+      "output": "<p>b&rdquo;&gt;Hi</p>",
+      "note": "A '>' inside a curly-quoted value truncates the tag and leaks the remainder into text content. Both implementations corrupt this; theirs at least yields well-formed HTML.",
+      "ours": "<p>Hi</p>",
+      "oursNote": "DELIBERATE (N). We accept curly quotes as attribute delimiters, so the value stays intact and the classes/IDs option removes it cleanly. Theirs truncates the tag at the '>' inside the value and leaks the remainder into text content."
+    },
+    {
+      "id": "straight-quoted-attribute-control",
+      "input": "<p class=\"hero lede\">Hi</p>",
+      "layer1": "<p class=\"hero lede\">Hi</p>",
+      "output": "<p>Hi</p>",
+      "note": "Control for the two above."
+    },
+    {
+      "id": "curly-punctuation-in-prose",
+      "input": "<p>It’s a “big” day — really.</p>",
+      "layer1": "<p>It&rsquo;s a &ldquo;big&rdquo; day &mdash; really.</p>",
+      "output": "<p>It&rsquo;s a &ldquo;big&rdquo; day &mdash; really.</p>",
+      "note": "Layer 1 entity-encodes real smart punctuation (entity_encoding:'named'); layer 2 leaves it alone with option 9 off. Prose typography is preserved, which is why our N fix must touch attribute delimiters only.",
+      "ours": "<p>It’s a “big” day — really.</p>",
+      "oursNote": "DELIBERATE (layer 1). Their TinyMCE round-trip runs with entity_encoding:'named', so real smart punctuation comes back as entities. We have no round-trip and keep the literal characters, which are valid UTF-8 HTML. The opt-straighten-quotes Extra (default OFF) converts them to ASCII for anyone who wants that."
+    },
+    {
+      "id": "google-docs-paste",
+      "divergence": "issue #22",
+      "input": "<b style=\"font-weight:normal\" id=\"docs-internal-guid-abc123\"><p dir=\"ltr\" role=\"presentation\"><span style=\"font-size:11pt;font-family:Arial\">Hello</span></p><h2 dir=\"ltr\" aria-level=\"2\"><span style=\"font-weight:700\">Head</span></h2></b>",
+      "layer1": "<p dir=\"ltr\"><span style=\"font-size: 11pt; font-family: Arial;\">Hello</span></p>\n<h2 dir=\"ltr\"><span style=\"font-weight: bold;\">Head</span></h2>",
+      "output": "<p dir=\"ltr\"><span>Hello</span></p>\n<h2 dir=\"ltr\"><span>Head</span></h2>",
+      "note": "ANSWERS ISSUE #22. dir=\"ltr\" SURVIVES on prettyhtml.com — so removing it is better-than-parity, as the plan predicted. Note also that layer 1 (not any cleaner) is what strips role=\"presentation\", aria-level, and the docs-internal-guid <b> wrapper. Our port has no layer 1, so it must handle all of that explicitly. Synthetic sample, structurally faithful to real Docs clipboard HTML; replace with a genuine paste when one is available.",
+      "synthetic": true,
+      "ours": "<p>Hello</p>\n<h2>Head</h2>",
+      "oursNote": "DELIBERATE. Two default-ON Extras go past their output: opt-docs-residue strips dir=\"ltr\" (which survives on their site), and opt-unwrap-spans drops the <span> once option 1 has emptied it of attributes. Closes issue #22."
+    },
+    {
+      "id": "script-block",
+      "input": "<p>a</p><script>var x=1;</script><p>b</p>",
+      "layer1": "<p>a</p>\n<p>b</p>",
+      "output": "<p>a</p>\n<p>b</p>",
+      "note": "TinyMCE removes script blocks at layer 1, before the unconditional layer-2 strip ever runs."
+    },
+    {
+      "id": "style-block",
+      "input": "<p>a</p><style>.x{color:red}</style><p>b</p>",
+      "layer1": "<p>a</p>\n<p>b</p>",
+      "output": "<p>a</p>\n<p>b</p>",
+      "note": "Same as script blocks."
+    },
+    {
+      "id": "inter-tag-gap-join",
+      "divergence": "F",
+      "input": "<div> <p>x</p> </div>",
+      "layer1": "<div>\n<p>x</p>\n</div>",
+      "output": "<div>\n<p>x</p>\n</div>",
+      "note": "Layer 1 has already converted the inter-tag spaces to newlines, so option 3's '> <' join has nothing to do here."
+    },
+    {
+      "id": "empty-nested-end-to-end",
+      "divergence": "B",
+      "input": "<div><p></p></div>",
+      "layer1": "<div>&nbsp;</div>",
+      "output": "",
+      "note": "CRITICAL. End-to-end output is empty, but NOT via cascading empty-tag removal. Layer 1 turns the empty <p> into &nbsp;, and option 4 removes the result as a one-space tag. Compare the primitive fixture above, which returns <div></div>."
+    },
+    {
+      "id": "nbsp-spacer-paragraph",
+      "input": "<p>a</p>\n<p>&nbsp;</p>\n<p>b</p>",
+      "layer1": "<p>a</p>\n<p>&nbsp;</p>\n<p>b</p>",
+      "output": "<p>a</p>\n<p>b</p>",
+      "note": "Option 4 removes the spacer paragraph."
+    }
+  ]
+}
diff --git a/formatter/tests/parity.test.mjs b/formatter/tests/parity.test.mjs
new file mode 100644
index 0000000..9c1fb02
--- /dev/null
+++ b/formatter/tests/parity.test.mjs
@@ -0,0 +1,148 @@
+import { test, assert } from './helpers.mjs';
+import { readFileSync } from 'node:fs';
+import { runTidyPipeline, replaceUntilStable, tidy } from '../app.mjs';
+
+const fixtures = JSON.parse(
+  readFileSync(new URL('./fixtures/prettyhtml-golden.json', import.meta.url), 'utf8'),
+);
+
+// The tool's shipped defaults: prettyhtml options 1-6 on, 7-10 off, plus our
+// Extras. Fixtures without an "ours" field must match prettyhtml.com exactly
+// under these; the ones with it are the documented deliberate divergences.
+const DEFAULTS = {
+  lowercaseTags: true, lowercaseAttrs: true, sortAttrs: false,
+  removeEmptyAttrs: false, fixSelfClosing: true, quoteAttrs: true,
+  removeStyles: true, removeClassesIds: true, removeEmptyTags: true,
+  removeOneSpaceTags: true, trimWhitespace: true, removeComments: true,
+  tagAttributes: false, plainText: false, aiWatermarks: false, smartNbsps: false,
+  strayBreaks: true, nestedEmpties: true, docsResidue: true, stripScripts: true,
+  blockNewlines: true, straightenQuotes: false,
+  removeDataAttrs: false, unwrapSpans: true,
+};
+
+const withOpts = (over) => ({ ...DEFAULTS, ...over });
+
+// --- Golden pipeline fixtures, captured from prettyhtml.com ---
+
+for (const f of fixtures.pipeline) {
+  const expected = 'ours' in f ? f.ours : f.output;
+  const label = 'ours' in f ? `${f.id} (deliberate divergence)` : `${f.id} (parity)`;
+  test(`pipeline: ${label}`, () => {
+    assert.equal(runTidyPipeline(f.input, DEFAULTS).output, expected);
+  });
+}
+
+// --- replaceUntilStable mirrors their helyettesit() looping ---
+
+test('replaceUntilStable collapses a run of any length', () => {
+  assert.equal(replaceUntilStable('a          b', '  ', ' '), 'a b');
+});
+
+test('replaceUntilStable is a no-op when the pattern is absent', () => {
+  assert.equal(replaceUntilStable('abc', 'xy', 'z'), 'abc');
+});
+
+test('replaceUntilStable does one pass when the replacement cannot converge', () => {
+  // " " -> "  " re-creates its own pattern; looping would grow without bound.
+  assert.equal(replaceUntilStable('a b', ' ', '  '), 'a  b');
+});
+
+test('replaceUntilStable ignores an empty pattern', () => {
+  assert.equal(replaceUntilStable('abc', '', 'x'), 'abc');
+});
+
+// --- Option 5 is nbsp-only (divergence C), verified live 2026-09-04 ---
+
+test('option 5 collapses adjacent &nbsp; entities', () => {
+  assert.equal(runTidyPipeline('a&nbsp;&nbsp;b', DEFAULTS).output, 'a b');
+});
+
+test('option 5 leaves a lone &nbsp; between words alone', () => {
+  assert.equal(runTidyPipeline('a&nbsp;b', DEFAULTS).output, 'a&nbsp;b');
+});
+
+test('literal whitespace runs collapse even with option 5 off', () => {
+  // Theirs too: the pre/post-passes do this, not the checkbox.
+  assert.equal(runTidyPipeline('a     b', withOpts({ trimWhitespace: false })).output, 'a b');
+});
+
+// --- Option 3 / option 4 boundary (divergence F) ---
+
+test('a newline-only tag is removed by option 3, not option 4', () => {
+  const opts = withOpts({ removeOneSpaceTags: false, blockNewlines: false });
+  assert.equal(runTidyPipeline('<p>\n</p>', opts).output, '');
+});
+
+test('an &nbsp;-only tag is removed by option 4, not option 3', () => {
+  const opts = withOpts({ removeEmptyTags: false, blockNewlines: false });
+  assert.equal(runTidyPipeline('<p>&nbsp;</p>', opts).output, '');
+});
+
+test('option 3 joins the "> <" gap so a spaced-open tag still clears', () => {
+  assert.equal(runTidyPipeline('<div> <p> </p> </div>', DEFAULTS).output, '');
+});
+
+// --- Divergence H: numeric nbsp spelling (deliberate improvement) ---
+
+test('option 4 also removes a numeric &#160; tag, which theirs misses', () => {
+  const opts = withOpts({ blockNewlines: false });
+  assert.equal(runTidyPipeline('<p>&#160;</p>', opts).output, '');
+});
+
+// --- Divergence G: canRemove is stricter than theirs (deliberate) ---
+
+test('mismatched tag names are not treated as an empty pair', () => {
+  const opts = withOpts({ blockNewlines: false });
+  assert.equal(tidy('<b></i>', opts).output, '<b></i>');
+});
+
+test('empty table cells survive, unlike theirs', () => {
+  const opts = withOpts({ blockNewlines: false });
+  assert.equal(tidy('<td></td>', opts).output, '<td></td>');
+});
+
+// --- Nested empties: layer-1 compensation, not optional polish ---
+
+test('nested empty tags clear completely when the Extra is on', () => {
+  assert.equal(runTidyPipeline('<section><div><p></p></div></section>', DEFAULTS).output, '');
+});
+
+test('with the Extra off, one pass leaves the outer tag — as theirs does', () => {
+  const opts = withOpts({ nestedEmpties: false, blockNewlines: false });
+  assert.equal(runTidyPipeline('<div><p></p></div>', opts).output, '<div></div>');
+});
+
+// --- tidy() passes whitespace through untouched ---
+//
+// Whitespace collapsing used to live in tidy()'s TEXT case as \s+ -> " ". It moved
+// into runTidyPipeline's unconditional pre/post passes, because on prettyhtml.com
+// that work is done by the passes and not by any checkbox (divergence C). These
+// pin the behavior change at the unit level: every direct tidy() assertion above
+// uses whitespace-free input, so nothing else would catch a regression here.
+
+const passthroughOpts = withOpts({ blockNewlines: false });
+
+test('tidy leaves a run of spaces in text alone', () => {
+  assert.equal(tidy('<p>a     b</p>', passthroughOpts).output, '<p>a     b</p>');
+});
+
+test('tidy leaves newlines in text alone', () => {
+  assert.equal(tidy('<p>a\n\nb</p>', passthroughOpts).output, '<p>a\n\nb</p>');
+});
+
+test('tidy does not collapse whitespace even with option 5 on', () => {
+  // The option is nbsp-only; it must not reach literal whitespace.
+  assert.equal(tidy('<p>a  b</p>', withOpts({ trimWhitespace: true, blockNewlines: false })).output,
+    '<p>a  b</p>');
+});
+
+test('tidy leaves whitespace between tags alone', () => {
+  assert.equal(tidy('<div>  <span>x</span>  </div>',
+    withOpts({ blockNewlines: false, unwrapSpans: false })).output,
+    '<div>  <span>x</span>  </div>');
+});
+
+test('the pipeline, not tidy, is what collapses those runs', () => {
+  assert.equal(runTidyPipeline('<p>a     b</p>', passthroughOpts).output, '<p>a b</p>');
+  assert.equal(runTidyPipeline('<p>a\n\nb</p>', passthroughOpts).output, '<p>a\nb</p>');
+});
diff --git a/formatter/tests/plain-text.test.mjs b/formatter/tests/plain-text.test.mjs
index 4b63c6b..8d889ab 100644
--- a/formatter/tests/plain-text.test.mjs
+++ b/formatter/tests/plain-text.test.mjs
@@ -1,26 +1,47 @@
 import { test, assert } from './helpers.mjs';
-import { toPlainText } from '../app.mjs';
+import { toPlainText, runTidyPipeline } from '../app.mjs';
 
-test('strips all tags', () => {
-  assert.equal(toPlainText('<p>hello <b>world</b></p>'), 'hello world');
+// prettyhtml.com's option 8 collapses every tag to "<>" and then substitutes a
+// single space, so tag removal leaves a separator behind. Verified live against
+// their pipeline on 2026-09-04:
+//   "a<br/>b"                              -> "a b"
+//   "<div><span>a</span><em>b</em></div>"  -> "  a  b  "
+//   "<p>x<!-- y --></p>"                   -> " x<!-- y --> "
+// The doubled spaces are collapsed later by the unconditional post-pass, which
+// is why the pipeline-level assertions below look tidier than the raw ones.
+
+test('substitutes a space for each stripped tag', () => {
+  assert.equal(toPlainText('<p>hello <b>world</b></p>'), ' hello  world  ');
 });
 
-test('preserves comments', () => {
-  assert.equal(toPlainText('<p>x<!-- y --></p>'), 'x<!-- y -->');
+test('preserves comments whole', () => {
+  assert.equal(toPlainText('<p>x<!-- y --></p>'), ' x<!-- y --> ');
 });
 
-test('handles nested tags', () => {
-  assert.equal(toPlainText('<div><span>a</span><em>b</em></div>'), 'ab');
+test('separates adjacent nested tags', () => {
+  assert.equal(toPlainText('<div><span>a</span><em>b</em></div>'), '  a  b  ');
 });
 
 test('handles tag attributes', () => {
-  assert.equal(toPlainText('<p class="x" id="y">hello</p>'), 'hello');
+  assert.equal(toPlainText('<p class="x" id="y">hello</p>'), ' hello ');
 });
 
 test('preserves text between tags', () => {
-  assert.equal(toPlainText('start <b>middle</b> end'), 'start middle end');
+  assert.equal(toPlainText('start <b>middle</b> end'), 'start  middle  end');
+});
+
+test('self-closing tag becomes a word separator, not a join', () => {
+  assert.equal(toPlainText('a<br/>b'), 'a b');
+});
+
+// --- pipeline level: the post-pass collapses the runs ---
+
+const plainOpts = { plainText: true, trimWhitespace: true };
+
+test('pipeline collapses the substituted spaces', () => {
+  assert.equal(runTidyPipeline('<div><span>a</span><em>b</em></div>', plainOpts).output, ' a b ');
 });
 
-test('handles self-closing tags', () => {
-  assert.equal(toPlainText('a<br/>b'), 'ab');
+test('pipeline keeps words apart across a <br>', () => {
+  assert.equal(runTidyPipeline('a<br/>b', plainOpts).output, 'a b');
 });
diff --git a/formatter/tests/stray-breaks.test.mjs b/formatter/tests/stray-breaks.test.mjs
index fac36a9..e9a3eef 100644
--- a/formatter/tests/stray-breaks.test.mjs
+++ b/formatter/tests/stray-breaks.test.mjs
@@ -95,3 +95,17 @@ test('the Google-Docs paste collapses its stray breaks to spacers', () => {
 test('leaves text with no <br> untouched', () => {
   assert.equal(normalizeStrayBreaks('<p>hello</p>'), '<p>hello</p>');
 });
+
+test('drops a <br> sitting just inside a block closing tag', () => {
+  // Filler, not a line break — it renders nothing. prettyhtml.com's TinyMCE
+  // layer drops these too; verified live on 2026-09-04.
+  assert.equal(normalizeStrayBreaks('<p>Body copy.<br></p>'), '<p>Body copy.</p>');
+});
+
+test('drops a trailing <br> across intervening whitespace', () => {
+  assert.equal(normalizeStrayBreaks('<p>Body copy.<br>\n  </p>'), '<p>Body copy.\n  </p>');
+});
+
+test('still keeps a <br> that has text after it', () => {
+  assert.equal(normalizeStrayBreaks('<p>a<br>b</p>'), '<p>a<br>b</p>');
+});
diff --git a/planning/2026-05-27-prettyhtml-parity.md b/planning/2026-05-27-prettyhtml-parity.md
index 6caf8e2..38383da 100644
--- a/planning/2026-05-27-prettyhtml-parity.md
+++ b/planning/2026-05-27-prettyhtml-parity.md
@@ -1,5 +1,7 @@
 # prettyhtml.com Functional Parity Implementation Plan
 
+> **⚠️ Partially superseded (2026-09-03).** This plan's option-by-option mapping and its literal-port transcriptions (options 7, 9, 10) still stand. Its **Algorithm Snapshot appendix is incomplete** — it captured the individual cleaners but not the pipeline that surrounds them (pre-pass, post-pass loop, unconditional script/style removal, option dispatch order, Prettify/Compress). For the complete and corrected spec, read **`2026-09-03-prettyhtml-complete-capture.md`** first; that document is authoritative where the two disagree.
+
 > **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
 
 **Goal:** Make `/formatter/` a functional replacement for prettyhtml.com — every option that exists there is available here, with the same labels and defaults, so the user is insulated from prettyhtml.com disappearing or changing hands.
@@ -37,7 +39,7 @@ prettyhtml.com exposes 10 cleaning toggles (defaults: 1-6 ON, 7-10 OFF, cookie-p
 
 ### Source-of-truth files (already gathered, 2026-05-27 snapshot)
 
-If you're executing this plan later and prettyhtml.com has changed/disappeared, the working copies on the user's machine are at:
+**These `/tmp` paths are gone** — `/tmp` did not survive. A fresh capture was taken on 2026-09-03 and now lives in `planning/captures/` (gitignored, local-only; see the legal note in `2026-09-03-prettyhtml-complete-capture.md`). The original list, for the record:
 - `/tmp/prettyhtml-home.html` — full HTML of prettyhtml.com (33 KB)
 - `/tmp/prettyhtml.js` — cleaning logic (73 KB minified)
 - `/tmp/prettyhtml-pretty.js` — naively pretty-printed (1133 lines)
diff --git a/planning/2026-09-03-prettyhtml-complete-capture.md b/planning/2026-09-03-prettyhtml-complete-capture.md
new file mode 100644
index 0000000..dca02c2
--- /dev/null
+++ b/planning/2026-09-03-prettyhtml-complete-capture.md
@@ -0,0 +1,285 @@
+# prettyhtml.com — Complete Algorithm Capture (clean-room)
+
+**Date:** 2026-09-03
+**Supersedes:** the Algorithm Snapshot appendix in `2026-05-27-prettyhtml-parity.md` (which remains valid but incomplete — see [What the 2026-05-27 snapshot missed](#what-the-2026-05-27-snapshot-missed)).
+**Status:** authoritative behavior spec for `/formatter/`.
+
+## Why this document exists
+
+Mark depends on prettyhtml.com's core function — stripping pasted HTML down to bare tags — for daily publishing work. It is a one-person operation (Ruwix Services SRL; the Hungarian identifiers `helyettesit`, `uresTagotTorul`, `gondolkodobaesett` give it away). If it disappears, `/formatter/` has to be able to stand in for it. That requires knowing not just *what* it does but *exactly* how, including its bugs.
+
+### Legal posture — read before touching the capture
+
+The raw site files are copyrighted third-party code. They are kept **locally only**, in `planning/captures/`, which is gitignored (`.gitignore:29`). **They must never be committed to this public repo.** This document is the committed artifact: a behavior specification written from observation, in our own words and our own pseudocode. No verbatim source is reproduced here.
+
+Local capture set (2026-09-03), for provenance:
+
+| File | SHA-256 |
+|---|---|
+| `prettyhtml-index.html` | `f1b84885ead042faee4ceb049999fb618399e19a3fad4bae7e3d22c4200e781b` |
+| `prettyhtml.js` | `1d6becb456303759fe0b9b4326b94510a90e7febaeaf043599e605459b0f8046` |
+| `prettyhtml-split.js` | `ce62efe41bd56bb53c0bd5f5385262052742d1511910c264dd9eefa387d592cf` |
+| `prettyhtml.css` | *(added to the capture set after the hashes above were taken)* |
+
+`prettyhtml-split.js` is the same bytes as `prettyhtml.js`, reflowed one-statement-per-line for readability. Line numbers cited below refer to the split version.
+
+### The kill-switch — never port this
+
+The site ships an anti-rehosting trap. A function (`elkur`, line 117) checks whether `document.domain` contains the substring `"tyht"`; if it does not, it replaces the working text with a single space and blanks both editors. It is called at the end of every conversion, and the same guard appears in the editor-sync helpers (`updateRight`, `updateLeft`, line 25/27).
+
+Two consequences:
+
+1. **Never port this behavior**, in any form, for any reason.
+2. It is domain-gated, so driving their functions *on their own live page* works normally. That is the supported technique for the parity harness — see the `verify-formatter-parity-via-prettyhtml` memory note.
+
+---
+
+## Architecture: two layers
+
+The thing users call "Pretty" is `convertText()` (line 115). It runs on top of a DOM normalization layer, and conflating the two is the single most common source of parity confusion.
+
+**Layer 1 — TinyMCE round-trip.** The pipeline's first act is to read content out of a TinyMCE 4 instance (`tinymce.get("vizualisEditor").getContent()`). TinyMCE has already parsed and re-serialized the markup against its stock schema — no `valid_elements` restriction — with `entity_encoding:"named"` (a UI toggle can switch it to `"raw"`), `convert_urls:false`, and the paste plugin active. This layer silently repairs malformed nesting, wraps loose body-level text in `<p>`, and normalizes stray `<br>`s (a bare `<br>` between `</p>` and `<p>` becomes `<p>&nbsp;</p>`).
+
+Our port is a pure tokenizer with **no DOM round-trip**, deliberately. `normalizeStrayBreaks` (the default-ON `opt-stray-breaks` Extra) is a partial stand-in covering the `<br>` residue case. **When our output diverges from theirs, suspect this layer first.**
+
+**Layer 2 — the string cleaners.** Everything below. These operate on a module-global `text` variable rather than taking and returning arguments, which is why the live-driving technique is `window.text = input; theFunction(); /* read window.text */`.
+
+---
+
+## The primitives
+
+### `helyettesit(from, to)` — replace-until-idempotent
+
+The workhorse. Repeatedly applies a **string-pattern** replace (which in JS replaces only the *first* occurrence) until an application produces no change; returns the number of replacements performed.
+
+```
+count = 0
+loop forever:
+    next = text.replace(from, to)      # first occurrence only
+    if next == text: break
+    text = next; count += 1
+return count
+```
+
+Two properties that matter and are easy to get wrong:
+
+- It is **replace-all**, achieved by iteration, not by a global regex.
+- It is **fixpoint-seeking**, so `helyettesit("  ", " ")` collapses a run of *any* length down to one space, and the count it returns is what the caller uses to decide whether to keep looping.
+
+### `torolTagbanKettoKozt(startMarker, endMarker)` — delete between markers, inside tags only
+
+A character machine that deletes everything between two markers while **keeping both markers**. Returns a match count.
+
+The important subtlety: the *start* marker is only recognized while the scanner is **inside a tag** — it tracks a flag set on `<` and cleared on `>`, and only attempts a start-match when that flag is set. The *end* marker is matched unconditionally. This is what makes `torolTagbanKettoKozt('style="', '"')` an attribute-value eraser rather than a document-wide one.
+
+It is also why the attribute cleaners are **straight-double-quote-only** surgery: the literal marker is `style="`. A single-quoted or curly-quoted attribute is never matched at all.
+
+### The three empty-tag machines
+
+`uresTagotTorul`, `csakEnteresTagotTorul`, and `csakEgyNbspTagotTorul` (lines 61, 63, 65) are the **same character machine** three times over, differing only in a lookahead predicate. Each makes **one linear pass** and blanks out the span from an opening tag's `<` through the following closing tag's `>`:
+
+```
+state = LOOKING
+for each index a in text:
+    if state == LOOKING and text[a] == '<' and text[a+1] != '/':
+        state = IN_OPEN_TAG; start = a
+    if state == ARMED and text[a] == '>':
+        blank output positions start..a ; blank current ; state = LOOKING
+    if state == IN_OPEN_TAG and text[a] == '>':
+        state = ARMED if (not self-closing) and (PREDICATE holds at a+1) else LOOKING
+    copy text[a] to output
+```
+
+"Not self-closing" is tested by checking that neither of the two characters before `>` is `/`. The per-machine predicate is:
+
+| Machine | Predicate at `a+1` | Removes |
+|---|---|---|
+| `uresTagotTorul` | `<` `/` | `<x></x>` |
+| `csakEnteresTagotTorul` | `\n` `<` `/` | `<x>\n</x>` |
+| `csakEgyNbspTagotTorul` | `&` `n` `b` `s` `p` `;` `<` `/` | `<x>&nbsp;</x>` |
+
+Three consequences, each of which genuinely changes output:
+
+1. **Tag names are never compared.** `<b></i>` is deleted. So is `<div></span>`.
+2. **The `&nbsp;` predicate is a literal character sequence.** The numeric form `&#160;` is *not* matched.
+3. **Each machine is a single pass, and each is called exactly once.** They do not cascade. See the next section.
+
+---
+
+## Pipeline order (`convertText`, line 115)
+
+> **Re-verified live 2026-09-04** by reading `String(convertText)` in the page and
+> executing each option's replacement sequence against `window.text`. Every claim
+> in this section was confirmed against the running site, not inferred from the
+> minified bundle. The measured probes are recorded in
+> `formatter/tests/fixtures/prettyhtml-golden.json`.
+
+The function body is a `for` loop whose *initializer* holds the entire option dispatch and whose *condition* holds the post-pass. That is an unusual shape and it encodes the control flow precisely:
+
+- **initializer → runs exactly once**: script/style removal and all option handling
+- **condition → runs repeatedly until it evaluates false**: the whitespace post-pass, looping while any replacement fired
+- body and update: empty
+
+Full order:
+
+1. **Read from TinyMCE** (layer 1). Stash it as the undo buffer.
+2. **Pre-pass**, unconditional, in this order:
+   `\t`→`` · `"  "`→`" "` · `" \n"`→`\n` · `"\t\n"`→`\n` · `"\n\n"`→`\n` · `"  "`→`" "`
+3. **Script/style removal**, unconditional (not an option): delete between `<script`/`</script>` and between `<style`/`</style>`, then sweep the residue `<style</style>` and `<script</script>` to empty. Fires a UI popup naming whichever was removed.
+4. **Option dispatch — once, in this order** (note it is *not* the numeric order of the checkboxes):
+
+   | Order | Option | Behavior |
+   |---|---|---|
+   | 1st | **8 — To plain text** | Protect comments by swapping `<!--` for a sentinel; delete between `<` and `>`; turn the resulting `<>` into a single space; restore the sentinel. |
+   | 2nd | **1 — Inline styles** | Normalize `style = `/`style= `/`style =` to `style=`, erase between `style="` and `"`, drop leftover `style=""`. Repeat identically for `valign` and `align`. |
+   | 3rd | **5 — Successive spaces** | `&nbsp;&nbsp;`→`" "` · `&nbsp; `→`" "` · ` &nbsp;`→`" "` |
+   | 4th | **2 — Classes & IDs** | Same shape as option 1, for ` class=` and ` id=` — note the **leading space** in every marker. |
+   | 5th | **6 — Comments** | Erase between `<!--` and `-->`, then drop the resulting `<!---->`. |
+   | 6th | **4 — Tags with 1 space** | `> &nbsp;<`→`>&nbsp;<` · `>&nbsp; <`→`>&nbsp;<` · then `csakEgyNbspTagotTorul`. |
+   | 7th | **3 — Empty tags** | `> <`→`><` · `> \n`→`>\n` · then `uresTagotTorul` · then `csakEnteresTagotTorul`. |
+
+5. **Post-pass loop** — repeats while any replacement fired:
+   `"  "`→`" "` · `" >"`→`">"` · `\t`→`` · `"  "`→`" "` · `&nbsp;\n`→`\n` · `" \n"`→`\n` · `"\n\n"`→`\n` · and, when the Compress flag (opt 14) is set, `\n`→``
+6. **Option 7 — Tag attributes** (`removeTagAttributes`), then **option 9 — AI Watermarks** (`aiWatermarkFixer`), then **option 10 — Smart &nbsp;s** (`smartNbsps`).
+7. **Final cleanup**, unconditional: `" \n"`→`\n` · `"\t\n"`→`\n` · `"\n\n"`→`\n` · `"  "`→`" "`
+8. Kill-switch check, then write back to both editors.
+
+### Option 5 is about `&nbsp;`, not whitespace
+
+Worth calling out separately because the label invites the wrong assumption. "Successive spaces" touches **only** non-breaking-space entities. Literal whitespace runs are collapsed by the unconditional pre-pass and post-pass, which run whether or not option 5 is checked.
+
+Our option 5 used to do the opposite — collapse `\s+`, never touch `&nbsp;`. Fixed
+2026-09-04: option 5 is now nbsp-only (accepting `&#160;` as well, divergence H),
+and literal whitespace collapse moved to the unconditional pre/post-passes where
+it belongs.
+
+Measured, option 5 in isolation:
+
+| Input | Their output |
+|---|---|
+| `a&nbsp;b` | `a&nbsp;b` — a lone entity is left alone |
+| `a&nbsp;&nbsp;b` | `a b` |
+| `a &nbsp;b` | `a b` |
+| `a     b` | `a     b` — literal runs untouched |
+
+### Nothing cascades in layer 2 — but layer 1 hides it
+
+The option dispatch runs **once**. The only loop is the whitespace post-pass, and it contains no tag-level cleaner.
+
+Confirmed live against their own page: driving `uresTagotTorul` directly on `<div><p></p></div>` returns `<div></div>`. The inner empty tag goes; the outer one — which only *became* empty as a result — does not, because the single pass had already moved past its `>` before the inner pair was deleted. Calling the machine a second time returns `""`, which proves the cascade is a real behavior change and not a no-op. Nesting one level deeper behaves the same way: `<section><div><p></p></div></section>` → `<section><div></div></section>`.
+
+**But the end-to-end pipeline still emits `""` for that input**, by a completely different route. TinyMCE normalizes `<div><p></p></div>` to `<div>&nbsp;</div>` before layer 2 ever sees it, and option 4 (Tags with 1 space) then removes it as a one-space tag. The empty-tag machine is never what solves this case on the live site.
+
+This is the single most important lesson in this document, and it generalizes well past divergence B:
+
+> **Much of what looks like cleaner behavior is actually TinyMCE behavior.** Reasoning about their string cleaners in isolation will give you the wrong answer about what the site does. Always check the pipeline-level result too.
+
+So for our pure-tokenizer port, cascading empty-tag removal is best understood the way `normalizeStrayBreaks` already is: **a layer-1 compensation**, not a departure. It reaches the same end-to-end output by the only route available to us. It still belongs in a default-ON Extras option (`opt-nested-empties`) rather than inside the byte-faithful option-3 path, because option 3 alone must keep matching `uresTagotTorul` alone — that is what the parity fixtures pin. See divergence B in the tracking table.
+
+### Layer 1 line structure — the difference you actually see
+
+The single largest visible gap between their output and a pure layer-2 port is not
+any cleaner. It is that **TinyMCE hands back block-level elements one per line**,
+with no indentation. Their Tidy output arrives line-delimited; ours arrived as one
+long line. Measured live 2026-09-04:
+
+| Input | After layer 1 |
+|---|---|
+| `<p>a</p><p>b</p>` | `<p>a</p>\n<p>b</p>` |
+| `<div><p>x</p></div>` | `<div>\n<p>x</p>\n</div>` |
+| `<p>a <b>bold</b> c</p>` | `<p>a <strong>bold</strong> c</p>` — inline stays put |
+| `<ul><li>a</li><li>b</li></ul>` | `<ul>\n<li>a</li>\n<li>b</li>\n</ul>` |
+| `<pre>  keep\n   me</pre>` | unchanged — `<pre>` content is preserved |
+
+The rule: a block element's open tag starts a line, its close tag starts a line only
+when the block has block children, and inline content stays on its parent's line.
+`separateBlockElements()` in `app.mjs` reproduces this (default-ON Extra
+`opt-block-newlines`). Note it runs **after** our cleaners, not before as theirs
+does — emitting the newlines first would feed the empty-tag machine `<div>\n</div>`
+instead of the `<div></div>` it needs to match.
+
+This is also why option 3 carries a `> \n`→`>\n` normalization and a newline-only-tag
+machine at all: on their site, layer 1 has already put newlines everywhere by the
+time option 3 runs.
+
+TinyMCE does several other things at layer 1 that are **editor semantics, not
+cleanup**, and are deliberately not replicated (divergence K): `<b>`→`<strong>`,
+implied `<tbody>` insertion, wrapping loose text and inline content in `<p>`,
+`alt=""` injection on images, and entity-encoding real smart punctuation
+(`entity_encoding:"named"`, so `’` comes back as `&rsquo;`). It also drops a `<br>`
+sitting immediately before a block's closing tag — that one *is* cleanup, and
+`normalizeStrayBreaks` now does it too.
+
+### Prettify and Compress
+
+Prettify is a two-stage indenter (`bekezdeseketRendez` / `bekezdeseketRendezSECOND`) built on newlines and tabs, with a hardcoded void-element prefix list. It carries known bugs, including a reference to an undefined variable. Our two-stage `indent()` is conceptually the same shape and is *not* a literal port.
+
+Compress rides the same `convertText` pipeline via the opt-14 flag in the post-pass loop (`\n`→``), alongside a comment strip.
+
+---
+
+## What the 2026-05-27 snapshot missed
+
+The earlier Algorithm Snapshot is accurate on the individual literal-port cleaners (options 7, 9, 10) — those transcriptions still stand. It omitted the surrounding machinery:
+
+- the unconditional **pre-pass** and **final cleanup** replacement sets
+- the **post-pass loop** and its repeat-until-stable structure
+- the unconditional **script/style removal** (it is not an option)
+- the **option dispatch order**, in particular that plain-text runs *first*
+- the **Prettify/Compress** implementations (no capture existed)
+- `U+009D` in the AI-watermark opening-quote character class
+- the empty-tag machines' **tag names are never compared** quirk
+- that the empty-tag machines are **single-pass and non-cascading**
+
+---
+
+## Divergence tracking
+
+Full inventory and fix decisions live in the execution plan. Summary of classification
+and, as of 2026-09-04, implementation status:
+
+| ID | Divergence | Disposition |
+|---|---|---|
+| A | Always-on pre/post-pass missing from `app.mjs` | Fix — parity |
+| B | Empty-tag removal doesn't cascade | **Reclassified.** Their machine doesn't cascade either; their *layer 1* covers the case instead. Layer-1 compensation → default-ON Extras `opt-nested-empties` |
+| C | Option 5 semantics inverted (see above) | Fix — parity |
+| D | `toPlainText` deletes tags; theirs substitutes a space | Fix — parity (update tests) |
+| E | Options 1/2 structural vs their double-quote-only surgery | Keep ours — deliberate improvement |
+| F | Option 3/4 boundary misassigned; `> <` / `> \n` joins missing | Fix — parity |
+| G | Our `canRemove` exempts `td`/`th`/`script`/…; theirs removes blindly | Keep ours — deliberate improvement |
+| H | `&#160;` handled by stray-breaks but not option 4 | Fix — improvement (theirs is named-entity-only) |
+| I | `opt-newline-before-close` is dead code | Remove |
+| J | No Prettify/Compress reference existed | Documented above |
+| K | Layer 1 only covers stray `<br>`s | Partly closed. Block-per-line structure is now reproduced (`opt-block-newlines`), as is the trailing-`<br>` drop. Still not replicated: `<b>`→`<strong>`, implied `<tbody>`, loose-text wrapping, `alt=""`, entity encoding — all editor semantics |
+| L | `smartNbsps` Node-vs-browser serialization gap | Documented; acknowledged |
+| M | Stale `app.js` references in docs | Fix docs |
+| N | Curly-quoted attributes corrupt the tokenizer | Fix — improvement (theirs corrupts too) |
+| O | **New, 2026-09-04.** Block elements not put on their own lines — the biggest visible gap, and pure layer 1 | Layer-1 compensation → default-ON Extras `opt-block-newlines` |
+
+All of A–O are now implemented or consciously deferred. Verification: `npm test`
+(128 tests) plus `formatter/tests/parity.test.mjs`, which replays the golden
+fixtures through `runTidyPipeline`. Three fixtures carry an `ours` field recording
+where we deliberately differ — the curly-quote handling (N), literal characters
+instead of named entities (layer 1), and the Google Docs `dir="ltr"` / `<span>`
+strip (issue #22).
+
+### On N, specifically
+
+Google Docs autocorrects straight quotes to curly. HTML source that has passed through a Doc arrives carrying `U+201C`/`U+201D`/`U+2018`/`U+2019`. Neither implementation survives it:
+
+- **Theirs**: TinyMCE's parser only accepts straight quotes as attribute delimiters, so `class=“hero lede”` parses as an unquoted value terminating at the space; and every string cleaner keys on a literal straight-double-quote marker, so such an attribute is never matched for removal either.
+- **Ours** (before the fix): `parseAttributes` fell through to its bare-value branch, yielding `class` = `“hero` plus an invented bare attribute named `lede”`, which then got rebuilt into the output.
+
+Since both corrupt this input, parity is the wrong target and the fix is an
+unconditional tokenizer-level improvement. Real smart punctuation in *prose* is
+correct typography and is left alone by default — only attribute delimiters are
+normalized. (The `opt-straighten-quotes` Extra, default OFF, converts prose
+punctuation to ASCII for anyone who wants that; it is kept out of option 9 itself
+so the ten stay byte-faithful.)
+
+One measured detail worth keeping: their *end-to-end* output on
+`<p class=“hero lede”>Hi</p>` is a clean `<p>Hi</p>`, because TinyMCE mangles the
+class and option 2 then deletes the mangled result. Ours now reaches the same
+output by the honest route — parsing the attribute correctly, then removing it.
+On `<p class=“a > b”>Hi</p>` theirs truncates the tag and leaks `b&rdquo;&gt;` into
+the text; ours returns `<p>Hi</p>`.