diff --git a/docs/_ext/bench_table.py b/docs/_ext/bench_table.py
index d9e02d88..d98ddcf3 100644
--- a/docs/_ext/bench_table.py
+++ b/docs/_ext/bench_table.py
@@ -26,6 +26,7 @@
 
 import json
 import math
+from dataclasses import dataclass
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, ClassVar, Final
 
@@ -260,12 +261,53 @@ def _mark_entry(ordinal: int) -> nodes.entry:
     return entry
 
 
+def _table_frame(ncols: int) -> tuple[nodes.table, nodes.tgroup]:
+    """Build the table and its column group: a wide first column for the row label, then one per metric column."""
+    table = nodes.table(classes=["bench-table"])
+    group = nodes.tgroup(cols=ncols)
+    table += group
+    group += nodes.colspec(colwidth=2)
+    for _ in range(ncols - 1):
+        group += nodes.colspec(colwidth=1)
+    return table, group
+
+
+@dataclass(frozen=True)
+class _Layout:
+    """What every row of one table shares: its columns, its metrics, and the numbered reasons its cells key into."""
+
+    parties: list[str]
+    metrics: list[str]
+    reasons: dict[str, int]
+
+
+def _row_caveats(feed: dict[str, Any], taken: int) -> tuple[dict[str, int], dict[int, int]]:
+    """Assign each distinct per-row caveat an ordinal after those already taken, and map each row to its ordinal."""
+    notes: dict[str, int] = {}
+    marks: dict[int, int] = {}
+    for index, note in sorted((int(key), value) for key, value in (feed.get("row_notes") or {}).items()):
+        notes.setdefault(note, taken + len(notes) + 1)
+        marks[index] = notes[note]
+    return notes, marks
+
+
 def _ordered_notes(feed: dict[str, Any], parties: list[str]) -> list[str]:
     """Return the noted parties in the order their columns appear, so ordinals read left to right."""
     notes = feed.get("notes") or {}
     return [party for party in parties if party in notes]
 
 
+def _merge_legend(
+    reasons: dict[str, int], notes: dict[str, int], row_notes: dict[str, int], feed: dict[str, Any]
+) -> dict[str, int]:
+    """Gather the empty-cell reasons, the column notes and the row caveats into one numbered legend."""
+    legend = dict(reasons)
+    for party, ordinal in notes.items():
+        legend[f"{party} {feed['notes'][party]}"] = ordinal
+    legend.update(row_notes)
+    return legend
+
+
 def _legend(reasons: dict[str, int]) -> nodes.container:
     """Spell each numbered reason out under the table; reason text is literal so a message cannot inject markup."""
     legend = nodes.container(classes=["bench-legend"])
@@ -291,30 +333,34 @@ def run(self) -> list[nodes.Node]:
         metrics = feed["metrics"] or ["time"]
         parties, rows, spread = _order_columns(feed["parties"], metrics, feed["rows"], feed.get("spread") or [])
         ncols = 1 + len(parties) * len(metrics)
-        table = nodes.table(classes=["bench-table"])
-        group = nodes.tgroup(cols=ncols)
-        table += group
-        group += nodes.colspec(colwidth=2)
-        for _ in range(ncols - 1):
-            group += nodes.colspec(colwidth=1)
-        reasons = _reason_map(rows)
+        table, group = _table_frame(ncols)
+        layout = _Layout(parties, metrics, _reason_map(rows))
         # notes number on from the empty-cell reasons so one legend carries both without colliding ordinals
-        notes = {party: len(reasons) + offset for offset, party in enumerate(_ordered_notes(feed, parties), start=1)}
+        notes = {
+            party: len(layout.reasons) + offset for offset, party in enumerate(_ordered_notes(feed, parties), start=1)
+        }
+        row_notes, row_marks = _row_caveats(feed, len(layout.reasons) + len(notes))
         group += self._head(feed["label"], parties, feed["metrics"], notes)
+        group += self._body(rows, spread, layout, row_marks, ncols)
+        legend = _merge_legend(layout.reasons, notes, row_notes, feed)
+        return [table] if not legend else [table, _legend(legend)]
+
+    def _body(
+        self,
+        rows: list[list[Any]],
+        spread: list[Any],
+        layout: _Layout,
+        row_marks: dict[int, int],
+        ncols: int,
+    ) -> nodes.tbody:
         body = nodes.tbody()
-        group += body
-        for row_index, cells in enumerate(rows):
+        for index, cells in enumerate(rows):
             if len(cells) != ncols:
                 msg = f"bench-table row has {len(cells)} cells, expected {ncols}: {cells!r}"
                 raise self.error(msg)
-            noise = spread[row_index] if row_index < len(spread) else None
-            body += self._body_row(cells, parties, metrics, reasons, noise)
-        legend = dict(reasons)
-        for party, ordinal in notes.items():
-            legend[f"{party} {feed['notes'][party]}"] = ordinal
-        if not legend:
-            return [table]
-        return [table, _legend(legend)]
+            noise = spread[index] if index < len(spread) else None
+            body += self._body_row(cells, layout, noise, row_marks.get(index))
+        return body
 
     def _head(self, label: str, parties: list[str], metrics: list[str], notes: dict[str, int]) -> nodes.thead:
         head = nodes.thead()
@@ -352,15 +398,17 @@ def _head(self, label: str, parties: list[str], metrics: list[str], notes: dict[
         return head
 
     def _body_row(
-        self,
-        cells: list[Any],
-        parties: list[str],
-        metrics: list[str],
-        reasons: dict[str, int],
-        spread: list[Any] | None = None,
+        self, cells: list[Any], layout: _Layout, spread: list[Any] | None = None, caveat: int | None = None
     ) -> nodes.row:
+        parties, metrics, reasons = layout.parties, layout.metrics, layout.reasons
         row = nodes.row()
-        row += self._entry(str(cells[0]))
+        label = self._entry(str(cells[0]))
+        # a caveat that belongs to one operation marks that row, not the library's whole column
+        if caveat is not None:
+            superscript = nodes.superscript()
+            superscript += nodes.Text(str(caveat))
+            label.children[0] += superscript
+        row += label
         rendered: dict[int, tuple[str, str | None]] = {}
         marks: dict[int, int] = {}
         for metric_index, metric in enumerate(metrics):
diff --git a/docs/changelog/692.feature.rst b/docs/changelog/692.feature.rst
new file mode 100644
index 00000000..674c8e45
--- /dev/null
+++ b/docs/changelog/692.feature.rst
@@ -0,0 +1,20 @@
+Move the read path's per-item loops into C. :func:`turbohtml.saxparse.sax_parse` built a tuple, a typed record, and an
+isinstance chain for every event; the tokenizer now binds the six handler methods once and drives them off the tree
+walk, for 43.7% fewer instructions with instruction-cache misses down 71% on the WHATWG specification. URL cleaning
+(:func:`turbohtml.extract.clean_url`, :func:`~turbohtml.extract.normalize_url`,
+:func:`~turbohtml.extract.extract_links`), the :func:`~turbohtml.extract.dates` ``<meta>`` stage,
+:func:`turbohtml.query.escape_identifier`, and :func:`turbohtml.clean.linkify`'s scheme classification each moved their
+loops to C as well, for 3.5% to 56.8% fewer instructions on those operations. Differential runs against the retired
+Python across 1,484,640, 809,481, 360,282, 302,762, 38,590, and 4,828 inputs found one divergence: the URL resolver
+matches ``%2e`` in either case as the `WHATWG URL path state <https://url.spec.whatwg.org/#path-state>`_ specifies,
+which no public call reaches because percent-encoding uppercases escape hex first.
+:func:`~turbohtml.saxparse.iter_events` keeps its typed records, since those are its public product.
+
+Other hot paths keep their Python entry and shed work. XSD validation resolves each schema element's qname once at
+compile time into a binary-searched table for 17.2% fewer instructions, built for XSD only after the eager cache slowed
+RELAX NG compilation by 8.15%. The link walk mints element wrappers on first use (14.8% fewer) and skips the URL join
+that already returns an absolute reference (67.8% fewer); the ``<meta>`` encoding prescan jumps inert bytes with
+``memchr`` (8.67% fewer on ASCII); the gb18030 decoder maps astral pointers by arithmetic (13.4% fewer); and CSS
+property dispatch gates on the first byte (9.3% fewer on ``bootstrap.css``). The migration and benchmark tables also
+stopped over-claiming: a caveat marks only the rows of the operation it describes, a shared measurement shows in both
+columns, XPath labels render as inline code, and the CSS-stripper note gives the measured 1-3% size difference.
diff --git a/docs/development/bench/css-minification.json b/docs/development/bench/css-minification.json
index 4c2ea699..f7574ad6 100644
--- a/docs/development/bench/css-minification.json
+++ b/docs/development/bench/css-minification.json
@@ -18,237 +18,237 @@
     [
       "normalize.css (6 kB)",
       1750.0,
-      2.4677963665453717e-05,
+      3.2464727574677e-05,
       1834.0,
-      0.0006309785577135093,
+      0.0009276293920568909,
       1842.0,
-      0.00148522892307786,
+      0.0015539148210640026,
       1847.0,
-      0.0005264332545114788,
+      0.0005475900335341066,
       1816.0,
-      0.008701107213103873,
+      0.008969288615238232,
       1751.0,
-      6.477255408772938e-05,
+      7.805699825288077e-05,
       1775.0,
-      6.877973989460884e-06,
+      7.227439025925264e-06,
       1809.0,
-      0.006585243500618769
+      0.006976464842712933
     ],
     [
       "pico.css (90 kB)",
       81155.0,
-      0.0008415556360432674,
+      0.0010817124017800477,
       81883.0,
-      0.29427182641423616,
+      0.310369604092557,
       81616.0,
-      0.04783730468867967,
+      0.04725994185234109,
       81792.0,
-      0.29104015965519164,
+      0.290788572980091,
       82466.0,
-      0.01180374044815835,
+      0.015580497833677024,
       79992.0,
-      0.002079070472670234,
+      0.0022688593744533136,
       82078.0,
-      0.00026292298050141955,
+      0.0002621144950959812,
       82027.0,
-      0.008949477426237232
+      0.008984445535437166
     ],
     [
       "animate.css (93 kB)",
       73788.0,
-      0.0009074143608813756,
+      0.0012892222758485634,
       75811.0,
-      0.013143970048986375,
+      0.01716736372933762,
       75738.0,
-      0.03357629689950651,
+      0.034281230024741184,
       75797.0,
-      0.00972714366192425,
+      0.009972065103890296,
       73454.0,
-      0.012262740454389132,
+      0.01623697133497141,
       68773.0,
-      0.0016668788516653876,
+      0.0016953111445824713,
       75682.0,
-      0.0002218701103515741,
+      0.00022064549447501727,
       74366.0,
-      0.009337699213574524
+      0.00886903776518011
     ],
     [
       "foundation.css (164 kB)",
       132898.0,
-      0.0020137969298351286,
+      0.0028156564673433118,
       136503.0,
-      0.6699292880948633,
+      0.6890333229966927,
       136405.0,
-      0.08025021179734419,
+      0.08035445658606477,
       136345.0,
-      0.6636087951774243,
+      0.6649740381690208,
       131798.0,
-      0.015982563353948837,
+      0.018953305122219415,
       "Parsing stylesheet failed: Invalid media query at :577:29",
       "Parsing stylesheet failed: Invalid media query at :577:29",
       136682.0,
-      0.0004910595569450985,
+      0.00048533412052620406,
       136011.0,
-      0.012145074868991893
+      0.010203022582572885
     ],
     [
       "bootstrap.css (274 kB)",
       229554.0,
-      0.002807286729421321,
+      0.003730066627516256,
       234299.0,
-      0.801409038171793,
+      1.2760612014099024,
       234206.0,
-      0.10941284016977686,
+      0.10736939241178334,
       232361.0,
-      0.775202558899764,
+      0.8377778609962357,
       233022.0,
-      0.019398659741758213,
+      0.023000642783396568,
       228699.0,
-      0.006114484483987326,
+      0.006715550674622743,
       233172.0,
-      0.000885669812305423,
+      0.0008058121210675987,
       231850.0,
-      0.01339823480520863
+      0.012535955936982646
     ],
     [
       "bulma.css (745 kB)",
       681425.0,
-      0.0070988878069329076,
+      0.008693945529860988,
       681335.0,
-      3.7613919480742575,
+      4.194504024237783,
       681328.0,
-      0.77290790976258,
+      0.7723801529306608,
       679329.0,
-      3.675083399498059,
+      3.896613041588959,
       689213.0,
-      0.03429648437304422,
+      0.042386440123664215,
       674333.0,
-      0.015533043417235604,
+      0.01717652689573394,
       679974.0,
-      0.0022972218422789106,
+      0.0023041306975149687,
       685284.0,
-      0.020232135414213797
+      0.018881723948046176
     ]
   ],
   "spread": [
     [
       null,
       null,
-      0.021180385365301226,
+      0.09728764011828976,
       null,
-      0.02819642344696989,
+      0.09710277770104533,
       null,
-      0.05701234593429704,
+      0.019826228382515288,
       null,
-      0.01791848500486394,
+      0.03951865967357222,
       null,
-      0.06992896493221358,
+      0.09593713934997752,
       null,
-      0.02905783106689442,
+      0.12029726598732139,
       null,
-      0.026855005115815223,
+      0.07105855210195146,
       null,
-      0.07336334626591483
+      0.056758389135272015
     ],
     [
       null,
       null,
-      0.05709012427212532,
+      0.10598940421080025,
       null,
-      0.01741493259203369,
+      0.06063725346644621,
       null,
-      0.026944394476272976,
+      0.04641130544766816,
       null,
-      0.01774728348797553,
+      0.016772891775886107,
       null,
-      0.04412680403612263,
+      0.0703349525103437,
       null,
-      0.03479701834134207,
+      0.11557548323441176,
       null,
-      0.018144959164507132,
+      0.022144839124433217,
       null,
-      0.13643615670380904
+      0.03821462337771131
     ],
     [
       null,
       null,
-      0.029687965981479846,
+      0.07158741875788914,
       null,
-      0.020649446079126006,
+      0.1449496297491353,
       null,
-      0.019622682835288865,
+      0.02695020928613877,
       null,
-      0.021456622114735088,
+      0.04642749177523619,
       null,
-      0.027843021875434023,
+      0.0740337837276571,
       null,
-      0.025156253322567327,
+      0.04477117584138788,
       null,
-      0.025806845986799082,
+      0.018206653247167335,
       null,
-      0.1657667850197228
+      0.05216206832373801
     ],
     [
       null,
       null,
-      0.06837573110647958,
+      0.07838358803696824,
       null,
-      0.009653882996928344,
+      0.03607736265830405,
       null,
-      0.02003352814730991,
+      0.03547418507801415,
       null,
-      0.010765088339266779,
+      0.029390684090604573,
       null,
-      0.029451061695924832,
+      0.10257546470144385,
       null,
       null,
       null,
-      0.02766298223470719,
+      0.021725472885592095,
       null,
-      0.24559582538980165
+      0.040623528790115465
     ],
     [
       null,
       null,
-      0.023601218123909005,
+      0.10694045427657661,
       null,
-      0.032878105258768754,
+      0.40929399018038914,
       null,
-      0.033278616382448625,
+      0.07345581630301083,
       null,
-      0.008096442581343071,
+      0.09389019306439964,
       null,
-      0.02563378436764528,
+      0.059898574018461964,
       null,
-      0.03270786379047158,
+      0.10864175208310488,
       null,
-      0.1172214619078148,
+      0.06589567367731815,
       null,
-      0.060726743453138214
+      0.03603544359459969
     ],
     [
       null,
       null,
-      0.02956177866788225,
+      0.12618949595325846,
       null,
-      0.016781771728862072,
+      0.12147845408308942,
       null,
-      0.009543429204608288,
+      0.010728740875689466,
       null,
-      0.008905647770977644,
+      0.04641827022426012,
       null,
-      0.05813764649113857,
+      0.20987532850151677,
       null,
-      0.022578577927933375,
+      0.11449298554009829,
       null,
-      0.029345195540840696,
+      0.03676125016636636,
       null,
-      0.08500393756077515
+      0.024791779131297275
     ]
   ],
   "notes": {
-    "css-html-js-minify": "strips whitespace and comments only, leaving #ffffff, 0px 0px 0px 0px and font-weight:bold unshortened where turbohtml writes #fff, 0 and 700",
-    "cssmin": "strips whitespace and comments only, leaving #ffffff, 0px 0px 0px 0px and font-weight:bold unshortened where turbohtml writes #fff, 0 and 700",
-    "rcssmin": "strips whitespace and comments only, leaving #ffffff, 0px 0px 0px 0px and font-weight:bold unshortened where turbohtml writes #fff, 0 and 700"
+    "css-html-js-minify": "strips whitespace and comments without parsing, so it applies none of the color, number, and shorthand rewrites turbohtml does; on these stylesheets that leaves its output within 1.01-1.03x of turbohtml's, and 0.998x on bulma, so the structural shortenings change little on already-tight framework CSS",
+    "cssmin": "strips whitespace and comments without parsing, so it applies none of the color, number, and shorthand rewrites turbohtml does; on these stylesheets that leaves its output within 1.01-1.03x of turbohtml's, and 0.998x on bulma, so the structural shortenings change little on already-tight framework CSS",
+    "rcssmin": "strips whitespace and comments without parsing, so it applies none of the color, number, and shorthand rewrites turbohtml does; on these stylesheets that leaves its output within 1.01-1.03x of turbohtml's, and 0.998x on bulma, so the structural shortenings change little on already-tight framework CSS"
   }
 }
diff --git a/docs/development/bench/date-extraction.json b/docs/development/bench/date-extraction.json
index 5a95a0b0..5162baaf 100644
--- a/docs/development/bench/date-extraction.json
+++ b/docs/development/bench/date-extraction.json
@@ -12,62 +12,63 @@
   "rows": [
     [
       "post (4 KiB)",
-      1.1735952601436376e-05,
-      0.0032615539830658236,
-      2.6615594620693628e-05,
-      0.008319053811646882,
-      0.003010062393210925,
-      0.00017194148086711417
+      5.9304065735214335e-06,
+      0.0025007032345456537,
+      1.688457954903318e-05,
+      0.005928435221297453,
+      0.002119573241998296,
+      0.00011766121753945906
     ],
     [
       "longform (16 KiB)",
-      1.7074957939418784e-05,
-      0.011720733735273825,
-      4.910956235685641e-05,
-      0.0226524487795056,
-      0.008552690978831379,
-      0.0003579496258036367
+      1.030123477659591e-05,
+      0.008274378248340023,
+      3.404049680473994e-05,
+      0.01590911588452097,
+      0.00614426996041099,
+      0.0002502549162007502
     ],
     [
       "100 meta candidates",
-      0.00013010201349554032,
-      0.005897449650850224,
-      7.602037720270498e-05,
-      0.01212375239507916,
-      0.003707961801713585,
-      9.28465288912624e-05
+      1.828077740384515e-05,
+      0.004187224176651701,
+      5.459096957357209e-05,
+      0.00877185786581928,
+      0.002589482204257365,
+      7.32439337885656e-05
     ]
   ],
   "spread": [
     [
       null,
-      0.04329384536759802,
-      0.04084589772460682,
-      0.033263737396463294,
-      0.058179691141717345,
-      0.023286550889136903,
-      0.08089387135645254
+      0.004697496985019512,
+      0.15902130549302607,
+      0.009112355406770883,
+      0.03489928844853301,
+      0.025555266163807724,
+      0.019549316289211804
     ],
     [
       null,
-      0.03092662857915166,
-      0.03199195905089177,
-      0.054986089231601934,
-      0.022472019979233922,
-      0.028635270494106826,
-      0.03784222870872126
+      0.007721833090606347,
+      0.008266166525272227,
+      0.016598368815392547,
+      0.020043951211199545,
+      0.02156623309830427,
+      0.023385975296491182
     ],
     [
       null,
-      0.03639475424630214,
-      0.07349111320004241,
-      0.0308781661300203,
-      0.04241792606111163,
-      0.06898135336090556,
-      0.035977232455401555
+      0.008026401759229225,
+      0.017919851624633977,
+      0.021206735172214816,
+      0.04277533338146369,
+      0.013182086495236387,
+      0.058992245979526695
     ]
   ],
   "notes": {
-    "htmldate": "returns no date for the 100-candidate case, so its timing there is the cost of giving up rather than of finding the date turbohtml reports"
+    "htmldate": "returns no date for the 100-candidate case, so its timing there is the cost of giving up rather than of finding the date turbohtml reports",
+    "trafilatura": "returns no date for the 100-candidate case, so its timing there is the cost of giving up rather than of finding the date turbohtml reports"
   }
 }
diff --git a/docs/development/bench/encoding-detection.json b/docs/development/bench/encoding-detection.json
index b57cadc7..e4a0139c 100644
--- a/docs/development/bench/encoding-detection.json
+++ b/docs/development/bench/encoding-detection.json
@@ -12,113 +12,113 @@
   "rows": [
     [
       "ascii (1 kB)",
-      2.683881651736423e-06,
-      0.00016621675959527238,
-      1.235750171598345e-06,
-      0.00016340677547077576,
-      6.459631354971407e-05,
-      1.379581478166969e-06
+      1.1417041620257844e-06,
+      0.0001670253838407613,
+      1.1773475279142076e-06,
+      0.00014564843067432776,
+      4.932761466847069e-05,
+      1.029075331541544e-06
     ],
     [
       "utf-8 russian (4 kB)",
-      8.42264663110844e-06,
-      0.0002101907146917862,
-      5.730095120763205e-06,
-      0.00020473426656053562,
-      0.00045748297744315397,
-      4.134158238855434e-06
+      5.395650118404187e-06,
+      0.00019062113415202475,
+      0.00018844744206110894,
+      0.00016079087338501571,
+      0.00034693029781844115,
+      3.0797061919921966e-06
     ],
     [
       "windows-1251 russian (4 kB)",
-      0.00023194885286178155,
-      0.0007660471198960295,
-      0.00040475461815958624,
-      0.0007493408056310121,
-      0.0004235422777204197,
-      0.0004300928825008062
+      0.00017615521230140985,
+      0.0006824471162190093,
+      0.0010732773977603454,
+      0.0006862004258512874,
+      0.00030178521061922464,
+      0.00035062181920390384
     ],
     [
       "windows-1252 french (4 kB)",
-      0.00022984596078382916,
-      0.0009623634165715581,
-      0.000478496310885627,
-      0.0009485056960632695,
-      0.0014133275006618835,
-      0.0004874247093008914
+      0.00017919206403386548,
+      0.0009608074811543096,
+      0.0013673634986541099,
+      0.00096642504756043,
+      0.001020589817774938,
+      0.0003832794663291376
     ],
     [
       "shift_jis japanese (4 kB)",
-      0.00010243962940137408,
-      0.0007823282336403281,
-      4.349980590963772e-05,
-      0.0007782307262308071,
-      0.00048443899155851494,
-      4.1679475524839894e-05
+      8.727693684799458e-05,
+      0.0011041370983093657,
+      5.4442557456013674e-05,
+      0.0007336918404992806,
+      0.00034780594885811905,
+      3.797536552241354e-05
     ],
     [
       "utf-8 page (95 kB)",
-      1.0262474480586075e-06,
-      0.0017221563046708372,
-      6.99966448204729e-05,
-      0.0017224917549659342,
-      0.0007871857096309517,
-      7.612719218741404e-05
+      9.080427233835545e-07,
+      0.0017875253332325276,
+      0.029714249164195888,
+      0.0013319131658893941,
+      0.000590463311179216,
+      6.985357494215805e-05
     ]
   ],
   "spread": [
     [
       null,
-      0.017880736659094357,
-      0.018251613038969026,
-      0.009398139741706679,
-      0.010724686631088845,
-      0.0447636886199731,
-      0.01669212179717228
+      0.009158479913916974,
+      0.09234027113797867,
+      0.10468818317444338,
+      0.13673752459469665,
+      0.04216924148520772,
+      0.007167867015191341
     ],
     [
       null,
-      0.013928849417596853,
-      0.04709186896538359,
-      0.024881909180794498,
-      0.02288405959591961,
-      0.08554927173830451,
-      0.02525687093898264
+      0.0038712062652642206,
+      0.0877226744657706,
+      0.18627333668661952,
+      0.04049806799196369,
+      0.015485661727082682,
+      0.0062008850358656635
     ],
     [
       null,
-      0.030374690128129544,
-      0.05534154336710747,
-      0.03358285021685917,
-      0.027327653967104393,
-      0.0365463065399403,
-      0.049845411634993224
+      0.004080075123940598,
+      0.09585776641164494,
+      0.02315224237339274,
+      0.12213514583063445,
+      0.016158813820105353,
+      0.021001531511425205
     ],
     [
       null,
-      0.024415342494636606,
-      0.01597170853773811,
-      0.026737823847515163,
-      0.03283025755818031,
-      0.02930554925922803,
-      0.06204167242122492
+      0.059916699660372115,
+      0.1426199999041337,
+      0.04027212843423796,
+      0.10209968241403904,
+      0.015039601460871254,
+      0.01910706894477701
     ],
     [
       null,
-      0.011882884549205048,
-      0.07681575774619458,
-      0.022649954602732364,
-      0.03392169078973562,
-      0.037535858472558255,
-      0.017271426636053563
+      0.09053675269683122,
+      0.2738526726895093,
+      0.0761583266038194,
+      0.4077870034036728,
+      0.020993992514227677,
+      0.21023172288412514
     ],
     [
       null,
-      0.027875914121933836,
-      0.02169554352319668,
-      0.016122380494513,
-      0.02346546131727304,
-      0.01868390630267981,
-      0.016350123964366924
+      0.09984062000003383,
+      0.13921153915640078,
+      0.06216476696663551,
+      0.010247606289130554,
+      0.013470151385193491,
+      0.12703643729605826
     ]
   ],
   "notes": {}
diff --git a/docs/development/bench/link-filtering.json b/docs/development/bench/link-filtering.json
index b53c71ff..e24c0b77 100644
--- a/docs/development/bench/link-filtering.json
+++ b/docs/development/bench/link-filtering.json
@@ -14,93 +14,93 @@
   "rows": [
     [
       "daring fireball (10 kB)",
-      0.00019244289493750935,
-      0.0017440380336969004,
-      0.001393361708323937,
-      0.0006250226910348525,
-      0.00019721312124450682,
-      0.000488335463084392,
-      0.0005061203476846762,
-      0.00038065648076705355
+      0.00014374658196440274,
+      0.0017214570859020266,
+      0.0012449160982062797,
+      0.0005456723903686603,
+      0.0001782515766611444,
+      0.00031386787206126127,
+      0.000519150458671902,
+      0.00022196778021073746
     ],
     [
       "ars technica (56 kB)",
-      0.00044414784745564856,
-      0.007564480031457303,
-      0.0060377776668853285,
-      0.001392310166693278,
-      0.0007186282415053332,
-      0.001623948243529109,
-      0.001544980251992456,
-      0.0014216306973745911
+      0.0003625916885994229,
+      0.007038899739200133,
+      0.005221934676834887,
+      0.0011215508353264643,
+      0.0006590101314714047,
+      0.0009077950169663987,
+      0.0013566567936322826,
+      0.0007716973326902613
     ],
     [
       "mozilla blog (95 kB)",
-      0.0007429536545942028,
-      0.016098750425347436,
-      0.013269332885101903,
-      0.0016785657044238178,
-      0.0013903054759794031,
-      0.001837482583293119,
-      0.0025982647539422032,
-      0.0030353482511600305
+      0.0006187186553461288,
+      0.01468123565427959,
+      0.01133143881209738,
+      0.0014856392695037357,
+      0.0012879373646986398,
+      0.0015391715760415536,
+      0.002153627226713676,
+      0.002120180878894947
     ],
     [
       "whatwg spec (235 kB)",
-      0.0011912915304037597,
-      0.04389768487211162,
-      0.03420185421418864,
-      0.002558890350276973,
-      0.0026491308064275168,
-      0.0029560183917662166,
-      0.005002468530619808,
-      0.004674338865394627
+      0.0010619639210744936,
+      0.04029734718399899,
+      0.02999120229408921,
+      0.002259075846571553,
+      0.002192290147074042,
+      0.0024546149131007646,
+      0.003185567546703775,
+      0.003025346355570946
     ]
   ],
   "spread": [
     [
       null,
-      0.08681901513017418,
-      0.09382784824059776,
-      0.05176701109354531,
-      0.04141089927327427,
-      0.04488725193794102,
-      0.16714035155438928,
-      0.08937633737215606,
-      0.17030466917906792
+      0.016529254132972147,
+      0.09998025007016155,
+      0.049664879874346625,
+      0.05383105561293264,
+      0.03447410098169276,
+      0.1747140577921019,
+      0.1548508345091371,
+      0.16077568061287117
     ],
     [
       null,
-      0.0246925729997723,
-      0.08924334518887247,
-      0.07457086740968584,
-      0.18645796673891377,
-      0.05360533600629835,
-      0.2701872344537394,
-      0.045770404845422295,
-      0.08557130079910938
+      0.030487043860911212,
+      0.08727937480889225,
+      0.019173792772694,
+      0.03613938286491891,
+      0.034279497415174796,
+      0.08997365611435819,
+      0.10023359791906923,
+      0.08754994332451231
     ],
     [
       null,
-      0.039027527214139324,
-      0.05894036352347361,
-      0.11979623071713057,
-      0.10402639227526292,
-      0.17998380661528665,
-      0.11281040625913531,
-      0.11107236330616468,
-      0.15053014588465377
+      0.06359342029387884,
+      0.03759982374861031,
+      0.04678582098573661,
+      0.07919831191163934,
+      0.03935445011673912,
+      0.07830637881531415,
+      0.05121286092087061,
+      0.07848986100113335
     ],
     [
       null,
-      0.04936646995438586,
-      0.11418698795426512,
-      0.12059134279394809,
-      0.059124346380420974,
-      0.15330362335285372,
-      0.02801464412122382,
-      0.2631809071714095,
-      0.16291120403068735
+      0.1209415112126743,
+      0.09622909825766862,
+      0.13128710317602377,
+      0.037431188522577784,
+      0.0443077820770914,
+      0.02974163487052947,
+      0.037910575804407244,
+      0.05793325990372666
     ]
   ],
   "notes": {}
diff --git a/docs/development/bench/linkify-2.json b/docs/development/bench/linkify-2.json
index ee090aaf..4aecb4df 100644
--- a/docs/development/bench/linkify-2.json
+++ b/docs/development/bench/linkify-2.json
@@ -8,45 +8,45 @@
   "rows": [
     [
       "find comment (1 link, 1 email)",
-      8.640649716099938e-07,
-      4.180944566201106e-05
+      7.194867801540994e-07,
+      4.504933335406728e-05
     ],
     [
       "find prose (1 KiB)",
-      1.14918323094552e-05,
-      0.00047429550526582415
+      9.341246917908089e-06,
+      0.0004767802053417351
     ],
     [
       "has_link comment",
-      3.2787860089940796e-07,
-      3.0382425125689377e-05
+      3.198661542302972e-07,
+      3.284947037703508e-05
     ],
     [
       "has_link prose (1 KiB)",
-      3.2681881587670603e-06,
-      6.782535560153254e-06
+      3.3264642806211477e-06,
+      9.183685302597647e-06
     ]
   ],
   "spread": [
     [
       null,
-      0.07667559493150078,
-      0.08598486268838779
+      0.0618758313713348,
+      0.03938719948399893
     ],
     [
       null,
-      0.059957129302934314,
-      0.03809032894512174
+      0.028533419404982167,
+      0.04244540017319504
     ],
     [
       null,
-      0.05860313007389166,
-      0.07780476576176569
+      0.033248584024003644,
+      0.10193610366200706
     ],
     [
       null,
-      0.049319246480825606,
-      0.10847816873948599
+      0.051427368974886416,
+      0.11944680145655517
     ]
   ],
   "notes": {}
diff --git a/docs/development/bench/linkify.json b/docs/development/bench/linkify.json
index 30788053..25ec797f 100644
--- a/docs/development/bench/linkify.json
+++ b/docs/development/bench/linkify.json
@@ -9,41 +9,41 @@
   "rows": [
     [
       "comment (1 link, 1 email)",
-      3.781744958963884e-06,
-      8.422372941652156e-05,
-      9.69350645322701e-06
+      2.833639196916001e-06,
+      5.694690112060622e-05,
+      6.928771550581321e-06
     ],
     [
       "prose (1 KiB)",
-      5.8999148810319944e-05,
-      0.0004075837402789754,
-      3.3387339279045136e-05
+      4.209216648121128e-05,
+      0.00027776850697591726,
+      2.2991062156307862e-05
     ],
     [
       "markup (4 KiB)",
-      0.00015994283040754453,
-      0.002666328884060931,
-      0.0002128102349843175
+      0.00011087927229406584,
+      0.0016154013672651975,
+      0.0001395619845349453
     ]
   ],
   "spread": [
     [
       null,
-      0.07086155915802331,
-      0.11050801498867782,
-      0.06710410389389247
+      0.011325012124501117,
+      0.05308123636925894,
+      0.1543128775631675
     ],
     [
       null,
-      0.03361607989819003,
-      0.05731269830817569,
-      0.049776091948529826
+      0.02196262985378034,
+      0.029872045724290235,
+      0.009715185602970897
     ],
     [
       null,
-      0.09089060583931145,
-      0.024059342839235647,
-      0.1153154111287691
+      0.01391027709579616,
+      0.00807868275609938,
+      0.011463713324468537
     ]
   ],
   "notes": {
diff --git a/docs/development/bench/links-2.json b/docs/development/bench/links-2.json
index fa29aab5..84b3ffea 100644
--- a/docs/development/bench/links-2.json
+++ b/docs/development/bench/links-2.json
@@ -13,85 +13,85 @@
   "rows": [
     [
       "daring fireball (10 kB)",
-      7.897827523587846e-05,
-      8.12796183519519e-05,
-      8.698945166922083e-05,
-      0.000250384097607063,
-      0.00038412135465174896,
-      6.171742408866976e-05,
-      7.739290134622934e-05
+      3.9356466906781407e-05,
+      8.537428512530217e-05,
+      9.082854247803122e-05,
+      0.00026713285042963736,
+      0.00040999616032877384,
+      6.321872400860684e-05,
+      7.794494342761027e-05
     ],
     [
       "ars technica (56 kB)",
-      0.00020205170371430844,
-      0.00020543835923566198,
-      0.0002171601645386545,
-      0.0008300663818469426,
-      0.0009304267897126314,
-      0.0001539198813039396,
-      0.00019101100989852662
+      9.180021663250197e-05,
+      0.00022045485021256658,
+      0.00026355090974069145,
+      0.0008682723103750808,
+      0.0009889522232242598,
+      0.0001591197206967839,
+      0.00020195030824273394
     ],
     [
       "mozilla blog (95 kB)",
-      0.00038564827292475456,
-      0.00033134097158911874,
-      0.0003516682579440082,
-      0.0017100880424247105,
-      0.001365599822065633,
-      0.00022994135863048845,
-      0.0002855855775199719
+      0.00015685727829387966,
+      0.0006314839385671197,
+      0.00039728056947296864,
+      0.0017832083479637124,
+      0.0014447408797574706,
+      0.00023703871545421862,
+      0.0002975679419705557
     ],
     [
       "whatwg spec (235 kB)",
-      0.0002516408542116248,
-      0.0005860067427647664,
-      0.00060525605241916,
-      0.004560957929849489,
-      0.001670862858190958,
-      0.0002454043833305756,
-      0.000329380882969114
+      0.00022430012273844113,
+      0.000799342570189765,
+      0.0006994879075818972,
+      0.004874164802458836,
+      0.0018399412986885484,
+      0.0002569203213814338,
+      0.00034682959583657674
     ]
   ],
   "spread": [
     [
       null,
-      0.007903863312063752,
-      0.007429985977232138,
-      0.005709366712022955,
-      0.011168518748499024,
-      0.021407393605724665,
-      0.006656947080682276,
-      0.011522194117990854
+      0.033531589420485355,
+      0.04178334636226221,
+      0.03830741719481508,
+      0.06037825177403394,
+      0.05293479393063974,
+      0.01444574611302369,
+      0.01255406380524888
     ],
     [
       null,
-      0.008416212374072259,
-      0.012317455813324451,
-      0.003385509132172714,
-      0.011320861995438535,
-      0.02602873694670547,
-      0.011528585462947888,
-      0.006757544346601625
+      0.009126761347801857,
+      0.03805325222482105,
+      0.09008961757808379,
+      0.01561318603994385,
+      0.03240088513209726,
+      0.013455508700929193,
+      0.017830661159506885
     ],
     [
       null,
-      0.007817411254915526,
-      0.0023171634993249296,
-      0.009952790930482652,
-      0.007166528598781359,
-      0.021365815957723074,
-      0.012502247588426139,
-      0.006927772624274505
+      0.018904092332618992,
+      0.399494085088914,
+      0.05530115918703297,
+      0.009489188340622848,
+      0.02683016582508581,
+      0.014220798955373341,
+      0.04909279135012377
     ],
     [
       null,
-      0.004943329428493678,
-      0.024256358650669513,
-      0.012263418617546295,
-      0.015439725544316302,
-      0.03968631110153472,
-      0.006164063549205968,
-      0.002263677275762299
+      0.012208253570299738,
+      0.3257678679866179,
+      0.03681841828896033,
+      0.021499411697625023,
+      0.046222957523014585,
+      0.024146840663983656,
+      0.03191584179688344
     ]
   ],
   "notes": {}
diff --git a/docs/development/bench/links-3.json b/docs/development/bench/links-3.json
index 8f4490e9..ad17e201 100644
--- a/docs/development/bench/links-3.json
+++ b/docs/development/bench/links-3.json
@@ -13,85 +13,85 @@
   "rows": [
     [
       "daring fireball (10 kB)",
-      2.9012148117975776e-06,
-      1.647298982613658e-05,
-      2.085971535355687e-05,
-      0.00016380464004820774,
-      0.00031565070213446234,
-      6.868505702565623e-06,
-      3.0170525394150143e-05
+      2.996172853079552e-06,
+      1.6866881041484778e-05,
+      2.1706805336899986e-05,
+      0.00015877394261565314,
+      0.000377997809456095,
+      6.781967589593781e-06,
+      2.5443278827215938e-05
     ],
     [
       "ars technica (56 kB)",
-      1.0269556899681712e-05,
-      5.5183893759173465e-05,
-      6.536129939623454e-05,
-      0.0005821447746635992,
-      0.0007010560300007759,
-      2.8764750588550214e-05,
-      7.275252779000614e-05
+      1.07103676191637e-05,
+      5.6803982133146746e-05,
+      6.689157613000891e-05,
+      0.0006096830510765964,
+      0.0007505117190855041,
+      2.0788973480752777e-05,
+      6.889208313509698e-05
     ],
     [
       "mozilla blog (95 kB)",
-      1.9159150432083532e-05,
-      0.00011386105690765665,
-      0.00012480539973580562,
-      0.0012378039816667297,
-      0.0009803983301329329,
-      4.462856290861813e-05,
-      0.00011860925278028844
+      1.986850784400455e-05,
+      0.00010975474037877575,
+      0.00012791490657567314,
+      0.0015380178776164637,
+      0.0010356462663973314,
+      3.3864474813090815e-05,
+      9.120389460785343e-05
     ],
     [
       "whatwg spec (235 kB)",
-      3.324762803439777e-05,
-      0.0003635839235016647,
-      0.0003821885512707013,
-      0.004207888346172695,
-      0.00117126177284869,
-      8.501805953642361e-05,
-      0.00020120629204711804
+      3.3264580665104404e-05,
+      0.00036030607740637305,
+      0.0004281737738741261,
+      0.0043626483299400816,
+      0.0012034119750599832,
+      6.291491365573165e-05,
+      0.00014887399307402424
     ]
   ],
   "spread": [
     [
       null,
-      0.010201463727222403,
-      0.00933812413740348,
-      0.011533179321718892,
-      0.12236105538400183,
-      0.05625420494982334,
-      0.022898679174978225,
-      0.08858303598727786
+      0.025611308465656468,
+      0.024929672582158197,
+      0.12761429143963907,
+      0.027426530099872986,
+      0.24629390122961012,
+      0.01749473297617237,
+      0.16459705665378513
     ],
     [
       null,
-      0.01609684234917494,
-      0.01366943413516007,
-      0.0093306751370152,
-      0.021519429819065447,
-      0.019177383357006687,
-      0.052164122173223595,
-      0.11822096596853024
+      0.012653954590904381,
+      0.03626613003301336,
+      0.0359179002687463,
+      0.04759523037029265,
+      0.05540787554018989,
+      0.04563892482693914,
+      0.3423383136610574
     ],
     [
       null,
-      0.020570331464049258,
-      0.04141288334957416,
-      0.039089211844657266,
-      0.01635702860576924,
-      0.02058753440810391,
-      0.15837575088354486,
-      0.07787966013169513
+      0.004280553044310928,
+      0.00732471497482255,
+      0.02772667459186675,
+      0.1957462990870172,
+      0.05034219665700394,
+      0.03608952637075124,
+      0.027443453926115163
     ],
     [
       null,
-      0.013042710419117346,
-      0.05247061676530608,
-      0.04035566901289052,
-      0.04823647361536105,
-      0.06098590259526779,
-      0.11855757337902133,
-      0.06347518140035155
+      0.01749493908665723,
+      0.017292612809595903,
+      0.16058448881226262,
+      0.03129440164383621,
+      0.031074925454776758,
+      0.02347315070153482,
+      0.01986339625402406
     ]
   ],
   "notes": {}
diff --git a/docs/development/bench/links.json b/docs/development/bench/links.json
index f26e6c3c..a094f500 100644
--- a/docs/development/bench/links.json
+++ b/docs/development/bench/links.json
@@ -14,93 +14,93 @@
   "rows": [
     [
       "daring fireball (10 kB)",
-      8.540413328243327e-06,
-      1.525457977180622e-05,
-      1.4777843472775961e-05,
-      0.00014333100397342,
-      6.561983910557956e-05,
-      0.00016360655047265027,
-      4.940687075164855e-06,
-      1.3445289171206317e-05
+      1.3464031636563808e-05,
+      2.3068925242360667e-05,
+      2.2397782224459206e-05,
+      0.0003142650891921524,
+      9.973011774870126e-05,
+      0.0003138677027815599,
+      9.217930897402008e-06,
+      2.158080079084357e-05
     ],
     [
       "ars technica (56 kB)",
-      2.6025344868211658e-05,
-      5.213720703522995e-05,
-      5.237701754860306e-05,
-      0.0005540351831617348,
-      0.00014437131739934253,
-      0.0003849035105645271,
-      1.5787857462849313e-05,
-      4.660196942059732e-05
+      4.56970487050512e-05,
+      7.421023221354517e-05,
+      7.385782030174444e-05,
+      0.0009934364973105403,
+      0.00021189110598622088,
+      0.000759260253857974,
+      3.0278296154762074e-05,
+      7.016041224024623e-05
     ],
     [
       "mozilla blog (95 kB)",
-      4.8695574463408775e-05,
-      0.0001045537347768762,
-      0.0001032916394857845,
-      0.0011797156849600772,
-      0.00020872188315479434,
-      0.0005297147486468626,
-      2.6800711765417873e-05,
-      7.235715739284387e-05
+      7.54788005347488e-05,
+      0.00014937739054706375,
+      0.00016065289965657334,
+      0.0019831697577501473,
+      0.0003283788316821301,
+      0.0009935191236157455,
+      5.544195894439478e-05,
+      0.00011029813313712111
     ],
     [
       "whatwg spec (235 kB)",
-      7.78339928473315e-05,
-      0.00034933633753553295,
-      0.0003470544843745908,
-      0.0038690176822152957,
-      0.0002640740081195266,
-      0.0006312846954112198,
-      5.1771214761705174e-05,
-      0.00010719847622908674
+      6.635500418402292e-05,
+      0.0004964120270566733,
+      0.0008334717876626504,
+      0.005672234596204362,
+      0.0004924321832125619,
+      0.0009501940104807242,
+      0.00011188485726165709,
+      0.00017877139274939205
     ]
   ],
   "spread": [
     [
       null,
-      0.007242716319812719,
-      0.03169356051174955,
-      0.0043339976144837564,
-      0.010369854528747738,
-      0.012627035478506262,
-      0.01772626344351562,
-      0.006520162247562928,
-      0.01634958110066657
+      0.1905638942872358,
+      0.03679384648962025,
+      0.04534085848493278,
+      0.06410865945029473,
+      0.05908721604046851,
+      0.09626079076033368,
+      0.0909416989953497,
+      0.09917425590704307
     ],
     [
       null,
-      0.009166139408406725,
-      0.005314394159905668,
-      0.03330596578214335,
-      0.023762094377173783,
-      0.011709054446375005,
-      0.013334857731245094,
-      0.014321374691221661,
-      0.012827710105623906
+      0.13979209516180388,
+      0.07871130987482713,
+      0.03917221707941639,
+      0.15994702991516405,
+      0.05260820873932838,
+      0.10844328620105656,
+      0.056583749631377044,
+      0.10048894632853245
     ],
     [
       null,
-      0.014768482199177618,
-      0.0076536327905726426,
-      0.005099330122068768,
-      0.02465577507151008,
-      0.01509937603236634,
-      0.01936229950139161,
-      0.025897374770069242,
-      0.011186973314843278
+      0.09227398650154403,
+      0.04563892872259157,
+      0.1447248262670361,
+      0.11060052253645324,
+      0.15167755894071033,
+      0.0994675158765982,
+      0.15721457116372592,
+      0.1141461853260426
     ],
     [
       null,
-      0.022917952283766932,
-      0.009346667245721365,
-      0.007447811410346574,
-      0.007954385763851199,
-      0.0103005754478309,
-      0.009477237356627631,
-      0.015177916807503744,
-      0.027481283435293748
+      0.04344184305052661,
+      0.03314387934749421,
+      0.09659320127367052,
+      0.028492143372953548,
+      0.06490956049840732,
+      0.04952645743644296,
+      0.16176136051599438,
+      0.2509424430049855
     ]
   ],
   "notes": {}
diff --git a/docs/development/bench/querying-6.json b/docs/development/bench/querying-6.json
new file mode 100644
index 00000000..733f8b3d
--- /dev/null
+++ b/docs/development/bench/querying-6.json
@@ -0,0 +1,23 @@
+{
+  "label": "escape 1,000 raw CSS identifiers",
+  "parties": [
+    "turbohtml",
+    "soupsieve"
+  ],
+  "metrics": [],
+  "rows": [
+    [
+      "mixed shapes (1,000)",
+      6.690426293687324e-05,
+      0.001079754202616338
+    ]
+  ],
+  "spread": [
+    [
+      null,
+      0.018333627446141816,
+      0.007448910606025241
+    ]
+  ],
+  "notes": {}
+}
diff --git a/docs/development/bench/url-cleaning.json b/docs/development/bench/url-cleaning.json
index ed443a90..532f8fca 100644
--- a/docs/development/bench/url-cleaning.json
+++ b/docs/development/bench/url-cleaning.json
@@ -9,29 +9,29 @@
   "rows": [
     [
       "clean 100 URLs",
-      0.0003844782578047064,
-      0.0007859442811574505,
-      0.0009630483129967615
+      0.0002001551580595636,
+      0.0006741690810182869,
+      0.0008954732669508303
     ],
     [
       "normalize 100 URLs",
-      0.0003070245703611363,
-      0.0005983442112741008,
-      0.0020177926968851048
+      0.00019102673005969942,
+      0.0005294812288714942,
+      0.0014264048398520874
     ]
   ],
   "spread": [
     [
       null,
-      0.022289454081313064,
-      0.06607782769251852,
-      0.03681145454277887
+      0.023980473452570077,
+      0.27020235261272907,
+      0.19362889792689836
     ],
     [
       null,
-      0.028259459443914923,
-      0.04054379615181831,
-      0.04726044582904961
+      0.05593996284173067,
+      0.10269535838979268,
+      0.047716221029633424
     ]
   ],
   "notes": {}
diff --git a/docs/development/performance.rst b/docs/development/performance.rst
index fe35e9e7..f0b150fc 100644
--- a/docs/development/performance.rst
+++ b/docs/development/performance.rst
@@ -78,8 +78,8 @@ escape each untrusted operand through the same C ``escape``.
 :func:`turbohtml.clean.linkify` against `bleach <https://bleach.readthedocs.io>`_'s ``linkify``, the HTML-aware
 linkifier it succeeds, and `lxml-html-clean <https://github.com/fedora-python/lxml_html_clean>`_'s ``autolink``. All
 three parse the HTML and rewrite it. turbohtml's C candidate scan and its own tree carry it past bleach's html5lib pass
-by seven to twenty times. It leads lxml's autolink on the comment and 4 KiB markup inputs and trails it on the plain 1
-KiB prose row (0.6x), though that row is not a like-for-like comparison: ``autolink`` only rewrites URLs already inside
+by six to twenty times. It leads lxml's autolink on the comment and 4 KiB markup inputs and trails it on the plain 1 KiB
+prose row (0.6x), though that row is not a like-for-like comparison: ``autolink`` only rewrites URLs already inside
 markup and never linkifies an email address, so on plain prose it produces no links at all where turbohtml produces
 thirty. Its figure there is the cost of finding nothing.
 
@@ -89,8 +89,8 @@ thirty. Its figure there is the cost of finding nothing.
 The detection primitive on its own, :meth:`turbohtml.clean.LinkDetector.find` against ``LinkifyIt().match`` and
 :meth:`~turbohtml.clean.LinkDetector.has_link` against ``LinkifyIt().test``, scans a run of plain text and returns the
 spans or a boolean without rewriting any HTML, so this isolates the C scan from the full linkify rewrite above. It runs
-37 to 93 times faster, except on the ``has_link`` prose row (2.1x), where ``test`` short-circuits on the first link near
-the start.
+51 to 103 times faster, except on the ``has_link`` prose row (2.8x), where ``test`` short-circuits on the first link
+near the start.
 
 .. bench-table::
     :file: bench/linkify-2.json
@@ -207,11 +207,11 @@ navigation and footer each classifier must reject are part of the measured cost.
 finder, and the article extractors trafilatura, newspaper3k, goose3, and news-please that surface a date beside the body
 text. All read the same signals -- publication/modification ``<meta>`` tags, JSON-LD, ``<time>`` elements, and a date in
 the URL -- and are parse-bound; htmldate builds an lxml tree, turbohtml the WHATWG tree. turbohtml's early-exit over the
-structured signals runs 2.3 to 2.9 times faster than htmldate on the real pages and 15 to 21 times faster than
-trafilatura. The synthetic ``100 meta candidates`` row is the exception: a page stacked with a hundred date-like
-``<meta>`` tags forces turbohtml to weigh every candidate, where htmldate and trafilatura stop early and edge ahead
-(0.6x and 0.7x). htmldate stops by giving up, returning no date at all for that page, so its figure there is the cost of
-the search it abandoned rather than of finding what turbohtml reports.
+structured signals runs 2.9 to 3.3 times faster than htmldate on the real pages and 20 to 24 times faster than
+trafilatura. The synthetic ``100 meta candidates`` row -- a page stacked with a hundred date-like ``<meta>`` tags -- was
+the one case turbohtml lost, since it weighed every candidate where htmldate and trafilatura stopped early; moving that
+weighing into C turns it around, and turbohtml now leads the row too, 3.0 times over htmldate and 4.1 times over
+trafilatura.
 
 .. bench-table::
     :file: bench/date-extraction.json
@@ -330,6 +330,15 @@ and over a hundred times faster than BeautifulSoup and pyquery.
 .. bench-table::
     :file: bench/matching.json
 
+:func:`turbohtml.query.escape_identifier` escapes a raw string into a CSS identifier per the CSSOM
+serialize-an-identifier rules -- the safe way to drop an untrusted class or id into a selector -- against soupsieve's
+``escape``. The workload escapes a thousand identifiers spanning leading digits, embedded specials, astral characters,
+and a lone dash. turbohtml walks the code points and emits the escape in C, where soupsieve builds the result through a
+per-character Python loop, so it runs 16 times faster.
+
+.. bench-table::
+    :file: bench/querying-6.json
+
 A text-content search runs through :meth:`~turbohtml.Node.find_all` with ``text=`` (a regex matched against each
 element's collected subtree text), raced against ``BeautifulSoup.find_all(string=...)`` and the equivalent text filters
 on lxml, parsel, and pyquery. When the ``text=`` filter is a plain string or a literal (no regex metacharacters,
@@ -569,7 +578,7 @@ tables also carry the anchor collectors resiliparse, selectolax, BeautifulSoup,
 ``<a href>`` and so do strictly less work. Each operation runs over the three real saved pages and the 235 kB WHATWG
 spec; extraction is read-only and rewrite applies an identity callback, so both reuse one cached parse, while absolutize
 rebuilds a fresh tree before each iteration since ``make_links_absolute`` rewrites the hrefs in place. turbohtml walks
-the attribute set in C and leads lxml's like-for-like helpers from low single digits up to over a hundred times, the gap
+the attribute set in C and leads lxml's like-for-like helpers from seven times up to over a hundred times, the gap
 widening with the link count; against the anchor-only collectors it does more work per element, so resiliparse and
 selectolax land near or just ahead on extraction while turbohtml pulls away on the rewrite.
 
@@ -655,9 +664,9 @@ comparison is output size, where turbohtml stays within a couple percent and com
 
 ``csscompressor`` (the YUI port) and ``cssmin`` (its BSD descendant) rewrite values to their shortest form the way
 turbohtml does, but as pure-Python regex passes they turn quadratic on a large stylesheet and trail the C engine by tens
-to over five hundred times, ``cssmin`` and ``css-html-js-minify`` reaching 2.8 seconds on the 745 kB ``bulma.css`` where
-turbohtml takes 5 ms. ``rcssmin`` is a C extension and faster than turbohtml, though it only strips comments and
-whitespace, so it leaves a larger result everywhere except the custom-property-heavy ``bulma.css``.
+to over four hundred times, ``cssmin`` and ``css-html-js-minify`` reaching roughly four seconds on the 745 kB
+``bulma.css`` where turbohtml takes 9 ms. ``rcssmin`` is a C extension and faster than turbohtml, though it only strips
+comments and whitespace, so it leaves a larger result everywhere except the custom-property-heavy ``bulma.css``.
 ``css-html-js-minify`` is among the slowest of the set. The three pure-Python tools and rcssmin also break value safety:
 each rewrites the internal whitespace of a custom-property value, which `CSS Variables 1 §2
 <https://www.w3.org/TR/css-variables-1/#defining-variables>`_ keeps as the literal token stream that ``var()`` splices
@@ -670,8 +679,8 @@ properties.
 declarations overridden elsewhere in the sheet and rewrites syntax for a browser-target set, so it reaches a smaller
 size than turbohtml on most of the corpus (turbohtml comes out ahead on ``normalize.css``). That target-dependent
 optimization is the same idea as turbohtml's ``baseline`` option carried further, and it is in scope. Its Rust engine
-runs about twice slower than turbohtml across the corpus, the cascade pass costing it the most on ``animate.css``, and
-it rejects ``foundation.css`` with a parse error on a media query the WHATWG recovery rules accept, where turbohtml
+runs 1.3 to 2.4 times slower than turbohtml across the corpus, its per-target cascade pass the added cost, and it
+rejects ``foundation.css`` with a parse error on a media query the WHATWG recovery rules accept, where turbohtml
 minifies all six. turbohtml gives the smallest value-safe output at the most compatible baseline and recovers from
 malformed input.
 
@@ -706,13 +715,15 @@ what ``requests`` uses), `faust-cchardet <https://github.com/faust-streaming/cCh
 uchardet; the original cchardet stops compiling at Python 3.11), `resiliparse <https://resiliparse.chatnoir.eu/>`_'s
 ``detect_encoding``, and BeautifulSoup's ``UnicodeDammit``, benchmarked with the ``chardet`` backend it only sniffs
 with. turbohtml resolves certain input -- a byte-order mark, a ``<meta>`` declaration, valid UTF-8, pure ASCII --
-structurally before any scoring, which is where the 70x-1700x rows on the pre-declared page come from, and its chardetng
-frequency scoring keeps declaration-less single-byte text 3.2x-4.0x ahead of chardet.
+structurally before any scoring, which is where the tens-to-nearly-2000x rows on the ASCII and pre-declared pages come
+from, and its chardetng frequency scoring keeps declaration-less single-byte text 3.9x-5.4x ahead of chardet.
 
-The two native C detectors, faust-cchardet and resiliparse, win two workloads. On a kilobyte of ASCII or UTF-8 all three
-native detectors finish inside five microseconds, where the winner is whoever has less to set up rather than whoever
-scans faster. On CJK-heavy bytes uchardet's tables stay about 2.5x ahead, because turbohtml decodes each candidate
-encoding to score it and a CJK stream leaves several candidates standing.
+resiliparse's native scan is quickest on the small and CJK inputs, ahead of turbohtml by 1.1 to 2.3 times where the
+structural checks find nothing to short-circuit on; faust-cchardet (uchardet) leads only the Shift_JIS row, 1.6 times.
+On everything else turbohtml's structural resolution runs away from the full-table scanners: uchardet spends 188
+microseconds on the 4 kB UTF-8 stream turbohtml settles in five, and 30 milliseconds on the 95 kB pre-declared page it
+settles in under one. CJK is the case both native detectors keep, since turbohtml decodes each candidate encoding to
+score it and a CJK stream leaves several standing.
 
 .. bench-table::
     :file: bench/encoding-detection.json
@@ -739,14 +750,14 @@ the one case where the CPython codec's table lookup edges ahead.
 :func:`turbohtml.extract.clean_url`, :func:`~turbohtml.extract.normalize_url`, and
 :func:`~turbohtml.extract.extract_links` against `courlan <https://github.com/adbar/courlan>`_, trafilatura's URL
 cleaner, and `w3lib <https://w3lib.readthedocs.io/>`_'s ``safe_url_string``/``canonicalize_url``, Scrapy's URL
-utilities. The per-URL pass wins 2x-6x by scanning each component once in C-backed regexes and percent-encoding only
+utilities. The per-URL pass wins 2.8x-7.5x by scanning each component once in C-backed regexes and percent-encoding only
 when a scan finds something to encode, where both competitors re-encode unconditionally through urllib's per-character
-quoters. Page-level filtered extraction parses the real WHATWG DOM and cleans each link, and finishes 2.0x-3.2x ahead of
+quoters. Page-level filtered extraction parses the real WHATWG DOM and cleans each link, and finishes 2.2x-3.8x ahead of
 courlan's regex scan, because each distinct href is cleaned once and absolute links skip resolution. Every tree-based
 competitor here resolves each href against the base and deduplicates the result, the work
 :func:`~turbohtml.extract.extract_links` does, so the row compares the same answer rather than a bare attribute read:
-lxml trails by 1.0 to 2.2 times, selectolax by 2.0 to 4.1, parsel and pyquery by 2.5 to 4.2, and BeautifulSoup by 7.2 to
-36.9 depending on its tree builder.
+lxml trails by 1.3 to 2.1 times, selectolax by 1.6 to 3.5, parsel and pyquery by 2.2 to 3.8, and BeautifulSoup by 8.7 to
+38.0 depending on its tree builder.
 
 .. bench-table::
     :file: bench/url-cleaning.json
diff --git a/docs/migration/bench/airium.json b/docs/migration/bench/airium.json
index c9b8bbc2..deb9b0e3 100644
--- a/docs/migration/bench/airium.json
+++ b/docs/migration/bench/airium.json
@@ -39,5 +39,5 @@
       0.03586474634366849
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/beautifulsoup.json b/docs/migration/bench/beautifulsoup.json
index 6069969f..7d17a549 100644
--- a/docs/migration/bench/beautifulsoup.json
+++ b/docs/migration/bench/beautifulsoup.json
@@ -11,55 +11,55 @@
       "build a list (constructors) — 100 rows",
       5.7091425532007634e-05,
       0.0007816329752283006,
-      null
+      0.0007816329752283006
     ],
     [
       "build a list (constructors) — 1k rows",
       0.0005440194775019336,
       0.007474331593887958,
-      null
+      0.007474331593887958
     ],
     [
       "build a list (constructors) — 10k rows",
       0.005411195857050188,
       0.0822198923851829,
-      null
+      0.0822198923851829
     ],
     [
       "construct N elements (no serialize) — 100 rows",
       4.288681538374325e-05,
       0.0002607024263738822,
-      null
+      0.0002607024263738822
     ],
     [
       "construct N elements (no serialize) — 1k rows",
       0.0004355111897590784,
       0.0025463228632058113,
-      null
+      0.0025463228632058113
     ],
     [
       "construct N elements (no serialize) — 10k rows",
       0.0043399677733759745,
       0.025400459164908778,
-      null
+      0.025400459164908778
     ],
     [
       "emit a built tree — 100 rows",
       4.327393534175883e-06,
       0.0003889943512641973,
-      null
+      0.0003889943512641973
     ],
     [
       "emit a built tree — 1k rows",
       4.2981901363721896e-05,
       0.003848052945007415,
-      null
+      0.003848052945007415
     ],
     [
       "emit a built tree — 10k rows",
       0.00045268575032271957,
       0.040861342851712834,
-      null
+      0.040861342851712834
     ],
     [
       "parse to a tree — wpt tiny (0.6 kB)",
@@ -441,75 +441,75 @@
     ],
     [
       "extract every link — daring fireball (10 kB)",
-      8.540413328243327e-06,
-      1.525457977180622e-05,
-      1.4777843472775961e-05
+      1.3464031636563808e-05,
+      2.3068925242360667e-05,
+      2.2397782224459206e-05
     ],
     [
       "extract every link — ars technica (56 kB)",
-      2.6025344868211658e-05,
-      5.213720703522995e-05,
-      5.237701754860306e-05
+      4.56970487050512e-05,
+      7.421023221354517e-05,
+      7.385782030174444e-05
     ],
     [
       "extract every link — mozilla blog (95 kB)",
-      4.8695574463408775e-05,
-      0.0001045537347768762,
-      0.0001032916394857845
+      7.54788005347488e-05,
+      0.00014937739054706375,
+      0.00016065289965657334
     ],
     [
       "extract every link — whatwg spec (235 kB)",
-      7.78339928473315e-05,
-      0.00034933633753553295,
-      0.0003470544843745908
+      6.635500418402292e-05,
+      0.0004964120270566733,
+      0.0008334717876626504
     ],
     [
       "absolutize every link — daring fireball (10 kB)",
-      7.897827523587846e-05,
-      8.12796183519519e-05,
-      8.698945166922083e-05
+      3.9356466906781407e-05,
+      8.537428512530217e-05,
+      9.082854247803122e-05
     ],
     [
       "absolutize every link — ars technica (56 kB)",
-      0.00020205170371430844,
-      0.00020543835923566198,
-      0.0002171601645386545
+      9.180021663250197e-05,
+      0.00022045485021256658,
+      0.00026355090974069145
     ],
     [
       "absolutize every link — mozilla blog (95 kB)",
-      0.00038564827292475456,
-      0.00033134097158911874,
-      0.0003516682579440082
+      0.00015685727829387966,
+      0.0006314839385671197,
+      0.00039728056947296864
     ],
     [
       "absolutize every link — whatwg spec (235 kB)",
-      0.0002516408542116248,
-      0.0005860067427647664,
-      0.00060525605241916
+      0.00022430012273844113,
+      0.000799342570189765,
+      0.0006994879075818972
     ],
     [
       "rewrite every link — daring fireball (10 kB)",
-      2.9012148117975776e-06,
-      1.647298982613658e-05,
-      2.085971535355687e-05
+      2.996172853079552e-06,
+      1.6866881041484778e-05,
+      2.1706805336899986e-05
     ],
     [
       "rewrite every link — ars technica (56 kB)",
-      1.0269556899681712e-05,
-      5.5183893759173465e-05,
-      6.536129939623454e-05
+      1.07103676191637e-05,
+      5.6803982133146746e-05,
+      6.689157613000891e-05
     ],
     [
       "rewrite every link — mozilla blog (95 kB)",
-      1.9159150432083532e-05,
-      0.00011386105690765665,
-      0.00012480539973580562
+      1.986850784400455e-05,
+      0.00010975474037877575,
+      0.00012791490657567314
     ],
     [
       "rewrite every link — whatwg spec (235 kB)",
-      3.324762803439777e-05,
-      0.0003635839235016647,
-      0.0003821885512707013
+      3.3264580665104404e-05,
+      0.00036030607740637305,
+      0.0004281737738741261
     ],
     [
       "social-card extraction — head",
@@ -609,63 +609,63 @@
     ],
     [
       "detect a byte stream's encoding — ascii (1 kB)",
-      2.683881651736423e-06,
-      0.00016621675959527238,
-      null
+      1.1417041620257844e-06,
+      0.0001670253838407613,
+      0.0001670253838407613
     ],
     [
       "detect a byte stream's encoding — utf-8 russian (4 kB)",
-      8.42264663110844e-06,
-      0.0002101907146917862,
-      null
+      5.395650118404187e-06,
+      0.00019062113415202475,
+      0.00019062113415202475
     ],
     [
       "detect a byte stream's encoding — windows-1251 russian (4 kB)",
-      0.00023194885286178155,
-      0.0007660471198960295,
-      null
+      0.00017615521230140985,
+      0.0006824471162190093,
+      0.0006824471162190093
     ],
     [
       "detect a byte stream's encoding — windows-1252 french (4 kB)",
-      0.00022984596078382916,
-      0.0009623634165715581,
-      null
+      0.00017919206403386548,
+      0.0009608074811543096,
+      0.0009608074811543096
     ],
     [
       "detect a byte stream's encoding — shift_jis japanese (4 kB)",
-      0.00010243962940137408,
-      0.0007823282336403281,
-      null
+      8.727693684799458e-05,
+      0.0011041370983093657,
+      0.0011041370983093657
     ],
     [
       "detect a byte stream's encoding — utf-8 page (95 kB)",
-      1.0262474480586075e-06,
-      0.0017221563046708372,
-      null
+      9.080427233835545e-07,
+      0.0017875253332325276,
+      0.0017875253332325276
     ],
     [
       "extract filtered page links — daring fireball (10 kB)",
-      0.00019244289493750935,
-      0.0017440380336969004,
-      0.001393361708323937
+      0.00014374658196440274,
+      0.0017214570859020266,
+      0.0012449160982062797
     ],
     [
       "extract filtered page links — ars technica (56 kB)",
-      0.00044414784745564856,
-      0.007564480031457303,
-      0.0060377776668853285
+      0.0003625916885994229,
+      0.007038899739200133,
+      0.005221934676834887
     ],
     [
       "extract filtered page links — mozilla blog (95 kB)",
-      0.0007429536545942028,
-      0.016098750425347436,
-      0.013269332885101903
+      0.0006187186553461288,
+      0.01468123565427959,
+      0.01133143881209738
     ],
     [
       "extract filtered page links — whatwg spec (235 kB)",
-      0.0011912915304037597,
-      0.04389768487211162,
-      0.03420185421418864
+      0.0010619639210744936,
+      0.04029734718399899,
+      0.02999120229408921
     ]
   ],
   "spread": [
@@ -673,55 +673,55 @@
       null,
       0.01788392867332312,
       0.03121492351385784,
-      null
+      0.03121492351385784
     ],
     [
       null,
       0.02098234232783449,
       0.032482085826574664,
-      null
+      0.032482085826574664
     ],
     [
       null,
       0.024406729859124777,
       0.09801825368387174,
-      null
+      0.09801825368387174
     ],
     [
       null,
       0.02944875019031374,
       0.011449485274073672,
-      null
+      0.011449485274073672
     ],
     [
       null,
       0.024838279255060405,
       0.0259580795839295,
-      null
+      0.0259580795839295
     ],
     [
       null,
       0.0409794960756543,
       0.015063071698137679,
-      null
+      0.015063071698137679
     ],
     [
       null,
       0.013612393164726814,
       0.026381832222267913,
-      null
+      0.026381832222267913
     ],
     [
       null,
       0.00837903216048809,
       0.0035044858351730617,
-      null
+      0.0035044858351730617
     ],
     [
       null,
       0.02765221451091796,
       0.03831919610907921,
-      null
+      0.03831919610907921
     ],
     [
       null,
@@ -1103,75 +1103,75 @@
     ],
     [
       null,
-      0.007242716319812719,
-      0.03169356051174955,
-      0.0043339976144837564
+      0.1905638942872358,
+      0.03679384648962025,
+      0.04534085848493278
     ],
     [
       null,
-      0.009166139408406725,
-      0.005314394159905668,
-      0.03330596578214335
+      0.13979209516180388,
+      0.07871130987482713,
+      0.03917221707941639
     ],
     [
       null,
-      0.014768482199177618,
-      0.0076536327905726426,
-      0.005099330122068768
+      0.09227398650154403,
+      0.04563892872259157,
+      0.1447248262670361
     ],
     [
       null,
-      0.022917952283766932,
-      0.009346667245721365,
-      0.007447811410346574
+      0.04344184305052661,
+      0.03314387934749421,
+      0.09659320127367052
     ],
     [
       null,
-      0.007903863312063752,
-      0.007429985977232138,
-      0.005709366712022955
+      0.033531589420485355,
+      0.04178334636226221,
+      0.03830741719481508
     ],
     [
       null,
-      0.008416212374072259,
-      0.012317455813324451,
-      0.003385509132172714
+      0.009126761347801857,
+      0.03805325222482105,
+      0.09008961757808379
     ],
     [
       null,
-      0.007817411254915526,
-      0.0023171634993249296,
-      0.009952790930482652
+      0.018904092332618992,
+      0.399494085088914,
+      0.05530115918703297
     ],
     [
       null,
-      0.004943329428493678,
-      0.024256358650669513,
-      0.012263418617546295
+      0.012208253570299738,
+      0.3257678679866179,
+      0.03681841828896033
     ],
     [
       null,
-      0.010201463727222403,
-      0.00933812413740348,
-      0.011533179321718892
+      0.025611308465656468,
+      0.024929672582158197,
+      0.12761429143963907
     ],
     [
       null,
-      0.01609684234917494,
-      0.01366943413516007,
-      0.0093306751370152
+      0.012653954590904381,
+      0.03626613003301336,
+      0.0359179002687463
     ],
     [
       null,
-      0.020570331464049258,
-      0.04141288334957416,
-      0.039089211844657266
+      0.004280553044310928,
+      0.00732471497482255,
+      0.02772667459186675
     ],
     [
       null,
-      0.013042710419117346,
-      0.05247061676530608,
-      0.04035566901289052
+      0.01749493908665723,
+      0.017292612809595903,
+      0.16058448881226262
     ],
     [
       null,
@@ -1271,64 +1271,80 @@
     ],
     [
       null,
-      0.017880736659094357,
-      0.018251613038969026,
-      null
+      0.009158479913916974,
+      0.09234027113797867,
+      0.09234027113797867
     ],
     [
       null,
-      0.013928849417596853,
-      0.04709186896538359,
-      null
+      0.0038712062652642206,
+      0.0877226744657706,
+      0.0877226744657706
     ],
     [
       null,
-      0.030374690128129544,
-      0.05534154336710747,
-      null
+      0.004080075123940598,
+      0.09585776641164494,
+      0.09585776641164494
     ],
     [
       null,
-      0.024415342494636606,
-      0.01597170853773811,
-      null
+      0.059916699660372115,
+      0.1426199999041337,
+      0.1426199999041337
     ],
     [
       null,
-      0.011882884549205048,
-      0.07681575774619458,
-      null
+      0.09053675269683122,
+      0.2738526726895093,
+      0.2738526726895093
     ],
     [
       null,
-      0.027875914121933836,
-      0.02169554352319668,
-      null
+      0.09984062000003383,
+      0.13921153915640078,
+      0.13921153915640078
     ],
     [
       null,
-      0.08681901513017418,
-      0.09382784824059776,
-      0.05176701109354531
+      0.016529254132972147,
+      0.09998025007016155,
+      0.049664879874346625
     ],
     [
       null,
-      0.0246925729997723,
-      0.08924334518887247,
-      0.07457086740968584
+      0.030487043860911212,
+      0.08727937480889225,
+      0.019173792772694
     ],
     [
       null,
-      0.039027527214139324,
-      0.05894036352347361,
-      0.11979623071713057
+      0.06359342029387884,
+      0.03759982374861031,
+      0.04678582098573661
     ],
     [
       null,
-      0.04936646995438586,
-      0.11418698795426512,
-      0.12059134279394809
+      0.1209415112126743,
+      0.09622909825766862,
+      0.13128710317602377
     ]
   ],
-  "notes": {}
+  "row_notes": {
+    "0": "same in both configurations, so measured once",
+    "1": "same in both configurations, so measured once",
+    "2": "same in both configurations, so measured once",
+    "3": "same in both configurations, so measured once",
+    "4": "same in both configurations, so measured once",
+    "5": "same in both configurations, so measured once",
+    "6": "same in both configurations, so measured once",
+    "7": "same in both configurations, so measured once",
+    "8": "same in both configurations, so measured once",
+    "100": "same in both configurations, so measured once",
+    "101": "same in both configurations, so measured once",
+    "102": "same in both configurations, so measured once",
+    "103": "same in both configurations, so measured once",
+    "104": "same in both configurations, so measured once",
+    "105": "same in both configurations, so measured once"
+  }
 }
diff --git a/docs/migration/bench/bleach.json b/docs/migration/bench/bleach.json
index fdda6c18..6d1c2a5f 100644
--- a/docs/migration/bench/bleach.json
+++ b/docs/migration/bench/bleach.json
@@ -18,18 +18,18 @@
     ],
     [
       "linkify HTML — comment (1 link, 1 email)",
-      3.781744958963884e-06,
-      8.422372941652156e-05
+      2.833639196916001e-06,
+      5.694690112060622e-05
     ],
     [
       "linkify HTML — prose (1 KiB)",
-      5.8999148810319944e-05,
-      0.0004075837402789754
+      4.209216648121128e-05,
+      0.00027776850697591726
     ],
     [
       "linkify HTML — markup (4 KiB)",
-      0.00015994283040754453,
-      0.002666328884060931
+      0.00011087927229406584,
+      0.0016154013672651975
     ]
   ],
   "spread": [
@@ -45,19 +45,19 @@
     ],
     [
       null,
-      0.07086155915802331,
-      0.11050801498867782
+      0.011325012124501117,
+      0.05308123636925894
     ],
     [
       null,
-      0.03361607989819003,
-      0.05731269830817569
+      0.02196262985378034,
+      0.029872045724290235
     ],
     [
       null,
-      0.09089060583931145,
-      0.024059342839235647
+      0.01391027709579616,
+      0.00807868275609938
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/boilerpy3.json b/docs/migration/bench/boilerpy3.json
index 92420b38..578823ee 100644
--- a/docs/migration/bench/boilerpy3.json
+++ b/docs/migration/bench/boilerpy3.json
@@ -39,5 +39,5 @@
       0.07765030969801458
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/calmjs-parse.json b/docs/migration/bench/calmjs-parse.json
index fbb63357..7db5327c 100644
--- a/docs/migration/bench/calmjs-parse.json
+++ b/docs/migration/bench/calmjs-parse.json
@@ -68,5 +68,5 @@
       0.06493109954770923
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/chardet.json b/docs/migration/bench/chardet.json
index 38e5b885..4daa27c5 100644
--- a/docs/migration/bench/chardet.json
+++ b/docs/migration/bench/chardet.json
@@ -8,66 +8,66 @@
   "rows": [
     [
       "ascii (1 kB)",
-      2.683881651736423e-06,
-      0.00016340677547077576
+      1.1417041620257844e-06,
+      0.00014564843067432776
     ],
     [
       "utf-8 russian (4 kB)",
-      8.42264663110844e-06,
-      0.00020473426656053562
+      5.395650118404187e-06,
+      0.00016079087338501571
     ],
     [
       "windows-1251 russian (4 kB)",
-      0.00023194885286178155,
-      0.0007493408056310121
+      0.00017615521230140985,
+      0.0006862004258512874
     ],
     [
       "windows-1252 french (4 kB)",
-      0.00022984596078382916,
-      0.0009485056960632695
+      0.00017919206403386548,
+      0.00096642504756043
     ],
     [
       "shift_jis japanese (4 kB)",
-      0.00010243962940137408,
-      0.0007782307262308071
+      8.727693684799458e-05,
+      0.0007336918404992806
     ],
     [
       "utf-8 page (95 kB)",
-      1.0262474480586075e-06,
-      0.0017224917549659342
+      9.080427233835545e-07,
+      0.0013319131658893941
     ]
   ],
   "spread": [
     [
       null,
-      0.017880736659094357,
-      0.010724686631088845
+      0.009158479913916974,
+      0.13673752459469665
     ],
     [
       null,
-      0.013928849417596853,
-      0.02288405959591961
+      0.0038712062652642206,
+      0.04049806799196369
     ],
     [
       null,
-      0.030374690128129544,
-      0.027327653967104393
+      0.004080075123940598,
+      0.12213514583063445
     ],
     [
       null,
-      0.024415342494636606,
-      0.03283025755818031
+      0.059916699660372115,
+      0.10209968241403904
     ],
     [
       null,
-      0.011882884549205048,
-      0.03392169078973562
+      0.09053675269683122,
+      0.4077870034036728
     ],
     [
       null,
-      0.027875914121933836,
-      0.02346546131727304
+      0.09984062000003383,
+      0.010247606289130554
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/charset-normalizer.json b/docs/migration/bench/charset-normalizer.json
index d535f93f..e590e0a6 100644
--- a/docs/migration/bench/charset-normalizer.json
+++ b/docs/migration/bench/charset-normalizer.json
@@ -8,66 +8,66 @@
   "rows": [
     [
       "ascii (1 kB)",
-      2.683881651736423e-06,
-      6.459631354971407e-05
+      1.1417041620257844e-06,
+      4.932761466847069e-05
     ],
     [
       "utf-8 russian (4 kB)",
-      8.42264663110844e-06,
-      0.00045748297744315397
+      5.395650118404187e-06,
+      0.00034693029781844115
     ],
     [
       "windows-1251 russian (4 kB)",
-      0.00023194885286178155,
-      0.0004235422777204197
+      0.00017615521230140985,
+      0.00030178521061922464
     ],
     [
       "windows-1252 french (4 kB)",
-      0.00022984596078382916,
-      0.0014133275006618835
+      0.00017919206403386548,
+      0.001020589817774938
     ],
     [
       "shift_jis japanese (4 kB)",
-      0.00010243962940137408,
-      0.00048443899155851494
+      8.727693684799458e-05,
+      0.00034780594885811905
     ],
     [
       "utf-8 page (95 kB)",
-      1.0262474480586075e-06,
-      0.0007871857096309517
+      9.080427233835545e-07,
+      0.000590463311179216
     ]
   ],
   "spread": [
     [
       null,
-      0.017880736659094357,
-      0.0447636886199731
+      0.009158479913916974,
+      0.04216924148520772
     ],
     [
       null,
-      0.013928849417596853,
-      0.08554927173830451
+      0.0038712062652642206,
+      0.015485661727082682
     ],
     [
       null,
-      0.030374690128129544,
-      0.0365463065399403
+      0.004080075123940598,
+      0.016158813820105353
     ],
     [
       null,
-      0.024415342494636606,
-      0.02930554925922803
+      0.059916699660372115,
+      0.015039601460871254
     ],
     [
       null,
-      0.011882884549205048,
-      0.037535858472558255
+      0.09053675269683122,
+      0.020993992514227677
     ],
     [
       null,
-      0.027875914121933836,
-      0.01868390630267981
+      0.09984062000003383,
+      0.013470151385193491
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/courlan.json b/docs/migration/bench/courlan.json
index c39aa04a..76689c28 100644
--- a/docs/migration/bench/courlan.json
+++ b/docs/migration/bench/courlan.json
@@ -8,66 +8,66 @@
   "rows": [
     [
       "clean and normalize 100 URLs — clean 100 URLs",
-      0.0003844782578047064,
-      0.0007859442811574505
+      0.0002001551580595636,
+      0.0006741690810182869
     ],
     [
       "clean and normalize 100 URLs — normalize 100 URLs",
-      0.0003070245703611363,
-      0.0005983442112741008
+      0.00019102673005969942,
+      0.0005294812288714942
     ],
     [
       "extract filtered page links — daring fireball (10 kB)",
-      0.00019244289493750935,
-      0.0006250226910348525
+      0.00014374658196440274,
+      0.0005456723903686603
     ],
     [
       "extract filtered page links — ars technica (56 kB)",
-      0.00044414784745564856,
-      0.001392310166693278
+      0.0003625916885994229,
+      0.0011215508353264643
     ],
     [
       "extract filtered page links — mozilla blog (95 kB)",
-      0.0007429536545942028,
-      0.0016785657044238178
+      0.0006187186553461288,
+      0.0014856392695037357
     ],
     [
       "extract filtered page links — whatwg spec (235 kB)",
-      0.0011912915304037597,
-      0.002558890350276973
+      0.0010619639210744936,
+      0.002259075846571553
     ]
   ],
   "spread": [
     [
       null,
-      0.022289454081313064,
-      0.06607782769251852
+      0.023980473452570077,
+      0.27020235261272907
     ],
     [
       null,
-      0.028259459443914923,
-      0.04054379615181831
+      0.05593996284173067,
+      0.10269535838979268
     ],
     [
       null,
-      0.08681901513017418,
-      0.04141089927327427
+      0.016529254132972147,
+      0.05383105561293264
     ],
     [
       null,
-      0.0246925729997723,
-      0.18645796673891377
+      0.030487043860911212,
+      0.03613938286491891
     ],
     [
       null,
-      0.039027527214139324,
-      0.10402639227526292
+      0.06359342029387884,
+      0.07919831191163934
     ],
     [
       null,
-      0.04936646995438586,
-      0.059124346380420974
+      0.1209415112126743,
+      0.037431188522577784
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/csscompressor.json b/docs/migration/bench/csscompressor.json
index a10e1d31..2ee7b4cd 100644
--- a/docs/migration/bench/csscompressor.json
+++ b/docs/migration/bench/csscompressor.json
@@ -12,89 +12,89 @@
     [
       "normalize.css (6 kB)",
       1750.0,
-      2.4677963665453717e-05,
+      3.2464727574677e-05,
       1842.0,
-      0.00148522892307786
+      0.0015539148210640026
     ],
     [
       "pico.css (90 kB)",
       81155.0,
-      0.0008415556360432674,
+      0.0010817124017800477,
       81616.0,
-      0.04783730468867967
+      0.04725994185234109
     ],
     [
       "animate.css (93 kB)",
       73788.0,
-      0.0009074143608813756,
+      0.0012892222758485634,
       75738.0,
-      0.03357629689950651
+      0.034281230024741184
     ],
     [
       "foundation.css (164 kB)",
       132898.0,
-      0.0020137969298351286,
+      0.0028156564673433118,
       136405.0,
-      0.08025021179734419
+      0.08035445658606477
     ],
     [
       "bootstrap.css (274 kB)",
       229554.0,
-      0.002807286729421321,
+      0.003730066627516256,
       234206.0,
-      0.10941284016977686
+      0.10736939241178334
     ],
     [
       "bulma.css (745 kB)",
       681425.0,
-      0.0070988878069329076,
+      0.008693945529860988,
       681328.0,
-      0.77290790976258
+      0.7723801529306608
     ]
   ],
   "spread": [
     [
       null,
       null,
-      0.021180385365301226,
+      0.09728764011828976,
       null,
-      0.05701234593429704
+      0.019826228382515288
     ],
     [
       null,
       null,
-      0.05709012427212532,
+      0.10598940421080025,
       null,
-      0.026944394476272976
+      0.04641130544766816
     ],
     [
       null,
       null,
-      0.029687965981479846,
+      0.07158741875788914,
       null,
-      0.019622682835288865
+      0.02695020928613877
     ],
     [
       null,
       null,
-      0.06837573110647958,
+      0.07838358803696824,
       null,
-      0.02003352814730991
+      0.03547418507801415
     ],
     [
       null,
       null,
-      0.023601218123909005,
+      0.10694045427657661,
       null,
-      0.033278616382448625
+      0.07345581630301083
     ],
     [
       null,
       null,
-      0.02956177866788225,
+      0.12618949595325846,
       null,
-      0.009543429204608288
+      0.010728740875689466
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/cssselect.json b/docs/migration/bench/cssselect.json
index 00538cf9..fc429981 100644
--- a/docs/migration/bench/cssselect.json
+++ b/docs/migration/bench/cssselect.json
@@ -109,5 +109,5 @@
       0.037440091999251815
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/dominate.json b/docs/migration/bench/dominate.json
index 39eed83f..9a385dd6 100644
--- a/docs/migration/bench/dominate.json
+++ b/docs/migration/bench/dominate.json
@@ -269,5 +269,5 @@
       0.0705497022490886
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/dompurify.json b/docs/migration/bench/dompurify.json
index 17edceaa..d9698332 100644
--- a/docs/migration/bench/dompurify.json
+++ b/docs/migration/bench/dompurify.json
@@ -39,5 +39,5 @@
       0.06365377101405542
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/extruct.json b/docs/migration/bench/extruct.json
index 59575240..ef5d7420 100644
--- a/docs/migration/bench/extruct.json
+++ b/docs/migration/bench/extruct.json
@@ -49,5 +49,5 @@
       0.12373022254611753
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/fast-html.json b/docs/migration/bench/fast-html.json
index 52850d3f..1a303711 100644
--- a/docs/migration/bench/fast-html.json
+++ b/docs/migration/bench/fast-html.json
@@ -39,7 +39,9 @@
       0.02516429468186054
     ]
   ],
-  "notes": {
-    "fast-html": "concatenates a string rather than constructing a navigable tree, so nothing it builds can afterwards be queried or mutated"
+  "row_notes": {
+    "0": "concatenates a string rather than constructing a navigable tree, so nothing it builds can afterwards be queried or mutated",
+    "1": "concatenates a string rather than constructing a navigable tree, so nothing it builds can afterwards be queried or mutated",
+    "2": "concatenates a string rather than constructing a navigable tree, so nothing it builds can afterwards be queried or mutated"
   }
 }
diff --git a/docs/migration/bench/feedparser.json b/docs/migration/bench/feedparser.json
index fc942de4..21b80b3f 100644
--- a/docs/migration/bench/feedparser.json
+++ b/docs/migration/bench/feedparser.json
@@ -19,5 +19,5 @@
       0.18465721167062013
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/goose3.json b/docs/migration/bench/goose3.json
index 8790831a..b65d214e 100644
--- a/docs/migration/bench/goose3.json
+++ b/docs/migration/bench/goose3.json
@@ -28,18 +28,18 @@
     ],
     [
       "publication-date extraction — post (4 KiB)",
-      1.1735952601436376e-05,
-      0.0032615539830658236
+      5.9304065735214335e-06,
+      0.0025007032345456537
     ],
     [
       "publication-date extraction — longform (16 KiB)",
-      1.7074957939418784e-05,
-      0.011720733735273825
+      1.030123477659591e-05,
+      0.008274378248340023
     ],
     [
       "publication-date extraction — 100 meta candidates",
-      0.00013010201349554032,
-      0.005897449650850224
+      1.828077740384515e-05,
+      0.004187224176651701
     ],
     [
       "main-content text — main (4 KiB)",
@@ -70,18 +70,18 @@
     ],
     [
       null,
-      0.04329384536759802,
-      0.04084589772460682
+      0.004697496985019512,
+      0.15902130549302607
     ],
     [
       null,
-      0.03092662857915166,
-      0.03199195905089177
+      0.007721833090606347,
+      0.008266166525272227
     ],
     [
       null,
-      0.03639475424630214,
-      0.07349111320004241
+      0.008026401759229225,
+      0.017919851624633977
     ],
     [
       null,
@@ -89,5 +89,5 @@
       0.056976880840888505
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/htbuilder.json b/docs/migration/bench/htbuilder.json
index 1ec83277..aa46c053 100644
--- a/docs/migration/bench/htbuilder.json
+++ b/docs/migration/bench/htbuilder.json
@@ -99,7 +99,12 @@
       0.010705242198592509
     ]
   ],
-  "notes": {
-    "htbuilder": "concatenates a string rather than constructing a navigable tree, so nothing it builds can afterwards be queried or mutated"
+  "row_notes": {
+    "0": "concatenates a string rather than constructing a navigable tree, so nothing it builds can afterwards be queried or mutated",
+    "1": "concatenates a string rather than constructing a navigable tree, so nothing it builds can afterwards be queried or mutated",
+    "2": "concatenates a string rather than constructing a navigable tree, so nothing it builds can afterwards be queried or mutated",
+    "3": "concatenates a string rather than constructing a navigable tree, so nothing it builds can afterwards be queried or mutated",
+    "4": "concatenates a string rather than constructing a navigable tree, so nothing it builds can afterwards be queried or mutated",
+    "5": "concatenates a string rather than constructing a navigable tree, so nothing it builds can afterwards be queried or mutated"
   }
 }
diff --git a/docs/migration/bench/html-sanitizer.json b/docs/migration/bench/html-sanitizer.json
index d61d7e65..fe90be35 100644
--- a/docs/migration/bench/html-sanitizer.json
+++ b/docs/migration/bench/html-sanitizer.json
@@ -29,5 +29,5 @@
       0.12087625676310836
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/html-text.json b/docs/migration/bench/html-text.json
index b11b32cc..a2d110cd 100644
--- a/docs/migration/bench/html-text.json
+++ b/docs/migration/bench/html-text.json
@@ -39,5 +39,5 @@
       0.035766572600784
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/html2text.json b/docs/migration/bench/html2text.json
index 974c4c67..5ff5b851 100644
--- a/docs/migration/bench/html2text.json
+++ b/docs/migration/bench/html2text.json
@@ -59,5 +59,5 @@
       0.16195119580371894
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/html5-parser.json b/docs/migration/bench/html5-parser.json
index 93b6c437..75df6e96 100644
--- a/docs/migration/bench/html5-parser.json
+++ b/docs/migration/bench/html5-parser.json
@@ -79,5 +79,5 @@
       0.01906238222885146
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/html5lib.json b/docs/migration/bench/html5lib.json
index f0735c94..fe9714d1 100644
--- a/docs/migration/bench/html5lib.json
+++ b/docs/migration/bench/html5lib.json
@@ -299,5 +299,5 @@
       0.011445626925372463
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/htmldate.json b/docs/migration/bench/htmldate.json
index c40affb8..be07dfff 100644
--- a/docs/migration/bench/htmldate.json
+++ b/docs/migration/bench/htmldate.json
@@ -8,38 +8,40 @@
   "rows": [
     [
       "post (4 KiB)",
-      1.1735952601436376e-05,
-      2.6615594620693628e-05
+      5.9304065735214335e-06,
+      1.688457954903318e-05
     ],
     [
       "longform (16 KiB)",
-      1.7074957939418784e-05,
-      4.910956235685641e-05
+      1.030123477659591e-05,
+      3.404049680473994e-05
     ],
     [
       "100 meta candidates",
-      0.00013010201349554032,
-      7.602037720270498e-05
+      1.828077740384515e-05,
+      5.459096957357209e-05
     ]
   ],
   "spread": [
     [
       null,
-      0.04329384536759802,
-      0.033263737396463294
+      0.004697496985019512,
+      0.009112355406770883
     ],
     [
       null,
-      0.03092662857915166,
-      0.054986089231601934
+      0.007721833090606347,
+      0.016598368815392547
     ],
     [
       null,
-      0.03639475424630214,
-      0.0308781661300203
+      0.008026401759229225,
+      0.021206735172214816
     ]
   ],
-  "notes": {
-    "htmldate": "returns no date for the 100-candidate case, so its timing there is the cost of giving up rather than of finding the date turbohtml reports"
+  "row_notes": {
+    "0": "returns no date for the 100-candidate case, so its timing there is the cost of giving up rather than of finding the date turbohtml reports",
+    "1": "returns no date for the 100-candidate case, so its timing there is the cost of giving up rather than of finding the date turbohtml reports",
+    "2": "returns no date for the 100-candidate case, so its timing there is the cost of giving up rather than of finding the date turbohtml reports"
   }
 }
diff --git a/docs/migration/bench/htmlmin.json b/docs/migration/bench/htmlmin.json
index 518eb33a..60006cf1 100644
--- a/docs/migration/bench/htmlmin.json
+++ b/docs/migration/bench/htmlmin.json
@@ -68,5 +68,5 @@
       0.012759859238077997
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/htpy.json b/docs/migration/bench/htpy.json
index 46c3258b..0a1e404e 100644
--- a/docs/migration/bench/htpy.json
+++ b/docs/migration/bench/htpy.json
@@ -99,7 +99,12 @@
       0.008694864767394896
     ]
   ],
-  "notes": {
-    "htpy": "concatenates a string rather than constructing a navigable tree, so nothing it builds can afterwards be queried or mutated"
+  "row_notes": {
+    "0": "concatenates a string rather than constructing a navigable tree, so nothing it builds can afterwards be queried or mutated",
+    "1": "concatenates a string rather than constructing a navigable tree, so nothing it builds can afterwards be queried or mutated",
+    "2": "concatenates a string rather than constructing a navigable tree, so nothing it builds can afterwards be queried or mutated",
+    "3": "concatenates a string rather than constructing a navigable tree, so nothing it builds can afterwards be queried or mutated",
+    "4": "concatenates a string rather than constructing a navigable tree, so nothing it builds can afterwards be queried or mutated",
+    "5": "concatenates a string rather than constructing a navigable tree, so nothing it builds can afterwards be queried or mutated"
   }
 }
diff --git a/docs/migration/bench/hyperpython.json b/docs/migration/bench/hyperpython.json
index a746c2e4..f5d97a00 100644
--- a/docs/migration/bench/hyperpython.json
+++ b/docs/migration/bench/hyperpython.json
@@ -99,5 +99,5 @@
       0.019251615715996477
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/inscriptis.json b/docs/migration/bench/inscriptis.json
index 03fda4d2..cd933b07 100644
--- a/docs/migration/bench/inscriptis.json
+++ b/docs/migration/bench/inscriptis.json
@@ -39,5 +39,5 @@
       0.0437664506698881
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/jsmin.json b/docs/migration/bench/jsmin.json
index 724136df..d7725cad 100644
--- a/docs/migration/bench/jsmin.json
+++ b/docs/migration/bench/jsmin.json
@@ -68,7 +68,10 @@
       0.01459254660160529
     ]
   ],
-  "notes": {
-    "jsmin": "strips whitespace and comments without parsing the source, so it performs none of the renaming or structural compression the parsed minifiers do: on jQuery it emits 141.1 kB where turbohtml emits 87.8 kB"
+  "row_notes": {
+    "0": "strips whitespace and comments without parsing the source, so it performs none of the renaming or structural compression the parsed minifiers do: on jQuery it emits 141.1 kB where turbohtml emits 87.8 kB",
+    "1": "strips whitespace and comments without parsing the source, so it performs none of the renaming or structural compression the parsed minifiers do: on jQuery it emits 141.1 kB where turbohtml emits 87.8 kB",
+    "2": "strips whitespace and comments without parsing the source, so it performs none of the renaming or structural compression the parsed minifiers do: on jQuery it emits 141.1 kB where turbohtml emits 87.8 kB",
+    "3": "strips whitespace and comments without parsing the source, so it performs none of the renaming or structural compression the parsed minifiers do: on jQuery it emits 141.1 kB where turbohtml emits 87.8 kB"
   }
 }
diff --git a/docs/migration/bench/justext.json b/docs/migration/bench/justext.json
index 5905d45a..7d57b90d 100644
--- a/docs/migration/bench/justext.json
+++ b/docs/migration/bench/justext.json
@@ -39,5 +39,5 @@
       0.05705413454393241
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/lightningcss.json b/docs/migration/bench/lightningcss.json
index d242c8b1..d27932dd 100644
--- a/docs/migration/bench/lightningcss.json
+++ b/docs/migration/bench/lightningcss.json
@@ -12,75 +12,75 @@
     [
       "normalize.css (6 kB)",
       1750.0,
-      2.4677963665453717e-05,
+      3.2464727574677e-05,
       1751.0,
-      6.477255408772938e-05
+      7.805699825288077e-05
     ],
     [
       "pico.css (90 kB)",
       81155.0,
-      0.0008415556360432674,
+      0.0010817124017800477,
       79992.0,
-      0.002079070472670234
+      0.0022688593744533136
     ],
     [
       "animate.css (93 kB)",
       73788.0,
-      0.0009074143608813756,
+      0.0012892222758485634,
       68773.0,
-      0.0016668788516653876
+      0.0016953111445824713
     ],
     [
       "bootstrap.css (274 kB)",
       229554.0,
-      0.002807286729421321,
+      0.003730066627516256,
       228699.0,
-      0.006114484483987326
+      0.006715550674622743
     ],
     [
       "bulma.css (745 kB)",
       681425.0,
-      0.0070988878069329076,
+      0.008693945529860988,
       674333.0,
-      0.015533043417235604
+      0.01717652689573394
     ]
   ],
   "spread": [
     [
       null,
       null,
-      0.021180385365301226,
+      0.09728764011828976,
       null,
-      0.02905783106689442
+      0.12029726598732139
     ],
     [
       null,
       null,
-      0.05709012427212532,
+      0.10598940421080025,
       null,
-      0.03479701834134207
+      0.11557548323441176
     ],
     [
       null,
       null,
-      0.029687965981479846,
+      0.07158741875788914,
       null,
-      0.025156253322567327
+      0.04477117584138788
     ],
     [
       null,
       null,
-      0.023601218123909005,
+      0.10694045427657661,
       null,
-      0.03270786379047158
+      0.10864175208310488
     ],
     [
       null,
       null,
-      0.02956177866788225,
+      0.12618949595325846,
       null,
-      0.022578577927933375
+      0.11449298554009829
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/linkify-it-py.json b/docs/migration/bench/linkify-it-py.json
index 135fd41f..218188e1 100644
--- a/docs/migration/bench/linkify-it-py.json
+++ b/docs/migration/bench/linkify-it-py.json
@@ -8,46 +8,46 @@
   "rows": [
     [
       "find comment (1 link, 1 email)",
-      8.640649716099938e-07,
-      4.180944566201106e-05
+      7.194867801540994e-07,
+      4.504933335406728e-05
     ],
     [
       "find prose (1 KiB)",
-      1.14918323094552e-05,
-      0.00047429550526582415
+      9.341246917908089e-06,
+      0.0004767802053417351
     ],
     [
       "has_link comment",
-      3.2787860089940796e-07,
-      3.0382425125689377e-05
+      3.198661542302972e-07,
+      3.284947037703508e-05
     ],
     [
       "has_link prose (1 KiB)",
-      3.2681881587670603e-06,
-      6.782535560153254e-06
+      3.3264642806211477e-06,
+      9.183685302597647e-06
     ]
   ],
   "spread": [
     [
       null,
-      0.07667559493150078,
-      0.08598486268838779
+      0.0618758313713348,
+      0.03938719948399893
     ],
     [
       null,
-      0.059957129302934314,
-      0.03809032894512174
+      0.028533419404982167,
+      0.04244540017319504
     ],
     [
       null,
-      0.05860313007389166,
-      0.07780476576176569
+      0.033248584024003644,
+      0.10193610366200706
     ],
     [
       null,
-      0.049319246480825606,
-      0.10847816873948599
+      0.051427368974886416,
+      0.11944680145655517
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/lxml-html-clean.json b/docs/migration/bench/lxml-html-clean.json
index 4d9cad5c..5ca24201 100644
--- a/docs/migration/bench/lxml-html-clean.json
+++ b/docs/migration/bench/lxml-html-clean.json
@@ -18,18 +18,18 @@
     ],
     [
       "linkify HTML — comment (1 link, 1 email)",
-      3.781744958963884e-06,
-      9.69350645322701e-06
+      2.833639196916001e-06,
+      6.928771550581321e-06
     ],
     [
       "linkify HTML — prose (1 KiB)",
-      5.8999148810319944e-05,
-      3.3387339279045136e-05
+      4.209216648121128e-05,
+      2.2991062156307862e-05
     ],
     [
       "linkify HTML — markup (4 KiB)",
-      0.00015994283040754453,
-      0.0002128102349843175
+      0.00011087927229406584,
+      0.0001395619845349453
     ]
   ],
   "spread": [
@@ -45,21 +45,23 @@
     ],
     [
       null,
-      0.07086155915802331,
-      0.06710410389389247
+      0.011325012124501117,
+      0.1543128775631675
     ],
     [
       null,
-      0.03361607989819003,
-      0.049776091948529826
+      0.02196262985378034,
+      0.009715185602970897
     ],
     [
       null,
-      0.09089060583931145,
-      0.1153154111287691
+      0.01391027709579616,
+      0.011463713324468537
     ]
   ],
-  "notes": {
-    "lxml-html-clean": "links URLs inside existing markup and never linkifies email addresses; on the prose case it produces no links at all, so that timing is the cost of finding nothing"
+  "row_notes": {
+    "2": "links URLs inside existing markup and never linkifies email addresses; on the prose case it produces no links at all, so that timing is the cost of finding nothing",
+    "3": "links URLs inside existing markup and never linkifies email addresses; on the prose case it produces no links at all, so that timing is the cost of finding nothing",
+    "4": "links URLs inside existing markup and never linkifies email addresses; on the prose case it produces no links at all, so that timing is the cost of finding nothing"
   }
 }
diff --git a/docs/migration/bench/lxml.json b/docs/migration/bench/lxml.json
index 73107abc..a984a067 100644
--- a/docs/migration/bench/lxml.json
+++ b/docs/migration/bench/lxml.json
@@ -108,13 +108,13 @@
     ],
     [
       "validate a document against an XSD schema — catalog XSD + doc",
-      0.0012982356501349084,
-      0.0005059401457856438
+      0.0010764436301542446,
+      0.00047998421246120415
     ],
     [
       "validate a document against an XSD schema — 1,024 global declarations",
-      7.782762441547556e-07,
-      1.1341596712159212e-06
+      7.977661558763079e-07,
+      1.050973467364713e-06
     ],
     [
       "parse a fragment — table-row fragment (2 kB)",
@@ -423,63 +423,63 @@
     ],
     [
       "extract every link — daring fireball (10 kB)",
-      8.540413328243327e-06,
-      0.00014333100397342
+      1.3464031636563808e-05,
+      0.0003142650891921524
     ],
     [
       "extract every link — ars technica (56 kB)",
-      2.6025344868211658e-05,
-      0.0005540351831617348
+      4.56970487050512e-05,
+      0.0009934364973105403
     ],
     [
       "extract every link — mozilla blog (95 kB)",
-      4.8695574463408775e-05,
-      0.0011797156849600772
+      7.54788005347488e-05,
+      0.0019831697577501473
     ],
     [
       "extract every link — whatwg spec (235 kB)",
-      7.78339928473315e-05,
-      0.0038690176822152957
+      6.635500418402292e-05,
+      0.005672234596204362
     ],
     [
       "absolutize every link — daring fireball (10 kB)",
-      7.897827523587846e-05,
-      0.000250384097607063
+      3.9356466906781407e-05,
+      0.00026713285042963736
     ],
     [
       "absolutize every link — ars technica (56 kB)",
-      0.00020205170371430844,
-      0.0008300663818469426
+      9.180021663250197e-05,
+      0.0008682723103750808
     ],
     [
       "absolutize every link — mozilla blog (95 kB)",
-      0.00038564827292475456,
-      0.0017100880424247105
+      0.00015685727829387966,
+      0.0017832083479637124
     ],
     [
       "absolutize every link — whatwg spec (235 kB)",
-      0.0002516408542116248,
-      0.004560957929849489
+      0.00022430012273844113,
+      0.004874164802458836
     ],
     [
       "rewrite every link — daring fireball (10 kB)",
-      2.9012148117975776e-06,
-      0.00016380464004820774
+      2.996172853079552e-06,
+      0.00015877394261565314
     ],
     [
       "rewrite every link — ars technica (56 kB)",
-      1.0269556899681712e-05,
-      0.0005821447746635992
+      1.07103676191637e-05,
+      0.0006096830510765964
     ],
     [
       "rewrite every link — mozilla blog (95 kB)",
-      1.9159150432083532e-05,
-      0.0012378039816667297
+      1.986850784400455e-05,
+      0.0015380178776164637
     ],
     [
       "rewrite every link — whatwg spec (235 kB)",
-      3.324762803439777e-05,
-      0.004207888346172695
+      3.3264580665104404e-05,
+      0.0043626483299400816
     ],
     [
       "social-card extraction — head",
@@ -622,57 +622,57 @@
       0.009240193573229286
     ],
     [
-      "XPath feature surface (9.6 kB) — \\`\\`//div\\`\\`",
+      "XPath feature surface (9.6 kB) — ``//div``",
       2.3736853599724364e-06,
       1.6113240557539637e-05
     ],
     [
-      "XPath feature surface (9.6 kB) — \\`\\`//a[@href]\\`\\`",
+      "XPath feature surface (9.6 kB) — ``//a[@href]``",
       5.040668913380841e-07,
       5.463611704688749e-06
     ],
     [
-      "XPath feature surface (9.6 kB) — \\`\\`//div//a[@href]\\`\\`",
+      "XPath feature surface (9.6 kB) — ``//div//a[@href]``",
       2.1255928688290737e-06,
       1.3946604831005516e-05
     ],
     [
-      "XPath feature surface (9.6 kB) — \\`\\`/html/body/div\\`\\`",
+      "XPath feature surface (9.6 kB) — ``/html/body/div``",
       1.0570997409272327e-06,
       8.787026718692914e-06
     ],
     [
-      "XPath feature surface (9.6 kB) — \\`\\`//div//a[1]\\`\\`",
+      "XPath feature surface (9.6 kB) — ``//div//a[1]``",
       1.3267507367705397e-05,
       1.4027932903578252e-05
     ],
     [
-      "XPath feature surface (9.6 kB) — \\`\\`//a[contains(@href, '/')]\\`\\`",
+      "XPath feature surface (9.6 kB) — ``//a[contains(@href, '/')]``",
       4.957177105098983e-07,
       5.814983367713467e-06
     ],
     [
-      "XPath feature surface (9.6 kB) — \\`\\`//div[position() <= 3]\\`\\`",
+      "XPath feature surface (9.6 kB) — ``//div[position() <= 3]``",
       7.843027735413935e-06,
       1.910213848906513e-05
     ],
     [
-      "XPath feature surface (9.6 kB) — \\`\\`//a/ancestor::div\\`\\`",
+      "XPath feature surface (9.6 kB) — ``//a/ancestor::div``",
       5.287238756812584e-07,
       3.305691719764544e-06
     ],
     [
-      "XPath feature surface (9.6 kB) — \\`\\`//a \\| //span\\`\\`",
+      "XPath feature surface (9.6 kB) — ``//a | //span``",
       8.350158785900655e-07,
       4.410779320155693e-06
     ],
     [
-      "XPath feature surface (9.6 kB) — \\`\\`//\\*[local-name() = 'a']\\`\\`",
+      "XPath feature surface (9.6 kB) — ``//*[local-name() = 'a']``",
       6.361431324227358e-06,
       1.9792724193242368e-05
     ],
     [
-      "XPath feature surface (9.6 kB) — \\`\\`count(//a)\\`\\`",
+      "XPath feature surface (9.6 kB) — ``count(//a)``",
       5.315879322657461e-07,
       3.4405589680967332e-06
     ],
@@ -728,23 +728,23 @@
     ],
     [
       "extract filtered page links — daring fireball (10 kB)",
-      0.00019244289493750935,
-      0.00019721312124450682
+      0.00014374658196440274,
+      0.0001782515766611444
     ],
     [
       "extract filtered page links — ars technica (56 kB)",
-      0.00044414784745564856,
-      0.0007186282415053332
+      0.0003625916885994229,
+      0.0006590101314714047
     ],
     [
       "extract filtered page links — mozilla blog (95 kB)",
-      0.0007429536545942028,
-      0.0013903054759794031
+      0.0006187186553461288,
+      0.0012879373646986398
     ],
     [
       "extract filtered page links — whatwg spec (235 kB)",
-      0.0011912915304037597,
-      0.0026491308064275168
+      0.0010619639210744936,
+      0.002192290147074042
     ]
   ],
   "spread": [
@@ -850,13 +850,13 @@
     ],
     [
       null,
-      0.00646082226111806,
-      0.01409791312907743
+      0.005124643855452715,
+      0.010422734766308785
     ],
     [
       null,
-      0.00962811130364856,
-      0.047199648222947914
+      0.006338339618943664,
+      0.024057454276038753
     ],
     [
       null,
@@ -1165,63 +1165,63 @@
     ],
     [
       null,
-      0.007242716319812719,
-      0.010369854528747738
+      0.1905638942872358,
+      0.06410865945029473
     ],
     [
       null,
-      0.009166139408406725,
-      0.023762094377173783
+      0.13979209516180388,
+      0.15994702991516405
     ],
     [
       null,
-      0.014768482199177618,
-      0.02465577507151008
+      0.09227398650154403,
+      0.11060052253645324
     ],
     [
       null,
-      0.022917952283766932,
-      0.007954385763851199
+      0.04344184305052661,
+      0.028492143372953548
     ],
     [
       null,
-      0.007903863312063752,
-      0.011168518748499024
+      0.033531589420485355,
+      0.06037825177403394
     ],
     [
       null,
-      0.008416212374072259,
-      0.011320861995438535
+      0.009126761347801857,
+      0.01561318603994385
     ],
     [
       null,
-      0.007817411254915526,
-      0.007166528598781359
+      0.018904092332618992,
+      0.009489188340622848
     ],
     [
       null,
-      0.004943329428493678,
-      0.015439725544316302
+      0.012208253570299738,
+      0.021499411697625023
     ],
     [
       null,
-      0.010201463727222403,
-      0.12236105538400183
+      0.025611308465656468,
+      0.027426530099872986
     ],
     [
       null,
-      0.01609684234917494,
-      0.021519429819065447
+      0.012653954590904381,
+      0.04759523037029265
     ],
     [
       null,
-      0.020570331464049258,
-      0.01635702860576924
+      0.004280553044310928,
+      0.1957462990870172
     ],
     [
       null,
-      0.013042710419117346,
-      0.04823647361536105
+      0.01749493908665723,
+      0.03129440164383621
     ],
     [
       null,
@@ -1470,24 +1470,24 @@
     ],
     [
       null,
-      0.08681901513017418,
-      0.04488725193794102
+      0.016529254132972147,
+      0.03447410098169276
     ],
     [
       null,
-      0.0246925729997723,
-      0.05360533600629835
+      0.030487043860911212,
+      0.034279497415174796
     ],
     [
       null,
-      0.039027527214139324,
-      0.17998380661528665
+      0.06359342029387884,
+      0.03935445011673912
     ],
     [
       null,
-      0.04936646995438586,
-      0.15330362335285372
+      0.1209415112126743,
+      0.0443077820770914
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/markdownify.json b/docs/migration/bench/markdownify.json
index 1e7b52ec..ebf07972 100644
--- a/docs/migration/bench/markdownify.json
+++ b/docs/migration/bench/markdownify.json
@@ -49,5 +49,5 @@
       0.11239601430404433
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/markupsafe.json b/docs/migration/bench/markupsafe.json
index 79564afd..6a5b9d0c 100644
--- a/docs/migration/bench/markupsafe.json
+++ b/docs/migration/bench/markupsafe.json
@@ -99,5 +99,5 @@
       0.018830366328857713
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/markyp.json b/docs/migration/bench/markyp.json
index da9ce225..23b63053 100644
--- a/docs/migration/bench/markyp.json
+++ b/docs/migration/bench/markyp.json
@@ -99,7 +99,12 @@
       0.004369252534352652
     ]
   ],
-  "notes": {
-    "markyp": "concatenates a string rather than constructing a navigable tree, so nothing it builds can afterwards be queried or mutated"
+  "row_notes": {
+    "0": "concatenates a string rather than constructing a navigable tree, so nothing it builds can afterwards be queried or mutated",
+    "1": "concatenates a string rather than constructing a navigable tree, so nothing it builds can afterwards be queried or mutated",
+    "2": "concatenates a string rather than constructing a navigable tree, so nothing it builds can afterwards be queried or mutated",
+    "3": "concatenates a string rather than constructing a navigable tree, so nothing it builds can afterwards be queried or mutated",
+    "4": "concatenates a string rather than constructing a navigable tree, so nothing it builds can afterwards be queried or mutated",
+    "5": "concatenates a string rather than constructing a navigable tree, so nothing it builds can afterwards be queried or mutated"
   }
 }
diff --git a/docs/migration/bench/metadata_parser.json b/docs/migration/bench/metadata_parser.json
index 2870e63f..0957dae2 100644
--- a/docs/migration/bench/metadata_parser.json
+++ b/docs/migration/bench/metadata_parser.json
@@ -29,5 +29,5 @@
       0.0254309534022347
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/microdata.json b/docs/migration/bench/microdata.json
index 2ffed659..35f84904 100644
--- a/docs/migration/bench/microdata.json
+++ b/docs/migration/bench/microdata.json
@@ -29,5 +29,5 @@
       0.12540731424751708
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/minify-html.json b/docs/migration/bench/minify-html.json
index 3a17bf7e..5785bed7 100644
--- a/docs/migration/bench/minify-html.json
+++ b/docs/migration/bench/minify-html.json
@@ -68,5 +68,5 @@
       0.01800253451841663
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/news-please.json b/docs/migration/bench/news-please.json
index 815b0234..774c7a66 100644
--- a/docs/migration/bench/news-please.json
+++ b/docs/migration/bench/news-please.json
@@ -18,18 +18,18 @@
     ],
     [
       "publication-date extraction — post (4 KiB)",
-      1.1735952601436376e-05,
-      0.008319053811646882
+      5.9304065735214335e-06,
+      0.005928435221297453
     ],
     [
       "publication-date extraction — longform (16 KiB)",
-      1.7074957939418784e-05,
-      0.0226524487795056
+      1.030123477659591e-05,
+      0.01590911588452097
     ],
     [
       "publication-date extraction — 100 meta candidates",
-      0.00013010201349554032,
-      0.01212375239507916
+      1.828077740384515e-05,
+      0.00877185786581928
     ],
     [
       "main-content text — main (4 KiB)",
@@ -50,18 +50,18 @@
     ],
     [
       null,
-      0.04329384536759802,
-      0.058179691141717345
+      0.004697496985019512,
+      0.03489928844853301
     ],
     [
       null,
-      0.03092662857915166,
-      0.022472019979233922
+      0.007721833090606347,
+      0.020043951211199545
     ],
     [
       null,
-      0.03639475424630214,
-      0.04241792606111163
+      0.008026401759229225,
+      0.04277533338146369
     ],
     [
       null,
@@ -69,5 +69,5 @@
       0.034291817606264
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/newspaper3k.json b/docs/migration/bench/newspaper3k.json
index ea8b1cc7..a22b1ba7 100644
--- a/docs/migration/bench/newspaper3k.json
+++ b/docs/migration/bench/newspaper3k.json
@@ -18,18 +18,18 @@
     ],
     [
       "publication-date extraction — post (4 KiB)",
-      1.1735952601436376e-05,
-      0.003010062393210925
+      5.9304065735214335e-06,
+      0.002119573241998296
     ],
     [
       "publication-date extraction — longform (16 KiB)",
-      1.7074957939418784e-05,
-      0.008552690978831379
+      1.030123477659591e-05,
+      0.00614426996041099
     ],
     [
       "publication-date extraction — 100 meta candidates",
-      0.00013010201349554032,
-      0.003707961801713585
+      1.828077740384515e-05,
+      0.002589482204257365
     ],
     [
       "main-content text — main (4 KiB)",
@@ -50,18 +50,18 @@
     ],
     [
       null,
-      0.04329384536759802,
-      0.023286550889136903
+      0.004697496985019512,
+      0.025555266163807724
     ],
     [
       null,
-      0.03092662857915166,
-      0.028635270494106826
+      0.007721833090606347,
+      0.02156623309830427
     ],
     [
       null,
-      0.03639475424630214,
-      0.06898135336090556
+      0.008026401759229225,
+      0.013182086495236387
     ],
     [
       null,
@@ -69,5 +69,5 @@
       0.06384224146180023
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/nh3.json b/docs/migration/bench/nh3.json
index 4f12e647..b7786618 100644
--- a/docs/migration/bench/nh3.json
+++ b/docs/migration/bench/nh3.json
@@ -129,5 +129,5 @@
       0.07293692554531789
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/opengraph.json b/docs/migration/bench/opengraph.json
index be2bc559..64f37aae 100644
--- a/docs/migration/bench/opengraph.json
+++ b/docs/migration/bench/opengraph.json
@@ -29,5 +29,5 @@
       0.024326554863590765
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/pandas.json b/docs/migration/bench/pandas.json
index aee6ee9b..49f56701 100644
--- a/docs/migration/bench/pandas.json
+++ b/docs/migration/bench/pandas.json
@@ -69,5 +69,5 @@
       0.09468311152836278
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/parse5.json b/docs/migration/bench/parse5.json
index d634950a..b232f4e3 100644
--- a/docs/migration/bench/parse5.json
+++ b/docs/migration/bench/parse5.json
@@ -49,5 +49,5 @@
       0.0114561109118128
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/parsel.json b/docs/migration/bench/parsel.json
index cfa54b1c..26f6f324 100644
--- a/docs/migration/bench/parsel.json
+++ b/docs/migration/bench/parsel.json
@@ -163,23 +163,23 @@
     ],
     [
       "extract every link — daring fireball (10 kB)",
-      8.540413328243327e-06,
-      6.561983910557956e-05
+      1.3464031636563808e-05,
+      9.973011774870126e-05
     ],
     [
       "extract every link — ars technica (56 kB)",
-      2.6025344868211658e-05,
-      0.00014437131739934253
+      4.56970487050512e-05,
+      0.00021189110598622088
     ],
     [
       "extract every link — mozilla blog (95 kB)",
-      4.8695574463408775e-05,
-      0.00020872188315479434
+      7.54788005347488e-05,
+      0.0003283788316821301
     ],
     [
       "extract every link — whatwg spec (235 kB)",
-      7.78339928473315e-05,
-      0.0002640740081195266
+      6.635500418402292e-05,
+      0.0004924321832125619
     ],
     [
       "extract @href per match — daring fireball (10 kB)",
@@ -277,57 +277,57 @@
       2.3763821066798602e-05
     ],
     [
-      "XPath feature surface (9.6 kB) — \\`\\`//div\\`\\`",
+      "XPath feature surface (9.6 kB) — ``//div``",
       2.3736853599724364e-06,
       5.03802142712099e-05
     ],
     [
-      "XPath feature surface (9.6 kB) — \\`\\`//a[@href]\\`\\`",
+      "XPath feature surface (9.6 kB) — ``//a[@href]``",
       5.040668913380841e-07,
       8.142563511744546e-06
     ],
     [
-      "XPath feature surface (9.6 kB) — \\`\\`//div//a[@href]\\`\\`",
+      "XPath feature surface (9.6 kB) — ``//div//a[@href]``",
       2.1255928688290737e-06,
       1.682133992630952e-05
     ],
     [
-      "XPath feature surface (9.6 kB) — \\`\\`/html/body/div\\`\\`",
+      "XPath feature surface (9.6 kB) — ``/html/body/div``",
       1.0570997409272327e-06,
       2.60793461184979e-05
     ],
     [
-      "XPath feature surface (9.6 kB) — \\`\\`//div//a[1]\\`\\`",
+      "XPath feature surface (9.6 kB) — ``//div//a[1]``",
       1.3267507367705397e-05,
       1.6693899355620562e-05
     ],
     [
-      "XPath feature surface (9.6 kB) — \\`\\`//a[contains(@href, '/')]\\`\\`",
+      "XPath feature surface (9.6 kB) — ``//a[contains(@href, '/')]``",
       4.957177105098983e-07,
       8.489359324552007e-06
     ],
     [
-      "XPath feature surface (9.6 kB) — \\`\\`//div[position() <= 3]\\`\\`",
+      "XPath feature surface (9.6 kB) — ``//div[position() <= 3]``",
       7.843027735413935e-06,
       4.06000832503158e-05
     ],
     [
-      "XPath feature surface (9.6 kB) — \\`\\`//a/ancestor::div\\`\\`",
+      "XPath feature surface (9.6 kB) — ``//a/ancestor::div``",
       5.287238756812584e-07,
       5.880235143251866e-06
     ],
     [
-      "XPath feature surface (9.6 kB) — \\`\\`//a \\| //span\\`\\`",
+      "XPath feature surface (9.6 kB) — ``//a | //span``",
       8.350158785900655e-07,
       6.922895863681333e-06
     ],
     [
-      "XPath feature surface (9.6 kB) — \\`\\`//\\*[local-name() = 'a']\\`\\`",
+      "XPath feature surface (9.6 kB) — ``//*[local-name() = 'a']``",
       6.361431324227358e-06,
       2.2847661753644388e-05
     ],
     [
-      "XPath feature surface (9.6 kB) — \\`\\`count(//a)\\`\\`",
+      "XPath feature surface (9.6 kB) — ``count(//a)``",
       5.315879322657461e-07,
       7.570608128541305e-06
     ],
@@ -378,23 +378,23 @@
     ],
     [
       "extract filtered page links — daring fireball (10 kB)",
-      0.00019244289493750935,
-      0.000488335463084392
+      0.00014374658196440274,
+      0.00031386787206126127
     ],
     [
       "extract filtered page links — ars technica (56 kB)",
-      0.00044414784745564856,
-      0.001623948243529109
+      0.0003625916885994229,
+      0.0009077950169663987
     ],
     [
       "extract filtered page links — mozilla blog (95 kB)",
-      0.0007429536545942028,
-      0.001837482583293119
+      0.0006187186553461288,
+      0.0015391715760415536
     ],
     [
       "extract filtered page links — whatwg spec (235 kB)",
-      0.0011912915304037597,
-      0.0029560183917662166
+      0.0010619639210744936,
+      0.0024546149131007646
     ]
   ],
   "spread": [
@@ -555,23 +555,23 @@
     ],
     [
       null,
-      0.007242716319812719,
-      0.012627035478506262
+      0.1905638942872358,
+      0.05908721604046851
     ],
     [
       null,
-      0.009166139408406725,
-      0.011709054446375005
+      0.13979209516180388,
+      0.05260820873932838
     ],
     [
       null,
-      0.014768482199177618,
-      0.01509937603236634
+      0.09227398650154403,
+      0.15167755894071033
     ],
     [
       null,
-      0.022917952283766932,
-      0.0103005754478309
+      0.04344184305052661,
+      0.06490956049840732
     ],
     [
       null,
@@ -770,24 +770,24 @@
     ],
     [
       null,
-      0.08681901513017418,
-      0.16714035155438928
+      0.016529254132972147,
+      0.1747140577921019
     ],
     [
       null,
-      0.0246925729997723,
-      0.2701872344537394
+      0.030487043860911212,
+      0.08997365611435819
     ],
     [
       null,
-      0.039027527214139324,
-      0.11281040625913531
+      0.06359342029387884,
+      0.07830637881531415
     ],
     [
       null,
-      0.04936646995438586,
-      0.02801464412122382
+      0.1209415112126743,
+      0.02974163487052947
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/pyquery.json b/docs/migration/bench/pyquery.json
index d8619a78..d7d29cec 100644
--- a/docs/migration/bench/pyquery.json
+++ b/docs/migration/bench/pyquery.json
@@ -323,63 +323,63 @@
     ],
     [
       "extract every link — daring fireball (10 kB)",
-      8.540413328243327e-06,
-      0.00016360655047265027
+      1.3464031636563808e-05,
+      0.0003138677027815599
     ],
     [
       "extract every link — ars technica (56 kB)",
-      2.6025344868211658e-05,
-      0.0003849035105645271
+      4.56970487050512e-05,
+      0.000759260253857974
     ],
     [
       "extract every link — mozilla blog (95 kB)",
-      4.8695574463408775e-05,
-      0.0005297147486468626
+      7.54788005347488e-05,
+      0.0009935191236157455
     ],
     [
       "extract every link — whatwg spec (235 kB)",
-      7.78339928473315e-05,
-      0.0006312846954112198
+      6.635500418402292e-05,
+      0.0009501940104807242
     ],
     [
       "absolutize every link — daring fireball (10 kB)",
-      7.897827523587846e-05,
-      0.00038412135465174896
+      3.9356466906781407e-05,
+      0.00040999616032877384
     ],
     [
       "absolutize every link — ars technica (56 kB)",
-      0.00020205170371430844,
-      0.0009304267897126314
+      9.180021663250197e-05,
+      0.0009889522232242598
     ],
     [
       "absolutize every link — mozilla blog (95 kB)",
-      0.00038564827292475456,
-      0.001365599822065633
+      0.00015685727829387966,
+      0.0014447408797574706
     ],
     [
       "absolutize every link — whatwg spec (235 kB)",
-      0.0002516408542116248,
-      0.001670862858190958
+      0.00022430012273844113,
+      0.0018399412986885484
     ],
     [
       "rewrite every link — daring fireball (10 kB)",
-      2.9012148117975776e-06,
-      0.00031565070213446234
+      2.996172853079552e-06,
+      0.000377997809456095
     ],
     [
       "rewrite every link — ars technica (56 kB)",
-      1.0269556899681712e-05,
-      0.0007010560300007759
+      1.07103676191637e-05,
+      0.0007505117190855041
     ],
     [
       "rewrite every link — mozilla blog (95 kB)",
-      1.9159150432083532e-05,
-      0.0009803983301329329
+      1.986850784400455e-05,
+      0.0010356462663973314
     ],
     [
       "rewrite every link — whatwg spec (235 kB)",
-      3.324762803439777e-05,
-      0.00117126177284869
+      3.3264580665104404e-05,
+      0.0012034119750599832
     ],
     [
       "social-card extraction — head",
@@ -443,23 +443,23 @@
     ],
     [
       "extract filtered page links — daring fireball (10 kB)",
-      0.00019244289493750935,
-      0.0005061203476846762
+      0.00014374658196440274,
+      0.000519150458671902
     ],
     [
       "extract filtered page links — ars technica (56 kB)",
-      0.00044414784745564856,
-      0.001544980251992456
+      0.0003625916885994229,
+      0.0013566567936322826
     ],
     [
       "extract filtered page links — mozilla blog (95 kB)",
-      0.0007429536545942028,
-      0.0025982647539422032
+      0.0006187186553461288,
+      0.002153627226713676
     ],
     [
       "extract filtered page links — whatwg spec (235 kB)",
-      0.0011912915304037597,
-      0.005002468530619808
+      0.0010619639210744936,
+      0.003185567546703775
     ]
   ],
   "spread": [
@@ -780,63 +780,63 @@
     ],
     [
       null,
-      0.007242716319812719,
-      0.01772626344351562
+      0.1905638942872358,
+      0.09626079076033368
     ],
     [
       null,
-      0.009166139408406725,
-      0.013334857731245094
+      0.13979209516180388,
+      0.10844328620105656
     ],
     [
       null,
-      0.014768482199177618,
-      0.01936229950139161
+      0.09227398650154403,
+      0.0994675158765982
     ],
     [
       null,
-      0.022917952283766932,
-      0.009477237356627631
+      0.04344184305052661,
+      0.04952645743644296
     ],
     [
       null,
-      0.007903863312063752,
-      0.021407393605724665
+      0.033531589420485355,
+      0.05293479393063974
     ],
     [
       null,
-      0.008416212374072259,
-      0.02602873694670547
+      0.009126761347801857,
+      0.03240088513209726
     ],
     [
       null,
-      0.007817411254915526,
-      0.021365815957723074
+      0.018904092332618992,
+      0.02683016582508581
     ],
     [
       null,
-      0.004943329428493678,
-      0.03968631110153472
+      0.012208253570299738,
+      0.046222957523014585
     ],
     [
       null,
-      0.010201463727222403,
-      0.05625420494982334
+      0.025611308465656468,
+      0.24629390122961012
     ],
     [
       null,
-      0.01609684234917494,
-      0.019177383357006687
+      0.012653954590904381,
+      0.05540787554018989
     ],
     [
       null,
-      0.020570331464049258,
-      0.02058753440810391
+      0.004280553044310928,
+      0.05034219665700394
     ],
     [
       null,
-      0.013042710419117346,
-      0.06098590259526779
+      0.01749493908665723,
+      0.031074925454776758
     ],
     [
       null,
@@ -900,24 +900,24 @@
     ],
     [
       null,
-      0.08681901513017418,
-      0.08937633737215606
+      0.016529254132972147,
+      0.1548508345091371
     ],
     [
       null,
-      0.0246925729997723,
-      0.045770404845422295
+      0.030487043860911212,
+      0.10023359791906923
     ],
     [
       null,
-      0.039027527214139324,
-      0.11107236330616468
+      0.06359342029387884,
+      0.05121286092087061
     ],
     [
       null,
-      0.04936646995438586,
-      0.2631809071714095
+      0.1209415112126743,
+      0.037910575804407244
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/rcssmin.json b/docs/migration/bench/rcssmin.json
index 8237fb6e..1e8c143b 100644
--- a/docs/migration/bench/rcssmin.json
+++ b/docs/migration/bench/rcssmin.json
@@ -12,91 +12,96 @@
     [
       "normalize.css (6 kB)",
       1750.0,
-      2.4677963665453717e-05,
+      3.2464727574677e-05,
       1775.0,
-      6.877973989460884e-06
+      7.227439025925264e-06
     ],
     [
       "pico.css (90 kB)",
       81155.0,
-      0.0008415556360432674,
+      0.0010817124017800477,
       82078.0,
-      0.00026292298050141955
+      0.0002621144950959812
     ],
     [
       "animate.css (93 kB)",
       73788.0,
-      0.0009074143608813756,
+      0.0012892222758485634,
       75682.0,
-      0.0002218701103515741
+      0.00022064549447501727
     ],
     [
       "foundation.css (164 kB)",
       132898.0,
-      0.0020137969298351286,
+      0.0028156564673433118,
       136682.0,
-      0.0004910595569450985
+      0.00048533412052620406
     ],
     [
       "bootstrap.css (274 kB)",
       229554.0,
-      0.002807286729421321,
+      0.003730066627516256,
       233172.0,
-      0.000885669812305423
+      0.0008058121210675987
     ],
     [
       "bulma.css (745 kB)",
       681425.0,
-      0.0070988878069329076,
+      0.008693945529860988,
       679974.0,
-      0.0022972218422789106
+      0.0023041306975149687
     ]
   ],
   "spread": [
     [
       null,
       null,
-      0.021180385365301226,
+      0.09728764011828976,
       null,
-      0.026855005115815223
+      0.07105855210195146
     ],
     [
       null,
       null,
-      0.05709012427212532,
+      0.10598940421080025,
       null,
-      0.018144959164507132
+      0.022144839124433217
     ],
     [
       null,
       null,
-      0.029687965981479846,
+      0.07158741875788914,
       null,
-      0.025806845986799082
+      0.018206653247167335
     ],
     [
       null,
       null,
-      0.06837573110647958,
+      0.07838358803696824,
       null,
-      0.02766298223470719
+      0.021725472885592095
     ],
     [
       null,
       null,
-      0.023601218123909005,
+      0.10694045427657661,
       null,
-      0.1172214619078148
+      0.06589567367731815
     ],
     [
       null,
       null,
-      0.02956177866788225,
+      0.12618949595325846,
       null,
-      0.029345195540840696
+      0.03676125016636636
     ]
   ],
-  "notes": {
-    "rcssmin": "strips whitespace and comments only, leaving #ffffff, 0px 0px 0px 0px and font-weight:bold unshortened where turbohtml writes #fff, 0 and 700"
+  "row_notes": {
+    "0": "strips whitespace and comments without parsing, so it applies none of the color, number, and shorthand rewrites turbohtml does; on these stylesheets that leaves its output within 1.01-1.03x of turbohtml's, and 0.998x on bulma, so the structural shortenings change little on already-tight framework CSS",
+    "1": "strips whitespace and comments without parsing, so it applies none of the color, number, and shorthand rewrites turbohtml does; on these stylesheets that leaves its output within 1.01-1.03x of turbohtml's, and 0.998x on bulma, so the structural shortenings change little on already-tight framework CSS",
+    "2": "strips whitespace and comments without parsing, so it applies none of the color, number, and shorthand rewrites turbohtml does; on these stylesheets that leaves its output within 1.01-1.03x of turbohtml's, and 0.998x on bulma, so the structural shortenings change little on already-tight framework CSS",
+    "3": "strips whitespace and comments without parsing, so it applies none of the color, number, and shorthand rewrites turbohtml does; on these stylesheets that leaves its output within 1.01-1.03x of turbohtml's, and 0.998x on bulma, so the structural shortenings change little on already-tight framework CSS",
+    "4": "strips whitespace and comments without parsing, so it applies none of the color, number, and shorthand rewrites turbohtml does; on these stylesheets that leaves its output within 1.01-1.03x of turbohtml's, and 0.998x on bulma, so the structural shortenings change little on already-tight framework CSS",
+    "5": "strips whitespace and comments without parsing, so it applies none of the color, number, and shorthand rewrites turbohtml does; on these stylesheets that leaves its output within 1.01-1.03x of turbohtml's, and 0.998x on bulma, so the structural shortenings change little on already-tight framework CSS"
   }
 }
diff --git a/docs/migration/bench/readabilipy.json b/docs/migration/bench/readabilipy.json
index b76bfcaf..6a1016d1 100644
--- a/docs/migration/bench/readabilipy.json
+++ b/docs/migration/bench/readabilipy.json
@@ -29,5 +29,5 @@
       0.2572053059847665
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/readability-lxml.json b/docs/migration/bench/readability-lxml.json
index c61fd75e..f873584e 100644
--- a/docs/migration/bench/readability-lxml.json
+++ b/docs/migration/bench/readability-lxml.json
@@ -29,5 +29,5 @@
       0.09458795749284374
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/resiliparse.json b/docs/migration/bench/resiliparse.json
index 0173969e..c2496186 100644
--- a/docs/migration/bench/resiliparse.json
+++ b/docs/migration/bench/resiliparse.json
@@ -223,63 +223,63 @@
     ],
     [
       "extract every link — daring fireball (10 kB)",
-      8.540413328243327e-06,
-      4.940687075164855e-06
+      1.3464031636563808e-05,
+      9.217930897402008e-06
     ],
     [
       "extract every link — ars technica (56 kB)",
-      2.6025344868211658e-05,
-      1.5787857462849313e-05
+      4.56970487050512e-05,
+      3.0278296154762074e-05
     ],
     [
       "extract every link — mozilla blog (95 kB)",
-      4.8695574463408775e-05,
-      2.6800711765417873e-05
+      7.54788005347488e-05,
+      5.544195894439478e-05
     ],
     [
       "extract every link — whatwg spec (235 kB)",
-      7.78339928473315e-05,
-      5.1771214761705174e-05
+      6.635500418402292e-05,
+      0.00011188485726165709
     ],
     [
       "absolutize every link — daring fireball (10 kB)",
-      7.897827523587846e-05,
-      6.171742408866976e-05
+      3.9356466906781407e-05,
+      6.321872400860684e-05
     ],
     [
       "absolutize every link — ars technica (56 kB)",
-      0.00020205170371430844,
-      0.0001539198813039396
+      9.180021663250197e-05,
+      0.0001591197206967839
     ],
     [
       "absolutize every link — mozilla blog (95 kB)",
-      0.00038564827292475456,
-      0.00022994135863048845
+      0.00015685727829387966,
+      0.00023703871545421862
     ],
     [
       "absolutize every link — whatwg spec (235 kB)",
-      0.0002516408542116248,
-      0.0002454043833305756
+      0.00022430012273844113,
+      0.0002569203213814338
     ],
     [
       "rewrite every link — daring fireball (10 kB)",
-      2.9012148117975776e-06,
-      6.868505702565623e-06
+      2.996172853079552e-06,
+      6.781967589593781e-06
     ],
     [
       "rewrite every link — ars technica (56 kB)",
-      1.0269556899681712e-05,
-      2.8764750588550214e-05
+      1.07103676191637e-05,
+      2.0788973480752777e-05
     ],
     [
       "rewrite every link — mozilla blog (95 kB)",
-      1.9159150432083532e-05,
-      4.462856290861813e-05
+      1.986850784400455e-05,
+      3.3864474813090815e-05
     ],
     [
       "rewrite every link — whatwg spec (235 kB)",
-      3.324762803439777e-05,
-      8.501805953642361e-05
+      3.3264580665104404e-05,
+      6.291491365573165e-05
     ],
     [
       "social-card extraction — head",
@@ -358,33 +358,33 @@
     ],
     [
       "detect a byte stream's encoding — ascii (1 kB)",
-      2.683881651736423e-06,
-      1.379581478166969e-06
+      1.1417041620257844e-06,
+      1.029075331541544e-06
     ],
     [
       "detect a byte stream's encoding — utf-8 russian (4 kB)",
-      8.42264663110844e-06,
-      4.134158238855434e-06
+      5.395650118404187e-06,
+      3.0797061919921966e-06
     ],
     [
       "detect a byte stream's encoding — windows-1251 russian (4 kB)",
-      0.00023194885286178155,
-      0.0004300928825008062
+      0.00017615521230140985,
+      0.00035062181920390384
     ],
     [
       "detect a byte stream's encoding — windows-1252 french (4 kB)",
-      0.00022984596078382916,
-      0.0004874247093008914
+      0.00017919206403386548,
+      0.0003832794663291376
     ],
     [
       "detect a byte stream's encoding — shift_jis japanese (4 kB)",
-      0.00010243962940137408,
-      4.1679475524839894e-05
+      8.727693684799458e-05,
+      3.797536552241354e-05
     ],
     [
       "detect a byte stream's encoding — utf-8 page (95 kB)",
-      1.0262474480586075e-06,
-      7.612719218741404e-05
+      9.080427233835545e-07,
+      6.985357494215805e-05
     ]
   ],
   "spread": [
@@ -605,63 +605,63 @@
     ],
     [
       null,
-      0.007242716319812719,
-      0.006520162247562928
+      0.1905638942872358,
+      0.0909416989953497
     ],
     [
       null,
-      0.009166139408406725,
-      0.014321374691221661
+      0.13979209516180388,
+      0.056583749631377044
     ],
     [
       null,
-      0.014768482199177618,
-      0.025897374770069242
+      0.09227398650154403,
+      0.15721457116372592
     ],
     [
       null,
-      0.022917952283766932,
-      0.015177916807503744
+      0.04344184305052661,
+      0.16176136051599438
     ],
     [
       null,
-      0.007903863312063752,
-      0.006656947080682276
+      0.033531589420485355,
+      0.01444574611302369
     ],
     [
       null,
-      0.008416212374072259,
-      0.011528585462947888
+      0.009126761347801857,
+      0.013455508700929193
     ],
     [
       null,
-      0.007817411254915526,
-      0.012502247588426139
+      0.018904092332618992,
+      0.014220798955373341
     ],
     [
       null,
-      0.004943329428493678,
-      0.006164063549205968
+      0.012208253570299738,
+      0.024146840663983656
     ],
     [
       null,
-      0.010201463727222403,
-      0.022898679174978225
+      0.025611308465656468,
+      0.01749473297617237
     ],
     [
       null,
-      0.01609684234917494,
-      0.052164122173223595
+      0.012653954590904381,
+      0.04563892482693914
     ],
     [
       null,
-      0.020570331464049258,
-      0.15837575088354486
+      0.004280553044310928,
+      0.03608952637075124
     ],
     [
       null,
-      0.013042710419117346,
-      0.11855757337902133
+      0.01749493908665723,
+      0.02347315070153482
     ],
     [
       null,
@@ -740,36 +740,43 @@
     ],
     [
       null,
-      0.017880736659094357,
-      0.01669212179717228
+      0.009158479913916974,
+      0.007167867015191341
     ],
     [
       null,
-      0.013928849417596853,
-      0.02525687093898264
+      0.0038712062652642206,
+      0.0062008850358656635
     ],
     [
       null,
-      0.030374690128129544,
-      0.049845411634993224
+      0.004080075123940598,
+      0.021001531511425205
     ],
     [
       null,
-      0.024415342494636606,
-      0.06204167242122492
+      0.059916699660372115,
+      0.01910706894477701
     ],
     [
       null,
-      0.011882884549205048,
-      0.017271426636053563
+      0.09053675269683122,
+      0.21023172288412514
     ],
     [
       null,
-      0.027875914121933836,
-      0.016350123964366924
+      0.09984062000003383,
+      0.12703643729605826
     ]
   ],
-  "notes": {
-    "resiliparse": "reports about 11% fewer elements than every other parser here (876 against 989 on the mozilla page), so it collects text from a smaller tree"
+  "row_notes": {
+    "19": "reports about 11% fewer elements than every other parser here (876 against 989 on the mozilla page), so it collects text from a smaller tree",
+    "20": "reports about 11% fewer elements than every other parser here (876 against 989 on the mozilla page), so it collects text from a smaller tree",
+    "21": "reports about 11% fewer elements than every other parser here (876 against 989 on the mozilla page), so it collects text from a smaller tree",
+    "22": "reports about 11% fewer elements than every other parser here (876 against 989 on the mozilla page), so it collects text from a smaller tree",
+    "39": "reports about 11% fewer elements than every other parser here (876 against 989 on the mozilla page), so it collects text from a smaller tree",
+    "40": "reports about 11% fewer elements than every other parser here (876 against 989 on the mozilla page), so it collects text from a smaller tree",
+    "41": "reports about 11% fewer elements than every other parser here (876 against 989 on the mozilla page), so it collects text from a smaller tree",
+    "42": "reports about 11% fewer elements than every other parser here (876 against 989 on the mozilla page), so it collects text from a smaller tree"
   }
 }
diff --git a/docs/migration/bench/rjsmin.json b/docs/migration/bench/rjsmin.json
index d9619a79..a1785143 100644
--- a/docs/migration/bench/rjsmin.json
+++ b/docs/migration/bench/rjsmin.json
@@ -68,7 +68,10 @@
       0.015807151526946495
     ]
   ],
-  "notes": {
-    "rjsmin": "strips whitespace and comments without parsing the source, so it performs none of the renaming or structural compression the parsed minifiers do: on jQuery it emits 141.1 kB where turbohtml emits 87.8 kB"
+  "row_notes": {
+    "0": "strips whitespace and comments without parsing the source, so it performs none of the renaming or structural compression the parsed minifiers do: on jQuery it emits 141.1 kB where turbohtml emits 87.8 kB",
+    "1": "strips whitespace and comments without parsing the source, so it performs none of the renaming or structural compression the parsed minifiers do: on jQuery it emits 141.1 kB where turbohtml emits 87.8 kB",
+    "2": "strips whitespace and comments without parsing the source, so it performs none of the renaming or structural compression the parsed minifiers do: on jQuery it emits 141.1 kB where turbohtml emits 87.8 kB",
+    "3": "strips whitespace and comments without parsing the source, so it performs none of the renaming or structural compression the parsed minifiers do: on jQuery it emits 141.1 kB where turbohtml emits 87.8 kB"
   }
 }
diff --git a/docs/migration/bench/sanitize-html.json b/docs/migration/bench/sanitize-html.json
index a92f9978..d916e9b2 100644
--- a/docs/migration/bench/sanitize-html.json
+++ b/docs/migration/bench/sanitize-html.json
@@ -19,5 +19,5 @@
       0.11172668998026558
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/selectolax.json b/docs/migration/bench/selectolax.json
index 5a1d3f17..8de73498 100644
--- a/docs/migration/bench/selectolax.json
+++ b/docs/migration/bench/selectolax.json
@@ -263,63 +263,63 @@
     ],
     [
       "extract every link — daring fireball (10 kB)",
-      8.540413328243327e-06,
-      1.3445289171206317e-05
+      1.3464031636563808e-05,
+      2.158080079084357e-05
     ],
     [
       "extract every link — ars technica (56 kB)",
-      2.6025344868211658e-05,
-      4.660196942059732e-05
+      4.56970487050512e-05,
+      7.016041224024623e-05
     ],
     [
       "extract every link — mozilla blog (95 kB)",
-      4.8695574463408775e-05,
-      7.235715739284387e-05
+      7.54788005347488e-05,
+      0.00011029813313712111
     ],
     [
       "extract every link — whatwg spec (235 kB)",
-      7.78339928473315e-05,
-      0.00010719847622908674
+      6.635500418402292e-05,
+      0.00017877139274939205
     ],
     [
       "absolutize every link — daring fireball (10 kB)",
-      7.897827523587846e-05,
-      7.739290134622934e-05
+      3.9356466906781407e-05,
+      7.794494342761027e-05
     ],
     [
       "absolutize every link — ars technica (56 kB)",
-      0.00020205170371430844,
-      0.00019101100989852662
+      9.180021663250197e-05,
+      0.00020195030824273394
     ],
     [
       "absolutize every link — mozilla blog (95 kB)",
-      0.00038564827292475456,
-      0.0002855855775199719
+      0.00015685727829387966,
+      0.0002975679419705557
     ],
     [
       "absolutize every link — whatwg spec (235 kB)",
-      0.0002516408542116248,
-      0.000329380882969114
+      0.00022430012273844113,
+      0.00034682959583657674
     ],
     [
       "rewrite every link — daring fireball (10 kB)",
-      2.9012148117975776e-06,
-      3.0170525394150143e-05
+      2.996172853079552e-06,
+      2.5443278827215938e-05
     ],
     [
       "rewrite every link — ars technica (56 kB)",
-      1.0269556899681712e-05,
-      7.275252779000614e-05
+      1.07103676191637e-05,
+      6.889208313509698e-05
     ],
     [
       "rewrite every link — mozilla blog (95 kB)",
-      1.9159150432083532e-05,
-      0.00011860925278028844
+      1.986850784400455e-05,
+      9.120389460785343e-05
     ],
     [
       "rewrite every link — whatwg spec (235 kB)",
-      3.324762803439777e-05,
-      0.00020120629204711804
+      3.3264580665104404e-05,
+      0.00014887399307402424
     ],
     [
       "social-card extraction — head",
@@ -383,23 +383,23 @@
     ],
     [
       "extract filtered page links — daring fireball (10 kB)",
-      0.00019244289493750935,
-      0.00038065648076705355
+      0.00014374658196440274,
+      0.00022196778021073746
     ],
     [
       "extract filtered page links — ars technica (56 kB)",
-      0.00044414784745564856,
-      0.0014216306973745911
+      0.0003625916885994229,
+      0.0007716973326902613
     ],
     [
       "extract filtered page links — mozilla blog (95 kB)",
-      0.0007429536545942028,
-      0.0030353482511600305
+      0.0006187186553461288,
+      0.002120180878894947
     ],
     [
       "extract filtered page links — whatwg spec (235 kB)",
-      0.0011912915304037597,
-      0.004674338865394627
+      0.0010619639210744936,
+      0.003025346355570946
     ]
   ],
   "spread": [
@@ -660,63 +660,63 @@
     ],
     [
       null,
-      0.007242716319812719,
-      0.01634958110066657
+      0.1905638942872358,
+      0.09917425590704307
     ],
     [
       null,
-      0.009166139408406725,
-      0.012827710105623906
+      0.13979209516180388,
+      0.10048894632853245
     ],
     [
       null,
-      0.014768482199177618,
-      0.011186973314843278
+      0.09227398650154403,
+      0.1141461853260426
     ],
     [
       null,
-      0.022917952283766932,
-      0.027481283435293748
+      0.04344184305052661,
+      0.2509424430049855
     ],
     [
       null,
-      0.007903863312063752,
-      0.011522194117990854
+      0.033531589420485355,
+      0.01255406380524888
     ],
     [
       null,
-      0.008416212374072259,
-      0.006757544346601625
+      0.009126761347801857,
+      0.017830661159506885
     ],
     [
       null,
-      0.007817411254915526,
-      0.006927772624274505
+      0.018904092332618992,
+      0.04909279135012377
     ],
     [
       null,
-      0.004943329428493678,
-      0.002263677275762299
+      0.012208253570299738,
+      0.03191584179688344
     ],
     [
       null,
-      0.010201463727222403,
-      0.08858303598727786
+      0.025611308465656468,
+      0.16459705665378513
     ],
     [
       null,
-      0.01609684234917494,
-      0.11822096596853024
+      0.012653954590904381,
+      0.3423383136610574
     ],
     [
       null,
-      0.020570331464049258,
-      0.07787966013169513
+      0.004280553044310928,
+      0.027443453926115163
     ],
     [
       null,
-      0.013042710419117346,
-      0.06347518140035155
+      0.01749493908665723,
+      0.01986339625402406
     ],
     [
       null,
@@ -780,24 +780,24 @@
     ],
     [
       null,
-      0.08681901513017418,
-      0.17030466917906792
+      0.016529254132972147,
+      0.16077568061287117
     ],
     [
       null,
-      0.0246925729997723,
-      0.08557130079910938
+      0.030487043860911212,
+      0.08754994332451231
     ],
     [
       null,
-      0.039027527214139324,
-      0.15053014588465377
+      0.06359342029387884,
+      0.07848986100113335
     ],
     [
       null,
-      0.04936646995438586,
-      0.16291120403068735
+      0.1209415112126743,
+      0.05793325990372666
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/simple-html.json b/docs/migration/bench/simple-html.json
index 0ff43e5c..573125c6 100644
--- a/docs/migration/bench/simple-html.json
+++ b/docs/migration/bench/simple-html.json
@@ -99,7 +99,12 @@
       0.2111296673575497
     ]
   ],
-  "notes": {
-    "simple-html": "concatenates a string rather than constructing a navigable tree, so nothing it builds can afterwards be queried or mutated"
+  "row_notes": {
+    "0": "concatenates a string rather than constructing a navigable tree, so nothing it builds can afterwards be queried or mutated",
+    "1": "concatenates a string rather than constructing a navigable tree, so nothing it builds can afterwards be queried or mutated",
+    "2": "concatenates a string rather than constructing a navigable tree, so nothing it builds can afterwards be queried or mutated",
+    "3": "concatenates a string rather than constructing a navigable tree, so nothing it builds can afterwards be queried or mutated",
+    "4": "concatenates a string rather than constructing a navigable tree, so nothing it builds can afterwards be queried or mutated",
+    "5": "concatenates a string rather than constructing a navigable tree, so nothing it builds can afterwards be queried or mutated"
   }
 }
diff --git a/docs/migration/bench/soupsieve.json b/docs/migration/bench/soupsieve.json
index 784e3623..cee8d691 100644
--- a/docs/migration/bench/soupsieve.json
+++ b/docs/migration/bench/soupsieve.json
@@ -85,6 +85,11 @@
       "match each anchor against div a[href] — whatwg spec (235 kB)",
       6.4643849283877825e-06,
       0.0009399141432974526
+    ],
+    [
+      "escape 1,000 raw CSS identifiers — mixed shapes (1,000)",
+      6.690426293687324e-05,
+      0.001079754202616338
     ]
   ],
   "spread": [
@@ -167,7 +172,12 @@
       null,
       0.022279753460333986,
       0.01417893540370526
+    ],
+    [
+      null,
+      0.018333627446141816,
+      0.007448910606025241
     ]
   ],
-  "notes": {}
+  "row_notes": {}
 }
diff --git a/docs/migration/bench/stdlib.json b/docs/migration/bench/stdlib.json
index 374fc31f..7c92b567 100644
--- a/docs/migration/bench/stdlib.json
+++ b/docs/migration/bench/stdlib.json
@@ -178,23 +178,23 @@
     ],
     [
       "SAX parse a page (no tree) — daring fireball (10 kB)",
-      0.00019488833968731947,
-      0.0004437348903820748
+      4.5302655543366654e-05,
+      0.0003224700046757789
     ],
     [
       "SAX parse a page (no tree) — ars technica (56 kB)",
-      0.0008006775716467018,
-      0.0019547777784888845
+      0.00021376738864849662,
+      0.0014648784172853386
     ],
     [
       "SAX parse a page (no tree) — mozilla blog (95 kB)",
-      0.0017779560531986742,
-      0.00462147547659697
+      0.0004706636832831161,
+      0.003767693356773331
     ],
     [
       "SAX parse a page (no tree) — whatwg spec (235 kB)",
-      0.005535535153285309,
-      0.010424100907888109
+      0.0011398852811908,
+      0.008212086378989625
     ],
     [
       "decode a legacy byte stream — shift_jis japanese (8 kB)",
@@ -395,23 +395,23 @@
     ],
     [
       null,
-      0.030427926444935197,
-      0.03611087670798867
+      0.017992506887335107,
+      0.0231879122709088
     ],
     [
       null,
-      0.022637552962957476,
-      0.043289321507574384
+      0.007252168082139817,
+      0.0435339009772295
     ],
     [
       null,
-      0.024571963038992502,
-      0.03011866245056965
+      0.02031354060181494,
+      0.11412047057514978
     ],
     [
       null,
-      0.022454421855592255,
-      0.027822544865816024
+      0.020695723350710016,
+      0.0810322874863312
     ],
     [
       null,
@@ -439,7 +439,11 @@
       0.02023617070051036
     ]
   ],
-  "notes": {
-    "stdlib": "decodes with the nearest CPython codec under errors=replace, which is not the WHATWG decoder of that label: the two disagree on both the mapping tables and where decoding resumes after an error"
+  "row_notes": {
+    "38": "decodes with the nearest CPython codec under errors=replace, which is not the WHATWG decoder of that label: the two disagree on both the mapping tables and where decoding resumes after an error",
+    "39": "decodes with the nearest CPython codec under errors=replace, which is not the WHATWG decoder of that label: the two disagree on both the mapping tables and where decoding resumes after an error",
+    "40": "decodes with the nearest CPython codec under errors=replace, which is not the WHATWG decoder of that label: the two disagree on both the mapping tables and where decoding resumes after an error",
+    "41": "decodes with the nearest CPython codec under errors=replace, which is not the WHATWG decoder of that label: the two disagree on both the mapping tables and where decoding resumes after an error",
+    "42": "decodes with the nearest CPython codec under errors=replace, which is not the WHATWG decoder of that label: the two disagree on both the mapping tables and where decoding resumes after an error"
   }
 }
diff --git a/docs/migration/bench/trafilatura.json b/docs/migration/bench/trafilatura.json
index 839496c1..32c0e195 100644
--- a/docs/migration/bench/trafilatura.json
+++ b/docs/migration/bench/trafilatura.json
@@ -18,18 +18,18 @@
     ],
     [
       "publication-date extraction — post (4 KiB)",
-      1.1735952601436376e-05,
-      0.00017194148086711417
+      5.9304065735214335e-06,
+      0.00011766121753945906
     ],
     [
       "publication-date extraction — longform (16 KiB)",
-      1.7074957939418784e-05,
-      0.0003579496258036367
+      1.030123477659591e-05,
+      0.0002502549162007502
     ],
     [
       "publication-date extraction — 100 meta candidates",
-      0.00013010201349554032,
-      9.28465288912624e-05
+      1.828077740384515e-05,
+      7.32439337885656e-05
     ],
     [
       "main-content text — main (4 KiB)",
@@ -50,18 +50,18 @@
     ],
     [
       null,
-      0.04329384536759802,
-      0.08089387135645254
+      0.004697496985019512,
+      0.019549316289211804
     ],
     [
       null,
-      0.03092662857915166,
-      0.03784222870872126
+      0.007721833090606347,
+      0.023385975296491182
     ],
     [
       null,
-      0.03639475424630214,
-      0.035977232455401555
+      0.008026401759229225,
+      0.058992245979526695
     ],
     [
       null,
@@ -69,5 +69,9 @@
       0.09149282207360948
     ]
   ],
-  "notes": {}
+  "row_notes": {
+    "2": "returns no date for the 100-candidate case, so its timing there is the cost of giving up rather than of finding the date turbohtml reports",
+    "3": "returns no date for the 100-candidate case, so its timing there is the cost of giving up rather than of finding the date turbohtml reports",
+    "4": "returns no date for the 100-candidate case, so its timing there is the cost of giving up rather than of finding the date turbohtml reports"
+  }
 }
diff --git a/docs/migration/bench/w3lib.json b/docs/migration/bench/w3lib.json
index ce220227..4ebdff94 100644
--- a/docs/migration/bench/w3lib.json
+++ b/docs/migration/bench/w3lib.json
@@ -93,13 +93,13 @@
     ],
     [
       "clean and normalize 100 URLs — clean 100 URLs",
-      0.0003844782578047064,
-      0.0009630483129967615
+      0.0002001551580595636,
+      0.0008954732669508303
     ],
     [
       "clean and normalize 100 URLs — normalize 100 URLs",
-      0.0003070245703611363,
-      0.0020177926968851048
+      0.00019102673005969942,
+      0.0014264048398520874
     ]
   ],
   "spread": [
@@ -190,16 +190,19 @@
     ],
     [
       null,
-      0.022289454081313064,
-      0.03681145454277887
+      0.023980473452570077,
+      0.19362889792689836
     ],
     [
       null,
-      0.028259459443914923,
-      0.04726044582904961
+      0.05593996284173067,
+      0.047716221029633424
     ]
   ],
-  "notes": {
-    "w3lib": "removes the tags with a regular expression over the raw string and never parses, so it cannot honor nesting or the tokenizer rules that decide where an element really ends"
+  "row_notes": {
+    "7": "removes the tags with a regular expression over the raw string and never parses, so it cannot honor nesting or the tokenizer rules that decide where an element really ends",
+    "8": "removes the tags with a regular expression over the raw string and never parses, so it cannot honor nesting or the tokenizer rules that decide where an element really ends",
+    "9": "removes the tags with a regular expression over the raw string and never parses, so it cannot honor nesting or the tokenizer rules that decide where an element really ends",
+    "10": "removes the tags with a regular expression over the raw string and never parses, so it cannot honor nesting or the tokenizer rules that decide where an element really ends"
   }
 }
diff --git a/docs/migration/bench/yattag.json b/docs/migration/bench/yattag.json
index 4c641146..d6ebf07e 100644
--- a/docs/migration/bench/yattag.json
+++ b/docs/migration/bench/yattag.json
@@ -39,7 +39,9 @@
       0.013404825323645687
     ]
   ],
-  "notes": {
-    "yattag": "concatenates a string rather than constructing a navigable tree, so nothing it builds can afterwards be queried or mutated"
+  "row_notes": {
+    "0": "concatenates a string rather than constructing a navigable tree, so nothing it builds can afterwards be queried or mutated",
+    "1": "concatenates a string rather than constructing a navigable tree, so nothing it builds can afterwards be queried or mutated",
+    "2": "concatenates a string rather than constructing a navigable tree, so nothing it builds can afterwards be queried or mutated"
   }
 }
diff --git a/docs/migration/bleach.rst b/docs/migration/bleach.rst
index 01039656..e655b87c 100644
--- a/docs/migration/bleach.rst
+++ b/docs/migration/bleach.rst
@@ -86,7 +86,7 @@ What bleach has that turbohtml does not
 Performance
 ===========
 
-The sanitizer leads bleach by about fifty times and the linkifier by five to twenty times:
+The sanitizer leads bleach by about fifty times and the linkifier by six to twenty times:
 
 .. bench-table::
     :file: bench/bleach.json
diff --git a/docs/migration/chardet.rst b/docs/migration/chardet.rst
index 820d7cc5..9a6fd34b 100644
--- a/docs/migration/chardet.rst
+++ b/docs/migration/chardet.rst
@@ -40,8 +40,8 @@ call path, and returns a typed :class:`~turbohtml.detect.EncodingMatch` in place
       - ``detect``, ``detect_all``, ``UniversalDetector`` with a ``lang_filter``; no allow/exclude set, no language
         hint.
     - - Performance
-      - ASCII, valid UTF-8, and real web pages short-circuit before any scoring, resolving 24x to 1700x ahead; legacy
-        single-byte text runs 3.2x to 4.0x ahead. See the table below.
+      - ASCII, valid UTF-8, and real web pages short-circuit before any scoring, resolving 30x to 1500x ahead; legacy
+        single-byte text runs 3.9x to 5.4x ahead. See the table below.
       - Prober ensemble runs every model on every input; no fast path for clean UTF-8 or ASCII.
     - - Typing
       - Fully typed: ``EncodingMatch``, ``Detection``, ``EncodingDetector`` are annotated dataclasses/classes with
@@ -89,7 +89,7 @@ What chardet has that turbohtml does not
   resolve to the closest WHATWG candidate instead. No equivalent when you need one of those exact labels. A UTF-16 or
   UTF-32 stream that *does* carry a mark now reports its exact label (see below).
 - A raw CJK speed edge on the C fork. On CJK-heavy byte streams (the Shift_JIS row), ``cchardet``'s uchardet engine
-  stays about 2.5x ahead of turbohtml, which decodes each candidate encoding to score it and a CJK stream leaves several
+  stays about 1.6x ahead of turbohtml, which decodes each candidate encoding to score it and a CJK stream leaves several
   candidates standing. Workaround: keep ``faust-cchardet`` for that one workload if it dominates; turbohtml leads
   chardet on every row.
 
@@ -99,11 +99,11 @@ Performance
 .. bench-table::
     :file: bench/chardet.json
 
-Certain input short-circuits before any scoring, so ASCII, valid UTF-8, and real web pages resolve 24x to 1700x ahead of
-chardet's prober ensemble; declaration-less legacy single-byte text still runs 3.2x to 4.0x ahead. Both libraries decode
+Certain input short-circuits before any scoring, so ASCII, valid UTF-8, and real web pages resolve 30x to 1500x ahead of
+chardet's prober ensemble; declaration-less legacy single-byte text still runs 3.9x to 5.4x ahead. Both libraries decode
 a 15-sample multilingual differential correctly, though chardet often names a sibling or superset where turbohtml
 reports the WHATWG encoding a browser would pick. The one exception is CJK-heavy bytes, where ``cchardet``'s uchardet
-engine leads (the Shift_JIS row, 2.3x); turbohtml leads on the declaration-less single-byte rows.
+engine leads (the Shift_JIS row, 1.6x); turbohtml leads on the declaration-less single-byte rows.
 
 ****************
  How to migrate
diff --git a/docs/migration/charset-normalizer.rst b/docs/migration/charset-normalizer.rst
index 283dc586..bc4df236 100644
--- a/docs/migration/charset-normalizer.rst
+++ b/docs/migration/charset-normalizer.rst
@@ -34,7 +34,7 @@ common case of declared or structurally certain input resolves without running a
       - ``detect``, ``detect_all``, streaming ``EncodingDetector``, allow/exclude and language constraints
       - Rich match objects (chaos, coherence, alphabets, multiple languages), file/stream helpers, CLI, explain logging
     - - Performance
-      - C, short-circuits certain input in microseconds; 23x-760x ahead on declared/UTF-8/ASCII bytes (see table)
+      - C, short-circuits certain input in microseconds; 43x-650x ahead on declared/UTF-8/ASCII bytes (see table)
       - Pure Python, always runs its per-codec decode and scoring passes
     - - Typing
       - Fully typed; frozen ``EncodingMatch`` / ``Detection`` records with shipped stubs
@@ -109,8 +109,8 @@ Performance
     :file: bench/charset-normalizer.json
 
 Declared or structurally certain input short-circuits, so ASCII, UTF-8, and real web pages resolve in microseconds --
-23x to 760x ahead of charset-normalizer, which always runs its scoring passes. On declaration-less legacy bytes
-turbohtml stays 1.7x to 5.8x ahead (see the table).
+43x to 650x ahead of charset-normalizer, which always runs its scoring passes. On declaration-less legacy bytes
+turbohtml stays 1.7x to 5.7x ahead (see the table).
 
 ****************
  How to migrate
diff --git a/docs/migration/courlan.rst b/docs/migration/courlan.rst
index 6e4656bf..90ec6d9c 100644
--- a/docs/migration/courlan.rst
+++ b/docs/migration/courlan.rst
@@ -37,7 +37,7 @@ probing) stays out of scope by design.
       - clean, normalize, and link-extract over the parsed DOM, one frozen config
       - clean/scrub/normalize/check, regex link extraction, ``UrlStore``, spam and navigation heuristics, a CLI
     - - Performance
-      - ~2x per URL on cleaning, 2.0x-3.3x on link extraction including the parse (see below)
+      - ~3x per URL on cleaning, 2.1x-3.8x on link extraction including the parse (see below)
       - baseline
     - - Typing
       - fully typed, ships ``py.typed`` and stubs
@@ -105,10 +105,10 @@ Performance
 
 :func:`~turbohtml.extract.clean_url` and :func:`~turbohtml.extract.normalize_url` produce the WHATWG canonical form (the
 serialization a browser's address bar would show) and layer courlan's crawl canonicalization (query sorting, tracker
-removal, the strict allowlist, the language filter) on top, about 2x faster per URL.
+removal, the strict allowlist, the language filter) on top, about 3x faster per URL.
 :func:`~turbohtml.extract.extract_links` reads anchors from the real WHATWG DOM instead of regex-scanning the markup, so
 links inside comments or scripts never leak in, a ``<base href>`` is honored, and pages whose navigation repeats the
-same targets clean each spelling once, 2.0x-3.3x ahead over real saved pages even with the parse in the loop:
+same targets clean each spelling once, 2.1x-3.8x ahead over real saved pages even with the parse in the loop:
 
 .. bench-table::
     :file: bench/courlan.json
diff --git a/docs/migration/csscompressor.rst b/docs/migration/csscompressor.rst
index 0a5788f1..5814e8b8 100644
--- a/docs/migration/csscompressor.rst
+++ b/docs/migration/csscompressor.rst
@@ -34,7 +34,7 @@ byte-exact, and runs in linear time where csscompressor's regex passes degrade o
         merging, adjacent equal-body rule merging, optional Baseline-year shorthands
       - Whitespace/comment removal, color and number shortening, line wrapping, output partitioning
     - - Performance
-      - Native C, linear time (37x-109x faster on the corpus below)
+      - Native C, linear time (27x-89x faster on the corpus below)
       - Pure-Python regex passes, degrade on large stylesheets
     - - Typing
       - Typed public API (:func:`~turbohtml.clean.minify_css`, :class:`~turbohtml.clean.CSSMinify`)
@@ -90,7 +90,7 @@ Performance
 ===========
 
 turbohtml's output is smaller on every framework except the custom-property-heavy ``bulma.css``, where the two tie
-within 100 bytes, and its C engine is 37x to 109x faster -- csscompressor's regex passes turn quadratic on a large
+within 100 bytes, and its C engine is 27x to 89x faster -- csscompressor's regex passes turn quadratic on a large
 stylesheet, where turbohtml stays linear. csscompressor also rewrites whitespace inside custom-property values, which
 `CSS Variables 1 §2 <https://www.w3.org/TR/css-variables-1/#defining-variables>`_ keeps as the literal token stream that
 ``var()`` splices verbatim, so its output is not guaranteed to parse to the same cascade. Each ratio is against
diff --git a/docs/migration/htmldate.rst b/docs/migration/htmldate.rst
index f14c16e7..76011606 100644
--- a/docs/migration/htmldate.rst
+++ b/docs/migration/htmldate.rst
@@ -33,8 +33,8 @@ which signal the date came from instead of a bare string. No second parse, no ``
       - Same five signals (meta, JSON-LD, time, URL, text) scored off the DOM; standard-library date parsing
       - Same five signals plus boilerplate pruning, occurrence scoring, and ``dateparser`` for wide locale coverage
     - - Performance
-      - 2x to 2.9x faster on boilerplate pages with no date metadata (early exit over structured signals)
-      - Edges ahead on clean metadata pages where the header lookup returns first
+      - 2.9x to 3.3x faster across the corpus, early exit over the structured signals (BOM/meta/JSON-LD/time)
+      - Builds an lxml tree and scores pruned text; no structural fast path
     - - Typing
       - Fully typed; returns a :class:`~turbohtml.extract.PublicationDate` NamedTuple or ``None``
       - Typed hints; returns ``str`` or ``None``
@@ -91,9 +91,9 @@ What htmldate has that turbohtml does not
 Performance
 ===========
 
-Both libraries are parse-bound. On clean metadata pages htmldate's header lookup returns first and edges ahead; on
-boilerplate pages with no date metadata turbohtml's early exit over the structured signals runs 2x to 2.9x faster than
-htmldate's tree-pruning text scoring:
+Both libraries are parse-bound. turbohtml's early exit over the structured signals runs 2.9x to 3.3x faster than
+htmldate's tree-pruning text scoring across the corpus, and the row that once favored htmldate -- a page stacked with a
+hundred date-like ``<meta>`` tags -- now goes to turbohtml too, since it weighs the candidates in C:
 
 .. bench-table::
     :file: bench/htmldate.json
diff --git a/docs/migration/jsdom.rst b/docs/migration/jsdom.rst
index 0cf63de8..6997e3b8 100644
--- a/docs/migration/jsdom.rst
+++ b/docs/migration/jsdom.rst
@@ -410,6 +410,15 @@ turbohtml:
 
     childList 1
 
+*************
+ Performance
+*************
+
+jsdom runs on Node, never inside the CPython process, so it cannot share the per-venv Python harness that pairs
+turbohtml against a competitor on one input, and there is no in-process peer to benchmark it against. The traversal,
+range, and shadow-tree state machines this guide covers run in turbohtml's C core; only the ``NodeFilter`` callback
+re-enters Python, once per visited node.
+
 .. seealso::
 
     :doc:`/how-to/ranges`, :doc:`/how-to/shadow-dom`, and :doc:`/how-to/observing-mutations` for task-focused recipes,
diff --git a/docs/migration/lightningcss.rst b/docs/migration/lightningcss.rst
index c9da0e97..f3ee1741 100644
--- a/docs/migration/lightningcss.rst
+++ b/docs/migration/lightningcss.rst
@@ -35,7 +35,7 @@ everywhere, and recovers from malformed input that lightningcss rejects. The :cl
       - All of that plus cross-sheet dead-declaration removal, target-driven syntax rewriting, vendor prefixing,
         ``@import`` bundling
     - - Performance
-      - Faster on every corpus sheet, 1.8x to 2.6x (see Performance)
+      - Faster on every corpus sheet, 1.3x to 2.4x (see Performance)
       - Smaller output on most inputs by trading target configuration for size
     - - Typing
       - Fully typed, frozen ``CSSMinify`` config object
@@ -65,7 +65,7 @@ What turbohtml adds
   target list to configure and no way to emit syntax a target cannot parse.
 - WHATWG error recovery: turbohtml minifies malformed stylesheets that lightningcss's parser rejects, for example a
   media query in ``foundation.css`` that the WHATWG rules accept.
-- Faster on every sheet: up to 2.6x on ``normalize.css``, and ahead of the Rust engine even on the largest,
+- Faster on every sheet: up to 2.4x on ``normalize.css``, and ahead of the Rust engine even on the largest,
   ``bootstrap.css`` and ``bulma.css``.
 - Inline-declaration minify via :func:`turbohtml.clean.minify_css_inline` for bare ``style``-attribute declaration
   lists, without a surrounding selector or braces.
@@ -89,10 +89,10 @@ lightningcss produces the smaller output on most of the corpus -- up to seven pe
 those targets support. turbohtml applies only transforms that hold on any conformant browser, so its default output
 needs no target list and parses to the same cascade everywhere; the :class:`~turbohtml.clean.CSSMinify` ``baseline``
 year opts into the newer-syntax shorthand merges when you are ready to require them. On speed turbohtml leads across the
-corpus: 2.6x faster on ``normalize.css`` and 2.4x on ``pico.css``, down to 1.8x on ``animate.css``, and it stays ahead
-on the larger ``bootstrap.css`` and ``bulma.css`` at 2.1x each. turbohtml recovers from malformed CSS that lightningcss
-rejects: ``foundation.css`` raises a parse error on a media query the WHATWG rules accept, where turbohtml minifies all
-six stylesheets. Each ratio is against turbohtml:
+corpus: 2.4x faster on ``normalize.css`` and 2.1x on ``pico.css``, down to 1.3x on ``animate.css``, and it stays ahead
+on the larger ``bootstrap.css`` and ``bulma.css`` at 1.8x and 2.0x. turbohtml recovers from malformed CSS that
+lightningcss rejects: ``foundation.css`` raises a parse error on a media query the WHATWG rules accept, where turbohtml
+minifies all six stylesheets. Each ratio is against turbohtml:
 
 .. bench-table::
     :file: bench/lightningcss.json
diff --git a/docs/migration/linkify-it-py.rst b/docs/migration/linkify-it-py.rst
index 87ecd0b1..ae525f41 100644
--- a/docs/migration/linkify-it-py.rst
+++ b/docs/migration/linkify-it-py.rst
@@ -100,8 +100,8 @@ Performance
 
 linkify-it-py only locates link spans in plain text; it never rewrites HTML, so the comparison is on detection alone.
 The primitives outrun the Python scanner: :meth:`LinkDetector.find <turbohtml.clean.LinkDetector.find>` against
-``LinkifyIt().match`` runs 37x to 51x faster, and :meth:`~turbohtml.clean.LinkDetector.has_link` against
-``LinkifyIt().test`` up to 93x. The one close row is ``has_link`` on prose (2x), where ``test`` short-circuits on the
+``LinkifyIt().match`` runs 51x to 63x faster, and :meth:`~turbohtml.clean.LinkDetector.has_link` against
+``LinkifyIt().test`` up to 103x. The one close row is ``has_link`` on prose (2.8x), where ``test`` short-circuits on the
 first link near the start.
 
 ****************
diff --git a/docs/migration/lxml-html-clean.rst b/docs/migration/lxml-html-clean.rst
index d049d28b..cf312949 100644
--- a/docs/migration/lxml-html-clean.rst
+++ b/docs/migration/lxml-html-clean.rst
@@ -96,7 +96,7 @@ Performance
 ===========
 
 ``turbohtml.clean`` runs the filtering walk in C rather than over an lxml tree, sanitizing about 13x faster than the
-blocklist cleaner. lxml-html-clean also ships ``autolink_html``, benchmarked here as the linkify op: turbohtml runs 2.4x
+blocklist cleaner. lxml-html-clean also ships ``autolink_html``, benchmarked here as the linkify op: turbohtml runs 2.5x
 faster on the comment case and 1.3x on markup, and about half the speed on plain prose (0.6x).
 
 .. bench-table::
diff --git a/docs/migration/mechanicalsoup.rst b/docs/migration/mechanicalsoup.rst
index 887dbe67..8aa4bb04 100644
--- a/docs/migration/mechanicalsoup.rst
+++ b/docs/migration/mechanicalsoup.rst
@@ -91,7 +91,9 @@ What MechanicalSoup has that turbohtml does not
 Performance
 ===========
 
-Not directly benchmarked.
+MechanicalSoup parses and queries nothing itself: it hands both to BeautifulSoup. The cost of the half turbohtml
+replaces is therefore BeautifulSoup's, measured against turbohtml on the :doc:`beautifulsoup` page. The form-reading
+surface turbohtml adds runs in the C core over the already-parsed tree, so it carries no separate parse cost to compare.
 
 ****************
  How to migrate
diff --git a/docs/migration/soupsieve.rst b/docs/migration/soupsieve.rst
index 03565cd1..b063a5f9 100644
--- a/docs/migration/soupsieve.rst
+++ b/docs/migration/soupsieve.rst
@@ -100,7 +100,8 @@ Performance
 
 soupsieve interprets each selector in Python per element; turbohtml compiles it against the tree once and matches by
 comparing interned integer atoms in C, so a compiled ``select`` runs 196 to 1,480 times faster across real pages and
-per-element ``match`` 78 to 145 times faster:
+per-element ``match`` 78 to 145 times faster. :func:`~turbohtml.query.escape_identifier` builds its CSS identifier in C
+where soupsieve's ``escape`` loops in Python, so it runs 16 times faster on a thousand mixed identifiers:
 
 .. bench-table::
     :file: bench/soupsieve.json
diff --git a/docs/migration/w3lib.rst b/docs/migration/w3lib.rst
index e99803a4..7466e886 100644
--- a/docs/migration/w3lib.rst
+++ b/docs/migration/w3lib.rst
@@ -34,7 +34,7 @@ and file/data-URI plumbing stays outside turbohtml's scope.
       - Broader on HTML: real tree, ``strip_tags``, ``remove``, document URL hints, sanitizing ``clean``
       - Broader on transport: HTTP headers, file/data URIs, in-place query-parameter mutation
     - - Performance
-      - C extension; 2.4x-6.0x on the shared URL batch, several times faster on entity-heavy text
+      - C extension; 4.5x-7.5x on the shared URL batch, several times faster on entity-heavy text
       - Pure-Python regex and ``urllib`` re-encoding
     - - Typing
       - Fully annotated with bundled ``.pyi`` stubs for the C extension
@@ -96,7 +96,7 @@ What w3lib has that turbohtml does not
 Performance
 ===========
 
-The URL surface is 2.4x-6.0x faster over a shared 100-URL batch, and the entity and tag helpers each run a
+The URL surface is 4.5x-7.5x faster over a shared 100-URL batch, and the entity and tag helpers each run a
 structure-aware C pass that still beats w3lib's regex on entity-heavy input:
 
 .. bench-table::
diff --git a/pyproject.toml b/pyproject.toml
index a96a663e..15e13c12 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -83,6 +83,7 @@ dev = [
 ]
 test = [
   "covdefaults>=2.3",
+  "docutils>=0.22",             # render the docs bench-table directive in tests/test_bench_table_directive.py
   "elementpath>=5.1.3",         # the XPath 2.0 oracle the string-function differential test cross-checks against
   "httpx2>=2.5",                # the benchmark corpora and the tools/generate_* scripts fetch pinned data over it
   "jinja2>=3.1.6",              # the markup migration test renders templates with markupsafe swapped for turbohtml.markup
@@ -336,7 +337,10 @@ src.exclude = [
   "tests/html5lib-tests",
   "tools/html5lib-python"
 ]  # vendored suites, not our code
-environment.extra-paths = [ "tools" ]  # the CodSpeed benchmarks import the bench registry from tools/bench
+environment.extra-paths = [
+  "tools",
+  "docs/_ext"
+]  # bench registry from tools/bench; the bench-table directive from docs/_ext
 environment.python-version = "3.15"
 
 [tool.pytest]
diff --git a/src/turbohtml/_c/clean/linkify.c b/src/turbohtml/_c/clean/linkify.c
index 0a6e98dd..3edce481 100644
--- a/src/turbohtml/_c/clean/linkify.c
+++ b/src/turbohtml/_c/clean/linkify.c
@@ -19,9 +19,14 @@
 #include <stdint.h>
 
 enum th_link_kind {
+    /* A bare domain (``example.com``): no scheme of its own, so the Python layer prefixes ``http://``. */
     TH_LINK_URL = 0,
     TH_LINK_EMAIL = 1,
+    /* A registered scheme-less URL (``tel:+1``, ``bitcoin:1abc``): its opaque part carries the scheme. */
     TH_LINK_SCHEME = 2,
+    /* A ``scheme://host`` URL: the scanner matched an explicit scheme, so the match is kept verbatim. Classifying it
+       here spares the Python layer a per-match re.match against the scheme grammar. */
+    TH_LINK_HAS_SCHEME = 3,
 };
 
 /* A non-ASCII Unicode White_Space code point (the ASCII ones are c <= 0x20). UTS46
@@ -473,7 +478,9 @@ static PyObject *do_scan(PyObject *text, int parse_email, int bare_domains, PyOb
         int found = 0;
         if (c == ':') {
             found = match_url(kind, data, pos, 0, len, &match_start, &match_end, url_schemes);
-            if (!found && schemes != NULL) {
+            if (found) {
+                link_kind = TH_LINK_HAS_SCHEME; /* a scheme://host URL carries its own scheme, kept verbatim */
+            } else if (schemes != NULL) {
                 found = match_scheme_less(kind, data, pos, 0, len, &match_start, &match_end, schemes);
                 link_kind = TH_LINK_SCHEME;
             }
diff --git a/src/turbohtml/_c/core/common.h b/src/turbohtml/_c/core/common.h
index 73fb6549..8eb1b017 100644
--- a/src/turbohtml/_c/core/common.h
+++ b/src/turbohtml/_c/core/common.h
@@ -80,6 +80,10 @@ PyObject *turbohtml_css_parse_declarations(PyObject *module, PyObject *text);
 PyObject *turbohtml_css_parse_rules(PyObject *module, PyObject *text);
 PyObject *turbohtml_css_computed_style(PyObject *module, PyObject *arg);
 
+/* CSS.escape per the CSSOM serialize-an-identifier rules, behind turbohtml.query.escape_identifier.
+   Matches METH_O. */
+PyObject *turbohtml_css_escape_identifier(PyObject *module, PyObject *arg);
+
 /* Implemented in dom/element.c: stores the SelectorSyntaxError type the selector
    and XPath parsers raise on a malformed expression (METH_O); turbohtml._selectors
    registers it on import. */
@@ -109,6 +113,30 @@ PyObject *turbohtml_url_percent_decode(PyObject *module, PyObject *arg);
 PyObject *th_url_join(PyObject *base, PyObject *target);
 PyObject *turbohtml_url_join(PyObject *module, PyObject *args);
 
+/* _url_is_tracker(key): whether a lowercased query-parameter name names a referral rather than content, so a
+   crawl-oriented cleaner drops it. Matches METH_O. */
+PyObject *turbohtml_url_is_tracker(PyObject *module, PyObject *arg);
+
+/* _url_remove_dot_segments(path): resolve the "." and ".." segments of a path, in either their literal or
+   %2E spelling, as the WHATWG path state does (spec 4.4). Matches METH_O. */
+PyObject *turbohtml_url_remove_dot_segments(PyObject *module, PyObject *arg);
+
+/* _url_scrub(url): undo the HTML transport damage a scraped URL carries (edge C0/space strip, whitespace removal, CDATA
+   unwrap, markup-delimiter truncation, &amp; unescape) before it is split. Matches METH_O. */
+PyObject *turbohtml_url_scrub(PyObject *module, PyObject *arg);
+
+/* _url_variant_key(url): the scheme-and-trailing-slash-collapsed dedup key extract_links compares links by. METH_O. */
+PyObject *turbohtml_url_variant_key(PyObject *module, PyObject *arg);
+
+/* _url_normalize_query(query, allow, deny, strict, content, language): drop denied, tracker, or non-allowlisted query
+   parameters, encode the survivors, and sort them, the crawl cleaner's per-pair loop. Matches METH_VARARGS. */
+PyObject *turbohtml_url_normalize_query(PyObject *module, PyObject *args);
+
+/* _url_language_matches(query, path, hostname, language, strict, language_params, iso_639_1): judge a URL's own
+   language markers (a lang/language query parameter, a leading path segment, a strict-mode host label) against the
+   target language, the per-URL heuristics behind clean_url's language filter. Matches METH_VARARGS. */
+PyObject *turbohtml_url_language_matches(PyObject *module, PyObject *args);
+
 /* Implemented in url/idna.c. th_url_to_ascii runs the WHATWG domain-to-ASCII step (Unicode IDNA ToASCII, UTS #46 with
    Transitional_Processing=false and UseSTD3ASCIIRules=false): UTS #46 mapping, NFC, and per-label punycode. _urls.py
    reaches _url_to_ascii(host) for its registered-name hosts instead of the IDNA-2003 str.encode("idna") codec; the host
@@ -219,6 +247,13 @@ PyObject *turbohtml_date_scan(PyObject *module, PyObject *args);
 PyObject *turbohtml_date_scan_all(PyObject *module, PyObject *args);
 PyObject *turbohtml_date_url(PyObject *module, PyObject *url);
 
+/* Document._date_meta(want, current_year, min_y, min_m, min_d, max_y, max_m, max_d)
+   -> (year, month, day) or None (METH_VARARGS): the <meta> stage of
+   turbohtml.extract.dates, walking the meta elements, classifying each publication
+   or modification date against htmldate's key vocabulary, and returning the winner
+   the shared _pick selection would. Registered on the document method table. */
+PyObject *turbohtml_document_date_meta(PyObject *self, PyObject *args);
+
 /* Implemented in tokenizer/tokenizer.c. tokenize() matches METH_VARARGS | METH_KEYWORDS;
    the internal conformance hook _tokenize_states matches METH_VARARGS. */
 PyObject *turbohtml_tokenize(PyObject *module, PyObject *args, PyObject *kwargs);
diff --git a/src/turbohtml/_c/core/module.c b/src/turbohtml/_c/core/module.c
index ffb152bf..ab52f889 100644
--- a/src/turbohtml/_c/core/module.c
+++ b/src/turbohtml/_c/core/module.c
@@ -197,6 +197,7 @@ static PyMethodDef html_methods[] = {
     {"_build_document", (PyCFunction)(void (*)(void))turbohtml_build_document, METH_VARARGS | METH_KEYWORDS, NULL},
     {"_tokenize_states", turbohtml_tokenize_states, METH_VARARGS, NULL},
     {"_sax_events", turbohtml_sax_events, METH_O, NULL},
+    {"_sax_dispatch", turbohtml_sax_dispatch, METH_VARARGS, NULL},
     {"_parse_into", turbohtml_parse_into, METH_VARARGS, NULL},
     {"_rewrite", turbohtml_rewrite, METH_VARARGS, NULL},
     {"_parse_tree", turbohtml_parse_tree, METH_VARARGS, NULL},
@@ -212,6 +213,7 @@ static PyMethodDef html_methods[] = {
     {"_css_parse_declarations", turbohtml_css_parse_declarations, METH_O, NULL},
     {"_css_parse_rules", turbohtml_css_parse_rules, METH_O, NULL},
     {"_css_computed_style", turbohtml_css_computed_style, METH_O, NULL},
+    {"_css_escape_identifier", turbohtml_css_escape_identifier, METH_O, NULL},
     {"_minify_js", turbohtml_minify_js, METH_VARARGS, NULL},
     {"_minify_js_tokens", turbohtml_minify_js_tokens, METH_O, NULL},
     {"_minify_js_parse", turbohtml_minify_js_parse, METH_O, NULL},
@@ -230,6 +232,12 @@ static PyMethodDef html_methods[] = {
     {"_url_percent_encode", turbohtml_url_percent_encode, METH_VARARGS, NULL},
     {"_url_percent_decode", turbohtml_url_percent_decode, METH_O, NULL},
     {"_url_join", turbohtml_url_join, METH_VARARGS, NULL},
+    {"_url_is_tracker", turbohtml_url_is_tracker, METH_O, NULL},
+    {"_url_remove_dot_segments", turbohtml_url_remove_dot_segments, METH_O, NULL},
+    {"_url_scrub", turbohtml_url_scrub, METH_O, NULL},
+    {"_url_variant_key", turbohtml_url_variant_key, METH_O, NULL},
+    {"_url_normalize_query", turbohtml_url_normalize_query, METH_VARARGS, NULL},
+    {"_url_language_matches", turbohtml_url_language_matches, METH_VARARGS, NULL},
     {"_url_to_ascii", turbohtml_url_to_ascii, METH_O, NULL},
     {"_sanitize", turbohtml_sanitize, METH_VARARGS, NULL},
     {"_grow_probe", turbohtml_grow_probe, METH_VARARGS, NULL},
diff --git a/src/turbohtml/_c/css/cssom/cssom.c b/src/turbohtml/_c/css/cssom/cssom.c
index a59d92dd..efc34380 100644
--- a/src/turbohtml/_c/css/cssom/cssom.c
+++ b/src/turbohtml/_c/css/cssom/cssom.c
@@ -19,6 +19,7 @@
 #include "dom/nodes.h"
 #include "css/select/selector.h"
 
+#include <stdio.h>
 #include <string.h>
 
 /* One CSS longhand property the cascade resolves: its lowercase name, whether it
@@ -1241,3 +1242,47 @@ PyObject *turbohtml_css_computed_style(PyObject *module, PyObject *arg) {
     css_free_map(final_map);
     return result;
 }
+
+/* _css_escape_identifier(text): CSS.escape per the CSSOM serialize-an-identifier rules, so a raw class or id can be
+   dropped into a selector. Worst case every code point becomes "\XXXXXX " (8 UCS4), which bounds the buffer. */
+PyObject *turbohtml_css_escape_identifier(PyObject *Py_UNUSED(module), PyObject *arg) {
+    if (!PyUnicode_Check(arg)) {
+        PyErr_SetString(PyExc_TypeError, "escape_identifier() argument must be str");
+        return NULL;
+    }
+    Py_ssize_t len = PyUnicode_GET_LENGTH(arg);
+    int kind = PyUnicode_KIND(arg);
+    const void *data = PyUnicode_DATA(arg);
+    Py_UCS4 *out = PyMem_Malloc((size_t)(len > 0 ? len : 1) * 8 * sizeof(Py_UCS4));
+    if (out == NULL) {           /* GCOVR_EXCL_BR_LINE: allocation failure cannot be forced from a test */
+        return PyErr_NoMemory(); /* GCOVR_EXCL_LINE: allocation-failure path */
+    }
+    Py_ssize_t at = 0;
+    for (Py_ssize_t position = 0; position < len; position++) {
+        Py_UCS4 code = PyUnicode_READ(kind, data, position);
+        int is_digit = code >= 0x30 && code <= 0x39;
+        /* a digit leading the identifier (or following an initial dash) cannot start a CSS name */
+        int leading_digit = is_digit && (position == 0 || (position == 1 && PyUnicode_READ(kind, data, 0) == '-'));
+        int is_name_char = code >= 0x80 || is_digit || code == '-' || code == '_' || (code >= 0x41 && code <= 0x5A) ||
+                           (code >= 0x61 && code <= 0x7A);
+        /* a lone "-" cannot stand as an identifier, so it is backslashed exactly like a non-name character */
+        int lone_dash = position == 0 && code == '-' && len == 1;
+        if (code == 0) {
+            out[at++] = 0xFFFD;
+        } else if (code <= 0x1F || code == 0x7F || leading_digit) {
+            char hex[16];
+            int wrote = snprintf(hex, sizeof(hex), "\\%x ", (unsigned int)code);
+            for (int index = 0; index < wrote; index++) {
+                out[at++] = (Py_UCS4)(unsigned char)hex[index];
+            }
+        } else if (is_name_char && !lone_dash) {
+            out[at++] = code;
+        } else {
+            out[at++] = '\\';
+            out[at++] = code;
+        }
+    }
+    PyObject *result = th_str_from_kind(PyUnicode_4BYTE_KIND, out, at);
+    PyMem_Free(out);
+    return result;
+}
diff --git a/src/turbohtml/_c/css/minify/css_grammar.h b/src/turbohtml/_c/css/minify/css_grammar.h
index 4b89301a..1eb8c09a 100644
--- a/src/turbohtml/_c/css/minify/css_grammar.h
+++ b/src/turbohtml/_c/css/minify/css_grammar.h
@@ -25,9 +25,13 @@ static int css_decl_has_substitution(const css_buf *pool, const css_decl *decl)
 }
 
 static Py_ssize_t css_find_active_decl(const decl_vec *decls, const css_buf *pool, const char *name) {
+    /* name is a lower-case longhand literal; a declaration whose lowered first byte differs cannot match, so this
+       skips the css_run_ieq call for every declaration that is not this longhand (nearly all of them). */
+    css_char first = (css_char)(unsigned char)name[0];
     for (Py_ssize_t index = 0; index < decls->len; index++) {
         const css_decl *decl = &decls->items[index];
-        if (!decl->dropped && !decl->nested && css_run_ieq(pool->data + decl->prop_off, decl->prop_len, name)) {
+        if (!decl->dropped && !decl->nested && css_lower(pool->data[decl->prop_off]) == first &&
+            css_run_ieq(pool->data + decl->prop_off, decl->prop_len, name)) {
             return index;
         }
     }
diff --git a/src/turbohtml/_c/css/minify/css_render.h b/src/turbohtml/_c/css/minify/css_render.h
index 0b794fc3..bde91c90 100644
--- a/src/turbohtml/_c/css/minify/css_render.h
+++ b/src/turbohtml/_c/css/minify/css_render.h
@@ -103,8 +103,9 @@ static int css_prop_is_color(const css_char *prop, Py_ssize_t len) {
                                               "flood-color",
                                               "lighting-color",
                                               "text-emphasis-color"};
+    css_char first = css_lower(prop[0]);
     for (size_t index = 0; index < sizeof(color_props) / sizeof(color_props[0]); index++) {
-        if (css_run_ieq(prop, len, color_props[index])) {
+        if (css_run_ieq_first(prop, len, first, color_props[index])) {
             return 1;
         }
     }
@@ -146,8 +147,9 @@ static void css_render_raw_value(token_vec *vec, Py_ssize_t start, Py_ssize_t en
 }
 
 static int css_prop_in(const css_char *prop, Py_ssize_t len, const char *const *list, size_t count) {
+    css_char first = css_lower(prop[0]);
     for (size_t index = 0; index < count; index++) {
-        if (css_run_ieq(prop, len, list[index])) {
+        if (css_run_ieq_first(prop, len, first, list[index])) {
             return 1;
         }
     }
diff --git a/src/turbohtml/_c/css/minify/css_selector.h b/src/turbohtml/_c/css/minify/css_selector.h
index 39977af2..df0caf50 100644
--- a/src/turbohtml/_c/css/minify/css_selector.h
+++ b/src/turbohtml/_c/css/minify/css_selector.h
@@ -186,9 +186,14 @@ static int css_make_declaration(css_buf *pool, token_vec *vec, Py_ssize_t start,
             }
         } else if (token->kind != CSS_WS) {
             /* custom-property names are case-sensitive (CSS Variables 1 §2: "--foo" and "--FOO" are distinct), so a
-               --* name is kept verbatim; every other property name is ASCII case-insensitive and lower-cased. */
-            for (Py_ssize_t pos = 0; pos < token->text_len; pos++) {
-                cbuf_putc(pool, is_custom ? token->text[pos] : css_lower(token->text[pos]));
+               --* name is kept verbatim -- a bulk copy, which a framework :root of hundreds of them leans on; every
+               other property name is ASCII case-insensitive and lower-cased byte by byte. */
+            if (is_custom) {
+                cbuf_put_run(pool, token->text, token->text_len);
+            } else {
+                for (Py_ssize_t pos = 0; pos < token->text_len; pos++) {
+                    cbuf_putc(pool, css_lower(token->text[pos]));
+                }
             }
         }
     }
@@ -288,8 +293,12 @@ static const char *css_longhand_list(const css_char *prop, Py_ssize_t prop_len)
     if (prop_len < 4) {
         return NULL;
     }
+    /* Every shorthand literal is lower-case, so its first byte is the lower-cased first byte of a matching property.
+       Gating on it skips the css_run_ieq call for the majority of names that share no initial letter with any
+       shorthand -- the common case for a declaration list that is mostly longhands and custom properties. */
+    css_char first = css_lower(prop[0]);
     for (size_t index = 0; index < sizeof(shorthands) / sizeof(shorthands[0]); index++) {
-        if (css_run_ieq(prop, prop_len, shorthands[index])) {
+        if ((css_char)(unsigned char)shorthands[index][0] == first && css_run_ieq(prop, prop_len, shorthands[index])) {
             return longhands[index];
         }
     }
diff --git a/src/turbohtml/_c/css/minify/css_shorthand.h b/src/turbohtml/_c/css/minify/css_shorthand.h
index 96f870f1..fdba67ca 100644
--- a/src/turbohtml/_c/css/minify/css_shorthand.h
+++ b/src/turbohtml/_c/css/minify/css_shorthand.h
@@ -695,44 +695,50 @@ static void css_apply_handler(css_buf *pool, const css_char *prop, Py_ssize_t pr
             has_sep = 1;
         }
     }
+    css_char first = css_lower(prop[0]);
     if (!has_sep && css_prop_in(prop, prop_len, CSS_BOX_PROPS, sizeof(CSS_BOX_PROPS) / sizeof(char *))) {
         css_handle_box(pool, comps);
-    } else if (css_run_ieq(prop, prop_len, "background")) {
+    } else if (css_run_ieq_first(prop, prop_len, first, "background")) {
         css_handle_background(pool, comps);
-    } else if (css_run_ieq(prop, prop_len, "background-position")) {
+    } else if (css_run_ieq_first(prop, prop_len, first, "background-position")) {
         css_handle_background_position(pool, comps);
-    } else if (css_run_ieq(prop, prop_len, "background-repeat")) {
+    } else if (css_run_ieq_first(prop, prop_len, first, "background-repeat")) {
         css_handle_runs(pool, comps, css_collapse_repeat_run);
-    } else if (css_run_ieq(prop, prop_len, "background-size")) {
+    } else if (css_run_ieq_first(prop, prop_len, first, "background-size")) {
         css_handle_runs(pool, comps, css_collapse_size_run);
-    } else if (css_run_ieq(prop, prop_len, "border") || css_run_ieq(prop, prop_len, "border-top") ||
-               css_run_ieq(prop, prop_len, "border-bottom") || css_run_ieq(prop, prop_len, "border-left") ||
-               css_run_ieq(prop, prop_len, "border-right") || css_run_ieq(prop, prop_len, "outline") ||
-               css_run_ieq(prop, prop_len, "column-rule") || css_run_ieq(prop, prop_len, "text-decoration") ||
-               css_run_ieq(prop, prop_len, "text-emphasis")) {
+    } else if (css_run_ieq_first(prop, prop_len, first, "border") ||
+               css_run_ieq_first(prop, prop_len, first, "border-top") ||
+               css_run_ieq_first(prop, prop_len, first, "border-bottom") ||
+               css_run_ieq_first(prop, prop_len, first, "border-left") ||
+               css_run_ieq_first(prop, prop_len, first, "border-right") ||
+               css_run_ieq_first(prop, prop_len, first, "outline") ||
+               css_run_ieq_first(prop, prop_len, first, "column-rule") ||
+               css_run_ieq_first(prop, prop_len, first, "text-decoration") ||
+               css_run_ieq_first(prop, prop_len, first, "text-emphasis")) {
         css_handle_color_drop(pool, comps, prop, prop_len);
-    } else if (css_run_ieq(prop, prop_len, "border-color")) {
+    } else if (css_run_ieq_first(prop, prop_len, first, "border-color")) {
         css_handle_border_color(pool, comps);
     } else if (css_prop_in(prop, prop_len, CSS_CURRENTCOLOR_INIT, sizeof(CSS_CURRENTCOLOR_INIT) / sizeof(char *)) ||
                css_prop_in(prop, prop_len, CSS_SINGLE_COLOR, sizeof(CSS_SINGLE_COLOR) / sizeof(char *))) {
         css_handle_color_single(pool, comps, prop, prop_len);
-    } else if (css_run_ieq(prop, prop_len, "font-weight")) {
+    } else if (css_run_ieq_first(prop, prop_len, first, "font-weight")) {
         css_handle_font_weight(pool, comps);
-    } else if (css_run_ieq(prop, prop_len, "flex-basis")) {
+    } else if (css_run_ieq_first(prop, prop_len, first, "flex-basis")) {
         css_handle_flex_basis(pool, comps);
-    } else if (css_run_ieq(prop, prop_len, "flex-grow") || css_run_ieq(prop, prop_len, "order")) {
+    } else if (css_run_ieq_first(prop, prop_len, first, "flex-grow") ||
+               css_run_ieq_first(prop, prop_len, first, "order")) {
         css_handle_flex_grow(pool, comps);
-    } else if (css_run_ieq(prop, prop_len, "flex-shrink")) {
+    } else if (css_run_ieq_first(prop, prop_len, first, "flex-shrink")) {
         css_handle_flex_shrink(pool, comps);
-    } else if (css_run_ieq(prop, prop_len, "box-shadow")) {
+    } else if (css_run_ieq_first(prop, prop_len, first, "box-shadow")) {
         css_handle_runs(pool, comps, css_collapse_box_shadow_run);
-    } else if (css_run_ieq(prop, prop_len, "text-shadow")) {
+    } else if (css_run_ieq_first(prop, prop_len, first, "text-shadow")) {
         css_handle_text_shadow(pool, comps);
-    } else if (!has_sep && css_run_ieq(prop, prop_len, "flex")) {
+    } else if (!has_sep && css_run_ieq_first(prop, prop_len, first, "flex")) {
         css_handle_flex(pool, comps);
-    } else if (css_run_ieq(prop, prop_len, "font")) {
+    } else if (css_run_ieq_first(prop, prop_len, first, "font")) {
         css_handle_font(pool, comps);
-    } else if (css_run_ieq(prop, prop_len, "font-family")) {
+    } else if (css_run_ieq_first(prop, prop_len, first, "font-family")) {
         css_handle_font_family(pool, comps);
     }
 }
diff --git a/src/turbohtml/_c/css/minify/css_value.h b/src/turbohtml/_c/css/minify/css_value.h
index 9a61e27b..183f8b22 100644
--- a/src/turbohtml/_c/css/minify/css_value.h
+++ b/src/turbohtml/_c/css/minify/css_value.h
@@ -80,6 +80,13 @@ static int comp_ieq(const css_buf *pool, const css_comp *comp, const char *ascii
     return css_run_ieq(pool->data + comp->off, comp->len, ascii);
 }
 
+/* css_run_ieq gated on a pre-lowered first byte. A property name shares a first letter with only a handful of the
+   literals a dispatch chain tests, so the caller lowers prop[0] once and this skips the call for every literal that
+   cannot match. The literals passed here are lower-case, so their first byte is the value first must equal. */
+static inline int css_run_ieq_first(const css_char *text, Py_ssize_t len, css_char first, const char *ascii) {
+    return (css_char)(unsigned char)ascii[0] == first && css_run_ieq(text, len, ascii);
+}
+
 /* Decimal integer width of a (possibly negative) exponent. */
 static int css_int_width(int value) {
     int width = value < 0 ? 1 : 0;
diff --git a/src/turbohtml/_c/dom/document.c b/src/turbohtml/_c/dom/document.c
index 33301a09..7d176a1a 100644
--- a/src/turbohtml/_c/dom/document.c
+++ b/src/turbohtml/_c/dom/document.c
@@ -503,6 +503,7 @@ static PyMethodDef document_methods[] = {
      microdata_doc},
     {"rdfa", (PyCFunction)(void (*)(void))turbohtml_document_rdfa, METH_VARARGS | METH_KEYWORDS, rdfa_doc},
     {"dublin_core", turbohtml_document_dublin_core, METH_NOARGS, dublin_core_doc},
+    {"_date_meta", turbohtml_document_date_meta, METH_VARARGS, NULL},
     {"feed", turbohtml_document_feed, METH_NOARGS, feed_doc},
     {NULL, NULL, 0, NULL},
 };
diff --git a/src/turbohtml/_c/encoding/decode.h b/src/turbohtml/_c/encoding/decode.h
index be73312f..32302290 100644
--- a/src/turbohtml/_c/encoding/decode.h
+++ b/src/turbohtml/_c/encoding/decode.h
@@ -316,7 +316,16 @@ static TH_HOT int th_dec_euc_jp(th_decoder *dec, Py_UCS4 *point) {
 
 /* The spec's "index gb18030 ranges code point", using fixed rounds because four-byte pointers vary independently. */
 static int th_dec_gb18030_range(uint32_t pointer, Py_UCS4 *point) {
-    if ((pointer > 39419 && pointer < 189000) || pointer > 1237575) {
+    if (pointer >= 189000u) {
+        /* the astral plane is the range list's final entry {189000, U+10000}, a single linear run to U+10FFFF, so it
+           resolves without the search the BMP entries need -- the whole cost of an astral-heavy stream */
+        if (pointer > 1237575u) {
+            return 0;
+        }
+        *point = (Py_UCS4)(0x10000u + (pointer - 189000u));
+        return 1;
+    }
+    if (pointer > 39419u) {
         return 0;
     }
     if (pointer == 7457) { /* the one pointer the range list cannot express */
diff --git a/src/turbohtml/_c/encoding/encoding.h b/src/turbohtml/_c/encoding/encoding.h
index 7141c99e..dc615b15 100644
--- a/src/turbohtml/_c/encoding/encoding.h
+++ b/src/turbohtml/_c/encoding/encoding.h
@@ -544,6 +544,15 @@ static const th_encoding_entry *th_encoding_prescan(const unsigned char *buf, Py
         len = 1024;
     }
     while (pos < len) {
+        if (buf[pos] != '<') {
+            /* every branch below starts at a '<', so the bytes between tags are inert; jump the run in bulk rather
+               than stepping it one comparison at a time, the shape of prose or a legacy page that carries no meta */
+            const unsigned char *next = memchr(buf + pos, '<', (size_t)(len - pos));
+            if (next == NULL) {
+                break;
+            }
+            pos = next - buf;
+        }
         if (pos + 4 <= len && memcmp(buf + pos, "<!--", 4) == 0) {
             /* the spec closes the comment at the first '>' preceded by two '-' that comes after the '<', so the two
                dashes of "<!--" may double as the "--" of "-->" and "<!-->" is a complete comment */
@@ -552,7 +561,7 @@ static const th_encoding_entry *th_encoding_prescan(const unsigned char *buf, Py
                 at++;
             }
             pos = at + 3;
-        } else if (pos + 6 <= len && buf[pos] == '<' && (buf[pos + 1] | 32) == 'm' && (buf[pos + 2] | 32) == 'e' &&
+        } else if (pos + 6 <= len && (buf[pos + 1] | 32) == 'm' && (buf[pos + 2] | 32) == 'e' &&
                    (buf[pos + 3] | 32) == 't' && (buf[pos + 4] | 32) == 'a' &&
                    (is_attr_space(buf[pos + 5]) || buf[pos + 5] == '/')) {
             pos += 5;
@@ -588,9 +597,8 @@ static const th_encoding_entry *th_encoding_prescan(const unsigned char *buf, Py
                     return th_encoding_declared(entry);
                 }
             }
-        } else if (pos + 2 <= len && buf[pos] == '<' &&
-                   (is_ascii_alpha(buf[pos + 1]) ||
-                    (buf[pos + 1] == '/' && pos + 2 < len && is_ascii_alpha(buf[pos + 2])))) {
+        } else if (pos + 2 <= len && (is_ascii_alpha(buf[pos + 1]) ||
+                                      (buf[pos + 1] == '/' && pos + 2 < len && is_ascii_alpha(buf[pos + 2])))) {
             /* a start or end tag: skip the tag name, then consume its attributes
                so a '>' inside a quoted value does not terminate the tag early */
             pos += buf[pos + 1] == '/' ? 2 : 1;
@@ -601,8 +609,7 @@ static const th_encoding_entry *th_encoding_prescan(const unsigned char *buf, Py
                 /* attributes of an unrelated tag are discarded */
             }
             pos += pos < len ? 1 : 0;
-        } else if (pos + 2 <= len && buf[pos] == '<' &&
-                   (buf[pos + 1] == '!' || buf[pos + 1] == '?' || buf[pos + 1] == '/')) {
+        } else if (pos + 2 <= len && (buf[pos + 1] == '!' || buf[pos + 1] == '?' || buf[pos + 1] == '/')) {
             /* a bogus comment, including "</" not followed by a letter: skip to the next '>' */
             pos += 2;
             while (pos < len && buf[pos] != '>') {
diff --git a/src/turbohtml/_c/extract/dates.c b/src/turbohtml/_c/extract/dates.c
index 37cbb943..766b2723 100644
--- a/src/turbohtml/_c/extract/dates.c
+++ b/src/turbohtml/_c/extract/dates.c
@@ -28,7 +28,12 @@
 #include "core/ascii.h"
 #include "core/common.h"
 
+#include "dom/nodes.h"
+#include "tokenizer/binding.h" /* Py_BEGIN_CRITICAL_SECTION shim for the GIL/pre-3.13 build */
+
 #include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
 
 #define CP(index) PyUnicode_READ(kind, data, (index))
 
@@ -502,33 +507,27 @@ static int append_ymd(PyObject *list, int year, int month, int day) {
     return rc; /* GCOVR_EXCL_BR_LINE: PyList_Append only fails on allocation failure */
 }
 
-/* _scan: the first numeric date, trying ISO, then the compact stamp, then the
-   day-month-year spelling. ISO and compact fall through to the next pattern when
-   their first match is calendar-impossible; day-month-year is the last, so its
-   result (valid or None) is returned as is. */
-PyObject *turbohtml_date_scan(PyObject *Py_UNUSED(module), PyObject *args) {
-    PyObject *text;
-    int current_year;
-    if (!PyArg_ParseTuple(args, "Ui:_date_scan", &text, &current_year)) {
-        return NULL;
-    }
-    int kind = PyUnicode_KIND(text);
-    const void *data = PyUnicode_DATA(text);
-    Py_ssize_t len = PyUnicode_GET_LENGTH(text);
-    int year, month, day;
+/* The first numeric date in the text -- ISO, then the compact stamp, then the
+   day-month-year spelling, each tried in turn. ISO and compact fall through to the
+   next pattern when their first match is calendar-impossible; day-month-year is the
+   last, so its first match (valid or not) settles the answer. Writes (year, month,
+   day) and returns 1 on a hit, 0 when the text carries no date. Shared by the
+   _date_scan entry point and the <meta> date walk. */
+static int scan_first_date(const void *data, int kind, Py_ssize_t len, int current_year, int *year, int *month,
+                           int *day) {
     Py_ssize_t end;
     for (Py_ssize_t pos = 0; pos < len; pos++) {
-        if (iso_at(data, kind, len, pos, &year, &month, &day, &end)) {
-            if (ymd_valid(year, month, day)) {
-                return Py_BuildValue("(iii)", year, month, day);
+        if (iso_at(data, kind, len, pos, year, month, day, &end)) {
+            if (ymd_valid(*year, *month, *day)) {
+                return 1;
             }
             break;
         }
     }
     for (Py_ssize_t pos = 0; pos < len; pos++) {
-        if ((pos == 0 || !is_ascii_digit(CP(pos - 1))) && compact_at(data, kind, len, pos, &year, &month, &day)) {
-            if (ymd_valid(year, month, day)) {
-                return Py_BuildValue("(iii)", year, month, day);
+        if ((pos == 0 || !is_ascii_digit(CP(pos - 1))) && compact_at(data, kind, len, pos, year, month, day)) {
+            if (ymd_valid(*year, *month, *day)) {
+                return 1;
             }
             break;
         }
@@ -538,12 +537,28 @@ PyObject *turbohtml_date_scan(PyObject *Py_UNUSED(module), PyObject *args) {
         if ((pos == 0 || !is_ascii_digit(CP(pos - 1))) &&
             dmy_at(data, kind, len, pos, &raw_day, &raw_month, &raw_year, &end)) {
             int resolved_year = correct_year(raw_year, current_year);
-            if (dmy_resolve(raw_day, raw_month, resolved_year, &month, &day)) {
-                return Py_BuildValue("(iii)", resolved_year, month, day);
+            if (dmy_resolve(raw_day, raw_month, resolved_year, month, day)) {
+                *year = resolved_year;
+                return 1;
             }
             break;
         }
     }
+    return 0;
+}
+
+/* _scan: the first numeric date, or None. */
+PyObject *turbohtml_date_scan(PyObject *Py_UNUSED(module), PyObject *args) {
+    PyObject *text;
+    int current_year;
+    if (!PyArg_ParseTuple(args, "Ui:_date_scan", &text, &current_year)) {
+        return NULL;
+    }
+    int year, month, day;
+    if (scan_first_date(PyUnicode_DATA(text), PyUnicode_KIND(text), PyUnicode_GET_LENGTH(text), current_year, &year,
+                        &month, &day)) {
+        return Py_BuildValue("(iii)", year, month, day);
+    }
     Py_RETURN_NONE;
 }
 
@@ -668,3 +683,260 @@ PyObject *turbohtml_date_url(PyObject *Py_UNUSED(module), PyObject *url) {
     }
     Py_RETURN_NONE;
 }
+
+/* The <meta> date stage of turbohtml.extract.dates.
+
+   Python gathered every meta candidate into a list and then ran the shared _pick
+   selection over it; both now run here in one walk. The vocabularies below are
+   htmldate's meta key lists (the same tables the Python module held), sorted so a
+   lowercased key resolves by binary search. Every entry is lowercase ASCII, so a
+   key with a non-ASCII code point -- or one longer than the longest entry -- can
+   match neither list and is rejected before the search. */
+
+/* The longest vocabulary entry, "og:article:published_time" and
+   "citation_publication_date", both 25 bytes; the fold buffer holds that plus a
+   terminator. */
+#define MAX_KEY_LEN 25
+
+static const char *const PUBLISHED_KEYS[] = {
+    "article.created",
+    "article.published",
+    "article:published",
+    "article:published_time",
+    "article_date_original",
+    "bt:pubdate",
+    "citation_date",
+    "citation_publication_date",
+    "created",
+    "date",
+    "date_published",
+    "datecreated",
+    "dateposted",
+    "datepublished",
+    "dc.date",
+    "dc.date.created",
+    "dc.date.issued",
+    "dc.date.publication",
+    "dcterms.created",
+    "dcterms.date",
+    "dcterms.issued",
+    "og:article:published_time",
+    "og:pubdate",
+    "og:published_time",
+    "parsely-pub-date",
+    "pdate",
+    "pubdate",
+    "publication_date",
+    "publish-date",
+    "publish_date",
+    "published_date",
+    "published_time",
+    "publisheddate",
+    "pubyear",
+    "rnews:datepublished",
+    "sailthru.date",
+    "timestamp",
+};
+
+static const char *const MODIFIED_KEYS[] = {
+    "article:modified",
+    "article:modified_time",
+    "article:post_modified",
+    "datemodified",
+    "dateupdate",
+    "dc.modified",
+    "dcterms.modified",
+    "last-modified",
+    "lastdate",
+    "lastmod",
+    "lastmodified",
+    "modificationdate",
+    "modified",
+    "modified_time",
+    "og:article:modified_time",
+    "og:modified_time",
+    "og:updated_time",
+    "revision_date",
+    "updated_time",
+};
+
+/* The date roles a meta key can carry; 0 is "neither key list matched". */
+enum { META_NONE = 0, META_PUBLISHED = 1, META_MODIFIED = 2 };
+
+static int key_set_compare(const void *probe, const void *entry) {
+    return strcmp((const char *)probe, *(const char *const *)entry);
+}
+
+static int key_in_set(const char *key, const char *const *set, size_t count) {
+    return bsearch(key, set, count, sizeof(*set), key_set_compare) != NULL;
+}
+
+/* Fold an attribute value to a lowercase-ASCII C string in out, returning 1 on
+   success. A code point above U+007F, or a value longer than the longest key,
+   cannot equal any (lowercase, ASCII) vocabulary entry, so both short-circuit to 0
+   rather than folding. */
+static int fold_key(const Py_UCS4 *value, Py_ssize_t len, char *out) {
+    if (len > MAX_KEY_LEN) {
+        return 0;
+    }
+    for (Py_ssize_t index = 0; index < len; index++) {
+        Py_UCS4 codepoint = value[index];
+        if (codepoint > 0x7F) {
+            return 0;
+        }
+        out[index] = (char)((codepoint >= 'A' && codepoint <= 'Z') ? codepoint + ('a' - 'A') : codepoint);
+    }
+    out[len] = '\0';
+    return 1;
+}
+
+/* Which key list, if any, an attribute value falls in. */
+static int key_role(const Py_UCS4 *value, Py_ssize_t len) {
+    char folded[MAX_KEY_LEN + 1];
+    if (value == NULL || !fold_key(value, len, folded)) {
+        return META_NONE;
+    }
+    if (key_in_set(folded, PUBLISHED_KEYS, sizeof(PUBLISHED_KEYS) / sizeof(*PUBLISHED_KEYS))) {
+        return META_PUBLISHED;
+    }
+    if (key_in_set(folded, MODIFIED_KEYS, sizeof(MODIFIED_KEYS) / sizeof(*MODIFIED_KEYS))) {
+        return META_MODIFIED;
+    }
+    return META_NONE;
+}
+
+/* The value of a by-name attribute (property, pubdate: neither is an interned
+   atom), or NULL when the node has none. */
+static const th_node_attr *named_attr(th_tree *tree, th_node *node, const char *name, Py_ssize_t name_len) {
+    Py_ssize_t index = th_node_attr_find(tree, node, name, name_len);
+    return index < 0 ? NULL : &node->attrs[index];
+}
+
+/* The date role of a <meta> element from its name/property/itemprop/http-equiv keys
+   and a pubdate="pubdate" flag, publication winning over modification (htmldate's
+   _role_of returns the publication role whenever any key carries it). */
+static int meta_role(th_tree *tree, th_node *node) {
+    const th_node_attr *keys[] = {
+        find_node_attr(node, TH_ATTR_NAME),
+        named_attr(tree, node, "property", 8),
+        find_node_attr(node, TH_ATTR_ITEMPROP),
+        find_node_attr(node, TH_ATTR_HTTP_EQUIV),
+    };
+    int modified = 0;
+    for (size_t index = 0; index < sizeof(keys) / sizeof(*keys); index++) {
+        if (keys[index] == NULL) {
+            continue;
+        }
+        int role = key_role(keys[index]->value, keys[index]->value_len);
+        if (role == META_PUBLISHED) {
+            return META_PUBLISHED;
+        }
+        if (role == META_MODIFIED) {
+            modified = 1;
+        }
+    }
+    /* pubdate="pubdate" adds the literal key "pubdate", itself a publication key. */
+    const th_node_attr *pubdate = named_attr(tree, node, "pubdate", 7);
+    char folded[MAX_KEY_LEN + 1];
+    if (pubdate != NULL && pubdate->value != NULL && fold_key(pubdate->value, pubdate->value_len, folded) &&
+        strcmp(folded, "pubdate") == 0) {
+        return META_PUBLISHED;
+    }
+    return modified ? META_MODIFIED : META_NONE;
+}
+
+/* The text a <meta> dates from: its content, or its datetime when content is
+   absent or empty (htmldate reads `content or datetime`; an absent or empty
+   attribute has a NULL value here). Writes the length and returns the value, or
+   NULL when neither is present, which the caller drops. */
+static const Py_UCS4 *meta_date_text(th_node *node, Py_ssize_t *out_len) {
+    const th_node_attr *content = find_node_attr(node, TH_ATTR_CONTENT);
+    if (content != NULL && content->value != NULL) {
+        *out_len = content->value_len;
+        return content->value;
+    }
+    const th_node_attr *datetime = find_node_attr(node, TH_ATTR_DATETIME);
+    if (datetime != NULL && datetime->value != NULL) {
+        *out_len = datetime->value_len;
+        return datetime->value;
+    }
+    *out_len = 0;
+    return NULL;
+}
+
+/* Whether year-month-day is at least the min bound; the parts compare like the
+   ordinals htmldate's window uses, monotonically, so a component compare suffices. */
+static int date_at_least(int year, int month, int day, int min_year, int min_month, int min_day) {
+    if (year != min_year) {
+        return year > min_year;
+    }
+    if (month != min_month) {
+        return month > min_month;
+    }
+    return day >= min_day;
+}
+
+/* Document._date_meta(want, current_year, min_y, min_m, min_d, max_y, max_m, max_d)
+   -> (year, month, day) or None.
+
+   The <meta> stage of turbohtml.extract.dates, gathering and selection fused into
+   one walk. want is META_PUBLISHED (original=True) or META_MODIFIED; a candidate
+   whose role matches want wins on sight -- htmldate's _pick returns the first
+   wanted-role hit -- so the walk stops at the first such element instead of scoring
+   the rest. A date outside [min, max] is ignored; the first in-window off-role date
+   is the fallback _pick returns when no wanted-role date appears. */
+PyObject *turbohtml_document_date_meta(PyObject *self, PyObject *args) {
+    int want, current_year, min_year, min_month, min_day, max_year, max_month, max_day;
+    if (!PyArg_ParseTuple(args, "iiiiiiii:_date_meta", &want, &current_year, &min_year, &min_month, &min_day, &max_year,
+                          &max_month, &max_day)) {
+        return NULL;
+    }
+    th_tree *tree = tree_of(self);
+    th_node *root = ((NodeObject *)self)->node;
+    int wanted_hit = 0, wanted_year = 0, wanted_month = 0, wanted_day = 0;
+    int reserve_hit = 0, reserve_year = 0, reserve_month = 0, reserve_day = 0;
+    Py_BEGIN_CRITICAL_SECTION(((NodeObject *)self)->handle);
+    for (th_node *node = root->first_child; node != NULL; node = preorder_next(node, root)) {
+        if (node->type != TH_NODE_ELEMENT || node->atom != TH_TAG_META) {
+            continue;
+        }
+        int role = meta_role(tree, node);
+        if (role == META_NONE) {
+            continue;
+        }
+        Py_ssize_t len;
+        const Py_UCS4 *text = meta_date_text(node, &len);
+        if (text == NULL) {
+            continue;
+        }
+        int year, month, day;
+        if (!scan_first_date(text, PyUnicode_4BYTE_KIND, len, current_year, &year, &month, &day)) {
+            continue;
+        }
+        if (!date_at_least(year, month, day, min_year, min_month, min_day) ||
+            !date_at_least(max_year, max_month, max_day, year, month, day)) {
+            continue;
+        }
+        if (role == want) {
+            wanted_hit = 1;
+            wanted_year = year;
+            wanted_month = month;
+            wanted_day = day;
+            break;
+        }
+        if (!reserve_hit) {
+            reserve_hit = 1;
+            reserve_year = year;
+            reserve_month = month;
+            reserve_day = day;
+        }
+    }
+    Py_END_CRITICAL_SECTION();
+    if (wanted_hit) {
+        return Py_BuildValue("(iii)", wanted_year, wanted_month, wanted_day);
+    }
+    if (reserve_hit) {
+        return Py_BuildValue("(iii)", reserve_year, reserve_month, reserve_day);
+    }
+    Py_RETURN_NONE;
+}
diff --git a/src/turbohtml/_c/extract/links.c b/src/turbohtml/_c/extract/links.c
index 2d575c56..07bcfdcc 100644
--- a/src/turbohtml/_c/extract/links.c
+++ b/src/turbohtml/_c/extract/links.c
@@ -223,6 +223,11 @@ typedef struct {
     PyObject *owner;     /* the element/document the public call was made on, for wrapping enumerated nodes */
     PyObject *result;    /* list[Link] for enumerate, else NULL */
     PyObject *replace;   /* callable (str) -> str | None for rewrite, else NULL */
+    /* resolve_links only: the base URL's lowercased scheme, or NULL for the enumerate/rewrite paths. When set, a link
+       that urljoin(base, link) would return byte-for-byte (an absolute URL) is left untouched without the call. */
+    const char *base_scheme;
+    Py_ssize_t base_scheme_len;
+    int base_netloc_scheme; /* the base scheme reserializes an absolute same-scheme URL unchanged (http/https) */
     link_span *spans;
     Py_ssize_t span_count;
     Py_ssize_t span_cap;
@@ -282,15 +287,23 @@ static PyObject *ucs4_slice(const Py_UCS4 *value, Py_ssize_t start, Py_ssize_t e
     return PyUnicode_FromKindAndData(PyUnicode_4BYTE_KIND, value + start, end - start);
 }
 
-/* Append a Link(element, attr, url) for each span to the result list. `report_element` is the owning Element wrapper
-   and `report_attr` its attribute name (or None for <style> text); both are borrowed for the call's duration. */
-static int emit_enumerated(link_walk *walk, PyObject *report_element, PyObject *report_attr, const Py_UCS4 *value) {
+/* Append a Link(element, attr, url) for each span to the result list. The Element wrapper for `report_node` is minted
+   on the first link and cached in *report_element, so an element with no link (the vast majority on a real page) is
+   never wrapped. `report_attr` is the attribute name (or None for <style> text), borrowed for the call's duration. */
+static int emit_enumerated(link_walk *walk, PyObject **report_element, th_node *report_node, PyObject *report_attr,
+                           const Py_UCS4 *value) {
+    if (*report_element == NULL) {
+        *report_element = turbohtml_node_wrap_in(walk->owner, report_node);
+        if (*report_element == NULL) { /* GCOVR_EXCL_BR_LINE: allocation failure cannot be forced from a test */
+            return -1;                 /* GCOVR_EXCL_LINE: allocation-failure path */
+        }
+    }
     for (Py_ssize_t index = 0; index < walk->span_count; index++) {
         PyObject *url = ucs4_slice(value, walk->spans[index].start, walk->spans[index].end);
         if (url == NULL) { /* GCOVR_EXCL_BR_LINE: allocation failure cannot be forced from a test */
             return -1;     /* GCOVR_EXCL_LINE: allocation-failure path */
         }
-        PyObject *record = PyObject_CallFunction(walk->state->link_type, "OOO", report_element, report_attr, url);
+        PyObject *record = PyObject_CallFunction(walk->state->link_type, "OOO", *report_element, report_attr, url);
         Py_DECREF(url);
         if (record == NULL) { /* GCOVR_EXCL_BR_LINE: allocation failure cannot be forced from a test */
             return -1;        /* GCOVR_EXCL_LINE: allocation-failure path */
@@ -340,6 +353,59 @@ static int splice_value(link_walk *walk, th_node *target, const char *attr_name,
     return status;
 }
 
+/* True when resolve_links can prove urljoin(base, [start, end)) returns the URL byte-for-byte, so the urljoin call (the
+   bulk of resolve's cost, stdlib Python) is skipped for an already-absolute link. Mirrors CPython urllib.parse.urljoin:
+   a reference with a scheme differing from the base's (case-insensitively) is returned verbatim; a same-scheme absolute
+   reference (scheme://netloc...) is reserialized, which reproduces the input only when the scheme is already lowercase,
+   an authority is present, and no tab/CR/LF (which urlsplit strips) appears. The same-scheme case is enabled only for
+   an http/https base, whose scheme reserializes through urlunsplit's netloc branch. */
+static int url_resolves_to_itself(const Py_UCS4 *value, Py_ssize_t start, Py_ssize_t end, const char *base_scheme,
+                                  Py_ssize_t base_scheme_len, int base_netloc_scheme) {
+    if (!is_ascii_alpha(value[start])) { /* a scheme starts with a letter; a span is never empty (start < end) */
+        return 0;
+    }
+    Py_ssize_t colon = start + 1;
+    while (colon < end && value[colon] != ':') {
+        Py_UCS4 c = value[colon];
+        if (!is_ascii_alpha(c) && !is_ascii_digit(c) && c != '+' && c != '-' && c != '.') {
+            return 0;
+        }
+        colon++;
+    }
+    if (colon >= end) {
+        return 0;
+    }
+    Py_ssize_t scheme_len = colon - start;
+    int same_scheme = scheme_len == base_scheme_len;
+    for (Py_ssize_t index = 0; same_scheme && index < scheme_len; index++) {
+        same_scheme = lower_ascii(value[start + index]) == (Py_UCS4)(unsigned char)base_scheme[index];
+    }
+    if (!same_scheme) {
+        return 1;
+    }
+    if (!base_netloc_scheme) {
+        return 0;
+    }
+    for (Py_ssize_t index = 0; index < scheme_len; index++) {
+        if (value[start + index] != lower_ascii(value[start + index])) {
+            return 0;
+        }
+    }
+    if (colon + 2 >= end || value[colon + 1] != '/' || value[colon + 2] != '/') {
+        return 0;
+    }
+    Py_ssize_t netloc = colon + 3;
+    if (netloc >= end || value[netloc] == '/' || value[netloc] == '?' || value[netloc] == '#') {
+        return 0;
+    }
+    for (Py_ssize_t index = start; index < end; index++) {
+        if (value[index] == '\t' || value[index] == '\r' || value[index] == '\n') {
+            return 0;
+        }
+    }
+    return 1;
+}
+
 /* Call replace(url) for each span and build a rewritten value, or leave the value untouched when every replacement is
    None or unchanged. */
 static int rewrite_value(link_walk *walk, th_node *target, const char *attr_name, Py_ssize_t attr_len,
@@ -353,6 +419,11 @@ static int rewrite_value(link_walk *walk, th_node *target, const char *attr_name
     int changed = 0;
     int failed = 0;
     for (Py_ssize_t index = 0; index < walk->span_count; index++) {
+        if (walk->base_scheme != NULL &&
+            url_resolves_to_itself(value, walk->spans[index].start, walk->spans[index].end, walk->base_scheme,
+                                   walk->base_scheme_len, walk->base_netloc_scheme)) {
+            continue; /* an absolute URL resolve_links would leave unchanged; skip the urljoin call */
+        }
         PyObject *url = ucs4_slice(value, walk->spans[index].start, walk->spans[index].end);
         if (url == NULL) { /* GCOVR_EXCL_BR_LINE: allocation failure cannot be forced from a test */
             failed = 1;    /* GCOVR_EXCL_LINE: allocation-failure path */
@@ -392,11 +463,12 @@ static int rewrite_value(link_walk *walk, th_node *target, const char *attr_name
     return failed ? -1 : 0;
 }
 
-/* Scan one value with `scan`, then either record the spans or rewrite them. `report_element`/`report_attr` describe the
-   enumeration location; `target`/`attr_name`/`attr_len` describe where a rewrite writes back. */
-static int handle_value(link_walk *walk, PyObject *report_element, PyObject *report_attr, th_node *target,
-                        const char *attr_name, Py_ssize_t attr_len, const Py_UCS4 *value, Py_ssize_t len,
-                        scanner_fn scan) {
+/* Scan one value with `scan`, then either record the spans or rewrite them. `report_element` (the enumerate path's
+   lazily-wrapped element slot), `report_node`, and `report_attr` describe the enumeration location;
+   `target`/`attr_name`/ `attr_len` describe where a rewrite writes back. */
+static int handle_value(link_walk *walk, PyObject **report_element, th_node *report_node, PyObject *report_attr,
+                        th_node *target, const char *attr_name, Py_ssize_t attr_len, const Py_UCS4 *value,
+                        Py_ssize_t len, scanner_fn scan) {
     walk->span_count = 0;
     if (scan(value, len, collect_span, walk) < 0) { /* GCOVR_EXCL_BR_LINE: scan alloc only (collect_span realloc) */
         return -1;                                  /* GCOVR_EXCL_LINE: allocation-failure path */
@@ -405,7 +477,7 @@ static int handle_value(link_walk *walk, PyObject *report_element, PyObject *rep
         return 0;
     }
     if (walk->result != NULL) {
-        return emit_enumerated(walk, report_element, report_attr, value);
+        return emit_enumerated(walk, report_element, report_node, report_attr, value);
     }
     return rewrite_value(walk, target, attr_name, attr_len, value, len);
 }
@@ -477,13 +549,7 @@ static int is_meta_refresh(link_walk *walk, th_node *element) {
 }
 
 static int process_element(link_walk *walk, th_node *element) {
-    PyObject *report_element = NULL;
-    if (walk->result != NULL) {
-        report_element = turbohtml_node_wrap_in(walk->owner, element);
-        if (report_element == NULL) { /* GCOVR_EXCL_BR_LINE: allocation failure cannot be forced from a test */
-            return -1;                /* GCOVR_EXCL_LINE: allocation-failure path */
-        }
-    }
+    PyObject *report_element = NULL; /* the enumerate path wraps `element` lazily, on its first emitted link */
     int failed = 0;
     /* a <style>'s text children are a stylesheet, scanned for url()/@import like a style attribute. A parsed text node
        holds a zero-copy span, not a ready buffer, so its data is materialized (and freed) per child. The children are
@@ -508,8 +574,8 @@ static int process_element(link_walk *walk, th_node *element) {
                 failed = 1;     /* GCOVR_EXCL_LINE: allocation-failure path */
                 break;          /* GCOVR_EXCL_LINE */
             }
-            failed =
-                handle_value(walk, report_element, Py_None, children[index], NULL, 0, text, text_len, scan_css) < 0;
+            failed = handle_value(walk, &report_element, element, Py_None, children[index], NULL, 0, text, text_len,
+                                  scan_css) < 0;
             PyMem_Free(text);
         }
         PyMem_Free(children);
@@ -527,7 +593,7 @@ static int process_element(link_walk *walk, th_node *element) {
                     return -1;                  /* GCOVR_EXCL_LINE */
                 }
             }
-            failed = handle_value(walk, report_element, report_attr, element, "content", 7, content, len,
+            failed = handle_value(walk, &report_element, element, report_attr, element, "content", 7, content, len,
                                   scan_meta_refresh) < 0;
             Py_XDECREF(report_attr);
         }
@@ -547,8 +613,8 @@ static int process_element(link_walk *walk, th_node *element) {
                 break;                 /* GCOVR_EXCL_LINE */
             }
         }
-        failed = handle_value(walk, report_element, report_attr, element, name, name_len, element->attrs[index].value,
-                              element->attrs[index].value_len, scan) < 0;
+        failed = handle_value(walk, &report_element, element, report_attr, element, name, name_len,
+                              element->attrs[index].value, element->attrs[index].value_len, scan) < 0;
         Py_XDECREF(report_attr);
     }
     Py_XDECREF(report_element);
@@ -582,8 +648,15 @@ static int collect_subtree(link_walk *walk, th_node *root) {
 /* Shared engine: run the walk over `root` under `owner`'s per-tree critical section. The thin Node methods in
    dom/node.c derive (owner, tree, root) straight from the node and hand them here; the module state for the Link
    record type and the per-tree handle for the lock come off `owner`. */
-static PyObject *run_walk(PyObject *owner, th_tree *tree, th_node *root, PyObject *result, PyObject *replace) {
-    link_walk walk = {.tree = tree, .owner = owner, .result = result, .replace = replace};
+static PyObject *run_walk(PyObject *owner, th_tree *tree, th_node *root, PyObject *result, PyObject *replace,
+                          const char *base_scheme, Py_ssize_t base_scheme_len, int base_netloc_scheme) {
+    link_walk walk = {.tree = tree,
+                      .owner = owner,
+                      .result = result,
+                      .replace = replace,
+                      .base_scheme = base_scheme,
+                      .base_scheme_len = base_scheme_len,
+                      .base_netloc_scheme = base_netloc_scheme};
     walk.state = PyType_GetModuleState(Py_TYPE(owner));
     /* read the handle into the struct (always, so it is covered) rather than into the macro argument, which the GIL
        build's no-op Py_BEGIN_CRITICAL_SECTION does not evaluate */
@@ -618,7 +691,7 @@ PyObject *turbohtml_node_links(PyObject *owner, th_tree *tree, th_node *root) {
     if (result == NULL) { /* GCOVR_EXCL_BR_LINE: allocation failure cannot be forced from a test */
         return NULL;      /* GCOVR_EXCL_LINE: allocation-failure path */
     }
-    return run_walk(owner, tree, root, result, NULL);
+    return run_walk(owner, tree, root, result, NULL, NULL, 0, 0);
 }
 
 /* Node.rewrite_links(replace) -> None. Calls replace(url) for every link; a str result replaces it, None leaves it. */
@@ -627,7 +700,27 @@ PyObject *turbohtml_node_rewrite_links(PyObject *owner, th_tree *tree, th_node *
         PyErr_SetString(PyExc_TypeError, "rewrite_links expected a callable");
         return NULL;
     }
-    return run_walk(owner, tree, root, NULL, replace);
+    return run_walk(owner, tree, root, NULL, replace, NULL, 0, 0);
+}
+
+/* base_url's scheme, lowercased into `out` (capacity `cap`), or 0 when it carries no parseable RFC 3986 scheme (alpha
+ *(alpha / digit / "+" / "-" / ".") ":") or one too long to be one, in which case the absolute-URL skip stays off. */
+static Py_ssize_t base_scheme_of(PyObject *base_url, char *out, Py_ssize_t cap) {
+    Py_ssize_t len = PyUnicode_GET_LENGTH(base_url);
+    if (len == 0 || !is_ascii_alpha(PyUnicode_READ_CHAR(base_url, 0))) {
+        return 0;
+    }
+    for (Py_ssize_t index = 0; index < len && index < cap; index++) {
+        Py_UCS4 c = PyUnicode_READ_CHAR(base_url, index);
+        if (c == ':') {
+            return index;
+        }
+        if (!is_ascii_alpha(c) && !is_ascii_digit(c) && c != '+' && c != '-' && c != '.') {
+            return 0;
+        }
+        out[index] = (char)lower_ascii(c);
+    }
+    return 0;
 }
 
 /* Node.resolve_links(base_url) -> None. Rewrites every link absolute against base_url with functools.partial bound over
@@ -637,6 +730,10 @@ PyObject *turbohtml_node_resolve_links(PyObject *owner, th_tree *tree, th_node *
         PyErr_SetString(PyExc_TypeError, "resolve_links expected a base URL string");
         return NULL;
     }
+    char base_scheme[16];
+    Py_ssize_t base_scheme_len = base_scheme_of(base_url, base_scheme, (Py_ssize_t)sizeof(base_scheme));
+    int base_netloc_scheme = (base_scheme_len == 4 && memcmp(base_scheme, "http", 4) == 0) ||
+                             (base_scheme_len == 5 && memcmp(base_scheme, "https", 5) == 0);
     PyObject *parse_module = PyImport_ImportModule("urllib.parse");
     if (parse_module == NULL) { /* GCOVR_EXCL_BR_LINE: a stdlib import cannot be forced to fail from a test */
         return NULL;            /* GCOVR_EXCL_LINE: import-failure path */
@@ -663,7 +760,8 @@ PyObject *turbohtml_node_resolve_links(PyObject *owner, th_tree *tree, th_node *
     if (bound == NULL) { /* GCOVR_EXCL_BR_LINE: binding a partial cannot be forced to fail from a test */
         return NULL;     /* GCOVR_EXCL_LINE: allocation-failure path */
     }
-    PyObject *result = run_walk(owner, tree, root, NULL, bound);
+    PyObject *result = run_walk(owner, tree, root, NULL, bound, base_scheme_len > 0 ? base_scheme : NULL,
+                                base_scheme_len, base_netloc_scheme);
     Py_DECREF(bound);
     return result;
 }
diff --git a/src/turbohtml/_c/tokenizer/binding.h b/src/turbohtml/_c/tokenizer/binding.h
index 41673156..8cabce68 100644
--- a/src/turbohtml/_c/tokenizer/binding.h
+++ b/src/turbohtml/_c/tokenizer/binding.h
@@ -131,6 +131,11 @@ PyObject *turbohtml_rewrite(PyObject *module, PyObject *args);
    METH_O. */
 PyObject *turbohtml_sax_events(PyObject *module, PyObject *arg);
 
+/* Parse markup and drive a handler object's start_element/end_element/characters/comment/doctype/
+   processing_instruction methods over the events in document order, building no per-event record; the push
+   form behind turbohtml.saxparse.sax_parse. Matches METH_VARARGS: (source, handler). */
+PyObject *turbohtml_sax_dispatch(PyObject *module, PyObject *args);
+
 /* Parse markup and drive a caller-supplied builder object over the constructed tree in
    document order (create_document/create_doctype/create_element/create_text/
    create_comment/create_pi/append), returning whatever the builder made its root without
diff --git a/src/turbohtml/_c/tokenizer/sax.c b/src/turbohtml/_c/tokenizer/sax.c
index aafa3d35..45366b9b 100644
--- a/src/turbohtml/_c/tokenizer/sax.c
+++ b/src/turbohtml/_c/tokenizer/sax.c
@@ -280,3 +280,157 @@ int sax_register(PyObject *module, module_state *state) {
     }
     return 0;
 }
+
+/* The handler methods _sax_dispatch drives, bound once per call and indexed by the enum, so binding walks the name
+   table rather than testing six lookups in one condition. */
+enum { SAX_H_START, SAX_H_END, SAX_H_CHARACTERS, SAX_H_COMMENT, SAX_H_DOCTYPE, SAX_H_PI, SAX_H_COUNT };
+
+static const char *const SAX_HANDLER_NAMES[SAX_H_COUNT] = {
+    "start_element", "end_element", "characters", "comment", "doctype", "processing_instruction",
+};
+
+typedef struct {
+    PyObject *fn[SAX_H_COUNT];
+} sax_dispatch_handlers;
+
+static void sax_handlers_release(sax_dispatch_handlers *bound) {
+    for (int index = 0; index < SAX_H_COUNT; index++) {
+        Py_XDECREF(bound->fn[index]);
+    }
+}
+
+static int sax_handlers_bind(sax_dispatch_handlers *bound, PyObject *handler) {
+    for (int index = 0; index < SAX_H_COUNT; index++) {
+        bound->fn[index] = NULL;
+    }
+    for (int index = 0; index < SAX_H_COUNT; index++) {
+        bound->fn[index] = PyObject_GetAttrString(handler, SAX_HANDLER_NAMES[index]);
+        if (bound->fn[index] == NULL) {
+            sax_handlers_release(bound);
+            return -1;
+        }
+    }
+    return 0;
+}
+
+/* Call one bound handler for entering node; 0 to continue, -1 with an exception set to stop. A node that emits
+   nothing on entry (the document root, a template content fragment) continues without a call. */
+static int dispatch_enter(th_tree *tree, th_node *node, sax_dispatch_handlers *bound) {
+    PyObject *result = NULL;
+    switch (node->type) {
+    case TH_NODE_ELEMENT: {
+        PyObject *tag = PyUnicode_FromKindAndData(PyUnicode_4BYTE_KIND, node->text, node->text_len);
+        if (tag == NULL) { /* GCOVR_EXCL_BR_LINE: allocation failure cannot be forced from a test */
+            return -1;     /* GCOVR_EXCL_LINE: allocation-failure path */
+        }
+        PyObject *attrs = attrs_tuple(tree, node);
+        if (attrs == NULL) { /* GCOVR_EXCL_BR_LINE: allocation failure cannot be forced from a test */
+            Py_DECREF(tag);  /* GCOVR_EXCL_LINE: allocation-failure path */
+            return -1;       /* GCOVR_EXCL_LINE: allocation-failure path */
+        }
+        result = PyObject_CallFunctionObjArgs(bound->fn[SAX_H_START], tag, attrs, NULL);
+        Py_DECREF(tag);
+        Py_DECREF(attrs);
+        break;
+    }
+    case TH_NODE_TEXT:
+    case TH_NODE_COMMENT: {
+        PyObject *data = data_str(tree, node);
+        if (data == NULL) { /* GCOVR_EXCL_BR_LINE: allocation failure cannot be forced from a test */
+            return -1;      /* GCOVR_EXCL_LINE: allocation-failure path */
+        }
+        int which = node->type == TH_NODE_TEXT             ? SAX_H_CHARACTERS
+                    : (node->tag_flags & TH_COMMENT_IS_PI) ? SAX_H_PI
+                                                           : SAX_H_COMMENT;
+        result = PyObject_CallFunctionObjArgs(bound->fn[which], data, NULL);
+        Py_DECREF(data);
+        break;
+    }
+    case TH_NODE_DOCTYPE: {
+        /* the tuple event builder is reused, then unpacked, so the identifier extraction lives in one place */
+        PyObject *event = doctype_event(tree, node);
+        if (event == NULL) { /* GCOVR_EXCL_BR_LINE: allocation failure cannot be forced from a test */
+            return -1;       /* GCOVR_EXCL_LINE: allocation-failure path */
+        }
+        result = PyObject_CallFunctionObjArgs(bound->fn[SAX_H_DOCTYPE], PyTuple_GET_ITEM(event, 1),
+                                              PyTuple_GET_ITEM(event, 2), PyTuple_GET_ITEM(event, 3), NULL);
+        Py_DECREF(event);
+        break;
+    }
+    default: /* TH_NODE_DOCUMENT and TH_NODE_CONTENT emit nothing themselves */
+        return 0;
+    }
+    if (result == NULL) {
+        return -1;
+    }
+    Py_DECREF(result);
+    return 0;
+}
+
+/* Call the end_element handler when leaving node; 0 to continue, -1 with an exception set to stop. Only an
+   element has a close. */
+static int dispatch_leave(th_node *node, sax_dispatch_handlers *bound) {
+    if (node->type != TH_NODE_ELEMENT) {
+        return 0;
+    }
+    PyObject *tag = PyUnicode_FromKindAndData(PyUnicode_4BYTE_KIND, node->text, node->text_len);
+    if (tag == NULL) { /* GCOVR_EXCL_BR_LINE: allocation failure cannot be forced from a test */
+        return -1;     /* GCOVR_EXCL_LINE: allocation-failure path */
+    }
+    PyObject *result = PyObject_CallFunctionObjArgs(bound->fn[SAX_H_END], tag, NULL);
+    Py_DECREF(tag);
+    if (result == NULL) {
+        return -1;
+    }
+    Py_DECREF(result);
+    return 0;
+}
+
+/* _sax_dispatch(html, handler): parse and drive the handler's methods over the events in document order, building
+   no per-event record. The push form of the walk _sax_events streams; sax_parse wraps this. */
+PyObject *turbohtml_sax_dispatch(PyObject *Py_UNUSED(module), PyObject *args) {
+    PyObject *html;
+    PyObject *handler;
+    if (!PyArg_ParseTuple(args, "UO:_sax_dispatch", &html, &handler)) {
+        return NULL;
+    }
+    sax_dispatch_handlers bound;
+    if (sax_handlers_bind(&bound, handler) < 0) {
+        return NULL;
+    }
+    th_tree *tree = th_tree_parse(PyUnicode_KIND(html), PyUnicode_DATA(html), PyUnicode_GET_LENGTH(html), 0, 0, 0, 1);
+    if (tree == NULL) {               /* GCOVR_EXCL_BR_LINE: only an allocation failure returns NULL */
+        sax_handlers_release(&bound); /* GCOVR_EXCL_LINE: allocation-failure path */
+        return PyErr_NoMemory();      /* GCOVR_EXCL_LINE: allocation-failure path */
+    }
+    th_node *cursor = th_tree_document(tree);
+    int leaving = 0;
+    int failed = 0;
+    while (!failed) {
+        th_node *node = cursor;
+        if (!leaving) {
+            failed = dispatch_enter(tree, node, &bound) < 0;
+            if (node->first_child != NULL) {
+                cursor = node->first_child;
+            } else {
+                leaving = 1;
+            }
+        } else {
+            failed = dispatch_leave(node, &bound) < 0;
+            if (node->next_sibling != NULL) {
+                cursor = node->next_sibling;
+                leaving = 0;
+            } else if (node->parent != NULL) {
+                cursor = node->parent;
+            } else {
+                break;
+            }
+        }
+    }
+    th_tree_free(tree);
+    sax_handlers_release(&bound);
+    if (failed) {
+        return NULL;
+    }
+    Py_RETURN_NONE;
+}
diff --git a/src/turbohtml/_c/url/url.c b/src/turbohtml/_c/url/url.c
index 9c847036..e9f68435 100644
--- a/src/turbohtml/_c/url/url.c
+++ b/src/turbohtml/_c/url/url.c
@@ -56,18 +56,13 @@ Py_ssize_t th_url_encode_span(char *out, Py_ssize_t at, const char *bytes, Py_ss
     return at;
 }
 
-/* _url_percent_encode(text, set_id): the shim's per-component encoder, replacing urllib.parse.quote plus a preceding
-   uppercase-escape sweep. It UTF-8 encodes the component (a lone surrogate has no encoding, so this raises), then
-   rewrites an existing %XX to uppercase hex and percent-encodes every byte outside the set. Since '%' stays in every
-   keep set, a valid escape survives; a stray '%' or a truncated %X is a literal byte the set keeps. */
-PyObject *turbohtml_url_percent_encode(PyObject *Py_UNUSED(module), PyObject *args) {
-    PyObject *text;
-    int set_id;
-    if (!PyArg_ParseTuple(args, "Ui", &text, &set_id)) {
-        return NULL;
-    }
+/* th_url_percent_encode_obj(text, set_id): the per-component encoder body, exposed so the query normalizer can encode a
+   surviving pair without rebuilding an argument tuple. It UTF-8 encodes the component (a lone surrogate has no
+   encoding, so this raises the UnicodeEncodeError PyUnicode_AsUTF8AndSize sets), then rewrites an existing %XX to
+   uppercase hex and percent-encodes every byte outside the set. Since '%' stays in every keep set, a valid escape
+   survives; a stray '%' or a truncated %X is a literal byte the set keeps. */
+static PyObject *th_url_percent_encode_obj(PyObject *text, int set_id) {
     Py_ssize_t len;
-    /* a lone surrogate has no UTF-8 form; the shim rewraps the UnicodeEncodeError PyUnicode_AsUTF8AndSize sets */
     const char *bytes = PyUnicode_AsUTF8AndSize(text, &len);
     if (bytes == NULL) {
         return NULL;
@@ -104,6 +99,18 @@ PyObject *turbohtml_url_percent_encode(PyObject *Py_UNUSED(module), PyObject *ar
     return result; /* NULL only on the excluded decode-failure path */
 }
 
+/* _url_percent_encode(text, set_id): the shim's per-component encoder, replacing urllib.parse.quote plus a preceding
+   uppercase-escape sweep. A lone surrogate has no encoding, so this raises; the shim rewraps that UnicodeEncodeError.
+ */
+PyObject *turbohtml_url_percent_encode(PyObject *Py_UNUSED(module), PyObject *args) {
+    PyObject *text;
+    int set_id;
+    if (!PyArg_ParseTuple(args, "Ui", &text, &set_id)) {
+        return NULL;
+    }
+    return th_url_percent_encode_obj(text, set_id);
+}
+
 /* Flush the decoded byte run to the UCS4 output as UTF-8 with U+FFFD replacement (urllib's errors="replace"), so an
    invalid sequence never fails; returns -1 with an error set only on the excluded allocation-failure path. */
 static int decode_flush(const unsigned char *run, Py_ssize_t run_len, Py_UCS4 *out, Py_ssize_t *out_len) {
@@ -124,11 +131,12 @@ static int decode_flush(const unsigned char *run, Py_ssize_t run_len, Py_UCS4 *o
     return 0;
 }
 
-/* _url_percent_decode(text): the shim's per-component decoder, replacing urllib.parse.unquote. It walks the string,
-   turning a %XX inside an ASCII run into its byte and keeping any other ASCII char or non-ASCII code point verbatim,
-   then UTF-8 decodes each ASCII byte run with U+FFFD replacement. A non-ASCII input char ends the current run, matching
-   the ascii/non-ascii split unquote makes, so a raw code point (even a lone surrogate) survives unencoded. */
-PyObject *turbohtml_url_percent_decode(PyObject *Py_UNUSED(module), PyObject *arg) {
+/* th_url_percent_decode_obj(text): the per-component decoder body, exposed so the query normalizer and language filter
+   can decode a key span without an argument tuple. It walks the string, turning a %XX inside an ASCII run into its byte
+   and keeping any other ASCII char or non-ASCII code point verbatim, then UTF-8 decodes each ASCII byte run with U+FFFD
+   replacement. A non-ASCII input char ends the current run, matching the ascii/non-ascii split unquote makes, so a raw
+   code point (even a lone surrogate) survives unencoded. */
+static PyObject *th_url_percent_decode_obj(PyObject *arg) {
     Py_ssize_t len = PyUnicode_GET_LENGTH(arg);
     int kind = PyUnicode_KIND(arg);
     const void *data = PyUnicode_DATA(arg);
@@ -173,6 +181,11 @@ PyObject *turbohtml_url_percent_decode(PyObject *Py_UNUSED(module), PyObject *ar
     return result; /* NULL only on the excluded flush- or build-failure path */
 }
 
+/* _url_percent_decode(text): the shim's per-component decoder, replacing urllib.parse.unquote. */
+PyObject *turbohtml_url_percent_decode(PyObject *Py_UNUSED(module), PyObject *arg) {
+    return th_url_percent_decode_obj(arg);
+}
+
 /* The bytes the basic parser removes from anywhere in the input (spec 4.4 step 2). Leading C0-or-space is stripped
    separately; these three are also excised mid-URL. An array probe, not a chained ||, keeps the branch gate stable. */
 static int is_removed(Py_UCS4 ch) {
@@ -798,3 +811,661 @@ PyObject *turbohtml_url_join(PyObject *Py_UNUSED(module), PyObject *args) {
     }
     return th_url_join(base, target);
 }
+
+/* The tracking-parameter vocabulary. A crawl-oriented cleaner drops these query keys because they identify the
+   referral, not the content, so two URLs differing only in them address the same page. Kept sorted so the exact-name
+   test is a binary search. */
+static const char *const TRACKER_NAMES[] = {
+    "clickid", "dclid",  "efid",   "epik",   "fb_ref",   "fb_source", "fbclid",    "gbraid",
+    "gclid",   "gclsrc", "igsh",   "igshid", "mkt_tok",  "msclkid",   "partnerid", "s_cid",
+    "sc_cid",  "ttclid", "twclid", "wbraid", "wickedid", "yclid",     "ysclid",
+};
+
+static const char *const TRACKER_PREFIXES[] = {
+    "ad_", "ads_", "ga_", "gs_", "hsa_", "itm_", "mc_", "mtm_", "oly_", "pk_", "utm_", "vero_",
+};
+
+/* The words a tracking key is built from, matched as a whole underscore-delimited word rather than a substring so
+   "reference" is not read as "ref". */
+static const char *const TRACKER_WORDS[] = {
+    "aff", "affi",  "affiliate", "campaign", "cid",     "clid",   "keyword", "kwd",  "medium",
+    "ref", "refer", "referer",   "referrer", "session", "source", "uid",     "xtor",
+};
+
+static int tracker_name_known(const char *key, size_t len) {
+    size_t low = 0;
+    size_t high = sizeof(TRACKER_NAMES) / sizeof(TRACKER_NAMES[0]);
+    while (low < high) {
+        size_t mid = low + (high - low) / 2;
+        int order = strncmp(TRACKER_NAMES[mid], key, len);
+        if (order == 0 && TRACKER_NAMES[mid][len] != '\0') {
+            order = 1;
+        }
+        if (order == 0) {
+            return 1;
+        }
+        if (order < 0) {
+            low = mid + 1;
+        } else {
+            high = mid;
+        }
+    }
+    return 0;
+}
+
+static int tracker_word_at(const char *key, size_t start, size_t end) {
+    size_t len = end - start;
+    for (size_t index = 0; index < sizeof(TRACKER_WORDS) / sizeof(TRACKER_WORDS[0]); index++) {
+        if (strlen(TRACKER_WORDS[index]) == len && strncmp(TRACKER_WORDS[index], key + start, len) == 0) {
+            return 1;
+        }
+    }
+    return 0;
+}
+
+/* th_url_is_tracker_obj(key): whether a lowercased query-parameter name identifies a referral rather than content;
+   returns 1 for a tracker, 0 otherwise, and -1 with a UnicodeEncodeError set when the key carries a lone surrogate (a
+   raw surrogate the caller's URL held, which has no UTF-8 form). Exposed so the query normalizer decides a pair without
+   materializing a Py_True/Py_False per key. */
+static int th_url_is_tracker_obj(PyObject *key_obj) {
+    Py_ssize_t size;
+    const char *key = PyUnicode_AsUTF8AndSize(key_obj, &size);
+    if (key == NULL) {
+        return -1;
+    }
+    size_t len = (size_t)size;
+    if (tracker_name_known(key, len)) {
+        return 1;
+    }
+    for (size_t index = 0; index < sizeof(TRACKER_PREFIXES) / sizeof(TRACKER_PREFIXES[0]); index++) {
+        size_t plen = strlen(TRACKER_PREFIXES[index]);
+        if (len >= plen && strncmp(key, TRACKER_PREFIXES[index], plen) == 0) {
+            return 1;
+        }
+    }
+    if (len >= 4 && strncmp(key + len - 4, "clid", 4) == 0) {
+        return 1;
+    }
+    /* each underscore-delimited word, so a tracking word anywhere in the name matches but a longer word containing
+       one does not */
+    size_t start = 0;
+    for (size_t index = 0; index <= len; index++) {
+        if (index == len || key[index] == '_') {
+            if (tracker_word_at(key, start, index)) {
+                return 1;
+            }
+            start = index + 1;
+        }
+    }
+    return 0;
+}
+
+/* _url_is_tracker(key): whether a lowercased query-parameter name identifies a referral rather than content. */
+PyObject *turbohtml_url_is_tracker(PyObject *Py_UNUSED(module), PyObject *arg) {
+    if (!PyUnicode_Check(arg)) {
+        PyErr_SetString(PyExc_TypeError, "_url_is_tracker() argument must be str");
+        return NULL;
+    }
+    int tracker = th_url_is_tracker_obj(arg);
+    if (tracker < 0) { /* a lone-surrogate key has no UTF-8 form, so the UnicodeEncodeError propagates */
+        return NULL;
+    }
+    return PyBool_FromLong(tracker);
+}
+
+/* Whether the segment work[start,end) spells "." or ".." once its %2E escapes are read as dots; `dots` receives the
+   dot count so the caller can tell the two apart. A segment of anything else answers zero. */
+static int dot_segment(const Py_UCS4 *work, Py_ssize_t start, Py_ssize_t end, int *dots) {
+    int count = 0;
+    for (Py_ssize_t index = start; index < end;) {
+        if (work[index] == '.') {
+            index += 1;
+        } else if (index + 2 < end && work[index] == '%' && work[index + 1] == '2' &&
+                   (work[index + 2] == 'E' || work[index + 2] == 'e')) {
+            index += 3;
+        } else {
+            return 0;
+        }
+        count += 1;
+        if (count > 2) {
+            return 0;
+        }
+    }
+    *dots = count;
+    return count == 1 || count == 2;
+}
+
+/* _url_remove_dot_segments(path): resolve the "." and ".." segments of a path, in either their literal or %2E
+   spelling, keeping every other segment's encoding verbatim. */
+PyObject *turbohtml_url_remove_dot_segments(PyObject *Py_UNUSED(module), PyObject *arg) {
+    if (!PyUnicode_Check(arg)) {
+        PyErr_SetString(PyExc_TypeError, "_url_remove_dot_segments() argument must be str");
+        return NULL;
+    }
+    Py_ssize_t len = PyUnicode_GET_LENGTH(arg);
+    int kind = PyUnicode_KIND(arg);
+    const void *data = PyUnicode_DATA(arg);
+    Py_UCS4 *work = PyMem_Malloc((size_t)(len + 1) * sizeof(Py_UCS4));
+    if (work == NULL) {          /* GCOVR_EXCL_BR_LINE: allocation failure cannot be forced from a test */
+        return PyErr_NoMemory(); /* GCOVR_EXCL_LINE: allocation-failure path */
+    }
+    int dotted = 0;
+    for (Py_ssize_t index = 0; index < len; index++) {
+        work[index] = PyUnicode_READ(kind, data, index);
+        if (work[index] == '.' || work[index] == '%') {
+            dotted = 1;
+        }
+    }
+    if (!dotted) { /* no segment can be dotted, so the path resolves to itself */
+        PyMem_Free(work);
+        return Py_NewRef(arg);
+    }
+    /* segment starts, so popping a ".." is dropping the last recorded start */
+    Py_ssize_t *starts = PyMem_Malloc((size_t)(len + 2) * sizeof(Py_ssize_t));
+    Py_ssize_t *ends = PyMem_Malloc((size_t)(len + 2) * sizeof(Py_ssize_t));
+    if (starts == NULL || ends == NULL) { /* GCOVR_EXCL_BR_LINE: allocation failure cannot be forced from a test */
+        PyMem_Free(work);                 /* GCOVR_EXCL_LINE: allocation-failure path */
+        PyMem_Free(starts);               /* GCOVR_EXCL_LINE: allocation-failure path */
+        PyMem_Free(ends);                 /* GCOVR_EXCL_LINE: allocation-failure path */
+        return PyErr_NoMemory();          /* GCOVR_EXCL_LINE: allocation-failure path */
+    }
+    Py_ssize_t kept = 0;
+    Py_ssize_t start = 0;
+    int last_dots = 0;
+    for (Py_ssize_t index = 0; index <= len; index++) {
+        if (index != len && work[index] != '/') {
+            continue;
+        }
+        last_dots = 0;
+        int single = dot_segment(work, start, index, &last_dots);
+        if (single && last_dots == 1) {
+            last_dots = 1;
+        } else if (single) {
+            /* a ".." drops the previous segment, but never the leading empty one a rooted path opens with */
+            if (kept > 1) {
+                kept -= 1;
+            }
+        } else {
+            starts[kept] = start;
+            ends[kept] = index;
+            kept += 1;
+            last_dots = 0;
+        }
+        start = index + 1;
+    }
+    if (last_dots != 0) { /* a trailing dot segment leaves the path ending in a separator */
+        starts[kept] = 0;
+        ends[kept] = 0;
+        kept += 1;
+    }
+    Py_ssize_t total = kept - 1; /* kept >= 1: the final segment always records one entry or bumps the trailing dot */
+    for (Py_ssize_t index = 0; index < kept; index++) {
+        total += ends[index] - starts[index];
+    }
+    Py_UCS4 *out = PyMem_Malloc((size_t)(total + 1) * sizeof(Py_UCS4));
+    if (out == NULL) {           /* GCOVR_EXCL_BR_LINE: allocation failure cannot be forced from a test */
+        PyMem_Free(work);        /* GCOVR_EXCL_LINE: allocation-failure path */
+        PyMem_Free(starts);      /* GCOVR_EXCL_LINE: allocation-failure path */
+        PyMem_Free(ends);        /* GCOVR_EXCL_LINE: allocation-failure path */
+        return PyErr_NoMemory(); /* GCOVR_EXCL_LINE: allocation-failure path */
+    }
+    Py_ssize_t at = 0;
+    for (Py_ssize_t index = 0; index < kept; index++) {
+        if (index != 0) {
+            out[at++] = '/';
+        }
+        for (Py_ssize_t scan = starts[index]; scan < ends[index]; scan++) {
+            out[at++] = work[scan];
+        }
+    }
+    PyObject *result = PyUnicode_FromKindAndData(PyUnicode_4BYTE_KIND, out, at);
+    PyMem_Free(work);
+    PyMem_Free(starts);
+    PyMem_Free(ends);
+    PyMem_Free(out);
+    return result;
+}
+
+/* _url_scrub(url): undo the HTML transport damage a scraped URL carries before it is split. It strips the leading and
+   trailing C0-control and space bytes the WHATWG basic parser removes (spec 4.4 steps 1-2), drops every whitespace
+   character str.split() would so a URL broken across lines rejoins, unwraps a <![CDATA[...]]> wrapper, truncates at the
+   first '<', '>', or '"' a stray markup delimiter left, undoes a leftover &amp; escape, and drops a trailing '&' left
+   dangling after a '/'. Replaces the Python scrub's strip/split/join, regex split, and replace chain, run once per URL.
+ */
+PyObject *turbohtml_url_scrub(PyObject *Py_UNUSED(module), PyObject *arg) {
+    if (!PyUnicode_Check(arg)) {
+        PyErr_SetString(PyExc_TypeError, "_url_scrub() argument must be str");
+        return NULL;
+    }
+    Py_ssize_t len = PyUnicode_GET_LENGTH(arg);
+    int kind = PyUnicode_KIND(arg);
+    const void *data = PyUnicode_DATA(arg);
+    /* strip(_C0_AND_SPACE): the edge run of code points at or below U+0020, which includes the non-whitespace C0
+       controls str.split() would keep in the middle */
+    Py_ssize_t start = 0;
+    Py_ssize_t end = len;
+    while (start < end && PyUnicode_READ(kind, data, start) <= 0x20) {
+        start++;
+    }
+    while (end > start && PyUnicode_READ(kind, data, end - 1) <= 0x20) {
+        end--;
+    }
+    Py_UCS4 *work = PyMem_Malloc((size_t)(end - start + 1) * sizeof(Py_UCS4));
+    if (work == NULL) {          /* GCOVR_EXCL_BR_LINE: allocation failure cannot be forced from a test */
+        return PyErr_NoMemory(); /* GCOVR_EXCL_LINE: allocation-failure path */
+    }
+    /* "".join(...split()): drop every whitespace code point, leaving the non-whitespace runs concatenated */
+    Py_ssize_t count = 0;
+    for (Py_ssize_t index = start; index < end; index++) {
+        Py_UCS4 ch = PyUnicode_READ(kind, data, index);
+        if (!Py_UNICODE_ISSPACE(ch)) {
+            work[count++] = ch;
+        }
+    }
+    Py_ssize_t lo = 0;
+    Py_ssize_t hi = count;
+    static const Py_UCS4 CDATA_OPEN[] = {'<', '!', '[', 'C', 'D', 'A', 'T', 'A', '['};
+    Py_ssize_t cdata_len = (Py_ssize_t)(sizeof(CDATA_OPEN) / sizeof(CDATA_OPEN[0]));
+    int is_cdata = hi - lo >= cdata_len;
+    for (Py_ssize_t index = 0; is_cdata && index < cdata_len; index++) {
+        is_cdata = work[lo + index] == CDATA_OPEN[index];
+    }
+    if (is_cdata) {
+        lo += cdata_len;
+        if (hi - lo >= 3 && work[hi - 3] == ']' && work[hi - 2] == ']' && work[hi - 1] == '>') {
+            hi -= 3; /* removesuffix("]]>") applies only after the prefix was stripped */
+        }
+    }
+    for (Py_ssize_t index = lo; index < hi; index++) { /* truncate at the first markup delimiter, the regex split */
+        Py_UCS4 ch = work[index];
+        if (ch == '<' || ch == '>' || ch == '"') {
+            hi = index;
+            break;
+        }
+    }
+    /* replace("&amp;", "&") in place: the write cursor never overtakes the read cursor, so no second buffer is needed
+     */
+    Py_ssize_t at = 0;
+    for (Py_ssize_t index = lo; index < hi;) {
+        if (hi - index >= 5 && work[index] == '&' && work[index + 1] == 'a' && work[index + 2] == 'm' &&
+            work[index + 3] == 'p' && work[index + 4] == ';') {
+            work[at++] = '&';
+            index += 5;
+        } else {
+            work[at++] = work[index];
+            index++;
+        }
+    }
+    if (at >= 2 && work[at - 2] == '/' && work[at - 1] == '&') {
+        at -= 1; /* removesuffix("&") on a "/&" tail, the dangling separator a stripped &amp; can leave */
+    }
+    PyObject *result = PyUnicode_FromKindAndData(PyUnicode_4BYTE_KIND, work, at);
+    PyMem_Free(work);
+    return result;
+}
+
+/* _url_variant_key(url): collapse the scheme and a bare trailing slash so the http/https and slash twins of one address
+   deduplicate. The key is everything after the first "://" (nothing when the URL carries no authority marker); a key
+   holding a '?' or '#' keeps its trailing slashes, since there a slash is content, otherwise the trailing run is
+   trimmed. Runs once per surviving link in the extract_links dedup walk. */
+PyObject *turbohtml_url_variant_key(PyObject *Py_UNUSED(module), PyObject *arg) {
+    if (!PyUnicode_Check(arg)) {
+        PyErr_SetString(PyExc_TypeError, "_url_variant_key() argument must be str");
+        return NULL;
+    }
+    Py_ssize_t len = PyUnicode_GET_LENGTH(arg);
+    int kind = PyUnicode_KIND(arg);
+    const void *data = PyUnicode_DATA(arg);
+    Py_ssize_t start = len; /* the partition("://")[2] start, or len (an empty remainder) when the marker is absent */
+    for (Py_ssize_t index = 0; index + 2 < len; index++) {
+        if (PyUnicode_READ(kind, data, index) == ':' && PyUnicode_READ(kind, data, index + 1) == '/' &&
+            PyUnicode_READ(kind, data, index + 2) == '/') {
+            start = index + 3;
+            break;
+        }
+    }
+    Py_ssize_t end = len;
+    int keep_slashes = 0;
+    for (Py_ssize_t index = start; index < len; index++) {
+        Py_UCS4 ch = PyUnicode_READ(kind, data, index);
+        if (ch == '?' || ch == '#') {
+            keep_slashes = 1;
+            break;
+        }
+    }
+    if (!keep_slashes) {
+        while (end > start && PyUnicode_READ(kind, data, end - 1) == '/') {
+            end--;
+        }
+    }
+    return PyUnicode_Substring(arg, start, end);
+}
+
+/* Percent-encode the query pair query[start:end) for the query set, rewrapping the encoder's UnicodeEncodeError as the
+   ValueError the Python _encode raised, so a lone surrogate reports the same "cannot be percent-encoded" message. */
+static PyObject *normalize_query_encode_pair(PyObject *query, Py_ssize_t start, Py_ssize_t end) {
+    PyObject *pair = PyUnicode_Substring(query, start, end);
+    if (pair == NULL) { /* GCOVR_EXCL_BR_LINE: substring of an existing string cannot fail here */
+        return NULL;    /* GCOVR_EXCL_LINE: allocation-failure path */
+    }
+    PyObject *encoded = th_url_percent_encode_obj(pair, TH_URL_SET_QUERY);
+    if (encoded != NULL) {
+        Py_DECREF(pair);
+        return encoded;
+    }
+    PyObject *type;
+    PyObject *value;
+    PyObject *traceback;
+    PyErr_Fetch(&type, &value, &traceback);
+    PyErr_NormalizeException(&type, &value, &traceback);
+    PyObject *reason = PyObject_GetAttrString(value, "reason"); /* UnicodeEncodeError always carries a reason str */
+    PyErr_Format(PyExc_ValueError, "URL component %R has a character that cannot be percent-encoded: %U", pair, reason);
+    Py_XDECREF(reason);
+    Py_DECREF(type);
+    Py_DECREF(value);
+    Py_XDECREF(traceback);
+    Py_DECREF(pair);
+    return NULL;
+}
+
+/* _url_normalize_query(query, allow, deny, strict, content, language): drop denied, tracker, or non-allowlisted query
+   parameters, encode each survivor for the query set, and sort them, the per-pair loop the crawl cleaner ran in Python.
+   `allow` is a lowercased name set or None (keep only these), `deny` a lowercased name set (always drop); `strict`
+   keeps only the `content` and `language` parameter names. Each pair's key is percent-decoded and lowercased for the
+   filter, while the kept pair keeps its raw encoding. Runs once per URL query (and per query-shaped fragment). */
+PyObject *turbohtml_url_normalize_query(PyObject *Py_UNUSED(module), PyObject *args) {
+    PyObject *query;
+    PyObject *allow;
+    PyObject *deny;
+    int strict;
+    PyObject *content;
+    PyObject *language;
+    if (!PyArg_ParseTuple(args, "UOOpOO", &query, &allow, &deny, &strict, &content, &language)) {
+        return NULL;
+    }
+    Py_ssize_t len = PyUnicode_GET_LENGTH(query);
+    int kind = PyUnicode_KIND(query);
+    const void *data = PyUnicode_DATA(query);
+    PyObject *kept = PyList_New(0);
+    if (kept == NULL) { /* GCOVR_EXCL_BR_LINE: allocation failure cannot be forced from a test */
+        return NULL;    /* GCOVR_EXCL_LINE: allocation-failure path */
+    }
+    Py_ssize_t pair_start = 0;
+    for (Py_ssize_t index = 0; index <= len; index++) {
+        if (index != len && PyUnicode_READ(kind, data, index) != '&') {
+            continue;
+        }
+        if (index == pair_start) { /* an empty pair, which "".split("&") drops */
+            pair_start = index + 1;
+            continue;
+        }
+        Py_ssize_t key_end = pair_start;
+        while (key_end < index && PyUnicode_READ(kind, data, key_end) != '=') {
+            key_end++;
+        }
+        PyObject *raw_key = PyUnicode_Substring(query, pair_start, key_end);
+        if (raw_key == NULL) { /* GCOVR_EXCL_BR_LINE: substring of an existing string cannot fail here */
+            goto error;        /* GCOVR_EXCL_LINE: allocation-failure path */
+        }
+        PyObject *decoded = th_url_percent_decode_obj(raw_key);
+        Py_DECREF(raw_key);
+        if (decoded == NULL) { /* GCOVR_EXCL_BR_LINE: decode only fails on the excluded allocation path */
+            goto error;        /* GCOVR_EXCL_LINE: allocation-failure path */
+        }
+        PyObject *key = PyObject_CallMethod(decoded, "lower", NULL);
+        Py_DECREF(decoded);
+        if (key == NULL) { /* GCOVR_EXCL_BR_LINE: str.lower cannot fail on a decoded key */
+            goto error;    /* GCOVR_EXCL_LINE: allocation-failure path */
+        }
+        int drop = PySet_Contains(deny, key);
+        if (drop == 0) {
+            if (allow != Py_None) {
+                drop = !PySet_Contains(allow, key);
+            } else if (strict) {
+                drop = !(PySet_Contains(content, key) || PySet_Contains(language, key));
+            } else {
+                drop = th_url_is_tracker_obj(key);
+            }
+        }
+        if (drop < 0) { /* the tracker test hit a lone-surrogate key with no UTF-8 form; propagate its error */
+            Py_DECREF(key);
+            goto error;
+        }
+        if (drop == 0) {
+            PyObject *encoded = normalize_query_encode_pair(query, pair_start, index);
+            if (encoded == NULL) {
+                Py_DECREF(key);
+                goto error;
+            }
+            /* sort each survivor by (lowercased key, encoded pair), the tuple order sorted(kept) compares */
+            PyObject *pair = PyTuple_Pack(2, key, encoded);
+            Py_DECREF(encoded);
+            if (pair == NULL || PyList_Append(kept, pair) < 0) { /* GCOVR_EXCL_BR_LINE: append cannot fail here */
+                Py_XDECREF(pair);                                /* GCOVR_EXCL_LINE: allocation-failure path */
+                Py_DECREF(key);                                  /* GCOVR_EXCL_LINE: allocation-failure path */
+                goto error;                                      /* GCOVR_EXCL_LINE: allocation-failure path */
+            }
+            Py_DECREF(pair);
+        }
+        Py_DECREF(key);
+        pair_start = index + 1;
+    }
+    if (PyList_Sort(kept) < 0) { /* GCOVR_EXCL_BR_LINE: a list of (str, str) tuples sorts without error */
+        goto error;              /* GCOVR_EXCL_LINE: sort-failure path */
+    }
+    Py_ssize_t survivors = PyList_GET_SIZE(kept);
+    PyObject *values = PyList_New(survivors);
+    if (values == NULL) { /* GCOVR_EXCL_BR_LINE: allocation failure cannot be forced from a test */
+        goto error;       /* GCOVR_EXCL_LINE: allocation-failure path */
+    }
+    for (Py_ssize_t index = 0; index < survivors; index++) {
+        PyObject *encoded = PyTuple_GET_ITEM(PyList_GET_ITEM(kept, index), 1);
+        Py_INCREF(encoded);
+        PyList_SET_ITEM(values, index, encoded);
+    }
+    Py_DECREF(kept);
+    PyObject *separator = PyUnicode_FromString("&");
+    if (separator == NULL) { /* GCOVR_EXCL_BR_LINE: interning "&" cannot fail here */
+        Py_DECREF(values);   /* GCOVR_EXCL_LINE: allocation-failure path */
+        return NULL;         /* GCOVR_EXCL_LINE: allocation-failure path */
+    }
+    PyObject *result = PyUnicode_Join(separator, values);
+    Py_DECREF(separator);
+    Py_DECREF(values);
+    return result;
+error:
+    Py_DECREF(kept);
+    return NULL;
+}
+
+/* An ASCII lowercase letter, the [a-z] the language-segment pattern matches (the leading path segment is already
+   lowercased, so an uppercase or non-ASCII code point fails and the segment is not a language marker). */
+static int is_ascii_lower(Py_UCS4 ch) {
+    return ch >= 'a' && ch <= 'z';
+}
+
+/* The two-letter language code the leading path segment carries, or -1 for a segment that is not a language marker.
+   Mirrors _LANGUAGE_SEGMENT.fullmatch: exactly two lowercase letters, optionally followed by a '-'/'_' separator and a
+   two- or three-letter subtag, with nothing else. `code` receives the first two code points on a match. */
+static int language_segment_code(const Py_UCS4 *segment, Py_ssize_t len, Py_UCS4 code[2]) {
+    if (len != 2 && len != 5 && len != 6) {
+        return -1;
+    }
+    if (!is_ascii_lower(segment[0]) || !is_ascii_lower(segment[1])) {
+        return -1;
+    }
+    if (len != 2) {
+        if (segment[2] != '-' && segment[2] != '_') {
+            return -1;
+        }
+        for (Py_ssize_t index = 3; index < len; index++) {
+            if (!is_ascii_lower(segment[index])) {
+                return -1;
+            }
+        }
+    }
+    code[0] = segment[0];
+    code[1] = segment[1];
+    return 0;
+}
+
+/* Whether the two-letter code[2] is a known ISO 639-1 language that differs from `language`, so a URL marked for it
+   points at another language and the filter rejects the URL. Returns 1 to reject, 0 to keep, -1 on error. */
+static int language_code_rejects(const Py_UCS4 code[2], PyObject *language, PyObject *iso_639_1) {
+    PyObject *code_obj = PyUnicode_FromKindAndData(PyUnicode_4BYTE_KIND, code, 2);
+    if (code_obj == NULL) { /* GCOVR_EXCL_BR_LINE: a two-code-point string cannot fail to build */
+        return -1;          /* GCOVR_EXCL_LINE: allocation-failure path */
+    }
+    int known = PySet_Contains(iso_639_1, code_obj);
+    int differs = known > 0 ? PyUnicode_Compare(code_obj, language) != 0 : 0;
+    Py_DECREF(code_obj);
+    if (known < 0) { /* GCOVR_EXCL_BR_LINE: a two-letter str is hashable, so membership cannot error */
+        return -1;   /* GCOVR_EXCL_LINE: membership-failure path */
+    }
+    return known > 0 && differs;
+}
+
+/* Whether the query carries a lang/language parameter naming a different language, so the URL is rejected. Returns 1 to
+   reject, 0 to keep, -1 on error. */
+static int language_query_rejects(PyObject *query, PyObject *language, PyObject *language_params) {
+    Py_ssize_t len = PyUnicode_GET_LENGTH(query);
+    int kind = PyUnicode_KIND(query);
+    const void *data = PyUnicode_DATA(query);
+    Py_ssize_t pair_start = 0;
+    for (Py_ssize_t index = 0; index <= len; index++) {
+        if (index != len && PyUnicode_READ(kind, data, index) != '&') {
+            continue;
+        }
+        Py_ssize_t equals = pair_start;
+        while (equals < index && PyUnicode_READ(kind, data, equals) != '=') {
+            equals++;
+        }
+        if (equals < index) { /* a pair with a '=' separator, the only shape carrying a language value */
+            PyObject *raw_key = PyUnicode_Substring(query, pair_start, equals);
+            if (raw_key == NULL) { /* GCOVR_EXCL_BR_LINE: substring of an existing string cannot fail here */
+                return -1;         /* GCOVR_EXCL_LINE: allocation-failure path */
+            }
+            PyObject *decoded_key = th_url_percent_decode_obj(raw_key);
+            Py_DECREF(raw_key);
+            if (decoded_key == NULL) { /* GCOVR_EXCL_BR_LINE: decode only fails on the excluded allocation path */
+                return -1;             /* GCOVR_EXCL_LINE: allocation-failure path */
+            }
+            PyObject *key = PyObject_CallMethod(decoded_key, "lower", NULL);
+            Py_DECREF(decoded_key);
+            if (key == NULL) { /* GCOVR_EXCL_BR_LINE: str.lower cannot fail on a decoded key */
+                return -1;     /* GCOVR_EXCL_LINE: allocation-failure path */
+            }
+            int is_language = PySet_Contains(language_params, key);
+            Py_DECREF(key);
+            if (is_language < 0) { /* GCOVR_EXCL_BR_LINE: a str key is hashable, so membership cannot error */
+                return -1;         /* GCOVR_EXCL_LINE: membership-failure path */
+            }
+            if (is_language) {
+                PyObject *raw_value = PyUnicode_Substring(query, equals + 1, index);
+                if (raw_value == NULL) { /* GCOVR_EXCL_BR_LINE: substring of an existing string cannot fail here */
+                    return -1;           /* GCOVR_EXCL_LINE: allocation-failure path */
+                }
+                PyObject *decoded_value = th_url_percent_decode_obj(raw_value);
+                Py_DECREF(raw_value);
+                if (decoded_value == NULL) { /* GCOVR_EXCL_BR_LINE: decode only fails on the excluded alloc path */
+                    return -1;               /* GCOVR_EXCL_LINE: allocation-failure path */
+                }
+                PyObject *code = PyObject_CallMethod(decoded_value, "lower", NULL);
+                Py_DECREF(decoded_value);
+                if (code == NULL) { /* GCOVR_EXCL_BR_LINE: str.lower cannot fail on a decoded value */
+                    return -1;      /* GCOVR_EXCL_LINE: allocation-failure path */
+                }
+                Py_ssize_t code_len = PyUnicode_GET_LENGTH(code);
+                int mismatched = code_len > 0 && PyUnicode_Tailmatch(code, language, 0, code_len, -1) == 0;
+                Py_DECREF(code);
+                if (mismatched) {
+                    return 1;
+                }
+            }
+        }
+        pair_start = index + 1;
+    }
+    return 0;
+}
+
+/* _url_language_matches(query, path, hostname, language, strict, language_params, iso_639_1): judge a URL's own
+   language markers against the target `language`, the URL-based heuristics clean_url's language filter runs. A
+   lang/language query parameter, a leading path segment that is an ISO 639-1 tag, and -- in strict mode -- a two-letter
+   host label each reject the URL when they name a different language. `path` and `query` are raw components; `hostname`
+   is already lowercased. Returns True to keep, False to reject. Runs once per URL, only when a language filter is
+   active. */
+PyObject *turbohtml_url_language_matches(PyObject *Py_UNUSED(module), PyObject *args) {
+    PyObject *query;
+    PyObject *path;
+    PyObject *hostname;
+    PyObject *language;
+    int strict;
+    PyObject *language_params;
+    PyObject *iso_639_1;
+    if (!PyArg_ParseTuple(args, "UUUUpOO", &query, &path, &hostname, &language, &strict, &language_params,
+                          &iso_639_1)) {
+        return NULL;
+    }
+    int rejected = language_query_rejects(query, language, language_params);
+    if (rejected < 0) { /* GCOVR_EXCL_BR_LINE: the decode/lower/membership steps only fail on the excluded alloc path */
+        return NULL;    /* GCOVR_EXCL_LINE: allocation-failure path */
+    }
+    if (rejected) {
+        Py_RETURN_FALSE;
+    }
+    PyObject *lowered = PyObject_CallMethod(path, "lower", NULL);
+    if (lowered == NULL) { /* GCOVR_EXCL_BR_LINE: str.lower cannot fail on a path component */
+        return NULL;       /* GCOVR_EXCL_LINE: allocation-failure path */
+    }
+    Py_ssize_t len = PyUnicode_GET_LENGTH(lowered);
+    int kind = PyUnicode_KIND(lowered);
+    const void *data = PyUnicode_DATA(lowered);
+    Py_ssize_t leading_start = 0;
+    while (leading_start < len && PyUnicode_READ(kind, data, leading_start) == '/') {
+        leading_start++; /* skip empty segments so the first non-empty path segment is the language marker */
+    }
+    Py_ssize_t leading_end = leading_start;
+    while (leading_end < len && PyUnicode_READ(kind, data, leading_end) != '/') {
+        leading_end++;
+    }
+    Py_UCS4 segment[6];
+    Py_ssize_t leading_len = leading_end - leading_start;
+    Py_UCS4 code[2];
+    int rejects = 0;
+    if (leading_len >= 2 && leading_len <= 6) {
+        for (Py_ssize_t index = 0; index < leading_len; index++) {
+            segment[index] = PyUnicode_READ(kind, data, leading_start + index);
+        }
+        if (language_segment_code(segment, leading_len, code) == 0) {
+            rejects = language_code_rejects(code, language, iso_639_1);
+        }
+    }
+    Py_DECREF(lowered);
+    if (rejects < 0) { /* GCOVR_EXCL_BR_LINE: building a two-letter code and testing membership cannot error */
+        return NULL;   /* GCOVR_EXCL_LINE: allocation-failure path */
+    }
+    if (rejects) {
+        Py_RETURN_FALSE;
+    }
+    if (strict) {
+        Py_ssize_t host_len = PyUnicode_GET_LENGTH(hostname);
+        int host_kind = PyUnicode_KIND(hostname);
+        const void *host_data = PyUnicode_DATA(hostname);
+        Py_ssize_t label_end = 0;
+        while (label_end < host_len && PyUnicode_READ(host_kind, host_data, label_end) != '.') {
+            label_end++;
+        }
+        if (label_end == 2) {
+            code[0] = PyUnicode_READ(host_kind, host_data, 0);
+            code[1] = PyUnicode_READ(host_kind, host_data, 1);
+            int label_rejects = language_code_rejects(code, language, iso_639_1);
+            if (label_rejects < 0) { /* GCOVR_EXCL_BR_LINE: a two-letter code test cannot error */
+                return NULL;         /* GCOVR_EXCL_LINE: membership-failure path */
+            }
+            if (label_rejects) {
+                Py_RETURN_FALSE;
+            }
+        }
+    }
+    Py_RETURN_TRUE;
+}
diff --git a/src/turbohtml/_c/validate/relaxng.h b/src/turbohtml/_c/validate/relaxng.h
index be7c693f..e6e17108 100644
--- a/src/turbohtml/_c/validate/relaxng.h
+++ b/src/turbohtml/_c/validate/relaxng.h
@@ -302,7 +302,7 @@ static nameclass *rng_nameclass_choice_children(th_schema *schema, th_node *node
         if (child->type != TH_NODE_ELEMENT) {
             continue;
         }
-        if (is_schema_el(schema->tree, child, RNG_NS, "except")) {
+        if (is_schema_el(schema, child, RNG_NS, "except")) {
             continue;
         }
         nameclass *part = rng_build_nameclass(schema, child);
@@ -323,13 +323,13 @@ static nameclass *rng_build_nameclass(th_schema *schema, th_node *node) {
     if (node == NULL) { /* a malformed <element>/<attribute> with no name class matches any name */
         return nc_new(schema, NC_ANY);
     }
-    if (is_schema_el(tree, node, RNG_NS, "name")) {
+    if (is_schema_el(schema, node, RNG_NS, "name")) {
         Py_ssize_t len = 0;
         const Py_UCS4 *text = element_text_raw(tree, node, &len);
         return nc_from_qname(schema, node, text, len, 0);
     }
-    if (is_schema_el(tree, node, RNG_NS, "anyName")) {
-        th_node *except = first_schema_child(tree, node, RNG_NS, "except");
+    if (is_schema_el(schema, node, RNG_NS, "anyName")) {
+        th_node *except = first_schema_child(schema, node, RNG_NS, "except");
         if (except == NULL) {
             return nc_new(schema, NC_ANY);
         }
@@ -338,7 +338,7 @@ static nameclass *rng_build_nameclass(th_schema *schema, th_node *node) {
         nc->b = rng_nameclass_choice_children(schema, except);
         return nc;
     }
-    if (is_schema_el(tree, node, RNG_NS, "nsName")) {
+    if (is_schema_el(schema, node, RNG_NS, "nsName")) {
         nameclass *nc = nc_new(schema, NC_NS);
         const th_node_attr *ns = attr_exact(tree, node, "ns", 2);
         if (ns == NULL) {
@@ -347,7 +347,7 @@ static nameclass *rng_build_nameclass(th_schema *schema, th_node *node) {
             nc->uri = ns->value;
             nc->uri_len = ns->value_len;
         }
-        th_node *except = first_schema_child(tree, node, RNG_NS, "except");
+        th_node *except = first_schema_child(schema, node, RNG_NS, "except");
         if (except == NULL) {
             return nc;
         }
@@ -423,16 +423,16 @@ static pattern *rng_build_children(th_schema *schema, th_node *node, th_node *sk
 
 static pattern *rng_build(th_schema *schema, th_node *node) {
     th_tree *tree = schema->tree;
-    if (is_schema_el(tree, node, RNG_NS, "empty")) {
+    if (is_schema_el(schema, node, RNG_NS, "empty")) {
         return schema->p_empty;
     }
-    if (is_schema_el(tree, node, RNG_NS, "text")) {
+    if (is_schema_el(schema, node, RNG_NS, "text")) {
         return schema->p_text;
     }
-    if (is_schema_el(tree, node, RNG_NS, "notAllowed")) {
+    if (is_schema_el(schema, node, RNG_NS, "notAllowed")) {
         return schema->p_notallowed;
     }
-    if (is_schema_el(tree, node, RNG_NS, "element")) {
+    if (is_schema_el(schema, node, RNG_NS, "element")) {
         pattern *node_pat = pat_new(schema, P_ELEMENT);
         const th_node_attr *name = attr_exact(tree, node, "name", 4);
         th_node *skip = NULL;
@@ -446,7 +446,7 @@ static pattern *rng_build(th_schema *schema, th_node *node) {
         node_pat->p1 = rng_build_children(schema, node, skip);
         return node_pat;
     }
-    if (is_schema_el(tree, node, RNG_NS, "attribute")) {
+    if (is_schema_el(schema, node, RNG_NS, "attribute")) {
         pattern *node_pat = pat_new(schema, P_ATTRIBUTE);
         const th_node_attr *name = attr_exact(tree, node, "name", 4);
         th_node *skip = NULL;
@@ -467,10 +467,10 @@ static pattern *rng_build(th_schema *schema, th_node *node) {
         node_pat->p1 = has_content ? rng_build_children(schema, node, skip) : schema->p_text;
         return node_pat;
     }
-    if (is_schema_el(tree, node, RNG_NS, "group")) {
+    if (is_schema_el(schema, node, RNG_NS, "group")) {
         return rng_build_children(schema, node, NULL);
     }
-    if (is_schema_el(tree, node, RNG_NS, "choice")) {
+    if (is_schema_el(schema, node, RNG_NS, "choice")) {
         pattern *combined = schema->p_notallowed;
         for (th_node *child = node->first_child; child != NULL; child = child->next_sibling) {
             if (child->type == TH_NODE_ELEMENT) {
@@ -479,7 +479,7 @@ static pattern *rng_build(th_schema *schema, th_node *node) {
         }
         return combined;
     }
-    if (is_schema_el(tree, node, RNG_NS, "interleave")) {
+    if (is_schema_el(schema, node, RNG_NS, "interleave")) {
         pattern *combined = schema->p_empty;
         for (th_node *child = node->first_child; child != NULL; child = child->next_sibling) {
             if (child->type == TH_NODE_ELEMENT) {
@@ -488,24 +488,24 @@ static pattern *rng_build(th_schema *schema, th_node *node) {
         }
         return combined;
     }
-    if (is_schema_el(tree, node, RNG_NS, "optional")) {
+    if (is_schema_el(schema, node, RNG_NS, "optional")) {
         return pat_choice(schema, rng_build_children(schema, node, NULL), schema->p_empty);
     }
-    if (is_schema_el(tree, node, RNG_NS, "zeroOrMore")) {
+    if (is_schema_el(schema, node, RNG_NS, "zeroOrMore")) {
         return pat_choice(schema, pat_onemore(schema, rng_build_children(schema, node, NULL)), schema->p_empty);
     }
-    if (is_schema_el(tree, node, RNG_NS, "oneOrMore")) {
+    if (is_schema_el(schema, node, RNG_NS, "oneOrMore")) {
         return pat_onemore(schema, rng_build_children(schema, node, NULL));
     }
-    if (is_schema_el(tree, node, RNG_NS, "mixed")) {
+    if (is_schema_el(schema, node, RNG_NS, "mixed")) {
         return pat_interleave(schema, rng_build_children(schema, node, NULL), schema->p_text);
     }
-    if (is_schema_el(tree, node, RNG_NS, "list")) {
+    if (is_schema_el(schema, node, RNG_NS, "list")) {
         pattern *node_pat = pat_new(schema, P_LIST);
         node_pat->p1 = rng_build_children(schema, node, NULL);
         return node_pat;
     }
-    if (is_schema_el(tree, node, RNG_NS, "data")) {
+    if (is_schema_el(schema, node, RNG_NS, "data")) {
         pattern *node_pat = pat_new(schema, P_DATA);
         node_pat->datatype_id = rng_datatype_id(schema, node);
         facetset *facets = arena_alloc(&schema->mem, sizeof(*facets));
@@ -514,7 +514,7 @@ static pattern *rng_build(th_schema *schema, th_node *node) {
         }
         facetset_init(facets, node_pat->datatype_id);
         for (th_node *param = node->first_child; param != NULL; param = param->next_sibling) {
-            if (is_schema_el(tree, param, RNG_NS, "param")) {
+            if (is_schema_el(schema, param, RNG_NS, "param")) {
                 const th_node_attr *pname = attr_exact(tree, param, "name", 4);
                 Py_ssize_t vlen = 0;
                 const Py_UCS4 *value = element_text_raw(tree, param, &vlen);
@@ -526,14 +526,14 @@ static pattern *rng_build(th_schema *schema, th_node *node) {
         node_pat->facets = facets;
         return node_pat;
     }
-    if (is_schema_el(tree, node, RNG_NS, "value")) {
+    if (is_schema_el(schema, node, RNG_NS, "value")) {
         pattern *node_pat = pat_new(schema, P_VALUE);
         node_pat->datatype_id = rng_datatype_id(schema, node);
         node_pat->value = element_text_raw(tree, node, &node_pat->value_len);
         node_pat->value_ws = dt_default_ws(node_pat->datatype_id);
         return node_pat;
     }
-    if (is_schema_el(tree, node, RNG_NS, "ref")) {
+    if (is_schema_el(schema, node, RNG_NS, "ref")) {
         const th_node_attr *name = attr_exact(tree, node, "name", 4);
         Py_ssize_t index = def_find(&schema->defines, name->value, name->value_len);
         if (index >= 0) {
@@ -963,12 +963,12 @@ static int rng_compile(th_schema *schema) {
     schema->p_empty = pat_new(schema, P_EMPTY);
     schema->p_notallowed = pat_new(schema, P_NOTALLOWED);
     schema->p_text = pat_new(schema, P_TEXT);
-    if (!is_schema_el(tree, schema->root, RNG_NS, "grammar")) {
+    if (!is_schema_el(schema, schema->root, RNG_NS, "grammar")) {
         schema->start = rng_build(schema, schema->root);
         return 1;
     }
     for (th_node *child = schema->root->first_child; child != NULL; child = child->next_sibling) {
-        if (is_schema_el(tree, child, RNG_NS, "define")) {
+        if (is_schema_el(schema, child, RNG_NS, "define")) {
             const th_node_attr *name = attr_exact(tree, child, "name", 4);
             if (name == NULL) {
                 continue;
@@ -979,7 +979,7 @@ static int rng_compile(th_schema *schema) {
             }
         }
     }
-    th_node *start = first_schema_child(tree, schema->root, RNG_NS, "start");
+    th_node *start = first_schema_child(schema, schema->root, RNG_NS, "start");
     if (start == NULL) {
         PyErr_SetString(PyExc_ValueError, "grammar has no start element");
         return 0;
diff --git a/src/turbohtml/_c/validate/schema.c b/src/turbohtml/_c/validate/schema.c
index c3e45914..9471259d 100644
--- a/src/turbohtml/_c/validate/schema.c
+++ b/src/turbohtml/_c/validate/schema.c
@@ -27,6 +27,7 @@
 #include "dom/tree.h"
 
 #include <stdarg.h>
+#include <stdlib.h>
 #include <string.h>
 
 static const char XSD_NS[] = "http://www.w3.org/2001/XMLSchema";
@@ -123,6 +124,20 @@ typedef struct {
     Py_ssize_t uri_len;
 } qname;
 
+/* The schema tree is immutable once compiled, yet is_schema_el reclassifies its element
+   nodes millions of times while a document validates (the content-model matcher revisits
+   the same particles on every step). resolve_ns walking the ancestor chain per call is the
+   validator's hottest cost, so each schema element node's namespace-resolved qname is
+   computed once at compile time and looked up by node pointer here. Built before any
+   compile classification runs and never mutated afterwards, so a compiled schema shared
+   across validating threads stays read-only. */
+struct th_schema;
+typedef struct {
+    th_node *node;
+    qname name;
+} sqname_entry;
+static const qname *schema_node_qname(const struct th_schema *schema, th_node *node);
+
 static void split_prefix(const Py_UCS4 *name, Py_ssize_t len, const Py_UCS4 **local, Py_ssize_t *local_len,
                          const Py_UCS4 **prefix, Py_ssize_t *prefix_len) {
     for (Py_ssize_t index = 0; index < len; index++) {
@@ -159,14 +174,19 @@ static const th_node_attr *attr_exact(th_tree *tree, th_node *node, const char *
     return NULL;
 }
 
+/* The constant xml-prefix namespace as UCS4, widened once; every later call reuses the filled buffer. */
+static const Py_UCS4 *xml_namespace_uri(void) {
+    static Py_UCS4 xml_uri[sizeof(XML_URI)];
+    for (Py_ssize_t index = 0; index < (Py_ssize_t)sizeof(XML_URI) - 1; index++) {
+        xml_uri[index] = (Py_UCS4)(unsigned char)XML_URI[index];
+    }
+    return xml_uri;
+}
+
 static void resolve_ns(th_tree *tree, th_node *node, const Py_UCS4 *prefix, Py_ssize_t prefix_len, const Py_UCS4 **uri,
                        Py_ssize_t *uri_len) {
     if (prefix_len == 3 && u_eq_ascii(prefix, 3, "xml")) {
-        static Py_UCS4 xml_uri[sizeof(XML_URI)];
-        for (Py_ssize_t index = 0; index < (Py_ssize_t)sizeof(XML_URI) - 1; index++) {
-            xml_uri[index] = (Py_UCS4)(unsigned char)XML_URI[index];
-        }
-        *uri = xml_uri;
+        *uri = xml_namespace_uri();
         *uri_len = sizeof(XML_URI) - 1;
         return;
     }
@@ -206,25 +226,34 @@ static qname node_qname(th_tree *tree, th_node *element, const Py_UCS4 *name, Py
     return out;
 }
 
-static int is_schema_el(th_tree *tree, th_node *node, const char *ns, const char *local) {
+/* The on-the-spot resolution a below-threshold schema uses; defined after th_schema, which is opaque here. */
+static qname schema_direct_qname(const struct th_schema *schema, th_node *node);
+
+static int is_schema_el(const struct th_schema *schema, th_node *node, const char *ns, const char *local) {
     if (node->type != TH_NODE_ELEMENT) {
         return 0;
     }
-    qname name = node_qname(tree, node, node->text, node->text_len, 0);
-    if (!u_eq_ascii(name.local, name.local_len, local)) {
+    const qname *cached = schema_node_qname(schema, node);
+    /* a schema below the cache threshold resolves the name on the spot; the direct walk is cheap at that size */
+    qname direct;
+    if (cached == NULL) {
+        direct = schema_direct_qname(schema, node);
+        cached = &direct;
+    }
+    if (!u_eq_ascii(cached->local, cached->local_len, local)) {
         return 0;
     }
-    if (name.uri == NULL) {
+    if (cached->uri == NULL) {
         return 0;
     }
-    return u_eq_ascii(name.uri, name.uri_len, ns);
+    return u_eq_ascii(cached->uri, cached->uri_len, ns);
 }
 
 /* The first element child of `node` in the schema namespace `ns` with local name
    `local`, or NULL. */
-static th_node *first_schema_child(th_tree *tree, th_node *node, const char *ns, const char *local) {
+static th_node *first_schema_child(const struct th_schema *schema, th_node *node, const char *ns, const char *local) {
     for (th_node *child = node->first_child; child != NULL; child = child->next_sibling) {
-        if (is_schema_el(tree, child, ns, local)) {
+        if (is_schema_el(schema, child, ns, local)) {
             return child;
         }
     }
@@ -451,8 +480,167 @@ typedef struct th_schema {
     pattern *start;
     pattern *p_empty, *p_notallowed, *p_text;
     def_vec defines;
+    /* every schema element node's resolved qname, sorted by node pointer for is_schema_el */
+    sqname_entry *sqnames;
+    Py_ssize_t sqname_count;
 } th_schema;
 
+/* Look up a schema element node's precomputed qname. schema_build_qname_cache enters every
+   element node of the schema tree before any classification runs, and is_schema_el only ever
+   asks about schema element nodes, so the search always hits. */
+static qname schema_direct_qname(const struct th_schema *schema, th_node *node) {
+    return node_qname(schema->tree, node, node->text, node->text_len, 0);
+}
+
+static const qname *schema_node_qname(const th_schema *schema, th_node *node) {
+    if (schema->sqname_count == 0) { /* a schema below the cache threshold resolves directly; see the build gate */
+        return NULL;
+    }
+    Py_ssize_t lo = 0, hi = schema->sqname_count - 1;
+    while (lo <= hi) { /* GCOVR_EXCL_BR_LINE: the searched-for node is always present, so the loop exits by return */
+        Py_ssize_t mid = lo + ((hi - lo) >> 1);
+        th_node *at = schema->sqnames[mid].node;
+        if (at == node) {
+            return &schema->sqnames[mid].name;
+        }
+        if (at < node) {
+            lo = mid + 1;
+        } else {
+            hi = mid - 1;
+        }
+    }
+    return NULL; /* GCOVR_EXCL_LINE: every schema element node is cached, so the search never misses */
+}
+
+static Py_ssize_t schema_count_elements(th_node *parent) {
+    Py_ssize_t total = 0;
+    for (th_node *child = parent->first_child; child != NULL; child = child->next_sibling) {
+        if (child->type == TH_NODE_ELEMENT) {
+            total += 1 + schema_count_elements(child);
+        }
+    }
+    return total;
+}
+
+/* One in-scope xmlns binding; the stack grows entering an element that declares bindings and shrinks leaving
+   it, so resolving a prefix is a top-down scan of what is in scope instead of an ancestor walk. */
+typedef struct {
+    const char *prefix; /* UTF-8 bytes into the interned attribute name; "" for the default namespace */
+    Py_ssize_t prefix_len;
+    const Py_UCS4 *uri;
+    Py_ssize_t uri_len;
+} ns_binding;
+
+typedef struct {
+    ns_binding *items;
+    Py_ssize_t len;
+    Py_ssize_t cap;
+} ns_scope;
+
+static int ns_scope_push(th_schema *schema, ns_scope *scope, const char *prefix, Py_ssize_t prefix_len,
+                         const Py_UCS4 *uri, Py_ssize_t uri_len) {
+    if (scope->len == scope->cap) {
+        Py_ssize_t cap = scope->cap ? scope->cap * 2 : 8;
+        ns_binding *items = arena_alloc(&schema->mem, (size_t)cap * sizeof(ns_binding));
+        if (items == NULL) { /* GCOVR_EXCL_BR_LINE: arena OOM is unforceable */
+            return -1;       /* GCOVR_EXCL_LINE */
+        }
+        if (scope->len > 0) {
+            memcpy(items, scope->items, (size_t)scope->len * sizeof(ns_binding));
+        }
+        scope->items = items;
+        scope->cap = cap;
+    }
+    scope->items[scope->len].prefix = prefix;
+    scope->items[scope->len].prefix_len = prefix_len;
+    scope->items[scope->len].uri = uri;
+    scope->items[scope->len].uri_len = uri_len;
+    scope->len++;
+    return 0;
+}
+
+/* The innermost binding for prefix, or no namespace at all. The xml prefix needs no special case here: the
+   cache resolves schema-element tag prefixes, an xml:-prefixed schema element is foreign, and is_schema_el
+   maps both the xml namespace and no namespace to "not a schema element" -- resolve_ns keeps the xml rule for
+   the document path, where xml:lang and friends are observable. */
+static void ns_scope_resolve(const ns_scope *scope, const Py_UCS4 *prefix, Py_ssize_t prefix_len, const Py_UCS4 **uri,
+                             Py_ssize_t *uri_len) {
+    for (Py_ssize_t index = scope->len - 1; index >= 0; index--) {
+        const ns_binding *binding = &scope->items[index];
+        if (binding->prefix_len == prefix_len && u_eq_ascii(prefix, prefix_len, binding->prefix)) {
+            *uri = binding->uri;
+            *uri_len = binding->uri_len;
+            return;
+        }
+    }
+    *uri = NULL;
+    *uri_len = 0;
+}
+
+static int schema_fill_qnames(th_schema *schema, th_node *parent, Py_ssize_t *at, ns_scope *scope) {
+    for (th_node *child = parent->first_child; child != NULL; child = child->next_sibling) {
+        if (child->type != TH_NODE_ELEMENT) {
+            continue;
+        }
+        /* the bindings this element declares extend the in-scope stack for its subtree only */
+        Py_ssize_t pushed = scope->len;
+        for (Py_ssize_t index = 0; index < child->attr_count; index++) {
+            Py_ssize_t alen = 0;
+            const char *abytes = th_attr_name(schema->tree, child->attrs[index].name_atom, &alen);
+            if (!is_xmlns_decl(abytes, alen)) {
+                continue;
+            }
+            /* a bare xmlns binds the default namespace; its prefix is the empty string, not a slice past the name */
+            const char *decl_prefix = alen > 5 ? abytes + 6 : "";
+            Py_ssize_t decl_prefix_len = alen > 5 ? alen - 6 : 0;
+            /* GCOVR_EXCL_BR_START: arena OOM is unforceable from a test */
+            if (ns_scope_push(schema, scope, decl_prefix, decl_prefix_len, child->attrs[index].value,
+                              child->attrs[index].value_len) < 0) {
+                /* GCOVR_EXCL_BR_STOP */
+                return -1; /* GCOVR_EXCL_LINE: allocation-failure path */
+            }
+        }
+        const Py_UCS4 *local;
+        const Py_UCS4 *prefix;
+        Py_ssize_t local_len = 0;
+        Py_ssize_t prefix_len = 0;
+        split_prefix(child->text, child->text_len, &local, &local_len, &prefix, &prefix_len);
+        qname name = {local, local_len, NULL, 0};
+        ns_scope_resolve(scope, prefix, prefix_len, &name.uri, &name.uri_len);
+        schema->sqnames[*at].node = child;
+        schema->sqnames[*at].name = name;
+        (*at)++;
+        if (schema_fill_qnames(schema, child, at, scope) < 0) { /* GCOVR_EXCL_BR_LINE: arena OOM is unforceable */
+            return -1;                                          /* GCOVR_EXCL_LINE */
+        }
+        scope->len = pushed;
+    }
+    return 0;
+}
+
+static int sqname_cmp(const void *left, const void *right) {
+    th_node *left_node = ((const sqname_entry *)left)->node;
+    th_node *right_node = ((const sqname_entry *)right)->node;
+    return (left_node > right_node) - (left_node < right_node);
+}
+
+static int schema_build_qname_cache(th_schema *schema) {
+    th_node *document = th_tree_document(schema->tree);
+    Py_ssize_t count = schema_count_elements(document);
+    schema->sqnames = arena_alloc(&schema->mem, (size_t)count * sizeof(sqname_entry));
+    if (schema->sqnames == NULL) { /* GCOVR_EXCL_BR_LINE: arena OOM is unforceable */
+        return -1;                 /* GCOVR_EXCL_LINE */
+    }
+    Py_ssize_t at = 0;
+    ns_scope scope = {0};
+    if (schema_fill_qnames(schema, document, &at, &scope) < 0) { /* GCOVR_EXCL_BR_LINE: arena OOM is unforceable */
+        return -1;                                               /* GCOVR_EXCL_LINE */
+    }
+    schema->sqname_count = count;
+    qsort(schema->sqnames, (size_t)count, sizeof(sqname_entry), sqname_cmp);
+    return 0;
+}
+
 static int named_push(th_schema *schema, named_vec *vec, const Py_UCS4 *name, Py_ssize_t len, th_node *node) {
     if (vec->len == vec->cap) {
         Py_ssize_t cap = vec->cap ? vec->cap * 2 : 8;
@@ -625,6 +813,13 @@ PyObject *turbohtml_schema_compile(PyObject *module, PyObject *args) {
     schema->tree = tree;
     schema->source = Py_NewRef(source);
     schema->root = document_root(tree);
+    /* The cache repays its build through the XSD content-model matcher, which re-classifies the same schema
+       elements on every particle step; RELAX NG's derivative walk never revisits at that rate, and the gated
+       compile benchmark showed the eager build as a pure 8% loss there, so RNG resolves names directly. */
+    if (kind == 0 && schema_build_qname_cache(schema) < 0) { /* GCOVR_EXCL_BR_LINE: arena OOM is unforceable */
+        schema_free(schema);                                 /* GCOVR_EXCL_LINE */
+        return PyErr_NoMemory();                             /* GCOVR_EXCL_LINE */
+    }
     int ok = kind == 0 ? xsd_compile(schema) : rng_compile(schema);
     if (!ok) {
         schema_free(schema);
diff --git a/src/turbohtml/_c/validate/xsd.h b/src/turbohtml/_c/validate/xsd.h
index a6fc9f3d..bb182ffc 100644
--- a/src/turbohtml/_c/validate/xsd.h
+++ b/src/turbohtml/_c/validate/xsd.h
@@ -24,9 +24,9 @@ typedef struct {
 } edecl_vec;
 
 /* Whether `node` is an XSD element whose local name is one of the listed particles. */
-static int xsd_is_particle(th_tree *tree, th_node *node, const char *const *locals, size_t count) {
+static int xsd_is_particle(const th_schema *schema, th_node *node, const char *const *locals, size_t count) {
     for (size_t index = 0; index < count; index++) {
-        if (is_schema_el(tree, node, XSD_NS, locals[index])) {
+        if (is_schema_el(schema, node, XSD_NS, locals[index])) {
             return 1;
         }
     }
@@ -117,7 +117,7 @@ static void xsd_element_name(th_schema *schema, th_node *particle, edecl *out) {
     out->local_len = name_len;
     out->decl = particle;
     /* an element particle always has a parent (its model group or the schema) */
-    int global = is_schema_el(tree, particle->parent, XSD_NS, "schema");
+    int global = is_schema_el(schema, particle->parent, XSD_NS, "schema");
     if (global || schema->element_qualified) {
         out->uri = schema->target_ns;
         out->uri_len = schema->target_ns_len;
@@ -146,7 +146,7 @@ static th_node *xsd_group_model(th_schema *schema, th_node *group_ref) {
         return NULL;
     }
     for (th_node *child = group->first_child; child != NULL; child = child->next_sibling) {
-        if (xsd_is_particle(schema->tree, child, XSD_MODEL_GROUPS, 3)) {
+        if (xsd_is_particle(schema, child, XSD_MODEL_GROUPS, 3)) {
             return child;
         }
     } /* GCOVR_EXCL_LINE: llvm miscredits this loop-exit brace when the group has no model group */
@@ -173,14 +173,13 @@ static int edecl_push(th_schema *schema, edecl_vec *vec, const edecl *item) {
 /* Gather every element declaration reachable in a particle so a child can find its
    type by name (unique-particle-attribution makes the name→decl mapping unambiguous). */
 static void xsd_collect_edecls(th_schema *schema, th_node *particle, edecl_vec *vec) {
-    th_tree *tree = schema->tree;
-    if (is_schema_el(tree, particle, XSD_NS, "element")) {
+    if (is_schema_el(schema, particle, XSD_NS, "element")) {
         edecl want;
         xsd_element_name(schema, particle, &want);
         edecl_push(schema, vec, &want);
         return;
     }
-    if (is_schema_el(tree, particle, XSD_NS, "group")) {
+    if (is_schema_el(schema, particle, XSD_NS, "group")) {
         th_node *model = xsd_group_model(schema, particle);
         if (model != NULL) {
             xsd_collect_edecls(schema, model, vec);
@@ -188,7 +187,7 @@ static void xsd_collect_edecls(th_schema *schema, th_node *particle, edecl_vec *
         return;
     }
     for (th_node *child = particle->first_child; child != NULL; child = child->next_sibling) {
-        if (xsd_is_particle(tree, child, XSD_PARTICLES, 5)) {
+        if (xsd_is_particle(schema, child, XSD_PARTICLES, 5)) {
             xsd_collect_edecls(schema, child, vec);
         }
     }
@@ -271,9 +270,8 @@ static void xsd_match_occurs(th_schema *schema, th_tree *inst, th_node *particle
 
 static void xsd_match_once(th_schema *schema, th_tree *inst, th_node *particle, th_node **children, const posset *in,
                            posset *out) {
-    th_tree *tree = schema->tree;
     memset(out->pos, 0, (size_t)out->size);
-    if (is_schema_el(tree, particle, XSD_NS, "element")) {
+    if (is_schema_el(schema, particle, XSD_NS, "element")) {
         edecl want;
         xsd_element_name(schema, particle, &want);
         for (Py_ssize_t pos = 0; pos + 1 < in->size; pos++) {
@@ -287,14 +285,14 @@ static void xsd_match_once(th_schema *schema, th_tree *inst, th_node *particle,
         }
         return;
     }
-    if (is_schema_el(tree, particle, XSD_NS, "group")) {
+    if (is_schema_el(schema, particle, XSD_NS, "group")) {
         th_node *model = xsd_group_model(schema, particle);
         if (model != NULL) {
             xsd_match_once(schema, inst, model, children, in, out);
         }
         return;
     }
-    if (is_schema_el(tree, particle, XSD_NS, "choice")) {
+    if (is_schema_el(schema, particle, XSD_NS, "choice")) {
         for (th_node *child = particle->first_child; child != NULL; child = child->next_sibling) {
             if (child->type != TH_NODE_ELEMENT) {
                 continue;
@@ -341,7 +339,7 @@ static void xsd_validate_all(valctx *ctx, th_node *all, th_node **children, Py_s
         qname name = node_qname(inst, children[index], children[index]->text, children[index]->text_len, 0);
         th_node *matched = NULL;
         for (th_node *particle = all->first_child; particle != NULL; particle = particle->next_sibling) {
-            if (!is_schema_el(tree, particle, XSD_NS, "element")) {
+            if (!is_schema_el(schema, particle, XSD_NS, "element")) {
                 continue;
             }
             edecl want;
@@ -362,7 +360,7 @@ static void xsd_validate_all(valctx *ctx, th_node *all, th_node **children, Py_s
         }
     }
     for (th_node *particle = all->first_child; particle != NULL; particle = particle->next_sibling) {
-        if (!is_schema_el(tree, particle, XSD_NS, "element") || xsd_occurs_min(tree, particle) == 0) {
+        if (!is_schema_el(schema, particle, XSD_NS, "element") || xsd_occurs_min(tree, particle) == 0) {
             continue;
         }
         edecl want;
@@ -405,7 +403,7 @@ static int xsd_base_id(th_schema *schema, th_node *owner, const Py_UCS4 *base, P
 
 static int xsd_gather_facets(th_schema *schema, th_node *simpletype, facetset *facets, int depth) {
     th_tree *tree = schema->tree;
-    th_node *restriction = first_schema_child(tree, simpletype, XSD_NS, "restriction");
+    th_node *restriction = first_schema_child(schema, simpletype, XSD_NS, "restriction");
     if (restriction == NULL) { /* list / union fall back to a permissive string base */
         return facets->base_id;
     }
@@ -415,7 +413,7 @@ static int xsd_gather_facets(th_schema *schema, th_node *simpletype, facetset *f
     if (base != NULL) {
         base_id = xsd_base_id(schema, restriction, base, base_len, facets, depth);
     } else {
-        th_node *inner = first_schema_child(tree, restriction, XSD_NS, "simpleType");
+        th_node *inner = first_schema_child(schema, restriction, XSD_NS, "simpleType");
         if (inner != NULL) {
             base_id = xsd_gather_facets(schema, inner, facets, depth + 1);
         }
@@ -522,7 +520,7 @@ static void xsd_validate_attr_decl(valctx *ctx, th_node *instance, th_node *decl
     }
     Py_ssize_t type_len = 0;
     const Py_UCS4 *type = xsd_attr(tree, effective, "type", &type_len);
-    th_node *inline_type = first_schema_child(tree, effective, XSD_NS, "simpleType");
+    th_node *inline_type = first_schema_child(schema, effective, XSD_NS, "simpleType");
     if (type != NULL) {
         facetset probe;
         facetset_init(&probe, DT_STRING);
@@ -549,7 +547,7 @@ static void xsd_collect_attrs(valctx *ctx, th_node *instance, th_node *scope, ed
     th_schema *schema = ctx->schema;
     th_tree *tree = schema->tree;
     for (th_node *child = scope->first_child; child != NULL; child = child->next_sibling) {
-        if (is_schema_el(tree, child, XSD_NS, "attribute")) {
+        if (is_schema_el(schema, child, XSD_NS, "attribute")) {
             xsd_validate_attr_decl(ctx, instance, child);
             th_node *eff = child;
             Py_ssize_t ref_len = 0;
@@ -567,7 +565,7 @@ static void xsd_collect_attrs(valctx *ctx, th_node *instance, th_node *scope, ed
                 edecl item = {NULL, 0, name, name_len, eff};
                 edecl_push(schema, declared, &item);
             }
-        } else if (is_schema_el(tree, child, XSD_NS, "attributeGroup")) {
+        } else if (is_schema_el(schema, child, XSD_NS, "attributeGroup")) {
             Py_ssize_t ref_len = 0;
             const Py_UCS4 *ref = xsd_attr(tree, child, "ref", &ref_len);
             if (ref != NULL) {
@@ -579,11 +577,11 @@ static void xsd_collect_attrs(valctx *ctx, th_node *instance, th_node *scope, ed
                     xsd_collect_attrs(ctx, instance, group, declared);
                 }
             }
-        } else if (is_schema_el(tree, child, XSD_NS, "complexContent") ||
-                   is_schema_el(tree, child, XSD_NS, "simpleContent")) {
-            th_node *derivation = first_schema_child(tree, child, XSD_NS, "extension");
+        } else if (is_schema_el(schema, child, XSD_NS, "complexContent") ||
+                   is_schema_el(schema, child, XSD_NS, "simpleContent")) {
+            th_node *derivation = first_schema_child(schema, child, XSD_NS, "extension");
             if (derivation == NULL) {
-                derivation = first_schema_child(tree, child, XSD_NS, "restriction");
+                derivation = first_schema_child(schema, child, XSD_NS, "restriction");
             }
             if (derivation != NULL) {
                 Py_ssize_t base_len = 0;
@@ -637,10 +635,10 @@ static void xsd_validate_attrs(valctx *ctx, th_node *instance, th_node *scope, e
 
 /* ---- complex-type content ---- */
 
-static th_node *xsd_content_model(th_tree *tree, th_node *scope) {
+static th_node *xsd_content_model(const th_schema *schema, th_node *scope) {
     static const char *const models[] = {"sequence", "choice", "all", "group"};
     for (size_t index = 0; index < sizeof(models) / sizeof(models[0]); index++) {
-        th_node *model = first_schema_child(tree, scope, XSD_NS, models[index]);
+        th_node *model = first_schema_child(schema, scope, XSD_NS, models[index]);
         if (model != NULL) {
             return model;
         }
@@ -653,11 +651,11 @@ static th_node *xsd_content_model(th_tree *tree, th_node *scope) {
 static th_node *xsd_effective_model(th_schema *schema, th_node *ctype, th_node **base_model_out) {
     th_tree *tree = schema->tree;
     *base_model_out = NULL;
-    th_node *complex_content = first_schema_child(tree, ctype, XSD_NS, "complexContent");
+    th_node *complex_content = first_schema_child(schema, ctype, XSD_NS, "complexContent");
     if (complex_content != NULL) {
-        th_node *extension = first_schema_child(tree, complex_content, XSD_NS, "extension");
+        th_node *extension = first_schema_child(schema, complex_content, XSD_NS, "extension");
         th_node *derivation =
-            extension != NULL ? extension : first_schema_child(tree, complex_content, XSD_NS, "restriction");
+            extension != NULL ? extension : first_schema_child(schema, complex_content, XSD_NS, "restriction");
         if (derivation == NULL) {
             return NULL;
         }
@@ -675,16 +673,17 @@ static th_node *xsd_effective_model(th_schema *schema, th_node *ctype, th_node *
                 }
             }
         }
-        return xsd_content_model(tree, derivation);
+        return xsd_content_model(schema, derivation);
     }
-    return xsd_content_model(tree, ctype);
+    return xsd_content_model(schema, ctype);
 }
 
-static int xsd_is_mixed(th_tree *tree, th_node *ctype) {
+static int xsd_is_mixed(const th_schema *schema, th_node *ctype) {
+    th_tree *tree = schema->tree;
     if (xsd_attr_is(tree, ctype, "mixed", "true")) {
         return 1;
     }
-    th_node *complex_content = first_schema_child(tree, ctype, XSD_NS, "complexContent");
+    th_node *complex_content = first_schema_child(schema, ctype, XSD_NS, "complexContent");
     if (complex_content != NULL) {
         return xsd_attr_is(tree, complex_content, "mixed", "true");
     }
@@ -698,7 +697,7 @@ static void xsd_validate_complex(valctx *ctx, th_node *instance, th_node *ctype)
     edecl_vec declared = {NULL, 0, 0};
     xsd_validate_attrs(ctx, instance, ctype, &declared);
 
-    th_node *simple_content = first_schema_child(tree, ctype, XSD_NS, "simpleContent");
+    th_node *simple_content = first_schema_child(schema, ctype, XSD_NS, "simpleContent");
     if (simple_content != NULL) {
         for (th_node *child = instance->first_child; child != NULL; child = child->next_sibling) {
             if (child->type == TH_NODE_ELEMENT) {
@@ -706,9 +705,9 @@ static void xsd_validate_complex(valctx *ctx, th_node *instance, th_node *ctype)
                 break;
             }
         }
-        th_node *extension = first_schema_child(tree, simple_content, XSD_NS, "extension");
+        th_node *extension = first_schema_child(schema, simple_content, XSD_NS, "extension");
         th_node *derivation =
-            extension != NULL ? extension : first_schema_child(tree, simple_content, XSD_NS, "restriction");
+            extension != NULL ? extension : first_schema_child(schema, simple_content, XSD_NS, "restriction");
         Py_ssize_t text_len = 0;
         const Py_UCS4 *text = element_text(ctx, instance, &text_len);
         if (derivation != NULL) {
@@ -724,7 +723,7 @@ static void xsd_validate_complex(valctx *ctx, th_node *instance, th_node *ctype)
 
     th_node *base_model;
     th_node *model = xsd_effective_model(schema, ctype, &base_model);
-    int mixed = xsd_is_mixed(tree, ctype);
+    int mixed = xsd_is_mixed(schema, ctype);
     if (!mixed) {
         for (th_node *child = instance->first_child; child != NULL; child = child->next_sibling) {
             if (is_chardata(child) && !th_node_text_is_blank(inst, child)) {
@@ -751,7 +750,7 @@ static void xsd_validate_complex(valctx *ctx, th_node *instance, th_node *ctype)
         }
     }
 
-    if (model != NULL && is_schema_el(tree, model, XSD_NS, "all")) {
+    if (model != NULL && is_schema_el(schema, model, XSD_NS, "all")) {
         xsd_validate_all(ctx, model, children, nchildren);
         return;
     }
@@ -831,8 +830,8 @@ static void xsd_validate_element_inner(valctx *ctx, th_node *instance, th_node *
 
     Py_ssize_t type_len = 0;
     const Py_UCS4 *type = xsd_attr(tree, decl, "type", &type_len);
-    th_node *inline_complex = first_schema_child(tree, decl, XSD_NS, "complexType");
-    th_node *inline_simple = first_schema_child(tree, decl, XSD_NS, "simpleType");
+    th_node *inline_complex = first_schema_child(schema, decl, XSD_NS, "complexType");
+    th_node *inline_simple = first_schema_child(schema, decl, XSD_NS, "simpleType");
     if (type != NULL) {
         const Py_UCS4 *local, *prefix, *uri;
         Py_ssize_t local_len = 0, prefix_len = 0, uri_len = 0;
@@ -869,7 +868,7 @@ static void xsd_validate_element_inner(valctx *ctx, th_node *instance, th_node *
 
 static int xsd_compile(th_schema *schema) {
     th_tree *tree = schema->tree;
-    if (!is_schema_el(tree, schema->root, XSD_NS, "schema")) {
+    if (!is_schema_el(schema, schema->root, XSD_NS, "schema")) {
         PyErr_SetString(PyExc_ValueError, "root element is not an xs:schema");
         return 0;
     }
@@ -890,17 +889,17 @@ static int xsd_compile(th_schema *schema) {
             continue;
         }
         named_vec *bucket = NULL;
-        if (is_schema_el(tree, child, XSD_NS, "element")) {
+        if (is_schema_el(schema, child, XSD_NS, "element")) {
             bucket = &schema->elements;
-        } else if (is_schema_el(tree, child, XSD_NS, "complexType")) {
+        } else if (is_schema_el(schema, child, XSD_NS, "complexType")) {
             bucket = &schema->complex_types;
-        } else if (is_schema_el(tree, child, XSD_NS, "simpleType")) {
+        } else if (is_schema_el(schema, child, XSD_NS, "simpleType")) {
             bucket = &schema->simple_types;
-        } else if (is_schema_el(tree, child, XSD_NS, "attribute")) {
+        } else if (is_schema_el(schema, child, XSD_NS, "attribute")) {
             bucket = &schema->attributes;
-        } else if (is_schema_el(tree, child, XSD_NS, "group")) {
+        } else if (is_schema_el(schema, child, XSD_NS, "group")) {
             bucket = &schema->groups;
-        } else if (is_schema_el(tree, child, XSD_NS, "attributeGroup")) {
+        } else if (is_schema_el(schema, child, XSD_NS, "attributeGroup")) {
             bucket = &schema->attr_groups;
         }
         if (bucket != NULL) {
diff --git a/src/turbohtml/_html.pyi b/src/turbohtml/_html.pyi
index cbfe671c..58d436fc 100644
--- a/src/turbohtml/_html.pyi
+++ b/src/turbohtml/_html.pyi
@@ -149,21 +149,39 @@ from ._stubs.features import (
 from ._stubs.features import (
     _sanitize as _sanitize,
 )
+from ._stubs.features import (
+    _url_is_tracker as _url_is_tracker,
+)
 from ._stubs.features import (
     _url_join as _url_join,
 )
+from ._stubs.features import (
+    _url_language_matches as _url_language_matches,
+)
+from ._stubs.features import (
+    _url_normalize_query as _url_normalize_query,
+)
 from ._stubs.features import (
     _url_percent_decode as _url_percent_decode,
 )
 from ._stubs.features import (
     _url_percent_encode as _url_percent_encode,
 )
+from ._stubs.features import (
+    _url_remove_dot_segments as _url_remove_dot_segments,
+)
+from ._stubs.features import (
+    _url_scrub as _url_scrub,
+)
 from ._stubs.features import (
     _url_split as _url_split,
 )
 from ._stubs.features import (
     _url_to_ascii as _url_to_ascii,
 )
+from ._stubs.features import (
+    _url_variant_key as _url_variant_key,
+)
 from ._stubs.features import (
     annotation_surface as annotation_surface,
 )
@@ -176,6 +194,9 @@ from ._stubs.query import (
 from ._stubs.query import (
     _css_computed_style as _css_computed_style,
 )
+from ._stubs.query import (
+    _css_escape_identifier as _css_escape_identifier,
+)
 from ._stubs.query import (
     _css_parse_declarations as _css_parse_declarations,
 )
@@ -275,6 +296,9 @@ from ._stubs.tokenizer import (
 from ._stubs.tokenizer import (
     _RewriteHandle as _RewriteHandle,
 )
+from ._stubs.tokenizer import (
+    _sax_dispatch as _sax_dispatch,
+)
 from ._stubs.tokenizer import (
     _sax_events as _sax_events,
 )
diff --git a/src/turbohtml/_stubs/dom.pyi b/src/turbohtml/_stubs/dom.pyi
index 98524e85..c3df286a 100644
--- a/src/turbohtml/_stubs/dom.pyi
+++ b/src/turbohtml/_stubs/dom.pyi
@@ -351,6 +351,18 @@ class Document(Node):
     def microdata(self, base_url: str | None = None) -> list[MicrodataItem]: ...
     def rdfa(self, base_url: str | None = None) -> list[RdfaItem]: ...
     def dublin_core(self) -> dict[str, str]: ...
+    def _date_meta(
+        self,
+        want: int,
+        current_year: int,
+        min_year: int,
+        min_month: int,
+        min_day: int,
+        max_year: int,
+        max_month: int,
+        max_day: int,
+        /,
+    ) -> tuple[int, int, int] | None: ...
     def feed(self) -> Feed | None: ...
     @property
     def errors(self) -> list[ParseError]: ...
diff --git a/src/turbohtml/_stubs/features.pyi b/src/turbohtml/_stubs/features.pyi
index 1867fee3..729b4d58 100644
--- a/src/turbohtml/_stubs/features.pyi
+++ b/src/turbohtml/_stubs/features.pyi
@@ -33,6 +33,29 @@ def _url_split(url: str, /) -> tuple[str, str, str, str, str, str, str, str, boo
 def _url_percent_encode(text: str, url_set: int, /) -> str: ...
 def _url_percent_decode(text: str, /) -> str: ...
 def _url_join(base: str, target: str, /) -> str: ...
+def _url_is_tracker(key: str, /) -> bool: ...
+def _url_remove_dot_segments(path: str, /) -> str: ...
+def _url_scrub(url: str, /) -> str: ...
+def _url_variant_key(url: str, /) -> str: ...
+def _url_normalize_query(
+    query: str,
+    allow: frozenset[str] | set[str] | None,
+    deny: frozenset[str] | set[str],
+    strict: bool,
+    content: frozenset[str],
+    language: frozenset[str],
+    /,
+) -> str: ...
+def _url_language_matches(
+    query: str,
+    path: str,
+    hostname: str,
+    language: str,
+    strict: bool,
+    language_params: frozenset[str],
+    iso_639_1: frozenset[str],
+    /,
+) -> bool: ...
 def _url_to_ascii(host: str, /) -> str: ...
 def _register_links(link_type: type, /) -> None: ...
 def _register_structured_data(
diff --git a/src/turbohtml/_stubs/query.pyi b/src/turbohtml/_stubs/query.pyi
index ebeec1b9..29d694db 100644
--- a/src/turbohtml/_stubs/query.pyi
+++ b/src/turbohtml/_stubs/query.pyi
@@ -19,6 +19,7 @@ def _css_specificity(selector: str, /) -> list[tuple[int, int, int]]: ...
 def _css_parse_declarations(text: str, /) -> tuple[tuple[str, str, bool], ...]: ...
 def _css_parse_rules(text: str, /) -> tuple[tuple[str, tuple[tuple[str, str, bool], ...]], ...]: ...
 def _css_computed_style(element: Element, /) -> tuple[tuple[str, str], ...]: ...
+def _css_escape_identifier(ident: str, /) -> str: ...
 def _register_xpath_string(xpath_string_type: type, /) -> None: ...
 def _register_selector_error(selector_error_type: type[ValueError], /) -> None: ...
 
diff --git a/src/turbohtml/_stubs/tokenizer.pyi b/src/turbohtml/_stubs/tokenizer.pyi
index 4f0ccfe7..74fd820a 100644
--- a/src/turbohtml/_stubs/tokenizer.pyi
+++ b/src/turbohtml/_stubs/tokenizer.pyi
@@ -103,6 +103,7 @@ def _rewrite(
     /,
 ) -> str: ...
 def _sax_events(html: str, /) -> Iterator[tuple[object, ...]]: ...
+def _sax_dispatch(html: str, handler: object, /) -> None: ...
 def _tokenize_states(
     text: str, initial_state: str, last_start_tag: str | None = ..., storage_kind: int = ..., /
 ) -> tuple[list[tuple[object, ...]], list[tuple[str, int, int]]]: ...
diff --git a/src/turbohtml/clean/_linkify.py b/src/turbohtml/clean/_linkify.py
index 4beccb5d..da7018e8 100644
--- a/src/turbohtml/clean/_linkify.py
+++ b/src/turbohtml/clean/_linkify.py
@@ -11,7 +11,6 @@
 
 from __future__ import annotations
 
-import re
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Final, TypeAlias
 
@@ -26,10 +25,10 @@
 # verbatim; only a bare domain (kind 0 without a ``scheme://``) is prefixed with ``http://``.
 _SCHEME_KIND: Final = 2
 
-# A leading ``scheme://`` tells a matched URL already carries its scheme; a bare domain (``example.com``, ``www.x.com``)
-# does not and is prefixed with ``http://``. Anchoring at the start avoids treating a ``://`` deeper in a bare domain's
-# path (an embedded redirect URL) as the link's own scheme.
-_SCHEME: Final = re.compile(r"[a-zA-Z][a-zA-Z0-9+.\-]*://")
+# A ``scheme://`` URL the scanner flagged as already carrying its scheme (the anchored ``[a-zA-Z][a-zA-Z0-9+.\-]*://``
+# rule, applied per match in C), so its url is the matched text verbatim. A bare domain (``example.com``, ``www.x.com``)
+# stays kind 0 and is prefixed with ``http://``; classifying in the scanner avoids re-running the rule here per match.
+_HAS_SCHEME_KIND: Final = 3
 
 # The ``scheme://host`` schemes autolinked when a config registers none: the fixed set linkify-it recognizes, so a typo
 # scheme or a ``javascript://`` payload stays plain text. A ``Linkify.schemes`` restricts to its own set (bleach), while
@@ -241,7 +240,7 @@ def _build_anchor(self, matched: str, kind: int) -> Element | None:
         """Build the ``<a>`` for one matched link, running the callbacks; return ``None`` if a callback vetoes it."""
         if kind == _EMAIL_KIND:
             url = "mailto:" + matched
-        elif _SCHEME.match(matched):  # the scanner already gated the scheme; a match here keeps its own scheme
+        elif kind == _HAS_SCHEME_KIND:  # the scanner flagged a ``scheme://`` URL, kept with its own scheme
             url = matched
         else:
             url = "http://" + matched
@@ -318,7 +317,7 @@ def _span_from_match(text: str, start: int, end: int, kind: int) -> LinkSpan:
     matched = text[start:end]
     if kind == _EMAIL_KIND:
         url = "mailto:" + matched
-    elif kind == _SCHEME_KIND or _SCHEME.match(matched):
+    elif kind in {_SCHEME_KIND, _HAS_SCHEME_KIND}:
         url = matched
     else:
         url = "http://" + matched
diff --git a/src/turbohtml/extract/_dates.py b/src/turbohtml/extract/_dates.py
index 729f08db..34a763ee 100644
--- a/src/turbohtml/extract/_dates.py
+++ b/src/turbohtml/extract/_dates.py
@@ -84,25 +84,6 @@ def __post_init__(self) -> None:
 
 _DEFAULT: Final = DateExtraction()
 
-_PUBLISHED_KEYS: Final[frozenset[str]] = frozenset({
-    *("article.created", "article.published", "article:published", "article:published_time", "article_date_original"),
-    *("bt:pubdate", "citation_date", "citation_publication_date", "created", "date", "date_published", "datecreated"),
-    *("dateposted", "datepublished", "dc.date", "dc.date.created", "dc.date.issued", "dc.date.publication"),
-    *("dcterms.created", "dcterms.date", "dcterms.issued", "og:article:published_time", "og:published_time"),
-    *("og:pubdate", "parsely-pub-date", "pdate", "pubdate", "publish-date", "publish_date", "published_date"),
-    *("published_time", "publisheddate", "publication_date", "rnews:datepublished", "sailthru.date", "timestamp"),
-    *("datecreated", "datepublished", "pubyear"),  # itemprop spellings
-})
-"""Meta ``name``/``property``/``itemprop`` keys that mark a publication date, drawn from htmldate's vocabulary."""
-
-_MODIFIED_KEYS: Final[frozenset[str]] = frozenset({
-    *("article:modified", "article:modified_time", "article:post_modified", "datemodified", "dc.modified"),
-    *("dcterms.modified", "lastdate", "lastmod", "lastmodified", "last-modified", "modified", "modified_time"),
-    *("modificationdate", "og:article:modified_time", "og:modified_time", "og:updated_time", "revision_date"),
-    *("updated_time", "dateupdate"),  # itemprop spelling
-})
-"""Meta keys that mark a modification date."""
-
 # Elements that tend to carry a date, drawn from htmldate's class/id vocabulary but kept to the high-precision
 # markers (skipping its broad 'info'/'author'/'footer' catch-alls, which pull in unrelated dates).
 _DATE_MARKUP: Final = ", ".join((
@@ -138,7 +119,7 @@ def dates(html: str, options: DateExtraction | None = None, /) -> PublicationDat
     current_year = today.year
     if found := _pick(_url_candidates(document), want, window, active.output_format, "url"):
         return found
-    if found := _pick(_meta_candidates(document, current_year), want, window, active.output_format, "meta"):
+    if found := _meta_date(document, want, window, active.output_format, current_year):
         return found
     if found := _pick(_json_candidates(document, current_year), want, window, active.output_format, "json-ld"):
         return found
@@ -196,20 +177,27 @@ def _url_date(url: str) -> date | None:
     return date(*parts) if parts else None
 
 
-def _meta_candidates(document: Document, current_year: int) -> list[tuple[_Role, date]]:
-    """Publication and modification dates from ``<meta>`` tags, keyed by name/property/itemprop/http-equiv/pubdate."""
-    found: list[tuple[_Role, date]] = []
-    for element in document.find_all("meta"):
-        attributes = element.attrs
-        content = attributes.get("content") or attributes.get("datetime")
-        if not isinstance(content, str):
-            continue
-        keys = [attributes.get(name) for name in ("name", "property", "itemprop", "http-equiv")]
-        if str(attributes.get("pubdate")).lower() == "pubdate":
-            keys.append("pubdate")
-        if (role := _role_of(keys)) is not None and (moment := _scan(content, current_year)):
-            found.append((role, moment))
-    return found
+def _meta_date(
+    document: Document, want: _Role, window: _Window, output_format: str, current_year: int
+) -> PublicationDate | None:
+    """
+    Return the ``<meta>`` stage's date, keyed by name/property/itemprop/http-equiv/pubdate as htmldate reads them.
+
+    The walk that classifies each meta element against htmldate's key vocabulary and returns the winner :func:`_pick`
+    would runs in C (:meth:`Document._date_meta`); this shim passes the window and the wanted role and formats the
+    (year, month, day) the walk returns.
+    """
+    parts = document._date_meta(  # ruff:ignore[private-member-access]  # the Document type's private C entry point
+        1 if want == _PUBLISHED else 2,
+        current_year,
+        window.earliest.year,
+        window.earliest.month,
+        window.earliest.day,
+        window.latest.year,
+        window.latest.month,
+        window.latest.day,
+    )
+    return PublicationDate(date(*parts).strftime(output_format), "meta") if parts else None
 
 
 def _json_candidates(document: Document, current_year: int) -> list[tuple[_Role, date]]:
@@ -273,16 +261,6 @@ def _text_candidates(
     return [(_GENERIC, min(finalists) if original else max(finalists))]
 
 
-def _role_of(keys: list[str | list[str] | None]) -> _Role | None:
-    """Classify a meta element's keys as a publication or modification marker, or neither."""
-    lowered = {key.lower() for key in keys if isinstance(key, str)}
-    if lowered & _PUBLISHED_KEYS:
-        return _PUBLISHED
-    if lowered & _MODIFIED_KEYS:
-        return _MODIFIED
-    return None
-
-
 def _walk_json(node: object, found: list[tuple[_Role, date]], current_year: int) -> None:
     """Collect datePublished/dateModified from a JSON-LD node, recursing through @graph and nested objects."""
     if isinstance(node, list):
diff --git a/src/turbohtml/extract/_urls.py b/src/turbohtml/extract/_urls.py
index ee806d75..76c4b123 100644
--- a/src/turbohtml/extract/_urls.py
+++ b/src/turbohtml/extract/_urls.py
@@ -12,7 +12,6 @@
 
 from __future__ import annotations
 
-import re
 from dataclasses import dataclass
 from functools import lru_cache
 from typing import Final, NamedTuple
@@ -20,11 +19,17 @@
 
 from turbohtml._html import (
     _registrable_domain,
+    _url_is_tracker,
     _url_join,
+    _url_language_matches,
+    _url_normalize_query,
     _url_percent_decode,
     _url_percent_encode,
+    _url_remove_dot_segments,
+    _url_scrub,
     _url_split,
     _url_to_ascii,
+    _url_variant_key,
     parse,
 )
 
@@ -50,38 +55,6 @@
 ])
 """The ISO 639-1 two-letter language codes, gating which URL segments count as language markers."""
 
-# Names compiled from the public query-stripping lists (Firefox's query-stripping records, the ClearURLs rules, and
-# AdGuard's TrackParamFilter), the same sources courlan cites.
-_TRACKER_NAMES: Final[frozenset[str]] = frozenset({
-    "clickid",
-    "dclid",
-    "efid",
-    "epik",
-    "fb_ref",
-    "fb_source",
-    "fbclid",
-    "gbraid",
-    "gclid",
-    "gclsrc",
-    "igsh",
-    "igshid",
-    "mkt_tok",
-    "msclkid",
-    "partnerid",
-    "s_cid",
-    "sc_cid",
-    "ttclid",
-    "twclid",
-    "wbraid",
-    "wickedid",
-    "yclid",
-    "ysclid",
-})
-_TRACKER_PREFIXES: Final = ("ad_", "ads_", "ga_", "gs_", "hsa_", "itm_", "mc_", "mtm_", "oly_", "pk_", "utm_", "vero_")
-_TRACKER_WORDS: Final = re.compile(
-    r"(?:^|_)(?:aff(?:i(?:liate)?)?|campaign|cl?id|keyword|kwd|medium|refer(?:r?er)?|ref|session|source|uid|xtor)(?:_|$)"
-)
-
 _CONTENT_PARAMS: Final[frozenset[str]] = frozenset({
     "aid",
     "article_id",
@@ -106,12 +79,8 @@
 # _c/url/url.h. The C encoder keeps the set's raw characters, UTF-8 percent-encodes the rest, and uppercases existing
 # %XX escapes, so a component that is already clean passes through unchanged.
 _SET_PATH: Final = 0
-_SET_QUERY: Final = 1
 _SET_FRAGMENT: Final = 2
 
-_MARKUP_DELIMITER: Final = re.compile(r'[<>"]')
-_C0_AND_SPACE: Final = "".join(map(chr, range(0x21)))
-_LANGUAGE_SEGMENT: Final = re.compile(r"([a-z]{2})(?:[-_][a-z]{2,3})?$")
 _DEFAULT_PORTS: Final[dict[str, int]] = {"ftp": 21, "http": 80, "ws": 80, "https": 443, "wss": 443}
 _WEB_SCHEMES: Final = ("http", "https")
 _WEB_PREFIXES: Final = ("http://", "https://")
@@ -213,7 +182,7 @@ def clean_url(url: str, options: UrlCleaning | None = None, /) -> str | None:
         msg = f"url must be a str, got {type(url).__name__}"
         raise TypeError(msg)
     active = options or _DEFAULT
-    scrubbed = _scrub(url)
+    scrubbed = _url_scrub(url)
     try:
         parts = _split(scrubbed)
     except ValueError:
@@ -308,43 +277,23 @@ def extract_links(
             cleaned = cleaned_of[link.url] = clean_url(candidate, active)
         if cleaned is None or (external_only and _site_of(cleaned) == site):
             continue
-        if (key := _variant_key(cleaned)) not in seen:
+        if (key := _url_variant_key(cleaned)) not in seen:
             seen.add(key)
             found.add(cleaned)
     return found
 
 
-def _scrub(url: str) -> str:
-    """Undo HTML transport damage: whitespace, a CDATA wrapper, markup delimiters, and leftover ``&amp;`` escapes."""
-    remainder = "".join(url.strip(_C0_AND_SPACE).split())
-    if remainder.startswith("<![CDATA["):
-        remainder = remainder.removeprefix("<![CDATA[").removesuffix("]]>")
-    remainder = _MARKUP_DELIMITER.split(remainder, maxsplit=1)[0].replace("&amp;", "&")
-    return remainder.removesuffix("&") if remainder.endswith("/&") else remainder
-
-
 def _language_matches(parts: _Split, language: str, *, strict: bool) -> bool:
     """
-    Judge the URL's own language markers against the target language.
+    Judge the URL's own language markers against the target language in C.
 
     Three URL-based heuristics (content-based detection is out of scope): a ``lang``/``language`` query parameter
     whose value does not start with the code, a leading path segment that is an ISO 639-1 tag of another language
     (``/de/``, ``/en-us/``), and -- in strict mode -- a two-letter language subdomain (``de.example.org``).
     """
-    for pair in parts.query.split("&"):
-        key, separator, value = pair.partition("=")
-        if separator and _url_percent_decode(key).lower() in _LANGUAGE_PARAMS:
-            code = _url_percent_decode(value).lower()
-            if code and not code.startswith(language):
-                return False
-    leading = next((segment for segment in parts.path.lower().split("/") if segment), "")
-    if (match := _LANGUAGE_SEGMENT.fullmatch(leading)) and match[1] in _ISO_639_1 and match[1] != language:
-        return False
-    if strict:
-        label = parts.hostname.partition(".")[0]
-        if len(label) == 2 and label in _ISO_639_1 and label != language:
-            return False
-    return True
+    return _url_language_matches(
+        parts.query, parts.path, parts.hostname, language, strict, _LANGUAGE_PARAMS, _ISO_639_1
+    )
 
 
 def _normalize(parts: _Split, options: UrlCleaning) -> str:
@@ -353,7 +302,7 @@ def _normalize(parts: _Split, options: UrlCleaning) -> str:
     netloc = _normalize_netloc(parts, scheme) if parts.netloc else ""
     path = _encode(parts.path, _SET_PATH)
     if netloc:
-        path = _remove_dot_segments(path)
+        path = _url_remove_dot_segments(path)
     query = _normalize_query(parts.query, options)
     if netloc and scheme in _WEB_SCHEMES and not path:
         path = "/"  # a special URL with a host never serializes an empty path (URL serializing, spec 4.5)
@@ -406,57 +355,11 @@ def _encode(text: str, url_set: int) -> str:
         raise ValueError(msg) from exc
 
 
-def _remove_dot_segments(path: str) -> str:
-    """Resolve ``.`` and ``..`` segments, including their ``%2e`` spellings, as the path state does (spec 4.4)."""
-    if "." not in path and "%2E" not in path:
-        return path
-    output: list[str] = []
-    dotted = ""
-    for segment in path.split("/"):
-        dotted = segment.replace("%2E", ".")
-        if dotted == ".":
-            continue
-        if dotted == "..":
-            if len(output) > 1:
-                output.pop()
-        else:
-            output.append(segment)
-    if dotted in {".", ".."}:
-        output.append("")
-    return "/".join(output)
-
-
 def _normalize_query(query: str, options: UrlCleaning) -> str:
-    """Drop denied, tracker, or non-allowlisted parameters and sort the rest, keeping each pair's raw encoding."""
+    """Drop denied, tracker, or non-allowlisted parameters and sort the rest in C, keeping each pair's raw encoding."""
     allow = {name.lower() for name in options.query_allow} if options.query_allow is not None else None
     deny = {name.lower() for name in options.query_deny}
-    kept: list[tuple[str, str]] = []
-    for pair in query.split("&"):
-        if not pair:
-            continue
-        key = _url_percent_decode(pair.partition("=")[0]).lower()
-        if key in deny:
-            continue
-        if allow is not None:
-            dropped = key not in allow
-        elif options.strict:
-            dropped = key not in _CONTENT_PARAMS and key not in _LANGUAGE_PARAMS
-        else:
-            dropped = _is_tracker(key)
-        if dropped:
-            continue
-        kept.append((key, _encode(pair, _SET_QUERY)))
-    return "&".join(pair for _key, pair in sorted(kept))
-
-
-def _is_tracker(key: str) -> bool:
-    """Match a query-parameter name against the compiled tracking-parameter vocabulary."""
-    return (
-        key in _TRACKER_NAMES
-        or key.startswith(_TRACKER_PREFIXES)
-        or key.endswith("clid")
-        or _TRACKER_WORDS.search(key) is not None
-    )
+    return _url_normalize_query(query, allow, deny, options.strict, _CONTENT_PARAMS, _LANGUAGE_PARAMS)
 
 
 def _normalize_fragment(fragment: str, options: UrlCleaning) -> str:
@@ -464,7 +367,7 @@ def _normalize_fragment(fragment: str, options: UrlCleaning) -> str:
     if "=" in fragment:
         if "&" in fragment:
             return _normalize_query(fragment, options)
-        if _is_tracker(_url_percent_decode(fragment.partition("=")[0]).lower()):
+        if _url_is_tracker(_url_percent_decode(fragment.partition("=")[0]).lower()):
             return ""
     return _encode(fragment, _SET_FRAGMENT)
 
@@ -492,9 +395,3 @@ def _site_of(url: str) -> str:
     ``blog.example.com`` both collapse to ``example.com``, ``a.co.uk`` and ``b.co.uk`` stay distinct).
     """
     return _registrable_domain(_ascii_host(_split(url).hostname))
-
-
-def _variant_key(url: str) -> str:
-    """Collapse the scheme and a bare trailing slash so ``http``/``https`` and slash twins deduplicate."""
-    remainder = url.partition("://")[2]
-    return remainder if "?" in remainder or "#" in remainder else remainder.rstrip("/")
diff --git a/src/turbohtml/query/_match.py b/src/turbohtml/query/_match.py
index 18d19f26..fc44c95b 100644
--- a/src/turbohtml/query/_match.py
+++ b/src/turbohtml/query/_match.py
@@ -23,7 +23,7 @@
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Final, cast
 
-from turbohtml._html import Document, Element, _matches_many, parse
+from turbohtml._html import Document, Element, _css_escape_identifier, _matches_many, parse
 from turbohtml._internal._selectors import SelectorSyntaxError
 
 if TYPE_CHECKING:
@@ -44,24 +44,7 @@ def escape_identifier(ident: str) -> str:
     :param ident: the raw identifier text.
     :returns: the identifier with CSS-significant characters backslash- or hex-escaped per the CSSOM rules.
     """
-    out: list[str] = []
-    for position, char in enumerate(ident):
-        code = ord(char)
-        is_digit = 0x30 <= code <= 0x39
-        # a digit leading the identifier (or following an initial dash) cannot start a CSS name, so it is hex-escaped
-        leading_digit = is_digit and (position == 0 or (position == 1 and ident[0] == "-"))
-        is_name_char = code >= 0x80 or is_digit or char in "-_" or 0x41 <= code <= 0x5A or 0x61 <= code <= 0x7A
-        if code == 0:
-            out.append("�")
-        elif code <= 0x1F or code == 0x7F or leading_digit:
-            out.append(f"\\{code:x} ")
-        elif position == 0 and code == 0x2D and len(ident) == 1:
-            out.append(f"\\{char}")
-        elif is_name_char:
-            out.append(char)
-        else:
-            out.append(f"\\{char}")
-    return "".join(out)
+    return _css_escape_identifier(ident)
 
 
 @dataclass(frozen=True)
diff --git a/src/turbohtml/saxparse.py b/src/turbohtml/saxparse.py
index a6a638f9..ef5546d3 100644
--- a/src/turbohtml/saxparse.py
+++ b/src/turbohtml/saxparse.py
@@ -28,7 +28,7 @@
 
 from typing import TYPE_CHECKING, NamedTuple, cast
 
-from ._html import _sax_events
+from ._html import _sax_dispatch, _sax_events
 
 if TYPE_CHECKING:
     from collections.abc import Iterator
@@ -157,16 +157,4 @@ def sax_parse(html: str, handler: SaxHandler) -> None:
     :param handler: a :class:`SaxHandler` (or subclass) whose overridden methods receive the events.
     :raises TypeError: if ``html`` is not a str.
     """
-    for event in iter_events(html):
-        if isinstance(event, StartElement):
-            handler.start_element(event.tag, event.attrs)
-        elif isinstance(event, EndElement):
-            handler.end_element(event.tag)
-        elif isinstance(event, Characters):
-            handler.characters(event.data)
-        elif isinstance(event, Comment):
-            handler.comment(event.data)
-        elif isinstance(event, Doctype):
-            handler.doctype(event.name, event.public_id, event.system_id)
-        else:
-            handler.processing_instruction(event.data)
+    _sax_dispatch(html, handler)
diff --git a/tests/clean/test_linkify.py b/tests/clean/test_linkify.py
index 8222056f..32664c58 100644
--- a/tests/clean/test_linkify.py
+++ b/tests/clean/test_linkify.py
@@ -266,17 +266,17 @@ def test_bare_domain_path_with_embedded_scheme_keeps_http_prefix() -> None:
 @pytest.mark.parametrize(
     ("text", "parse_email", "bare_domains", "spans"),
     [
-        pytest.param("http://example.com", False, False, [(0, 18, 0)], id="scheme-url"),
-        pytest.param("HTTP://EXAMPLE.COM", False, False, [(0, 18, 0)], id="uppercase-scheme-and-host"),
-        pytest.param("ftp://example.com/file", False, False, [(0, 22, 0)], id="ftp-scheme"),
-        pytest.param("svn+ssh://example.com", False, False, [(0, 21, 0)], id="scheme-with-plus"),
-        pytest.param("view-source://example.com", False, False, [(0, 25, 0)], id="scheme-with-hyphen"),
-        pytest.param("a.b://example.com", False, False, [(0, 17, 0)], id="scheme-with-dot"),
+        pytest.param("http://example.com", False, False, [(0, 18, 3)], id="scheme-url"),
+        pytest.param("HTTP://EXAMPLE.COM", False, False, [(0, 18, 3)], id="uppercase-scheme-and-host"),
+        pytest.param("ftp://example.com/file", False, False, [(0, 22, 3)], id="ftp-scheme"),
+        pytest.param("svn+ssh://example.com", False, False, [(0, 21, 3)], id="scheme-with-plus"),
+        pytest.param("view-source://example.com", False, False, [(0, 25, 3)], id="scheme-with-hyphen"),
+        pytest.param("a.b://example.com", False, False, [(0, 17, 3)], id="scheme-with-dot"),
         pytest.param("nothttp//example.com", False, True, [(9, 20, 0)], id="no-colon-slash-slash-falls-to-bare"),
         pytest.param("foo/example.com", False, True, [(4, 15, 0)], id="single-slash-keeps-bare-domain"),
         pytest.param("mailto:bob", False, False, [], id="scheme-without-slashes-no-match"),
         pytest.param(":no scheme here", False, False, [], id="leading-colon-no-scheme"),
-        pytest.param("xhttp://example.com", False, False, [(0, 19, 0)], id="arbitrary-scheme-matches-like-bleach"),
+        pytest.param("xhttp://example.com", False, False, [(0, 19, 3)], id="arbitrary-scheme-matches-like-bleach"),
         pytest.param("日http://example.com", False, False, [], id="non-ascii-before-scheme-blocks"),
         pytest.param("http://.example.com", False, False, [], id="host-starts-with-dot"),
         pytest.param("http://-example.com", False, False, [], id="host-starts-with-hyphen"),
@@ -314,46 +314,46 @@ def test_bare_domain_path_with_embedded_scheme_keeps_http_prefix() -> None:
         pytest.param("a@@example.com", True, False, [], id="email-double-at"),
         pytest.param("ab@cd@example.com", True, False, [], id="email-second-at-blocks-on-left"),
         pytest.param("a@b nope", True, False, [], id="email-no-dotted-host"),
-        pytest.param("word http://example.com", False, False, [(5, 23, 0)], id="space-then-url-not-blocked"),
-        pytest.param("end. http://example.com", False, False, [(5, 23, 0)], id="not-blocked-after-dot-space"),
-        pytest.param("http://example.com/a(b)c", False, False, [(0, 24, 0)], id="balanced-round-in-path"),
-        pytest.param("http://example.com/a[b]c", False, False, [(0, 24, 0)], id="balanced-square-in-path"),
-        pytest.param("http://example.com/a)b", False, False, [(0, 20, 0)], id="unbalanced-round-stops"),
-        pytest.param("http://example.com/a]b", False, False, [(0, 20, 0)], id="unbalanced-square-stops"),
-        pytest.param("http://example.com/a{b}c", False, False, [(0, 24, 0)], id="balanced-curly-in-path"),
-        pytest.param("http://example.com/a}b", False, False, [(0, 20, 0)], id="unbalanced-curly-stops"),
+        pytest.param("word http://example.com", False, False, [(5, 23, 3)], id="space-then-url-not-blocked"),
+        pytest.param("end. http://example.com", False, False, [(5, 23, 3)], id="not-blocked-after-dot-space"),
+        pytest.param("http://example.com/a(b)c", False, False, [(0, 24, 3)], id="balanced-round-in-path"),
+        pytest.param("http://example.com/a[b]c", False, False, [(0, 24, 3)], id="balanced-square-in-path"),
+        pytest.param("http://example.com/a)b", False, False, [(0, 20, 3)], id="unbalanced-round-stops"),
+        pytest.param("http://example.com/a]b", False, False, [(0, 20, 3)], id="unbalanced-square-stops"),
+        pytest.param("http://example.com/a{b}c", False, False, [(0, 24, 3)], id="balanced-curly-in-path"),
+        pytest.param("http://example.com/a}b", False, False, [(0, 20, 3)], id="unbalanced-curly-stops"),
         pytest.param(
-            "{http://example.com/foo_bar}", False, False, [(1, 27, 0)], id="brace-scoped-trailing-brace-trimmed"
+            "{http://example.com/foo_bar}", False, False, [(1, 27, 3)], id="brace-scoped-trailing-brace-trimmed"
         ),
-        pytest.param("http://example.com/foo'", False, False, [(0, 22, 0)], id="trailing-apostrophe-trimmed"),
-        pytest.param("http://example.com/o'reilly", False, False, [(0, 27, 0)], id="apostrophe-mid-path-kept"),
-        pytest.param("(http://example.com/path)", False, False, [(1, 24, 0)], id="link-in-parens"),
-        pytest.param("http://example.com/path.", False, False, [(0, 23, 0)], id="path-trailing-dot-trimmed"),
-        pytest.param("http://example.com/a,b,", False, False, [(0, 22, 0)], id="path-trailing-comma-trimmed"),
-        pytest.param("http://example.com/p!?:;", False, False, [(0, 20, 0)], id="path-trailing-punct-run-trimmed"),
+        pytest.param("http://example.com/foo'", False, False, [(0, 22, 3)], id="trailing-apostrophe-trimmed"),
+        pytest.param("http://example.com/o'reilly", False, False, [(0, 27, 3)], id="apostrophe-mid-path-kept"),
+        pytest.param("(http://example.com/path)", False, False, [(1, 24, 3)], id="link-in-parens"),
+        pytest.param("http://example.com/path.", False, False, [(0, 23, 3)], id="path-trailing-dot-trimmed"),
+        pytest.param("http://example.com/a,b,", False, False, [(0, 22, 3)], id="path-trailing-comma-trimmed"),
+        pytest.param("http://example.com/p!?:;", False, False, [(0, 20, 3)], id="path-trailing-punct-run-trimmed"),
         # '*' is an RFC 3986 sub-delim that bleach and linkify_it keep, so a trailing one stays in the link
-        pytest.param("http://example.com/path*", False, False, [(0, 24, 0)], id="path-trailing-star-kept"),
-        pytest.param("http://example.com:notaport/x", False, False, [(0, 18, 0)], id="colon-not-a-port-ends-host"),
-        pytest.param("http://example.com:8080", False, False, [(0, 23, 0)], id="port-at-end-of-string"),
-        pytest.param("http://example.com?q=1", False, False, [(0, 22, 0)], id="query-led-tail"),
-        pytest.param("http://example.com no tail", False, False, [(0, 18, 0)], id="host-only-no-tail"),
-        pytest.param("see http://example.com.", False, False, [(4, 22, 0)], id="host-trailing-dot-trimmed"),
-        pytest.param('http://example.com/a"b', False, False, [(0, 20, 0)], id="tail-stops-at-quote"),
-        pytest.param("http://example.com/a`b", False, False, [(0, 20, 0)], id="tail-stops-at-backtick"),
-        pytest.param("http://example.com/a b", False, False, [(0, 20, 0)], id="tail-stops-at-space"),
-        pytest.param("http://example.com/a\x7fb", False, False, [(0, 20, 0)], id="tail-stops-at-del"),
-        pytest.param("http://user:pass@host.com/x", True, False, [(0, 27, 0)], id="userinfo-url"),
-        pytest.param("http://u@example.com", False, False, [(0, 20, 0)], id="userinfo-at-only"),
-        pytest.param("http://a.b@example.com", False, False, [(0, 22, 0)], id="userinfo-is-a-valid-host"),
-        pytest.param("http://1.2.3.4/path", False, False, [(0, 19, 0)], id="schemeful-ipv4"),
+        pytest.param("http://example.com/path*", False, False, [(0, 24, 3)], id="path-trailing-star-kept"),
+        pytest.param("http://example.com:notaport/x", False, False, [(0, 18, 3)], id="colon-not-a-port-ends-host"),
+        pytest.param("http://example.com:8080", False, False, [(0, 23, 3)], id="port-at-end-of-string"),
+        pytest.param("http://example.com?q=1", False, False, [(0, 22, 3)], id="query-led-tail"),
+        pytest.param("http://example.com no tail", False, False, [(0, 18, 3)], id="host-only-no-tail"),
+        pytest.param("see http://example.com.", False, False, [(4, 22, 3)], id="host-trailing-dot-trimmed"),
+        pytest.param('http://example.com/a"b', False, False, [(0, 20, 3)], id="tail-stops-at-quote"),
+        pytest.param("http://example.com/a`b", False, False, [(0, 20, 3)], id="tail-stops-at-backtick"),
+        pytest.param("http://example.com/a b", False, False, [(0, 20, 3)], id="tail-stops-at-space"),
+        pytest.param("http://example.com/a\x7fb", False, False, [(0, 20, 3)], id="tail-stops-at-del"),
+        pytest.param("http://user:pass@host.com/x", True, False, [(0, 27, 3)], id="userinfo-url"),
+        pytest.param("http://u@example.com", False, False, [(0, 20, 3)], id="userinfo-at-only"),
+        pytest.param("http://a.b@example.com", False, False, [(0, 22, 3)], id="userinfo-is-a-valid-host"),
+        pytest.param("http://1.2.3.4/path", False, False, [(0, 19, 3)], id="schemeful-ipv4"),
         pytest.param("at 1.2.3.4 here", False, True, [], id="bare-ipv4-needs-tld"),
-        pytest.param("http://example.com#frag", False, False, [(0, 23, 0)], id="fragment-after-host"),
-        pytest.param("http://example.com:8080?q=1", False, False, [(0, 27, 0)], id="port-then-query-no-userinfo"),
-        pytest.param("http://example.com:8080#f", False, False, [(0, 25, 0)], id="port-then-fragment-no-userinfo"),
-        pytest.param("http://example.com:8080 x", False, False, [(0, 23, 0)], id="port-then-space-no-userinfo"),
+        pytest.param("http://example.com#frag", False, False, [(0, 23, 3)], id="fragment-after-host"),
+        pytest.param("http://example.com:8080?q=1", False, False, [(0, 27, 3)], id="port-then-query-no-userinfo"),
+        pytest.param("http://example.com:8080#f", False, False, [(0, 25, 3)], id="port-then-fragment-no-userinfo"),
+        pytest.param("http://example.com:8080 x", False, False, [(0, 23, 3)], id="port-then-space-no-userinfo"),
         pytest.param("see EXAMPLE.COM here", False, True, [(4, 15, 0)], id="bare-domain-uppercase-tld"),
-        pytest.param("https://cdn_1.example.org/x", False, False, [(0, 27, 0)], id="underscore-in-scheme-host"),
-        pytest.param("http://_dmarc.example.com/", False, False, [(0, 26, 0)], id="underscore-leading-scheme-host"),
+        pytest.param("https://cdn_1.example.org/x", False, False, [(0, 27, 3)], id="underscore-in-scheme-host"),
+        pytest.param("http://_dmarc.example.com/", False, False, [(0, 26, 3)], id="underscore-leading-scheme-host"),
         pytest.param("cdn_1.example.org/x", False, True, [(0, 19, 0)], id="underscore-in-bare-host"),
         pytest.param("_dmarc.example.com here", False, True, [(0, 18, 0)], id="underscore-leading-bare-host"),
     ],
@@ -370,10 +370,10 @@ def test_scanner_spans(
 @pytest.mark.parametrize(
     ("text", "url_schemes", "spans"),
     [
-        pytest.param("http://example.com", ("http", "https", "ftp"), [(0, 18, 0)], id="allowed-scheme-matches"),
+        pytest.param("http://example.com", ("http", "https", "ftp"), [(0, 18, 3)], id="allowed-scheme-matches"),
         pytest.param("ftp://example.com/file", ("http",), [], id="scheme-not-in-allowlist-skipped"),
         pytest.param("javascript://example.com", ("http", "https", "ftp"), [], id="javascript-scheme-excluded"),
-        pytest.param("HTTP://example.com", ("http",), [(0, 18, 0)], id="allowlist-is-case-insensitive"),
+        pytest.param("HTTP://example.com", ("http",), [(0, 18, 3)], id="allowlist-is-case-insensitive"),
         pytest.param("xhttp://example.com", (), [], id="empty-allowlist-matches-nothing"),
     ],
 )
@@ -387,7 +387,7 @@ def test_scanner_url_schemes_restrict_authority(
 
 
 def test_scanner_omitting_url_schemes_matches_any_scheme() -> None:
-    assert _linkify_scan("xyzzy://example.com", False, False) == [(0, 19, 0)]  # ruff:ignore[boolean-positional-value-in-call]  # positional C binding
+    assert _linkify_scan("xyzzy://example.com", False, False) == [(0, 19, 3)]  # ruff:ignore[boolean-positional-value-in-call]  # positional C binding
 
 
 def test_scanner_rejects_non_str_text() -> None:
diff --git a/tests/detect/test_detect_api.py b/tests/detect/test_detect_api.py
index 93219726..aea83e9f 100644
--- a/tests/detect/test_detect_api.py
+++ b/tests/detect/test_detect_api.py
@@ -407,3 +407,21 @@ def test_language_detection_rejects_an_out_of_range_threshold(threshold: float)
 def test_language_detection_rejects_allowed_with_excluded() -> None:
     with pytest.raises(ValueError, match="mutually exclusive"):
         LanguageDetection(allowed=frozenset({"eng"}), excluded=frozenset({"deu"}))
+
+
+@pytest.mark.parametrize(
+    "payload",
+    [
+        # each shape lands the prescan on a "<" whose following bytes exercise one dispatch arm the memchr jump
+        # otherwise skips past: a meta opened too close to the end, a meta closed by "/", a "</" with no room for
+        # its letter, and a bare "</" bogus comment
+        pytest.param(b"x" * 40 + b"<meta", id="meta-at-buffer-end"),
+        pytest.param(b'<meta/charset="windows-1250">\xe1', id="meta-self-closing-name"),
+        pytest.param(b"y" * 40 + b"</", id="closing-tag-at-buffer-end"),
+        pytest.param(b"<//not-a-tag><p>\xe1</p>", id="bogus-double-slash"),
+        pytest.param(b"<meta ><meta charset=windows-1251>\xd0", id="meta-space-no-attrs"),
+    ],
+)
+def test_prescan_dispatch_edges(payload: bytes) -> None:
+    # the answer only has to be a real decision; the point is that the prescan walks the shape without misreading it
+    assert detect(payload).encoding
diff --git a/tests/extract/test_extract_dates.py b/tests/extract/test_extract_dates.py
index b361d681..6538bb69 100644
--- a/tests/extract/test_extract_dates.py
+++ b/tests/extract/test_extract_dates.py
@@ -257,6 +257,20 @@ def test_json_ld_date_nested_in_a_list_value() -> None:
     assert dates(html) == PublicationDate("2016-05-01", "json-ld")
 
 
+def test_out_of_window_json_ld_candidate_is_skipped() -> None:
+    # the only date predates the default 1995 floor, so the stage yields nothing rather than returning it
+    html = '<script type="application/ld+json">{"datePublished":"1990-01-01"}</script>'
+    assert dates(html, DateExtraction(extensive_search=False)) is None
+
+
+def test_first_off_role_json_ld_date_is_the_reserve() -> None:
+    # want=publication, two modification dates, so the first is held as the reserve and the second does not replace it
+    html = '<script type="application/ld+json">[{"dateModified":"2016-01-01"},{"dateModified":"2017-01-01"}]</script>'
+    assert dates(html, DateExtraction(original=True, extensive_search=False)) == PublicationDate(
+        "2016-01-01", "json-ld"
+    )
+
+
 @pytest.mark.parametrize(
     ("text", "expected"),
     [
diff --git a/tests/extract/test_extract_dates_meta.py b/tests/extract/test_extract_dates_meta.py
new file mode 100644
index 00000000..2bbbd06e
--- /dev/null
+++ b/tests/extract/test_extract_dates_meta.py
@@ -0,0 +1,105 @@
+"""The <meta> date stage's C walk: key classification, the pubdate flag, and the window boundary.
+
+These exercise the branches the C _date_meta walk adds -- an over-long or non-ASCII key, a valueless key, the
+publication-wins-over-modification precedence, the pubdate="pubdate" flag's spellings, and the inclusive window
+edges -- through the public dates() API.
+"""
+
+from __future__ import annotations
+
+from datetime import date
+
+import pytest
+
+from turbohtml import parse
+from turbohtml.extract import DateExtraction, PublicationDate, dates
+
+_GOOD: str = '<meta name="date" content="2016-06-07">'
+"""A trailing publication meta that wins whenever the element under test contributes nothing."""
+
+
+@pytest.mark.parametrize(
+    "element",
+    [
+        pytest.param(
+            '<meta name="a-really-quite-long-meta-key-name" content="2011-01-02">', id="key-longer-than-vocab"
+        ),
+        pytest.param('<meta name="daté" content="2011-01-02">', id="non-ascii-key"),
+        pytest.param('<meta name content="2011-01-02">', id="valueless-key"),
+        pytest.param('<meta name="author" content="2011-01-02">', id="non-date-key"),
+        pytest.param('<meta property="og:title" content="2011-01-02">', id="off-vocab-property"),
+    ],
+)
+def test_a_meta_that_carries_no_date_key_is_skipped(element: str) -> None:
+    # each element parses a valid date but has no recognized key, so the trailing _GOOD meta is what wins
+    assert dates(element + _GOOD) == PublicationDate("2016-06-07", "meta")
+
+
+@pytest.mark.parametrize(
+    ("pubdate", "expected"),
+    [
+        pytest.param('pubdate="pubdate"', PublicationDate("2014-03-08", "meta"), id="pubdate-flag-set"),
+        pytest.param('pubdate="PubDate"', PublicationDate("2014-03-08", "meta"), id="pubdate-flag-any-case"),
+        pytest.param('pubdate="nope"', PublicationDate("2016-06-07", "meta"), id="pubdate-other-value-ignored"),
+        pytest.param("pubdate", PublicationDate("2016-06-07", "meta"), id="valueless-pubdate-ignored"),
+        pytest.param(
+            'pubdate="a-pubdate-value-longer-than-any-key"',
+            PublicationDate("2016-06-07", "meta"),
+            id="pubdate-over-long-value-ignored",
+        ),
+    ],
+)
+def test_pubdate_flag_only_marks_the_literal_value(pubdate: str, expected: PublicationDate) -> None:
+    # only pubdate="pubdate" (case-insensitively) makes an otherwise keyless meta a publication date
+    assert dates(f'<meta {pubdate} content="2014-03-08">{_GOOD}') == expected
+
+
+def test_date_meta_rejects_a_non_integer_argument() -> None:
+    # the private C entry point takes eight ints; a wrong type must fail the argument parse, not read the tree
+    with pytest.raises(TypeError):
+        parse("")._date_meta("published", 2016, 1, 1, 1, 2100, 1, 1)  # ty: ignore[invalid-argument-type]  # bad type
+
+
+def test_http_equiv_last_modified_is_a_modification_key() -> None:
+    html = '<meta http-equiv="last-modified" content="2019-05-06">'
+    assert dates(html) == PublicationDate("2019-05-06", "meta")
+
+
+def test_a_date_key_meta_without_content_or_datetime_is_skipped() -> None:
+    # the date key is recognized but there is no content and only a valueless datetime, so nothing is dated here
+    assert dates("<meta name=date datetime>" + _GOOD) == PublicationDate("2016-06-07", "meta")
+
+
+def test_publication_key_wins_over_a_modification_key_on_one_element() -> None:
+    # name marks a modification date and property a publication date on the same <meta>; publication wins
+    html = '<meta name="lastmod" property="article:published_time" content="2018-01-02">'
+    assert dates(html, DateExtraction(original=True)) == PublicationDate("2018-01-02", "meta")
+
+
+def test_a_modification_meta_is_the_reserve_when_a_publication_is_wanted() -> None:
+    # want=publication, only a modification date present, so it returns as the fallback reserve
+    html = '<meta name="lastmod" content="2017-02-01">'
+    assert dates(html, DateExtraction(original=True)) == PublicationDate("2017-02-01", "meta")
+
+
+@pytest.mark.parametrize(
+    ("content", "min_date", "max_date", "expected"),
+    [
+        pytest.param("2017-01-01", date(2016, 6, 15), date(2100, 1, 1), "2017-01-01", id="min-later-year-admits"),
+        pytest.param("2015-12-31", date(2016, 6, 15), date(2100, 1, 1), None, id="min-earlier-year-rejects"),
+        pytest.param("2016-08-20", date(2016, 6, 15), date(2100, 1, 1), "2016-08-20", id="min-same-year-later-month"),
+        pytest.param("2016-05-20", date(2016, 6, 15), date(2100, 1, 1), None, id="min-same-year-earlier-month"),
+        pytest.param("2016-06-20", date(2016, 6, 15), date(2100, 1, 1), "2016-06-20", id="min-same-month-later-day"),
+        pytest.param("2016-06-10", date(2016, 6, 15), date(2100, 1, 1), None, id="min-same-month-earlier-day"),
+        pytest.param("2015-01-01", date(1990, 1, 1), date(2016, 6, 15), "2015-01-01", id="max-earlier-year-admits"),
+        pytest.param("2017-01-01", date(1990, 1, 1), date(2016, 6, 15), None, id="max-later-year-rejects"),
+        pytest.param("2016-05-20", date(1990, 1, 1), date(2016, 6, 15), "2016-05-20", id="max-same-year-earlier-month"),
+        pytest.param("2016-08-20", date(1990, 1, 1), date(2016, 6, 15), None, id="max-same-year-later-month"),
+        pytest.param("2016-06-10", date(1990, 1, 1), date(2016, 6, 15), "2016-06-10", id="max-same-month-earlier-day"),
+        pytest.param("2016-06-20", date(1990, 1, 1), date(2016, 6, 15), None, id="max-same-month-later-day"),
+        pytest.param("2016-06-15", date(2016, 6, 15), date(2016, 6, 15), "2016-06-15", id="both-bounds-inclusive"),
+    ],
+)
+def test_window_boundary_is_inclusive(content: str, min_date: date, max_date: date, expected: str | None) -> None:
+    result = dates(f'<meta name="date" content="{content}">', DateExtraction(min_date=min_date, max_date=max_date))
+    assert result == (None if expected is None else PublicationDate(expected, "meta"))
diff --git a/tests/extract/test_extract_urls_query_filter.py b/tests/extract/test_extract_urls_query_filter.py
index 171b94c2..737f9ffb 100644
--- a/tests/extract/test_extract_urls_query_filter.py
+++ b/tests/extract/test_extract_urls_query_filter.py
@@ -4,7 +4,7 @@
 
 import pytest
 
-from turbohtml.extract import UrlCleaning, normalize_url
+from turbohtml.extract import UrlCleaning, clean_url, normalize_url
 
 
 @pytest.mark.parametrize(
@@ -70,3 +70,32 @@ def test_w3lib_preset_drops_the_fragment() -> None:
 def test_w3lib_preset_canonicalizes_like_canonicalize_url() -> None:
     url = "http://www.example.com/do?c=3&b=5&b=2&a=50#frag"
     assert normalize_url(url, UrlCleaning.w3lib()) == "http://www.example.com/do?a=50&b=2&b=5&c=3"
+
+
+@pytest.mark.parametrize(
+    ("url", "expected"),
+    [
+        pytest.param("https://x.org/p?wickedclid=1&keep=2", "https://x.org/p?keep=2", id="clid-suffix-dropped"),
+        pytest.param("https://x.org/p?lucid=1", "https://x.org/p?lucid=1", id="near-miss-lucid-kept"),
+        pytest.param("https://x.org/p?ref_source=1", "https://x.org/p", id="tracker-word-underscore"),
+        pytest.param("https://x.org/p?reference=1", "https://x.org/p?reference=1", id="longer-word-kept"),
+    ],
+)
+def test_tracker_suffix_and_word_boundaries(url: str, expected: str) -> None:
+    assert clean_url(url) == expected
+
+
+@pytest.mark.parametrize(
+    ("url", "expected"),
+    [
+        pytest.param("https://x.org/a/%2E%2E/b", "https://x.org/b", id="uppercase-escape-parent"),
+        pytest.param("https://x.org/a/%2E/b", "https://x.org/a/b", id="uppercase-escape-self"),
+        pytest.param("https://x.org/a/../../b", "https://x.org/b", id="parent-past-root-clamps"),
+        # a trailing dot segment resolves to the directory, so the slash survives (path state, spec 4.4)
+        pytest.param("https://x.org/a/b/..", "https://x.org/a/", id="trailing-parent-keeps-slash"),
+        pytest.param("https://x.org/a/.", "https://x.org/a/", id="trailing-self-keeps-slash"),
+        pytest.param("https://x.org/...", "https://x.org/...", id="triple-dot-is-a-segment"),
+    ],
+)
+def test_dot_segment_resolution(url: str, expected: str) -> None:
+    assert clean_url(url) == expected
diff --git a/tests/extract/test_links_resolve.py b/tests/extract/test_links_resolve.py
index 23f66e05..ddb6fedc 100644
--- a/tests/extract/test_links_resolve.py
+++ b/tests/extract/test_links_resolve.py
@@ -1,10 +1,14 @@
 from __future__ import annotations
 
+from html import escape
+from urllib.parse import urljoin
+
 import pytest
 
 from turbohtml import parse, parse_fragment
 
 _BASE = "https://example.com/dir/page.html"
+_HTTPS = "https://example.com/dir/"
 
 
 def _resolved(html: str, base: str = _BASE) -> str:
@@ -84,3 +88,79 @@ def test_nothing_to_resolve_is_a_no_op(html: str) -> None:
 def test_resolve_links_requires_a_string_base() -> None:
     with pytest.raises(TypeError, match="base URL string"):
         parse_fragment('<a href="a">x</a>').resolve_links(None)  # ty: ignore[invalid-argument-type]
+
+
+def _resolved_href(href: str, base: str) -> str:
+    root = parse_fragment(f'<a href="{escape(href, quote=True)}">x</a>')
+    root.resolve_links(base)
+    (link,) = root.links()
+    return link.url
+
+
+# resolve_links skips urljoin for an already-absolute link it would return unchanged; every case must still match the
+# stdlib join it stands in for, whether the link is skipped (absolute) or rejoined (relative, or a would-be
+# skip that urljoin rewrites). The href carries no surrounding whitespace, so the scanned span is the whole value.
+@pytest.mark.parametrize(
+    ("base", "href"),
+    [
+        pytest.param(_HTTPS, "https://host/p?q#f", id="same-scheme-absolute-skipped"),
+        pytest.param(_HTTPS, "https://user:pw@host:8080/a;b?q#f", id="same-scheme-userinfo-port"),
+        pytest.param(_HTTPS, "https://HOST.example/Path", id="same-scheme-host-case-preserved"),
+        pytest.param(_HTTPS, "https://host/a/../b", id="same-scheme-dot-segments-preserved"),
+        pytest.param(_HTTPS, "http://host/p", id="different-scheme-http"),
+        pytest.param(_HTTPS, "mailto:a@b.test", id="different-scheme-not-relative"),
+        pytest.param(_HTTPS, "data:text/plain,hi", id="different-scheme-data"),
+        pytest.param(_HTTPS, "wsabc://host", id="same-length-different-scheme"),
+        pytest.param(_HTTPS, "HTTPS://host/p", id="same-scheme-uppercase-rejoined"),
+        pytest.param(_HTTPS, "HtTpS://host/p", id="same-scheme-mixed-case-rejoined"),
+        pytest.param(_HTTPS, "https:/one-slash", id="same-scheme-single-slash-rejoined"),
+        pytest.param(_HTTPS, "https:opaque", id="same-scheme-no-slashes-rejoined"),
+        pytest.param(_HTTPS, "https:", id="same-scheme-bare-rejoined"),
+        pytest.param(_HTTPS, "https://", id="same-scheme-empty-authority-rejoined"),
+        pytest.param(_HTTPS, "https:///path", id="same-scheme-empty-authority-slash-rejoined"),
+        pytest.param(_HTTPS, "https://?q", id="same-scheme-empty-authority-query-rejoined"),
+        pytest.param(_HTTPS, "https://#f", id="same-scheme-empty-authority-fragment-rejoined"),
+        pytest.param(_HTTPS, "/root", id="relative-root"),
+        pytest.param(_HTTPS, "#frag", id="relative-fragment"),
+        pytest.param(_HTTPS, "?query", id="relative-query"),
+        pytest.param(_HTTPS, "path/to.html", id="relative-path-with-slash"),
+        pytest.param(_HTTPS, "bareword", id="relative-bareword-no-colon"),
+        pytest.param(_HTTPS, "s3://bucket/key", id="scheme-with-digit"),
+        pytest.param(_HTTPS, "a+b://host", id="scheme-with-plus"),
+        pytest.param(_HTTPS, "a-b://host", id="scheme-with-hyphen"),
+        pytest.param(_HTTPS, "a.b://host", id="scheme-with-dot"),
+        pytest.param("http://ex.test/a/b", "http://other.test/x", id="http-base-same-scheme"),
+        pytest.param("ftp://f.test/g/", "ftp://h.test/x", id="netloc-base-not-http-not-skipped"),
+        pytest.param("s3://n.test/", "s3://m.test/x", id="base-scheme-with-digit"),
+        pytest.param("a+b://n.test/", "a+b://m.test/x", id="base-scheme-with-plus"),
+        pytest.param("a-b://n.test/", "a-b://m.test/x", id="base-scheme-with-hyphen"),
+        pytest.param("a.b://n.test/", "a.b://m.test/x", id="base-scheme-with-dot"),
+        pytest.param("abcde://n.test/", "abcde://m.test/x", id="five-char-base-scheme-not-https"),
+        pytest.param("news://n.test/", "news://m.test/x", id="four-char-base-scheme-not-http"),
+        pytest.param("", "https://host/x", id="empty-base-absolute"),
+        pytest.param("", "relative/x", id="empty-base-relative"),
+        pytest.param("/no-scheme/base", "https://host/x", id="schemeless-base"),
+        pytest.param("http", "https://host/x", id="base-scheme-without-colon"),
+        pytest.param("ht tp://x/", "https://host/x", id="base-scheme-invalid-char"),
+        pytest.param("abcdefghijklmnop://h/", "abcdefghijklmnop://y", id="base-scheme-too-long"),
+    ],
+)
+def test_resolve_matches_urljoin(base: str, href: str) -> None:
+    assert _resolved_href(href, base) == urljoin(base, href)
+
+
+# A tab/CR/LF inside an otherwise-skippable absolute link forces the rejoin urlsplit would strip it in; a character
+# reference carries the raw control byte past the input stream's CR/LF normalization so each lands in the value.
+@pytest.mark.parametrize(
+    ("reference", "char"),
+    [
+        pytest.param("&#9;", "\t", id="tab"),
+        pytest.param("&#13;", "\r", id="carriage-return"),
+        pytest.param("&#10;", "\n", id="line-feed"),
+    ],
+)
+def test_same_scheme_absolute_with_internal_control_char_is_rejoined(reference: str, char: str) -> None:
+    root = parse_fragment(f'<a href="https://host/a{reference}b">x</a>')
+    root.resolve_links(_HTTPS)
+    (link,) = root.links()
+    assert link.url == urljoin(_HTTPS, f"https://host/a{char}b")
diff --git a/tests/extract/url/test_url_dot_segments.py b/tests/extract/url/test_url_dot_segments.py
new file mode 100644
index 00000000..86184eb7
--- /dev/null
+++ b/tests/extract/url/test_url_dot_segments.py
@@ -0,0 +1,43 @@
+"""Conformance tests for the C ``_url_remove_dot_segments`` behind :func:`turbohtml.extract.normalize_url`.
+
+The resolver drops ``.`` segments and pops the parent for ``..`` segments, reading each segment's ``%2e``/``%2E``
+escapes as dots the way the WHATWG path state does (spec 4.4). A path with no ``.`` or ``%`` resolves to itself. The
+cases reach each branch: the literal and both escape spellings, a three-dot segment that is not a dot segment, the
+trailing dot form, and the non-dotted fast path.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from turbohtml._html import _url_remove_dot_segments
+
+
+@pytest.mark.parametrize(
+    ("path", "expected"),
+    [
+        pytest.param("/a/b", "/a/b", id="no-dot-segments"),
+        pytest.param("no-percent-no-dot", "no-percent-no-dot", id="fast-path-unchanged"),
+        pytest.param("a.b/c", "a.b/c", id="dot-inside-segment-kept"),
+        pytest.param("/a/./b", "/a/b", id="single-dot-dropped"),
+        pytest.param("/a/../b", "/b", id="double-dot-pops-parent"),
+        pytest.param("/a/%2e/b", "/a/b", id="percent-2e-lower-is-dot"),
+        pytest.param("/a/%2E/b", "/a/b", id="percent-2e-upper-is-dot"),
+        pytest.param("/a/%2E./b", "/b", id="mixed-escape-and-literal-is-dotdot"),
+        pytest.param("/%2e%2e/b", "/b", id="escaped-dotdot-pops"),
+        pytest.param("/a/.../b", "/a/.../b", id="three-dots-not-a-dot-segment"),
+        pytest.param("/a/%2f/b", "/a/%2f/b", id="escape-not-2e-third-char"),
+        pytest.param("/a/%3e/b", "/a/%3e/b", id="escape-not-2e-second-char"),
+        pytest.param("/a/%2/b", "/a/%2/b", id="escape-too-short-for-2e"),
+        pytest.param("/a/.", "/a/", id="trailing-single-dot"),
+        pytest.param("/a/..", "/", id="trailing-double-dot"),
+        pytest.param("%2E", "", id="lone-escaped-dot"),
+    ],
+)
+def test_remove_dot_segments_cases(path: str, expected: str) -> None:
+    assert _url_remove_dot_segments(path) == expected
+
+
+def test_remove_dot_segments_rejects_non_str() -> None:
+    with pytest.raises(TypeError, match="must be str"):
+        _url_remove_dot_segments(123)  # ty: ignore[invalid-argument-type]  # a non-str exercises the TypeError guard
diff --git a/tests/extract/url/test_url_language_matches.py b/tests/extract/url/test_url_language_matches.py
new file mode 100644
index 00000000..b5493edc
--- /dev/null
+++ b/tests/extract/url/test_url_language_matches.py
@@ -0,0 +1,115 @@
+"""Conformance tests for the C ``_url_language_matches`` behind :func:`turbohtml.extract.clean_url`'s language filter.
+
+The filter judges a URL's own language markers against a target language: a ``lang``/``language`` query parameter whose
+value does not start with the target, a leading path segment that is an ISO 639-1 tag of another language, and -- in
+strict mode -- a two-letter host label of another language. Coverage is a differential against the Python heuristics the
+port replaced, over a corpus that reaches each segment shape and marker.
+"""
+
+from __future__ import annotations
+
+import itertools
+import re
+
+import pytest
+
+from turbohtml._html import _url_language_matches, _url_percent_decode
+
+_LANGUAGE_PARAMS = frozenset({"lang", "language"})
+_ISO = frozenset({"de", "en", "fr", "es", "ru", "nl"})
+_SEGMENT = re.compile(r"([a-z]{2})(?:[-_][a-z]{2,3})?$")
+
+
+def _oracle(query: str, path: str, hostname: str, language: str, *, strict: bool) -> bool:
+    for pair in query.split("&"):
+        key, separator, value = pair.partition("=")
+        if separator and _url_percent_decode(key).lower() in _LANGUAGE_PARAMS:
+            code = _url_percent_decode(value).lower()
+            if code and not code.startswith(language):
+                return False
+    leading = next((segment for segment in path.lower().split("/") if segment), "")
+    if (match := _SEGMENT.fullmatch(leading)) and match[1] in _ISO and match[1] != language:
+        return False
+    if strict:
+        label = hostname.partition(".")[0]
+        if len(label) == 2 and label in _ISO and label != language:
+            return False
+    return True
+
+
+_PATHS = (
+    "",
+    "/",
+    "/de/beitrag",
+    "/en-us/page",
+    "/en_us/page",
+    "/fr-fra/x",
+    "/de",
+    "//de//x",
+    "de/x",
+    "/DE/UPPER",
+    "/e1/x",
+    "/abc/x",
+    "/abcd/x",
+    "/en-u1/x",
+    "/en-u/x",
+    "/xy-ab/x",
+    "/ru/y",
+    "/zz/y",
+    "/en-abcd/x",
+    "/%64%65/x",
+    "/enxab/x",
+    "/z{/x",
+)
+_QUERIES = (
+    "",
+    "x=1",
+    "lang=de",
+    "language=fr",
+    "lang=en-US",
+    "lang=",
+    "lang=de&language=en",
+    "LANG=fr",
+    "%6c%61%6e%67=de",
+)
+_HOSTS = ("example.org", "de.example.org", "en.example.org", "zz.example.org", "e.org", "fr.a.b", "de", "localhost")
+_LANGS = ("de", "en", "fr")
+
+
+def test_language_matches_matches_oracle_over_corpus() -> None:
+    for path, query, host, lang, strict in itertools.product(_PATHS, _QUERIES, _HOSTS, _LANGS, (False, True)):
+        got = _url_language_matches(query, path, host, lang, strict, _LANGUAGE_PARAMS, _ISO)
+        want = _oracle(query, path, host, lang, strict=strict)
+        assert got is want, (query, path, host, lang, strict)
+
+
+@pytest.mark.parametrize(
+    ("markers", "strict", "expected"),
+    [
+        pytest.param(("", "/de/x", "h.org", "en"), False, False, id="path-segment-other-language"),
+        pytest.param(("", "/en/x", "h.org", "en"), False, True, id="path-segment-same-language"),
+        pytest.param(("", "/en-us/x", "h.org", "en"), False, True, id="path-subtag-two-letters"),
+        pytest.param(("", "/fr-fra/x", "h.org", "en"), False, False, id="path-subtag-three-letters"),
+        pytest.param(("", "/abc/x", "h.org", "en"), False, True, id="path-three-letters-not-marker"),
+        pytest.param(("", "/en-u1/x", "h.org", "en"), False, True, id="path-subtag-not-letters"),
+        pytest.param(("", "/e1/x", "h.org", "en"), False, True, id="path-second-char-not-letter"),
+        pytest.param(("lang=de", "/x", "h.org", "en"), False, False, id="query-lang-other-language"),
+        pytest.param(("lang=en-gb", "/x", "h.org", "en"), False, True, id="query-lang-prefix-matches"),
+        pytest.param(("lang=", "/x", "h.org", "en"), False, True, id="query-lang-empty-value"),
+        pytest.param(("", "/x", "de.example.org", "en"), True, False, id="strict-host-other-language"),
+        pytest.param(("", "/x", "de.example.org", "en"), False, True, id="non-strict-ignores-host"),
+        pytest.param(("", "/x", "en.example.org", "en"), True, True, id="strict-host-same-language"),
+        pytest.param(("", "/x", "abc.example.org", "en"), True, True, id="strict-host-label-not-two-letters"),
+        pytest.param(("", "/x", "de", "en"), True, False, id="strict-dotless-host-label"),
+        pytest.param(("", "/enxab/x", "h.org", "en"), False, True, id="path-five-chars-no-separator"),
+    ],
+)
+def test_language_matches_cases(markers: tuple[str, str, str, str], *, strict: bool, expected: bool) -> None:
+    query, path, hostname, language = markers
+    assert _url_language_matches(query, path, hostname, language, strict, _LANGUAGE_PARAMS, _ISO) is expected
+
+
+def test_language_matches_rejects_missing_arguments() -> None:
+    lax = False
+    with pytest.raises(TypeError):
+        _url_language_matches("", "/x", "h.org", "en", lax)  # ty: ignore[missing-argument]
diff --git a/tests/extract/url/test_url_normalize_query.py b/tests/extract/url/test_url_normalize_query.py
new file mode 100644
index 00000000..e8c0ed43
--- /dev/null
+++ b/tests/extract/url/test_url_normalize_query.py
@@ -0,0 +1,137 @@
+"""Conformance tests for the C ``_url_normalize_query`` behind :func:`turbohtml.extract.normalize_url`.
+
+The normalizer runs the crawl cleaner's per-pair loop: split the query on ``&``, decode and lowercase each key, drop the
+denied, tracker, or non-allowlisted parameters (strict mode keeps only the content and language names), encode each
+survivor for the query set, and sort them. Coverage is a differential against that Python loop across the cleaning
+filter surface, plus the lone-surrogate paths that raise.
+"""
+
+from __future__ import annotations
+
+import itertools
+from functools import partial
+from typing import TYPE_CHECKING
+
+import pytest
+
+from turbohtml._html import _url_is_tracker, _url_normalize_query, _url_percent_decode, _url_percent_encode
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+_QUERY_SET = 1
+_CONTENT = frozenset({"id", "page", "post", "article_id"})
+_LANGUAGE = frozenset({"lang", "language"})
+
+
+def _oracle(query: str, allow: frozenset[str] | None, deny: frozenset[str], *, strict: bool) -> str:
+    kept: list[tuple[str, str]] = []
+    for pair in query.split("&"):
+        if not pair:
+            continue
+        key = _url_percent_decode(pair.partition("=")[0]).lower()
+        if key in deny:
+            continue
+        if allow is not None:
+            dropped = key not in allow
+        elif strict:
+            dropped = key not in _CONTENT and key not in _LANGUAGE
+        else:
+            dropped = _url_is_tracker(key)
+        if dropped:
+            continue
+        try:
+            encoded = _url_percent_encode(pair, _QUERY_SET)
+        except UnicodeEncodeError as exc:
+            # the retired shim converted the encoder's failure to the public ValueError; the C does the same inline
+            msg = f"URL component {pair!r} has a character that cannot be percent-encoded: {exc.reason}"
+            raise ValueError(msg) from exc
+        kept.append((key, encoded))
+    return "&".join(pair for _key, pair in sorted(kept))
+
+
+def _outcome(call: Callable[[], str]) -> tuple[object, ...]:
+    try:
+        return ("ok", call())
+    except ValueError as exc:  # UnicodeEncodeError subclasses ValueError, so a lone-surrogate failure lands here too
+        return ("err", type(exc).__name__, str(exc))
+
+
+_QUERIES = (
+    "",
+    "a=1",
+    "ok=1&bad=\udcff",  # a lone surrogate cannot percent-encode, so both sides must fail identically
+    "a=1&b=2",
+    "b=2&a=1",
+    "id=1&utm_source=x",
+    "utm_campaign=z&fbclid=y&keep=1",
+    "a=1&a=2&a=3",
+    "=empty&x=",
+    "café=1&CAFÉ=2",
+    "%41=%42&ref=1",
+    "lang=de&page=3",
+    "session=1&content=2",
+    "aff_id=1&article_id=9",
+    "x=%ZZ&y=1",
+    "a=1&&b=2&",
+    "utm_medium=e&Id=7",
+    "A=1&a=2&B=3",
+    "a&b&c",
+)
+_ALLOWS = (None, frozenset({"id", "page"}), frozenset({"UTM_SOURCE"}), frozenset())
+_DENYS = (frozenset(), frozenset({"id"}), frozenset({"a", "b"}))
+
+
+def test_normalize_query_matches_oracle_over_corpus() -> None:
+    for query, allow, deny, strict in itertools.product(_QUERIES, _ALLOWS, _DENYS, (False, True)):
+        if strict and allow is not None:
+            continue
+        got = _outcome(partial(_url_normalize_query, query, allow, deny, strict, _CONTENT, _LANGUAGE))
+        want = _outcome(partial(_oracle, query, allow, deny, strict=strict))
+        assert got == want, (query, allow, deny, strict)
+
+
+@pytest.mark.parametrize(
+    ("query", "allow", "deny", "strict", "expected"),
+    [
+        pytest.param("b=2&a=1", None, frozenset(), False, "a=1&b=2", id="sort-non-trackers"),
+        pytest.param("utm_source=x&id=1", None, frozenset(), False, "id=1", id="drop-tracker"),
+        pytest.param("id=1&page=2&x=3", None, frozenset(), True, "id=1&page=2", id="strict-keeps-content"),
+        pytest.param("lang=de&x=3", None, frozenset(), True, "lang=de", id="strict-keeps-language"),
+        pytest.param("id=1&page=2", frozenset({"id"}), frozenset(), False, "id=1", id="allow-keeps-only-listed"),
+        pytest.param("id=1&keep=2", None, frozenset({"id"}), False, "keep=2", id="deny-drops-listed"),
+        pytest.param("Id=1&PAGE=2", None, frozenset(), True, "Id=1&PAGE=2", id="key-lowercased-for-filter"),
+        pytest.param("", None, frozenset(), False, "", id="empty-query"),
+        pytest.param("a=1&&b=2&", None, frozenset(), False, "a=1&b=2", id="empty-pairs-dropped"),
+    ],
+)
+def test_normalize_query_cases(
+    query: str, allow: frozenset[str] | None, deny: frozenset[str], expected: str, *, strict: bool
+) -> None:
+    assert _url_normalize_query(query, allow, deny, strict, _CONTENT, _LANGUAGE) == expected
+
+
+def test_normalize_query_surrogate_key_raises() -> None:
+    # a lone-surrogate key has no UTF-8 form, so the tracker test cannot classify it and the error propagates
+    lax = False
+    with pytest.raises(UnicodeEncodeError):
+        _url_normalize_query("\ud800=1", None, frozenset(), lax, _CONTENT, _LANGUAGE)
+
+
+def test_normalize_query_surrogate_value_raises() -> None:
+    # the key survives, then encoding the pair fails on the surrogate value, rewrapped as the shim's ValueError
+    lax = False
+    with pytest.raises(ValueError, match="cannot be percent-encoded"):
+        _url_normalize_query("ok=\ud800", None, frozenset(), lax, _CONTENT, _LANGUAGE)
+
+
+def test_normalize_query_rejects_non_str_query() -> None:
+    lax = False
+    with pytest.raises(TypeError):
+        _url_normalize_query(123, None, frozenset(), lax, _CONTENT, _LANGUAGE)  # ty: ignore[invalid-argument-type]
+
+
+def test_normalize_query_rejects_missing_arguments() -> None:
+    lax = False
+    with pytest.raises(TypeError):
+        _url_normalize_query("a=1", None, frozenset(), lax)  # ty: ignore[missing-argument]
diff --git a/tests/extract/url/test_url_scrub.py b/tests/extract/url/test_url_scrub.py
new file mode 100644
index 00000000..7656eb75
--- /dev/null
+++ b/tests/extract/url/test_url_scrub.py
@@ -0,0 +1,149 @@
+"""Conformance tests for the C ``_url_scrub`` behind :func:`turbohtml.extract.clean_url`.
+
+The scrub undoes the HTML transport damage a scraped URL carries before it is split: it strips the leading and trailing
+C0-control and space bytes, drops every whitespace character ``str.split()`` would, unwraps a ``<![CDATA[...]]>``
+wrapper, truncates at the first ``<``/``>``/``"`` delimiter, undoes a ``&amp;`` escape, and drops a ``&`` dangling after
+a ``/``. It replaces the Python strip/split/join, regex split, and replace chain, so the coverage is a differential
+against that chain over a generated corpus plus the branch-reaching cases.
+"""
+
+from __future__ import annotations
+
+import itertools
+import re
+
+import pytest
+
+from turbohtml._html import _url_scrub
+
+_C0_AND_SPACE = "".join(map(chr, range(0x21)))
+_MARKUP_DELIMITER = re.compile(r'[<>"]')
+
+
+# CPython's str whitespace (Py_UNICODE_ISSPACE), pinned because PyPy's str.split() disagrees on the C0 separators
+# 0x1C-0x1F, and the C scrub follows CPython's predicate on every interpreter
+_PY_WHITESPACE = frozenset(
+    map(
+        chr,
+        (
+            *range(0x09, 0x0E),
+            *range(0x1C, 0x21),
+            0x85,
+            0xA0,
+            0x1680,
+            *range(0x2000, 0x200B),
+            0x2028,
+            0x2029,
+            0x202F,
+            0x205F,
+            0x3000,
+        ),
+    )
+)
+
+
+def _oracle_scrub(url: str) -> str:
+    remainder = "".join(char for char in url.strip(_C0_AND_SPACE) if char not in _PY_WHITESPACE)
+    if remainder.startswith("<![CDATA["):
+        remainder = remainder.removeprefix("<![CDATA[").removesuffix("]]>")
+    remainder = _MARKUP_DELIMITER.split(remainder, maxsplit=1)[0].replace("&amp;", "&")
+    return remainder.removesuffix("&") if remainder.endswith("/&") else remainder
+
+
+# Pieces that reach every scrub branch: whitespace str.split() removes but the edge C0 strip alone would not (NBSP, NEL,
+# a separator), a non-whitespace C0 control that survives in the middle, and the CDATA, markup, and escape shapes.
+_PIECES = (
+    "https://x.example/p",
+    " ",
+    "\t",
+    "\n",
+    "\xa0",
+    "\x85",
+    "\x1c",
+    "\x01",
+    "<![CDATA[",
+    "]]>",
+    "<",
+    ">",
+    '"',
+    "&amp;",
+    "/&",
+    "&",
+    "a",
+    "//double",
+    "?q=1",
+    "#f",
+)
+_EDGE_CASES = (
+    "",
+    " ",
+    "  https://x.example/p  ",
+    "\t\nhttps://x.example/p\r\n",
+    "\x01\x02https://x.example/p\x03",
+    "a\xa0b\x85c",
+    "a\x1cb\x1fc",
+    "line break",
+    "mid\x01control",
+    "<![CDATA[https://x.example/p]]>",
+    "<![CDATA[https://x.example/p",
+    "<![CDATA[a>b",
+    "<![CDATA[]]>",
+    "<![CDAT",
+    "https://x.example/a<script>",
+    "https://x.example/a>b",
+    'https://x.example/p"junk',
+    "https://x.example/a&amp;b&amp;c",
+    "https://x.example/path/&amp;",
+    "https://x.example/path/&",
+    "https://x.example/&amp;",
+    "trailing&",
+)
+
+
+def _corpus() -> list[str]:
+    seen = set(_EDGE_CASES)
+    for length in range(4):
+        seen.update("".join(combo) for combo in itertools.product(_PIECES, repeat=length))
+    return sorted(seen)
+
+
+def test_scrub_matches_oracle_over_corpus() -> None:
+    for url in _corpus():
+        assert _url_scrub(url) == _oracle_scrub(url), repr(url)
+
+
+@pytest.mark.parametrize(
+    ("url", "expected"),
+    [
+        pytest.param("", "", id="empty"),
+        pytest.param("  https://x/p  ", "https://x/p", id="edge-space-stripped"),
+        pytest.param("\x01https://x/p\x02", "https://x/p", id="edge-c0-stripped"),
+        pytest.param("mid\x01control", "mid\x01control", id="mid-non-ws-c0-kept"),
+        pytest.param("a\xa0b", "ab", id="nbsp-whitespace-removed"),
+        pytest.param("a b\tc\nd", "abcd", id="internal-whitespace-removed"),
+        pytest.param("<![CDATA[https://x/p]]>", "https://x/p", id="cdata-unwrapped"),
+        pytest.param("<![CDATA[https://x/p", "https://x/p", id="cdata-open-only"),
+        pytest.param("<![CDATA[ab", "ab", id="cdata-content-too-short-for-suffix"),
+        pytest.param("<![CDATA[a]x]", "a]x]", id="cdata-suffix-second-char-mismatch"),
+        pytest.param("<![CDATA[a]]x", "a]]x", id="cdata-suffix-third-char-mismatch"),
+        pytest.param("<![CDAT", "", id="cdata-too-short-truncated-at-lt"),
+        pytest.param("https://x/a<b", "https://x/a", id="truncate-at-lt"),
+        pytest.param("https://x/a>b", "https://x/a", id="truncate-at-gt"),
+        pytest.param('https://x/a"b', "https://x/a", id="truncate-at-quote"),
+        pytest.param("https://x/a&amp;b", "https://x/a&b", id="amp-unescaped"),
+        pytest.param("https://x/&amp;a&amp;b", "https://x/&a&b", id="amp-unescaped-multiple"),
+        pytest.param("https://x/p/&amp;", "https://x/p/", id="trailing-slash-amp-dropped"),
+        pytest.param("keep&", "keep&", id="trailing-amp-not-after-slash-kept"),
+        pytest.param("a&xzzzz", "a&xzzzz", id="amp-first-char-mismatch"),
+        pytest.param("a&abbbb", "a&abbbb", id="amp-second-char-mismatch"),
+        pytest.param("a&amxxx", "a&amxxx", id="amp-third-char-mismatch"),
+        pytest.param("a&ampxy", "a&ampxy", id="amp-fourth-char-mismatch"),
+    ],
+)
+def test_scrub_cases(url: str, expected: str) -> None:
+    assert _url_scrub(url) == expected
+
+
+def test_scrub_rejects_non_str() -> None:
+    with pytest.raises(TypeError, match="must be str"):
+        _url_scrub(123)  # ty: ignore[invalid-argument-type]  # a non-str exercises the TypeError guard
diff --git a/tests/extract/url/test_url_tracker.py b/tests/extract/url/test_url_tracker.py
new file mode 100644
index 00000000..0c7f104b
--- /dev/null
+++ b/tests/extract/url/test_url_tracker.py
@@ -0,0 +1,121 @@
+"""Conformance tests for the C ``_url_is_tracker`` behind :func:`turbohtml.extract.normalize_url`.
+
+``_url_is_tracker`` classifies a lowercased query-parameter name as a referral marker (an exact name, a known prefix, a
+``clid`` suffix, or a tracking word between underscores) rather than content. The coverage is a differential against the
+compiled vocabulary the Python cleaner used before the port, plus the boundary cases that reach each rule.
+"""
+
+from __future__ import annotations
+
+import itertools
+import re
+
+import pytest
+
+from turbohtml._html import _url_is_tracker
+
+_TRACKER_NAMES = frozenset({
+    "clickid",
+    "dclid",
+    "efid",
+    "epik",
+    "fb_ref",
+    "fb_source",
+    "fbclid",
+    "gbraid",
+    "gclid",
+    "gclsrc",
+    "igsh",
+    "igshid",
+    "mkt_tok",
+    "msclkid",
+    "partnerid",
+    "s_cid",
+    "sc_cid",
+    "ttclid",
+    "twclid",
+    "wbraid",
+    "wickedid",
+    "yclid",
+    "ysclid",
+})
+_TRACKER_PREFIXES = ("ad_", "ads_", "ga_", "gs_", "hsa_", "itm_", "mc_", "mtm_", "oly_", "pk_", "utm_", "vero_")
+_TRACKER_WORDS = re.compile(
+    r"(?:^|_)(?:aff(?:i(?:liate)?)?|campaign|cl?id|keyword|kwd|medium|refer(?:r?er)?|ref|session|source|uid|xtor)(?:_|$)"
+)
+
+
+def _oracle(key: str) -> bool:
+    return (
+        key in _TRACKER_NAMES
+        or key.startswith(_TRACKER_PREFIXES)
+        or key.endswith("clid")
+        or _TRACKER_WORDS.search(key) is not None
+    )
+
+
+def _corpus() -> list[str]:
+    seen = (
+        set(_TRACKER_NAMES)
+        | set(_TRACKER_PREFIXES)
+        | {
+            "",
+            "id",
+            "page",
+            "myclid",
+            "reference",
+            "x_ref_y",
+            "campaign",
+            "affiliate",
+            "xtor",
+            "referer",
+            "referrer",
+            "utm_source",
+            "ad_id",
+            "a_uid_b",
+            "keyword",
+            "kwd",
+            "medium",
+            "session",
+            "cid",
+            "clid",
+            "not_a_ref",
+        }
+    )
+    fragments = ("utm", "ref", "id", "clid", "aff", "source", "_", "campaign", "uid")
+    for length in range(4):
+        seen.update("".join(combo) for combo in itertools.product(fragments, repeat=length))
+    return sorted(seen)
+
+
+def test_is_tracker_matches_oracle_over_corpus() -> None:
+    for key in _corpus():
+        assert _url_is_tracker(key) == _oracle(key), repr(key)
+
+
+@pytest.mark.parametrize(
+    ("key", "expected"),
+    [
+        pytest.param("gclid", True, id="exact-name"),
+        pytest.param("utm_source", True, id="known-prefix"),
+        pytest.param("myclid", True, id="clid-suffix-not-exact"),
+        pytest.param("x_ref_y", True, id="tracking-word-between-underscores"),
+        pytest.param("campaign", True, id="tracking-word-whole"),
+        pytest.param("reference", False, id="longer-word-not-matched"),
+        pytest.param("id", False, id="content-name"),
+        pytest.param("", False, id="empty"),
+    ],
+)
+def test_is_tracker_cases(key: str, *, expected: bool) -> None:
+    assert _url_is_tracker(key) is expected
+
+
+def test_is_tracker_rejects_non_str() -> None:
+    with pytest.raises(TypeError, match="must be str"):
+        _url_is_tracker(123)  # ty: ignore[invalid-argument-type]  # a non-str exercises the TypeError guard
+
+
+def test_is_tracker_lone_surrogate_raises() -> None:
+    # a lone-surrogate key has no UTF-8 form, so it cannot be classified and the UnicodeEncodeError propagates
+    with pytest.raises(UnicodeEncodeError):
+        _url_is_tracker("\ud800clid")
diff --git a/tests/extract/url/test_url_variant_key.py b/tests/extract/url/test_url_variant_key.py
new file mode 100644
index 00000000..3a094944
--- /dev/null
+++ b/tests/extract/url/test_url_variant_key.py
@@ -0,0 +1,71 @@
+"""Conformance tests for the C ``_url_variant_key`` behind :func:`turbohtml.extract.extract_links`.
+
+The key collapses the scheme and a bare trailing slash so the ``http``/``https`` and slash twins of one address
+deduplicate: it is everything after the first ``"://"``, with the trailing slash run trimmed unless the remainder holds
+a ``?`` or ``#`` (where a slash is content). Coverage is a differential against that partition/rstrip expression.
+"""
+
+from __future__ import annotations
+
+import itertools
+
+import pytest
+
+from turbohtml._html import _url_variant_key
+
+
+def _oracle_variant(url: str) -> str:
+    remainder = url.partition("://")[2]
+    return remainder if "?" in remainder or "#" in remainder else remainder.rstrip("/")
+
+
+_SCHEMES = ("https://", "http://", "ftp://", "", "://", "a://b://")
+_TAILS = (
+    "",
+    "/",
+    "//",
+    "x.example/p",
+    "x.example/p/",
+    "x.example/p//",
+    "x.example/p?q=1",
+    "x.example/p/#f",
+    "x.example/a/b/",
+    "x.example/?only",
+    "x.example/#only",
+    "mailto:x@y",
+    "a:/b/c/",
+)
+
+
+def _corpus() -> list[str]:
+    combined = {"".join(combo) for combo in itertools.product(_SCHEMES, _TAILS)}
+    return sorted(combined | {"", "no-scheme-path/", "://leading/", "a://b://c/d/"})
+
+
+def test_variant_key_matches_oracle_over_corpus() -> None:
+    for url in _corpus():
+        assert _url_variant_key(url) == _oracle_variant(url), repr(url)
+
+
+@pytest.mark.parametrize(
+    ("url", "expected"),
+    [
+        pytest.param("", "", id="empty"),
+        pytest.param("no-scheme-path/", "", id="no-scheme-empty-key"),
+        pytest.param("https://x/p/", "x/p", id="trailing-slash-trimmed"),
+        pytest.param("https://x/p///", "x/p", id="trailing-slashes-trimmed"),
+        pytest.param("https://x/p?q=1/", "x/p?q=1/", id="query-keeps-slash"),
+        pytest.param("https://x/p/#f", "x/p/#f", id="fragment-keeps-slash"),
+        pytest.param("https://x/", "x", id="root-slash-trimmed"),
+        pytest.param("a://b://c/", "b://c", id="first-marker-wins"),
+        pytest.param("mailto:x@y", "", id="colon-not-followed-by-slash"),
+        pytest.param("a:/b/c/", "", id="colon-single-slash-no-marker"),
+    ],
+)
+def test_variant_key_cases(url: str, expected: str) -> None:
+    assert _url_variant_key(url) == expected
+
+
+def test_variant_key_rejects_non_str() -> None:
+    with pytest.raises(TypeError, match="must be str"):
+        _url_variant_key(123)  # ty: ignore[invalid-argument-type]  # a non-str exercises the TypeError guard
diff --git a/tests/query/match/test_escape.py b/tests/query/match/test_escape.py
index 48b06615..77ef76b5 100644
--- a/tests/query/match/test_escape.py
+++ b/tests/query/match/test_escape.py
@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+from typing import cast
+
 import pytest
 
 from turbohtml.query import escape_identifier
@@ -26,7 +28,15 @@
         pytest.param("a\tb", "a\\9 b", id="interior-control"),
         pytest.param("\x7f", "\\7f ", id="delete-char"),
         pytest.param("\x00abc", "�abc", id="null-to-replacement"),
+        pytest.param("a1b", "a1b", id="digit-after-letter-stays"),
+        pytest.param("1-", "\\31 -", id="leading-digit-then-dash"),
+        pytest.param("-a1", "-a1", id="dash-letter-digit"),
     ],
 )
 def test_escape_matches_cssom(raw: str, expected: str) -> None:
     assert escape_identifier(raw) == expected
+
+
+def test_non_str_identifier_raises_type_error() -> None:
+    with pytest.raises(TypeError, match="must be str"):
+        escape_identifier(cast("str", b"raw-bytes"))
diff --git a/tests/test_bench_migration.py b/tests/test_bench_migration.py
index 31e2db45..3a1ea7db 100644
--- a/tests/test_bench_migration.py
+++ b/tests/test_bench_migration.py
@@ -93,7 +93,11 @@ def test_operation_one_backend_skips_keeps_the_row(tmp_path: Path) -> None:
             "encoding|bytes|bs4 (html.parser)": {"mean": 8.0, "cv": 0.02},
         },
     )
-    assert ["detect a byte stream's encoding — bytes", 1.0, 8.0, None] in feed["rows"]
+    # the configuration that skips the operation shows the shared measurement, and the row's note says it was
+    # measured once rather than leaving a blank or hiding the caveat
+    assert ["detect a byte stream's encoding — bytes", 1.0, 8.0, 8.0] in feed["rows"]
+    row_index = feed["rows"].index(["detect a byte stream's encoding — bytes", 1.0, 8.0, 8.0])
+    assert feed["row_notes"][str(row_index)] == "same in both configurations, so measured once"
 
 
 def test_spread_aligns_with_every_variant(tmp_path: Path) -> None:
diff --git a/tests/test_bench_table_directive.py b/tests/test_bench_table_directive.py
new file mode 100644
index 00000000..09b826d0
--- /dev/null
+++ b/tests/test_bench_table_directive.py
@@ -0,0 +1,77 @@
+"""
+Keep a per-row caveat marking only its own rows, and every caveat spelled out under the table.
+
+A note that belongs to one operation on a library page (lxml-html-clean linkifies but does not sanitize the same way)
+must superscript exactly the rows that operation produced, not the library's whole column. The feed carries the marks
+in ``row_notes``; these checks render the ``bench-table`` directive over a synthetic feed and fail if a noted row loses
+its superscript, an unnoted row gains one, two rows sharing a caveat stop sharing one ordinal, or the legend drops a
+caveat.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import pytest
+from docutils import nodes
+from docutils.core import publish_doctree
+from docutils.parsers.rst import directives
+
+_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(_ROOT / "docs" / "_ext"))
+
+from bench_table import BenchTable  # ruff:ignore[module-import-not-at-top-of-file]
+
+directives.register_directive("bench-table", BenchTable)
+
+_SHARED = "shared caveat"
+_OTHER = "other caveat"
+_FEED = {
+    "label": "operation",
+    "parties": ["turbohtml", "other"],
+    "metrics": [],
+    "rows": [["alpha", 1e-6, 2e-6], ["beta", 1e-6, 2e-6], ["gamma", 1e-6, 2e-6], ["delta", 1e-6, 2e-6]],
+    # rows 1 and 2 share one caveat, row 3 carries a second, row 0 carries none
+    "row_notes": {"1": _SHARED, "2": _SHARED, "3": _OTHER},
+}
+
+
+@pytest.fixture
+def doctree(tmp_path: Path) -> nodes.document:
+    """Render the synthetic feed through the directive and return the parsed document."""
+    (tmp_path / "feed.json").write_text(json.dumps(_FEED), encoding="utf-8")
+    page = tmp_path / "page.rst"
+    page.write_text(".. bench-table::\n    :file: feed.json\n", encoding="utf-8")
+    return publish_doctree(page.read_text(encoding="utf-8"), source_path=str(page))
+
+
+def _row_superscripts(doctree: nodes.document) -> list[list[str]]:
+    """Return the superscript ordinals carried by each body row's label cell, in row order."""
+    table = next(iter(doctree.findall(nodes.table)))
+    body = next(iter(table.findall(nodes.tbody)))
+    return [[sup.astext() for sup in row.children[0].findall(nodes.superscript)] for row in body.findall(nodes.row)]
+
+
+def _legend_lines(doctree: nodes.document) -> list[str]:
+    """Return each spelled-out legend line; the directive emits exactly one container, the legend under the table."""
+    legend = next(doctree.findall(nodes.container))
+    return [paragraph.astext() for paragraph in legend.findall(nodes.paragraph)]
+
+
+@pytest.mark.parametrize(
+    ("index", "expected"),
+    [
+        pytest.param(0, [], id="unnoted-row-has-no-superscript"),
+        pytest.param(1, ["1"], id="first-shared-row-marked"),
+        pytest.param(2, ["1"], id="second-shared-row-reuses-ordinal"),
+        pytest.param(3, ["2"], id="distinct-caveat-gets-next-ordinal"),
+    ],
+)
+def test_row_note_superscript_marks_only_noted_rows(doctree: nodes.document, index: int, expected: list[str]) -> None:
+    assert _row_superscripts(doctree)[index] == expected
+
+
+def test_row_note_legend_spells_each_distinct_caveat(doctree: nodes.document) -> None:
+    assert _legend_lines(doctree) == [f"1 {_SHARED}", f"2 {_OTHER}"]
diff --git a/tests/tokenizer/test_saxparse.py b/tests/tokenizer/test_saxparse.py
index c5622c0d..7973148f 100644
--- a/tests/tokenizer/test_saxparse.py
+++ b/tests/tokenizer/test_saxparse.py
@@ -253,3 +253,50 @@ class _Sentinel:
 def test_non_str_argument_raises_type_error() -> None:
     with pytest.raises(TypeError, match="must be str"):
         list(iter_events(cast("str", b"<p>")))
+
+
+def test_sax_parse_requires_every_handler_method() -> None:
+    # dispatch binds the six methods once up front, so an object missing one fails before any parsing happens
+    with pytest.raises(AttributeError, match="start_element"):
+        sax_parse("<p>x</p>", cast("SaxHandler", object()))
+
+
+def test_sax_parse_non_str_raises_type_error() -> None:
+    with pytest.raises(TypeError):
+        sax_parse(cast("str", b"<p>"), SaxHandler())
+
+
+def test_handler_exception_in_start_stops_the_parse() -> None:
+    class FailingStart(SaxHandler):
+        def __init__(self) -> None:
+            self.seen: list[str] = []
+
+        def start_element(self, tag: str, attrs: tuple[tuple[str, str | None], ...]) -> None:
+            self.seen.append(tag)
+            if tag == "i":
+                msg = f"stop at {tag} with {len(attrs)} attributes"
+                raise ValueError(msg)
+
+    handler = FailingStart()
+    with pytest.raises(ValueError, match="stop at i"):
+        sax_parse("<p><i>x</i></p>", handler)
+    # the walk stops where the handler raised rather than swallowing the error and continuing
+    assert handler.seen == ["html", "head", "body", "p", "i"]
+
+
+def test_handler_exception_in_end_stops_the_parse() -> None:
+    class FailingEnd(SaxHandler):
+        def __init__(self) -> None:
+            self.closed: list[str] = []
+
+        def end_element(self, tag: str) -> None:
+            self.closed.append(tag)
+            if tag == "p":
+                msg = f"stop closing {tag}"
+                raise RuntimeError(msg)
+
+    handler = FailingEnd()
+    with pytest.raises(RuntimeError, match="stop closing p"):
+        sax_parse("<p>x</p><div>y</div>", handler)
+    # the implied <head> closes before <p> opens, so it precedes the raise
+    assert handler.closed == ["head", "p"]
diff --git a/tests/validate/test_relaxng.py b/tests/validate/test_relaxng.py
index e8310bd8..62928f9f 100644
--- a/tests/validate/test_relaxng.py
+++ b/tests/validate/test_relaxng.py
@@ -252,3 +252,10 @@ def test_error_location_localized() -> None:
 def test_schema_from_parsed_document() -> None:
     schema_doc = parse_xml(wrap("<text/>"))
     assert RelaxNG(schema_doc).is_valid(parse_xml("<doc>x</doc>"))
+
+
+def test_prefix_resolution_skips_a_decoy_attribute() -> None:
+    # the attribute is exactly as long as "xmlns:" plus the prefix but is not a namespace declaration, so the
+    # resolver's name comparison has to reject it rather than matching on length alone
+    schema = '<x:element xmlnsyy="decoy" xmlns:x="http://relaxng.org/ns/structure/1.0" name="r"><x:text/></x:element>'
+    assert RelaxNG(schema).validate(parse_xml("<r>hi</r>")).valid
diff --git a/tests/validate/test_xsd.py b/tests/validate/test_xsd.py
index acf4710f..0a8be3db 100644
--- a/tests/validate/test_xsd.py
+++ b/tests/validate/test_xsd.py
@@ -312,6 +312,15 @@ def test_target_namespace_qualified() -> None:
     assert not check(schema, "<r><a>x</a></r>").valid  # wrong namespace
 
 
+def test_many_namespace_declarations_keep_the_xs_binding() -> None:
+    # Nine xmlns declarations grow the in-scope namespace stack past its initial capacity; xmlns:xs comes first,
+    # so a grow that failed to copy the existing bindings would drop the xs binding and stop recognizing xs:element.
+    dummies = " ".join(f'xmlns:p{index}="urn:p{index}"' for index in range(8))
+    schema = f'<xs:schema {XS} {dummies}><xs:element name="a" type="xs:string"/></xs:schema>'
+    assert check(schema, "<a>x</a>").valid
+    assert not check(schema, "<a><child/></a>").valid
+
+
 def test_root_errors() -> None:
     schema = f'<xs:schema {XS}><xs:element name="known" type="xs:string"/></xs:schema>'
     assert not check(schema, "<unknown/>").valid
diff --git a/tools/bench/competitors/lxml.py b/tools/bench/competitors/lxml.py
index 5e363b87..565d0d5b 100644
--- a/tools/bench/competitors/lxml.py
+++ b/tools/bench/competitors/lxml.py
@@ -309,7 +309,12 @@ def _div_rows(text: str) -> object:
 def xpath(case: tuple[str, str]) -> None:
     """Evaluate one XPath feature class with lxml's libxml2 engine, by case kind."""
     kind, text = case
-    _XPATH_CALLS[kind](_parsed(text), text)
+    if (call := _XPATH_CALLS.get(kind)) is None:
+        # libxml2 is an XPath 1.0 engine; the XPath 2.0 string functions turbohtml adds have nothing to run on here,
+        # so the worker records this sentence as the empty cell's reason rather than a bare KeyError token
+        unsupported = "lxml's libxml2 is XPath 1.0, without the XPath 2.0 string functions"
+        raise NotImplementedError(unsupported)
+    call(_parsed(text), text)
 
 
 @functools.cache
diff --git a/tools/bench/competitors/parsel.py b/tools/bench/competitors/parsel.py
index cd38a8ad..45639213 100644
--- a/tools/bench/competitors/parsel.py
+++ b/tools/bench/competitors/parsel.py
@@ -154,7 +154,11 @@ def _div_rows(text: str) -> list[object]:
 def xpath(case: tuple[str, str]) -> None:
     """Evaluate one XPath feature class with parsel's lxml-backed engine, by case kind."""
     kind, text = case
-    _XPATH_CALLS[kind](_parsed(text), text)
+    if (call := _XPATH_CALLS.get(kind)) is None:
+        # parsel runs on lxml's libxml2, an XPath 1.0 engine, so the same message keys both columns to one legend note
+        unsupported = "lxml's libxml2 is XPath 1.0, without the XPath 2.0 string functions"
+        raise NotImplementedError(unsupported)
+    call(_parsed(text), text)
 
 
 OPERATIONS = {
diff --git a/tools/bench/competitors/soupsieve.py b/tools/bench/competitors/soupsieve.py
index 0358f6e4..c6ba46a6 100644
--- a/tools/bench/competitors/soupsieve.py
+++ b/tools/bench/competitors/soupsieve.py
@@ -41,7 +41,14 @@ def match(text: str) -> None:
         _SELECT.match(anchor)
 
 
+def escape_identifier(idents: tuple[str, ...]) -> None:
+    """Escape each raw identifier with soupsieve's escape."""
+    for ident in idents:
+        soupsieve.escape(ident)
+
+
 OPERATIONS = {
+    "escape-identifier": (escape_identifier, "soupsieve"),
     "find": (find, "soupsieve"),
     "select": (select, "soupsieve"),
     "select-has": (select_has, "soupsieve"),
diff --git a/tools/bench/core.py b/tools/bench/core.py
index df57aeb5..540a2561 100644
--- a/tools/bench/core.py
+++ b/tools/bench/core.py
@@ -37,6 +37,7 @@
 from turbohtml.migration.markupsafe import escape as _markup_escape
 from turbohtml.migration.stdlib import HTMLParser as _TurboHTMLParser
 from turbohtml.query import Query as _Query
+from turbohtml.query import escape_identifier as _escape_identifier
 from turbohtml.rewrite import Element as _RewriteElement
 from turbohtml.rewrite import rewrite as _rewrite
 from turbohtml.saxparse import SaxHandler as _SaxHandler
@@ -853,6 +854,12 @@ def normalize(text: str) -> None:
     _normalize("NFC", text)
 
 
+def escape_identifier(idents: tuple[str, ...]) -> None:
+    """Escape each raw identifier for use in a selector with turbohtml's CSSOM escape."""
+    for ident in idents:
+        _escape_identifier(ident)
+
+
 def idna(urls: tuple[str, ...]) -> None:
     """Overflow the 1,024-entry cache so each IDNA conversion runs."""
     for url in urls:
@@ -955,6 +962,7 @@ def links_external(text: str) -> None:
     "linkify": (linkify, "turbohtml"),
     "detect": (detect, "turbohtml"),
     "normalize": (normalize, "turbohtml"),
+    "escape-identifier": (escape_identifier, "turbohtml"),
     "idna": (idna, "turbohtml"),
     "markdown": (markdown, "turbohtml"),
     "markdown-google": (markdown_google, "turbohtml"),
diff --git a/tools/bench/docs_feeds.py b/tools/bench/docs_feeds.py
index af9bb35a..545cecda 100644
--- a/tools/bench/docs_feeds.py
+++ b/tools/bench/docs_feeds.py
@@ -81,6 +81,7 @@ class Combined:
     "querying-3": "select-has",
     "querying-4": "find-text",
     "querying-5": "xpath",
+    "querying-6": "escape-identifier",
     "sanitize": "sanitize",
     "sanitize-templates": "sanitize-templates",
     "serializing": "serialize",
diff --git a/tools/bench/interpreters.py b/tools/bench/interpreters.py
index 2aefe139..0dcaf8fa 100644
--- a/tools/bench/interpreters.py
+++ b/tools/bench/interpreters.py
@@ -19,7 +19,6 @@
 from typing import TYPE_CHECKING, Final
 
 from bench import operations, orchestrator
-from bench.report import rst_safe
 
 if TYPE_CHECKING:
     from collections.abc import Iterator
@@ -81,7 +80,8 @@ def _rows(measured: dict[str, dict[str, dict[str, float | str]]]) -> Iterator[li
     """One row per operation-case; the label carries the operation title because the table spans several."""
     for operation in OPERATIONS:
         for case, cells in measured[operation].items():
-            label = rst_safe(f"{operations.OPERATIONS[operation].title} — {case}")
+            # the case name is an authored RST fragment, so it is rendered verbatim rather than re-escaped
+            label = f"{operations.OPERATIONS[operation].title} — {case}"
             yield [label, *(cells.get(party) for party, _ in INTERPRETERS)]
 
 
diff --git a/tools/bench/migration.py b/tools/bench/migration.py
index 7b87587d..5dc44571 100644
--- a/tools/bench/migration.py
+++ b/tools/bench/migration.py
@@ -23,7 +23,6 @@
 
 from bench import operations
 from bench.notes import NOTES
-from bench.report import rst_safe
 
 if TYPE_CHECKING:
     from collections.abc import Iterable
@@ -33,6 +32,10 @@
 _MEMORY_OPS: Final = frozenset({"parse-dense", "rewrite"})
 _WIDE_OPS: Final = _SIZE_OPS | _MEMORY_OPS
 
+# Why a variant repeats the sibling's figure when the library is measured in more than one configuration: the
+# operation runs the same code whichever one is chosen, so benchmarking it twice would publish a duplicate column.
+_SHARED_WITH_OTHER_VARIANT: Final = "same in both configurations, so measured once"
+
 # A competitor module's stem maps to its migration page's slug by turning ``_`` into ``-``; these libraries
 # name the two differently, so the map pins them. A stem with no ``docs/migration/<slug>.rst`` is skipped, so
 # columns that only appear inside another library's table (cchardet, cssmin, css_html_js_minify) fall out.
@@ -45,6 +48,13 @@
 }
 
 
+def _merge_caveat(note: str | None, *, shared: bool) -> str | None:
+    """Join an operation note with the measured-once caveat when a row repeats one figure across configurations."""
+    if not shared:
+        return note
+    return _SHARED_WITH_OTHER_VARIANT if note is None else f"{note}; {_SHARED_WITH_OTHER_VARIANT}"
+
+
 def _slug(stem: str) -> str:
     """Return the migration page slug for a competitor module stem."""
     return _SLUG_OVERRIDES.get(stem, stem.replace("_", "-"))
@@ -85,21 +95,22 @@ def _case_names(operation: str, stats: dict[str, dict[str, float]]) -> list[str]
 
 def _rows(
     variants: list[dict[str, str]], stats: dict[str, dict[str, float]]
-) -> tuple[list[list[str | float | None]], list[list[float | None]]]:
+) -> tuple[list[list[str | float]], list[list[float | None]], list[str | None]]:
     """
     Build a library's rows and their spread across every shared operation-case, prefixing labels that span ops.
 
     ``variants`` holds one ``{op: label}`` per competitor module sharing this page, so a library benchmarked in more
     than one configuration (BeautifulSoup over each of its tree builders) columns them side by side. A variant that
-    does not measure an operation leaves its cells empty rather than dropping the row for the ones that do.
+    does not measure an operation shows the sibling's shared figure rather than dropping the row for the ones that do.
     """
     covered = {operation for variant in variants for operation in variant}
-    prefixed = len(covered) > 1
+    labels = [next(iter(variant.values())) for variant in variants]
     # a leading metric only makes sense when every shared operation carries one; a library that spans a memory
     # operation and timing-only ones would otherwise emit rows of two different widths into one table
     wide = bool(_leading_metric(covered))
-    rows: list[list[str | float | None]] = []
+    rows: list[list[str | float]] = []
     spread: list[list[float | None]] = []
+    caveats: list[str | None] = []
     for operation, meta in ((op, operations.OPERATIONS[op]) for op in operations.OPERATIONS if op in covered):
         for case in _case_names(operation, stats):
             turbo = stats.get(f"{operation}|{case}|turbohtml")
@@ -109,23 +120,39 @@ def _rows(
             ]
             if turbo is None or all(other is None for other in others):
                 continue
-            row_label = rst_safe(f"{meta.title} — {case}" if prefixed else case)
+            # a case name is an authored RST fragment (an XPath expression arrives already wrapped in ``code``
+            # backticks), so it passes through verbatim; escaping it here would double up on that markup
+            row_label = f"{meta.title} — {case}" if len(covered) > 1 else case
+            # a configuration that skips an operation runs the same code as the one measuring it, so its cells show
+            # the shared measurement and the row's note says the figure was measured once
+            measured = next(other for other in others if other is not None)
+            shared = any(other is None for other in others)
+            filled = [other if other is not None else measured for other in others]
+            row: list[str | float]
             if wide:
                 lead = "size" if operation in _SIZE_OPS else "peak"
-                row: list[str | float | None] = [row_label, turbo[lead], turbo["mean"]]
+                row = [row_label, turbo[lead], turbo["mean"]]
                 noise: list[float | None] = [None, None, turbo.get("cv")]
-                for other in others:
-                    row += [None, None] if other is None else [other[lead], other["mean"]]
-                    noise += [None, None if other is None else other.get("cv")]
+                for other in filled:
+                    row += [other[lead], other["mean"]]
+                    noise += [None, other.get("cv")]
             else:
                 row = [row_label, turbo["mean"]]
                 noise = [None, turbo.get("cv")]
-                for other in others:
-                    row.append(None if other is None else other["mean"])
-                    noise.append(None if other is None else other.get("cv"))
+                for other in filled:
+                    row.append(other["mean"])
+                    noise.append(other.get("cv"))
             rows.append(row)
             spread.append(noise)
-    return rows, spread
+            # a library page mixes operations, so a caveat belongs on the rows of the operation it describes; a row
+            # repeating one measurement across configurations says so beside any operation note
+            caveats.append(
+                _merge_caveat(
+                    next((NOTES[operation][label] for label in labels if label in NOTES.get(operation, {})), None),
+                    shared=shared,
+                )
+            )
+    return rows, spread, caveats
 
 
 def _leading_metric(ops: Iterable[str]) -> list[str]:
@@ -159,7 +186,7 @@ def emit_migration_feeds(
     for slug, variants in by_slug.items():
         if not (docs_root / "migration" / f"{slug}.rst").exists():
             continue
-        rows, spread = _rows(variants, stats)
+        rows, spread, caveats = _rows(variants, stats)
         if not rows:
             skipped.append(slug)
             continue
@@ -170,13 +197,9 @@ def emit_migration_feeds(
             "metrics": _leading_metric({operation for variant in variants for operation in variant}),
             "rows": rows,
             "spread": spread,
-            # a migration page mixes operations, so a note applies once the library is noted for any of them
-            "notes": {
-                label: note
-                for variant, label in zip(variants, labels, strict=True)
-                for operation in variant
-                if (note := NOTES.get(operation, {}).get(label)) is not None
-            },
+            # keyed by row rather than by column: a library page mixes operations, and a caveat that belongs to one
+            # of them would otherwise read as covering every row the library appears in
+            "row_notes": {str(index): note for index, note in enumerate(caveats) if note is not None},
         }
         (directory / f"{slug}.json").write_text(json.dumps(feed, indent=2, ensure_ascii=False) + "\n", "utf-8")
     return skipped
@@ -209,7 +232,9 @@ def main() -> None:
     """Regenerate migration feeds from per-operation feeds. Args: FEEDS_DIR OUT_DIR DOCS_ROOT COMPETITOR_DIR."""
     feeds_dir, out_dir, docs_root, competitor_dir = (Path(argument) for argument in sys.argv[1:5])
     if skipped := emit_migration_feeds(stats_from_feeds(feeds_dir), competitor_dir, out_dir, docs_root):
-        print(f"pages with no fresh measurement, left as committed: {skipped}")
+        # to stderr so a redirected sweep still surfaces it: a page silently losing its table is the failure to catch
+        message = f"migration: {len(skipped)} page(s) with no shared measurement, left as committed: {skipped}"
+        print(message, file=sys.stderr)
 
 
 __all__ = ["discover_labels", "emit_migration_feeds", "stats_from_feeds"]
diff --git a/tools/bench/notes.py b/tools/bench/notes.py
index 6d83c723..b4fbf760 100644
--- a/tools/bench/notes.py
+++ b/tools/bench/notes.py
@@ -19,8 +19,9 @@
     "compression the parsed minifiers do: on jQuery it emits 141.1 kB where turbohtml emits 87.8 kB"
 )
 _STRIPPER_CSS: Final = (
-    "strips whitespace and comments only, leaving #ffffff, 0px 0px 0px 0px and font-weight:bold unshortened where "
-    "turbohtml writes #fff, 0 and 700"
+    "strips whitespace and comments without parsing, so it applies none of the color, number, and shorthand rewrites "
+    "turbohtml does; on these stylesheets that leaves its output within 1.01-1.03x of turbohtml's, and 0.998x on "
+    "bulma, so the structural shortenings change little on already-tight framework CSS"
 )
 _BUILDER: Final = (
     "concatenates a string rather than constructing a navigable tree, so nothing it builds can afterwards be queried "
@@ -50,12 +51,11 @@
             "links at all, so that timing is the cost of finding nothing"
         ),
     },
-    "date": {
-        "htmldate": (
-            "returns no date for the 100-candidate case, so its timing there is the cost of giving up rather than of "
-            "finding the date turbohtml reports"
-        ),
-    },
+    "date": dict.fromkeys(
+        ("htmldate", "trafilatura"),
+        "returns no date for the 100-candidate case, so its timing there is the cost of giving up rather than of "
+        "finding the date turbohtml reports",
+    ),
     "text-content": {
         "resiliparse": (
             "reports about 11% fewer elements than every other parser here (876 against 989 on the mozilla page), so "
diff --git a/tools/bench/operations.py b/tools/bench/operations.py
index f314d73b..f1fcf16b 100644
--- a/tools/bench/operations.py
+++ b/tools/bench/operations.py
@@ -368,6 +368,7 @@ class Operation:
     "decode": Operation("decode a legacy byte stream", "us"),
     "normalize": Operation("normalize text to Unicode NFC", "us"),
     "detect-language": Operation("detect a text's natural language", "us"),
+    "escape-identifier": Operation("escape 1,000 raw CSS identifiers", "us"),
     "idna": Operation("normalize 4,100 URLs with Unicode hosts", "ms"),
     "urls-clean": Operation("clean and normalize 100 URLs", "us"),
     "links-filter": Operation("extract filtered page links", "us"),
@@ -991,6 +992,16 @@ def _language_cases() -> tuple[tuple[str, object], ...]:
     "decode": _decode_cases,
     "normalize": _normalize_cases,
     "detect-language": _language_cases,
+    "escape-identifier": lambda: (
+        (
+            "mixed shapes (1,000)",
+            tuple(
+                shape.format(index)
+                for index in range(200)
+                for shape in ("item-{}", "{}leading-digit", "no escape {} needed?", "emoji-\U0001f642-{}", "-")
+            ),
+        ),
+    ),
     "idna": lambda: (
         ("4,100 uncached Unicode hosts", _IDNA_URLS),
         ("4,100 varied-script hosts", _IDNA_VARIED_URLS),
diff --git a/tools/bench/report.py b/tools/bench/report.py
index 8bd14057..26d5c651 100644
--- a/tools/bench/report.py
+++ b/tools/bench/report.py
@@ -152,11 +152,6 @@ def _cells(stat: _Stat | None, *, extra: str | None) -> list[float | str | None]
     return [stat[extra], stat["mean"]] if extra else [stat["mean"]]
 
 
-def rst_safe(label: str) -> str:
-    """Escape the RST inline-markup starters (an XPath case can carry ``*`` or ``|``); the directive parses labels."""
-    return label.replace("\\", "\\\\").replace("*", "\\*").replace("|", "\\|").replace("`", "\\`")
-
-
 def _spread_cells(stat: _Stat | None, *, extra: str | None) -> list[float | None]:
     """
     Return a party's noise level for one case, aligned with :func:`_cells`.