From a99c037dbf8c79fefa469015671e9ef8c94fa3fb Mon Sep 17 00:00:00 2001
From: Alek Petuskey <alek@reflex.dev>
Date: Tue, 4 Aug 2026 12:57:38 -0700
Subject: [PATCH 01/27] Add a report-only style-compatibility preflight and the
 applicable-slot matrix
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

chart.style_compatibility_report(target=..., engine=..., custom_css=...)
routes every declared slot style for one export target into exactly one of
four outcomes — survives, native-subset (naming the kept and lost properties
per format family), browser-only, or state-gated — and mirrors the export
path's own refusals (custom_css with a pinned native engine, Chromium SVG)
instead of re-deciding them. Report-only: computing it never changes an
export; the staged compatibility= modes that act on it come separately.

Two properties are load-bearing. The report is constant-time when there is
nothing to route: no class_names, no per-slot styles, no custom_css means no
slot walk, so preflight stays free exactly where exports are hot. And
state-gated is not lost: the capability registry now tags every slot with an
applicability — present in a clean static export, or gated by hover,
selection, crosshair, modebar, or view (reduction badges) — so a styled
tooltip is recorded with its gating state rather than counted against a file
that never contains a tooltip. Counting it before this change overstated the
static parity gap by exactly the chrome a static file cannot contain: of 48
slots, 24 are clean-static and 24 state-gated, and all 10 native-capable
slots are in the static set.

Routing derives from the capability registry, the honored property subsets
from the writers' own constants (xy._svg.SLOT_TEXT_PROPS / SLOT_RASTER_PROPS),
and engine selection from export._resolve_image_engine — the preflight
restates none of them, so it cannot disagree with them. The legend slot stays
at declaration granularity (its box properties route through the merged
legend declaration, which has no constant yet) and is qualified rather than
guessed either direction (§28).

The generated capability matrices gain the applicable-in column and the
applicable-slot counts; new registry tests pin the partition (a new
modebar_*/tooltip/crosshair/badge slot that forgets its family state fails
the suite, and native support on a state-gated slot is rejected until the
interaction-snapshot phase adds it deliberately). export.md §9 documents the
report as its programmatic form.
---
 CHANGELOG.md                             |  16 ++
 docs/styling/capabilities.md             | 109 ++++----
 python/xy/_figure.py                     |  18 ++
 python/xy/components.py                  |  21 ++
 python/xy/styling/__init__.py            |  12 +-
 python/xy/styling/capabilities.py        |  64 ++++-
 python/xy/styling/preflight.py           | 306 +++++++++++++++++++++++
 scripts/gen_capability_matrix.py         |  29 ++-
 spec/api/capability-matrix.md            | 109 ++++----
 spec/api/export.md                       |  25 ++
 tests/test_capability_registry.py        |  43 ++++
 tests/test_style_compatibility_report.py | 215 ++++++++++++++++
 12 files changed, 854 insertions(+), 113 deletions(-)
 create mode 100644 python/xy/styling/preflight.py
 create mode 100644 tests/test_style_compatibility_report.py

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b9e41d411..683641b54 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,22 @@ in the README).
 
 ## [Unreleased]
 
+### Added
+- `chart.style_compatibility_report(target=..., engine=..., custom_css=...)`:
+  a report-only export preflight that routes every declared slot style into
+  `survives`, `native-subset` (naming the kept and lost properties per
+  format family), `browser-only`, or `state-gated`, mirrors the export
+  path's refusals, and short-circuits in constant time for charts with no
+  class or per-slot declarations. The programmatic answer to
+  `spec/api/export.md` §9.
+- The capability registry now tags every chrome slot with an
+  **applicability** — present in a clean static export, or gated by an
+  export state (`hover`, `selection`, `crosshair`, `modebar`, `view`) — and
+  the generated capability matrices gained the *applicable in* column and
+  applicable-slot counts (24 static / 24 state-gated of 48). Live-only
+  chrome a static file never contains is no longer counted as missing from
+  static export parity.
+
 ## [0.0.5] - 2026-07-31
 
 ### Added
diff --git a/docs/styling/capabilities.md b/docs/styling/capabilities.md
index 595580796..9d79c0e72 100644
--- a/docs/styling/capabilities.md
+++ b/docs/styling/capabilities.md
@@ -12,7 +12,7 @@ and *does the change survive where I need it*. This page answers both from the
 registry the implementation is checked against.
 
 - **11** mark style properties across **21** mark kinds, drawn by all three renderers.
-- **48** stable chrome slots for CSS and Tailwind in the browser.
+- **48** stable chrome slots for CSS and Tailwind in the browser — **24** of them in a clean static export, **24** gated by an interaction or view state.
 - **1** way to add a mark kind XY does not ship, without forking it.
 
 ## Mark style properties
@@ -54,56 +54,63 @@ raster and vector writers have no cascade, so per-slot styling is a browser
 mechanism; put anything that must survive export in the chart-level `style=`
 token bag or in mark and axis `style=`, which every renderer reads.
 
-| slot | browser | native raster | native vector |
-|---|---|---|---|
-| `root` | full | partial | partial |
-| `title` | full | partial | partial |
-| `chrome` | full | none | none |
-| `canvas` | full | none | none |
-| `annotation_layer` | full | none | none |
-| `labels` | full | none | none |
-| `legend` | full | partial | partial |
-| `legend_title` | full | partial | partial |
-| `legend_item` | full | none | none |
-| `legend_swatch` | full | none | none |
-| `legend_label` | full | partial | partial |
-| `colorbar` | full | partial | partial |
-| `colorbar_bar` | full | none | none |
-| `colorbar_extension` | full | none | none |
-| `colorbar_line` | full | none | none |
-| `colorbar_tick` | full | partial | partial |
-| `colorbar_minor_tick` | full | none | none |
-| `colorbar_title` | full | partial | partial |
-| `tooltip` | full | none | none |
-| `tooltip_title` | full | none | none |
-| `tooltip_row` | full | none | none |
-| `tooltip_label` | full | none | none |
-| `tooltip_value` | full | none | none |
-| `modebar` | full | none | none |
-| `modebar_drag_handle` | full | none | none |
-| `modebar_control_group` | full | none | none |
-| `modebar_separator` | full | none | none |
-| `modebar_button` | full | none | none |
-| `modebar_icon` | full | none | none |
-| `modebar_zoom_value` | full | none | none |
-| `modebar_indicator` | full | none | none |
-| `modebar_selection_icon` | full | none | none |
-| `modebar_menu` | full | none | none |
-| `modebar_menu_separator` | full | none | none |
-| `modebar_menu_icon` | full | none | none |
-| `modebar_menu_label` | full | none | none |
-| `modebar_history_controls` | full | none | none |
-| `selection` | full | none | none |
-| `crosshair_x` | full | none | none |
-| `crosshair_y` | full | none | none |
-| `badge` | full | none | none |
-| `badge_item` | full | none | none |
-| `axis_band` | full | none | none |
-| `axis_line` | full | none | none |
-| `tick_mark` | full | none | none |
-| `tick_label` | full | partial | partial |
-| `axis_title` | full | partial | partial |
-| `annotation_label` | full | none | none |
+The *applicable in* column says which export contains the slot at all: a clean
+static export has no tooltip, modebar, crosshair, selection overlay, or
+reduction badge, so styling one is not lost in such a file — it simply is not
+there. Ask `chart.style_compatibility_report(target=...)` for the per-chart
+answer: it routes every declared style for a target and names anything that
+would not survive, before any bytes exist.
+
+| slot | applicable in | browser | native raster | native vector |
+|---|---|---|---|---|
+| `root` | clean static | full | partial | partial |
+| `title` | clean static | full | partial | partial |
+| `chrome` | clean static | full | none | none |
+| `canvas` | clean static | full | none | none |
+| `annotation_layer` | clean static | full | none | none |
+| `labels` | clean static | full | none | none |
+| `legend` | clean static | full | partial | partial |
+| `legend_title` | clean static | full | partial | partial |
+| `legend_item` | clean static | full | none | none |
+| `legend_swatch` | clean static | full | none | none |
+| `legend_label` | clean static | full | partial | partial |
+| `colorbar` | clean static | full | partial | partial |
+| `colorbar_bar` | clean static | full | none | none |
+| `colorbar_extension` | clean static | full | none | none |
+| `colorbar_line` | clean static | full | none | none |
+| `colorbar_tick` | clean static | full | partial | partial |
+| `colorbar_minor_tick` | clean static | full | none | none |
+| `colorbar_title` | clean static | full | partial | partial |
+| `tooltip` | hover state | full | none | none |
+| `tooltip_title` | hover state | full | none | none |
+| `tooltip_row` | hover state | full | none | none |
+| `tooltip_label` | hover state | full | none | none |
+| `tooltip_value` | hover state | full | none | none |
+| `modebar` | modebar state | full | none | none |
+| `modebar_drag_handle` | modebar state | full | none | none |
+| `modebar_control_group` | modebar state | full | none | none |
+| `modebar_separator` | modebar state | full | none | none |
+| `modebar_button` | modebar state | full | none | none |
+| `modebar_icon` | modebar state | full | none | none |
+| `modebar_zoom_value` | modebar state | full | none | none |
+| `modebar_indicator` | modebar state | full | none | none |
+| `modebar_selection_icon` | modebar state | full | none | none |
+| `modebar_menu` | modebar state | full | none | none |
+| `modebar_menu_separator` | modebar state | full | none | none |
+| `modebar_menu_icon` | modebar state | full | none | none |
+| `modebar_menu_label` | modebar state | full | none | none |
+| `modebar_history_controls` | modebar state | full | none | none |
+| `selection` | selection state | full | none | none |
+| `crosshair_x` | crosshair state | full | none | none |
+| `crosshair_y` | crosshair state | full | none | none |
+| `badge` | view state | full | none | none |
+| `badge_item` | view state | full | none | none |
+| `axis_band` | clean static | full | none | none |
+| `axis_line` | clean static | full | none | none |
+| `tick_mark` | clean static | full | none | none |
+| `tick_label` | clean static | full | partial | partial |
+| `axis_title` | clean static | full | partial | partial |
+| `annotation_label` | clean static | full | none | none |
 
 ### Notes
 
diff --git a/python/xy/_figure.py b/python/xy/_figure.py
index d42f72fef..af80981fa 100644
--- a/python/xy/_figure.py
+++ b/python/xy/_figure.py
@@ -2217,6 +2217,24 @@ def _repr_html_(self) -> str:
         """Notebook HTML repr isolated from the host document's styles."""
         return export.notebook_iframe(self.to_html(), width=self.width, height=self.height)
 
+    def style_compatibility_report(
+        self,
+        target: str = "png",
+        *,
+        engine: Optional[export.Engine | str] = None,
+        custom_css: Optional[str] = None,
+    ) -> Any:
+        """Route every declared style for one export target, without exporting.
+
+        The programmatic answer to export.md §9: which styling sources this
+        figure carries, how each styled slot routes under `target`/`engine`,
+        and exactly what would not survive — including the export path's own
+        refusals, mirrored rather than re-decided. Report-only: computing it
+        never changes an export."""
+        from .styling.preflight import preflight
+
+        return preflight(self, target=target, engine=engine, custom_css=custom_css)
+
     def to_svg(
         self,
         path: Optional[str | PathLike[str]] = None,
diff --git a/python/xy/components.py b/python/xy/components.py
index a5ec5b9c5..cdc3934cf 100644
--- a/python/xy/components.py
+++ b/python/xy/components.py
@@ -4169,6 +4169,27 @@ def html(
     def _repr_html_(self) -> str:
         return self.figure()._repr_html_()
 
+    def style_compatibility_report(
+        self,
+        target: str = "png",
+        *,
+        engine: Optional[export.Engine | str] = None,
+        custom_css: Optional[str] = None,
+    ) -> Any:
+        """What of this chart's styling survives an export to ``target``.
+
+        Report-only preflight: lists the styling sources present, how each
+        styled slot routes for the target and engine, and exactly which
+        declarations would not survive — before any bytes exist. Mirrors the
+        export path's behavior (including its refusals) rather than
+        re-deciding it; see `spec/api/export.md` §9.
+        """
+        return self.figure().style_compatibility_report(
+            target,
+            engine=engine,
+            custom_css=custom_css,
+        )
+
     def to_svg(
         self,
         path: Optional[str] = None,
diff --git a/python/xy/styling/__init__.py b/python/xy/styling/__init__.py
index dc6443181..5d71f30d3 100644
--- a/python/xy/styling/__init__.py
+++ b/python/xy/styling/__init__.py
@@ -1,13 +1,17 @@
 """Machine-checkable records about XY's styling surface.
 
-`capabilities` is the one that matters: what can be styled, in which renderer,
-and how far it travels. It is imported by the docs generator and pinned by
+`capabilities` is the inventory: what can be styled, in which renderer, and
+how far it travels. It is imported by the docs generator and pinned by
 `tests/test_capability_registry.py`, so a claim about customization can be
 checked against it rather than against a reading of `styles.py`.
+
+`preflight` applies that inventory to one concrete chart and export target:
+`chart.style_compatibility_report()` routes every declared style and names
+what would not survive, before any bytes exist.
 """
 
 from __future__ import annotations
 
-from . import capabilities
+from . import capabilities, preflight
 
-__all__ = ["capabilities"]
+__all__ = ["capabilities", "preflight"]
diff --git a/python/xy/styling/capabilities.py b/python/xy/styling/capabilities.py
index 205c04e2f..a16b98257 100644
--- a/python/xy/styling/capabilities.py
+++ b/python/xy/styling/capabilities.py
@@ -49,6 +49,20 @@
 STATUSES: frozenset[str] = frozenset({"shipped", "partial", "planned"})
 VOCABULARIES: frozenset[str] = frozenset({"css", "svg", "xy"})
 
+#: Interaction/view states that gate live-only chrome. A slot tagged with one
+#: of these exists in the document only while its state is active — a tooltip
+#: under hover, the modebar under a pointer, a reduction badge under the view
+#: that triggered it — so a clean static export does not *contain* it. Styling
+#: such a slot is therefore not "dropped" by a clean static export: there is
+#: nothing in the file to style. Counting those slots against static parity
+#: overstated the gap; tagging them records the distinction instead of leaving
+#: it silent (§28).
+EXPORT_STATES: tuple[str, ...] = ("hover", "selection", "crosshair", "modebar", "view")
+
+#: Every slot is either present in a clean static export ("static") or gated
+#: by exactly one export state.
+APPLICABILITIES: frozenset[str] = frozenset({"static", *EXPORT_STATES})
+
 
 @dataclass(frozen=True)
 class MarkStyleProperty:
@@ -79,6 +93,7 @@ class SlotCapability:
     support: dict[str, str]
     notes: str
     channel: str = ""
+    applicability: str = "static"
 
 
 @dataclass(frozen=True)
@@ -281,6 +296,39 @@ class ExtensionPoint:
 )
 
 
+#: The state that gates each live-only slot. Listed explicitly, one entry per
+#: slot rather than by prefix, so `tests/test_capability_registry.py` can
+#: assert the partition covers `CHART_DOM_SLOTS` exactly and that every member
+#: of a chrome family carries its family's state — a new `modebar_*` slot that
+#: forgets its entry fails the suite instead of quietly counting as static.
+_STATE_GATED_SLOTS: dict[str, str] = {
+    "tooltip": "hover",
+    "tooltip_title": "hover",
+    "tooltip_row": "hover",
+    "tooltip_label": "hover",
+    "tooltip_value": "hover",
+    "modebar": "modebar",
+    "modebar_drag_handle": "modebar",
+    "modebar_control_group": "modebar",
+    "modebar_separator": "modebar",
+    "modebar_button": "modebar",
+    "modebar_icon": "modebar",
+    "modebar_zoom_value": "modebar",
+    "modebar_indicator": "modebar",
+    "modebar_selection_icon": "modebar",
+    "modebar_menu": "modebar",
+    "modebar_menu_separator": "modebar",
+    "modebar_menu_icon": "modebar",
+    "modebar_menu_label": "modebar",
+    "modebar_history_controls": "modebar",
+    "selection": "selection",
+    "crosshair_x": "crosshair",
+    "crosshair_y": "crosshair",
+    "badge": "view",
+    "badge_item": "view",
+}
+
+
 CHART_SLOTS: tuple[SlotCapability, ...] = tuple(
     SlotCapability(
         id=slot,
@@ -291,6 +339,7 @@ class ExtensionPoint:
         },
         channel=_SLOT_EXCEPTIONS[slot][1] if slot in _SLOT_EXCEPTIONS else "",
         notes=_SLOT_EXCEPTIONS[slot][2] if slot in _SLOT_EXCEPTIONS else "",
+        applicability=_STATE_GATED_SLOTS.get(slot, "static"),
     )
     for slot in CHART_DOM_SLOTS
 )
@@ -358,12 +407,15 @@ def markdown_mark_property_table(
 def markdown_slot_table(slots: Iterable[SlotCapability] = CHART_SLOTS) -> list[str]:
     """One row per chrome slot, with how far its styling travels."""
     lines = [
-        "| slot | browser | native raster | native vector |",
-        "|---|---|---|---|",
+        "| slot | applicable in | browser | native raster | native vector |",
+        "|---|---|---|---|---|",
     ]
     for slot in slots:
+        applicable = (
+            "clean static" if slot.applicability == "static" else f"{slot.applicability} state"
+        )
         lines.append(
-            f"| `{slot.id}` | {slot.support['browser']} | "
+            f"| `{slot.id}` | {applicable} | {slot.support['browser']} | "
             f"{slot.support['native_raster']} | {slot.support['native_vector']} |"
         )
     return lines
@@ -400,12 +452,16 @@ def axis_style_keys() -> tuple[str, ...]:
 def summary() -> dict[str, object]:
     """Counts a release note can quote without anyone recounting by hand."""
     shipped = [p for p in MARK_STYLE_PROPERTIES if p.status == "shipped"]
+    static = [s for s in CHART_SLOTS if s.applicability == "static"]
     return {
         "axis_style_keys": len(axis_style_keys()),
         "mark_style_properties": len(MARK_STYLE_PROPERTIES),
         "mark_style_properties_shipped": len(shipped),
         "mark_kinds": len(styles._MARK_KINDS),
         "chart_slots": len(CHART_SLOTS),
+        "chart_slots_static": len(static),
+        "chart_slots_state_gated": len(CHART_SLOTS) - len(static),
+        "static_slots_native": sum(1 for s in static if s.support["native_raster"] != "none"),
         "slots_styleable_natively": sum(
             1 for s in CHART_SLOTS if s.support["native_raster"] != "none"
         ),
@@ -415,7 +471,9 @@ def summary() -> dict[str, object]:
 
 
 __all__ = [
+    "APPLICABILITIES",
     "CHART_SLOTS",
+    "EXPORT_STATES",
     "EXTENSION_POINTS",
     "KNOWN_RENDERER_DIVERGENCES",
     "MARK_STYLE_PROPERTIES",
diff --git a/python/xy/styling/preflight.py b/python/xy/styling/preflight.py
new file mode 100644
index 000000000..d6d3d523a
--- /dev/null
+++ b/python/xy/styling/preflight.py
@@ -0,0 +1,306 @@
+"""Report-only export preflight: what survives an export, and what does not.
+
+`chart.style_compatibility_report(target=...)` answers `spec/api/export.md` §9
+programmatically, per chart, before any bytes exist: for the requested target
+and engine it lists which styling sources are present, how each styled slot
+routes, and exactly which declarations would not survive. Nothing here changes
+export behavior — the staged `compatibility=` modes that act on this report
+land separately, so this module can be trusted from any code path.
+
+Three rules keep the report honest:
+
+1. **No silent decisions (§28).** Every declared style ends in exactly one
+   route: it survives, it is state-gated chrome a clean static file does not
+   contain, or it is named as a loss. There is no fourth, quiet bucket.
+2. **Constant time when there is nothing to route.** A chart with no
+   `class_names`, no per-slot `styles`, and no `custom_css` short-circuits to
+   a lossless report without walking any slot — the preflight is free exactly
+   where exports are hot.
+3. **One source of truth per fact.** Slot routing derives from the capability
+   registry, the honored property subsets from `xy._svg` (which the writers
+   themselves read), and engine selection from `xy.export`'s own resolver.
+   This module restates none of them, so it cannot disagree with them.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any, Optional
+
+from . import capabilities
+
+if TYPE_CHECKING:  # pragma: no cover - import cycle guard, typing only
+    from .._figure import Figure
+
+#: Routes a declared style can take. Stable strings: the staged
+#: `compatibility=` modes and the tests key on them.
+ROUTE_SURVIVES = "survives"
+ROUTE_SUBSET = "native-subset"
+ROUTE_BROWSER_ONLY = "browser-only"
+ROUTE_STATE_GATED = "state-gated"
+
+_RASTER_FORMATS = frozenset({"png", "jpeg", "webp"})
+_VECTOR_FORMATS = frozenset({"svg", "pdf"})
+
+_SLOTS_BY_ID = {slot.id: slot for slot in capabilities.CHART_SLOTS}
+
+
+@dataclass(frozen=True)
+class SlotFinding:
+    """How one styled slot routes for the requested target."""
+
+    slot: str
+    source: str  # "styles" | "class_names"
+    applicability: str  # "static" or the gating export state
+    route: str  # one of the ROUTE_* strings
+    kept: tuple[str, ...] = ()
+    lost: tuple[str, ...] = ()
+    detail: str = ""
+
+
+@dataclass(frozen=True)
+class StyleCompatibilityReport:
+    """The preflight answer for one chart and one export target.
+
+    `lossless` is the single bit the staged modes will act on: True means the
+    export preserves every declared style that the target's document can
+    contain (state-gated chrome is recorded, not counted — a clean static
+    file has no tooltip to style). `error` carries the message of an export
+    that would refuse outright (for example `custom_css` with a pinned native
+    engine), mirroring the export path's own exception rather than predicting
+    a different outcome.
+    """
+
+    target: str
+    engine: str
+    sources: dict[str, bool] = field(default_factory=dict)
+    findings: tuple[SlotFinding, ...] = ()
+    losses: tuple[str, ...] = ()
+    lossless: bool = True
+    error: Optional[str] = None
+
+    def explain(self) -> str:
+        """The report as readable lines, one decision each."""
+        head = f"style compatibility for {self.target} via {self.engine} engine"
+        lines = [head]
+        present = [name for name, on in self.sources.items() if on] or ["(defaults only)"]
+        lines.append("sources: " + ", ".join(present))
+        if self.error is not None:
+            lines.append(f"refused: {self.error}")
+            return "\n".join(lines)
+        for finding in self.findings:
+            bits = [f"{finding.source}[{finding.slot!r}]: {finding.route}"]
+            if finding.lost:
+                bits.append("loses " + ", ".join(finding.lost))
+            if finding.detail:
+                bits.append(finding.detail)
+            lines.append("  " + " — ".join(bits))
+        lines.append("lossless" if self.lossless else f"{len(self.losses)} loss(es)")
+        return "\n".join(lines)
+
+
+def _sources(figure: Figure, custom_css: Optional[str]) -> dict[str, bool]:
+    """Which styling sources this chart carries. Attribute checks only."""
+    return {
+        "chart_style": bool(figure.style),
+        "slot_styles": bool(figure.chrome_styles),
+        "class_names": bool(figure.class_names),
+        "custom_css": custom_css is not None,
+    }
+
+
+def _resolve(target: str, engine: object, custom_css: Optional[str]) -> tuple[str, str, str]:
+    """(format, engine, error) via the export module's own resolver.
+
+    Deferred import: `export` pulls in the browser-discovery machinery, and
+    `capabilities` must stay importable from the docs generator without it.
+    """
+    from .. import export
+
+    fmt = export._normalize_format(target, allow_html=True)
+    if fmt == "html":
+        return fmt, "browser", ""
+    try:
+        return fmt, export._resolve_image_engine(engine, fmt, custom_css), ""
+    except ValueError as exc:
+        return fmt, "unresolved", str(exc)
+
+
+def _honored_props(slot: str, fmt: str) -> tuple[frozenset[str], str]:
+    """(honored property names, qualifier) for a native-subset slot.
+
+    The subsets are the writers' own constants. `legend` honors box properties
+    beyond the shared text subset through its merged-declaration channel; that
+    set lives in the writer's merge logic rather than a constant yet, so the
+    report stays at declaration granularity there instead of guessing — the
+    qualifier says so, and the shared IR change makes it exact.
+    """
+    from .. import _svg
+
+    text = frozenset(_svg.SLOT_RASTER_PROPS if fmt in _RASTER_FORMATS else _svg.SLOT_TEXT_PROPS)
+    if slot == "legend":
+        return text, (
+            "box properties (background, shadow, radius, padding) route through the "
+            "merged legend declaration; see the capability matrix legend note"
+        )
+    return text, ""
+
+
+def _css_prop(name: str) -> str:
+    """Match the writers' spelling: kebab-case, custom properties untouched."""
+    text = str(name)
+    return text if text.startswith("--") else text.replace("_", "-")
+
+
+def _class_finding(slot: str, fmt: str) -> SlotFinding:
+    meta = _SLOTS_BY_ID[slot]
+    if meta.applicability != "static":
+        return SlotFinding(
+            slot=slot,
+            source="class_names",
+            applicability=meta.applicability,
+            route=ROUTE_STATE_GATED,
+            detail=(
+                f"{meta.applicability}-state chrome; a clean static {fmt} does not "
+                "contain it, so nothing in the file is unstyled"
+            ),
+        )
+    return SlotFinding(
+        slot=slot,
+        source="class_names",
+        applicability="static",
+        route=ROUTE_BROWSER_ONLY,
+        lost=("*",),
+        detail=(
+            "a class selects a rule out of a stylesheet, and a native export has no "
+            "stylesheet — browser and Chromium targets honor it"
+        ),
+    )
+
+
+def _styles_finding(slot: str, decls: dict[str, Any], fmt: str) -> SlotFinding:
+    meta = _SLOTS_BY_ID[slot]
+    family = "native_raster" if fmt in _RASTER_FORMATS else "native_vector"
+    props = tuple(_css_prop(name) for name in decls)
+    if meta.applicability != "static":
+        return SlotFinding(
+            slot=slot,
+            source="styles",
+            applicability=meta.applicability,
+            route=ROUTE_STATE_GATED,
+            detail=(
+                f"{meta.applicability}-state chrome; a clean static {fmt} does not "
+                "contain it, so nothing in the file is unstyled"
+            ),
+        )
+    if slot == "root" or meta.support[family] == "none":
+        detail = meta.notes if slot == "root" else "no native path for this slot yet"
+        return SlotFinding(
+            slot=slot,
+            source="styles",
+            applicability="static",
+            route=ROUTE_BROWSER_ONLY,
+            lost=props,
+            detail=detail,
+        )
+    honored, qualifier = _honored_props(slot, fmt)
+    kept = tuple(p for p in props if p in honored)
+    lost = tuple(p for p in props if p not in honored)
+    if slot == "legend":
+        # Declaration-level: unlisted properties may still route through the
+        # merged legend channel, so they are qualified rather than declared
+        # lost (§28: unsure is said out loud, not rounded either direction).
+        return SlotFinding(
+            slot=slot,
+            source="styles",
+            applicability="static",
+            route=ROUTE_SUBSET,
+            kept=kept,
+            lost=(),
+            detail=qualifier,
+        )
+    if lost:
+        return SlotFinding(
+            slot=slot,
+            source="styles",
+            applicability="static",
+            route=ROUTE_SUBSET,
+            kept=kept,
+            lost=lost,
+            detail="outside the writer's honored subset for this slot",
+        )
+    return SlotFinding(
+        slot=slot,
+        source="styles",
+        applicability="static",
+        route=ROUTE_SURVIVES,
+        kept=kept,
+    )
+
+
+def preflight(
+    figure: Figure,
+    *,
+    target: str = "png",
+    engine: object = None,
+    custom_css: Optional[str] = None,
+) -> StyleCompatibilityReport:
+    """Route every declared style for one export target, without exporting.
+
+    `engine` accepts the same values as the export APIs (`Engine`, its string
+    aliases, or None for auto). The report mirrors the export path's actual
+    behavior, including its refusals — it never predicts a different outcome
+    than running the export would produce.
+    """
+    fmt, resolved, error = _resolve(target, engine, custom_css)
+    sources = _sources(figure, custom_css)
+    if error:
+        return StyleCompatibilityReport(
+            target=fmt,
+            engine=resolved,
+            sources=sources,
+            lossless=False,
+            losses=(error,),
+            error=error,
+        )
+    if resolved == "browser":
+        # The live client renders the full cascade; nothing can drop.
+        return StyleCompatibilityReport(target=fmt, engine=resolved, sources=sources)
+    if not (figure.class_names or figure.chrome_styles):
+        # The constant-time path: chart-level `style=` and mark/axis `style=`
+        # are full in every renderer (see the capability matrix), so with no
+        # class or per-slot declarations there is nothing that can drop.
+        return StyleCompatibilityReport(target=fmt, engine=resolved, sources=sources)
+
+    findings: list[SlotFinding] = []
+    for slot in figure.class_names:
+        if slot in _SLOTS_BY_ID:
+            findings.append(_class_finding(slot, fmt))
+    for slot, decls in figure.chrome_styles.items():
+        if slot in _SLOTS_BY_ID and isinstance(decls, dict):
+            findings.append(_styles_finding(slot, decls, fmt))
+
+    losses = tuple(
+        f"{finding.source}[{finding.slot!r}] -> {', '.join(finding.lost)}"
+        for finding in findings
+        if finding.lost
+    )
+    return StyleCompatibilityReport(
+        target=fmt,
+        engine=resolved,
+        sources=sources,
+        findings=tuple(findings),
+        losses=losses,
+        lossless=not losses,
+    )
+
+
+__all__ = [
+    "ROUTE_BROWSER_ONLY",
+    "ROUTE_STATE_GATED",
+    "ROUTE_SUBSET",
+    "ROUTE_SURVIVES",
+    "SlotFinding",
+    "StyleCompatibilityReport",
+    "preflight",
+]
diff --git a/scripts/gen_capability_matrix.py b/scripts/gen_capability_matrix.py
index f7ce5f124..e76c38f5c 100644
--- a/scripts/gen_capability_matrix.py
+++ b/scripts/gen_capability_matrix.py
@@ -63,10 +63,15 @@ def render() -> str:
         f"- **{counts['mark_style_properties_shipped']}** mark style properties across "
         f"**{counts['mark_kinds']}** mark kinds, {claim}.",
         f"- **{counts['chart_slots']}** stable chrome slots, CSS- and Tailwind-addressable "
-        "in the browser; "
-        f"**{counts['slots_styleable_natively']}** of them reach the native writers — "
+        "in the browser. "
+        f"**{counts['chart_slots_static']}** of them name chrome a clean static export "
+        f"contains; **{counts['slots_styleable_natively']}** reach the native writers — "
         "nine through `styles={slot: ...}` itself, and `root` through the "
-        "chart-level `style=` token bag.",
+        "chart-level `style=` token bag. The other "
+        f"**{counts['chart_slots_state_gated']}** are interaction/view chrome "
+        "(tooltip, modebar, crosshair, selection, reduction badges) that a clean "
+        "static file does not contain, so they are gated by an export state "
+        "rather than missing.",
         f"- **{counts['extension_points_shipped']}** shipped extension point.",
         f"- **{counts['known_renderer_divergences']}** known default divergence between "
         "renderers, listed below rather than left to be discovered.",
@@ -96,6 +101,13 @@ def render() -> str:
         "contracted in [export.md](export.md) §9 and pinned by",
         "`tests/test_export_style_survival.py`.",
         "",
+        "The *applicable in* column records which export contains the slot at all: a",
+        "clean static export has no tooltip, modebar, crosshair, selection overlay, or",
+        "reduction badge, so styling one is not dropped by such an export — there is",
+        "nothing in the file to style. Per chart and target,",
+        "`chart.style_compatibility_report()` applies this table to what was actually",
+        "declared and names anything that would not survive.",
+        "",
     ]
     lines += caps.markdown_slot_table()
     lines += ["", "### Notes", ""]
@@ -168,7 +180,9 @@ def render_public() -> str:
         "",
         f"- **{counts['mark_style_properties_shipped']}** mark style properties across "
         f"**{counts['mark_kinds']}** mark kinds, {claim}.",
-        f"- **{counts['chart_slots']}** stable chrome slots for CSS and Tailwind in the browser.",
+        f"- **{counts['chart_slots']}** stable chrome slots for CSS and Tailwind in the "
+        f"browser — **{counts['chart_slots_static']}** of them in a clean static export, "
+        f"**{counts['chart_slots_state_gated']}** gated by an interaction or view state.",
         f"- **{counts['extension_points_shipped']}** way to add a mark kind XY does not "
         "ship, without forking it.",
         "",
@@ -192,6 +206,13 @@ def render_public() -> str:
         "mechanism; put anything that must survive export in the chart-level `style=`",
         "token bag or in mark and axis `style=`, which every renderer reads.",
         "",
+        "The *applicable in* column says which export contains the slot at all: a clean",
+        "static export has no tooltip, modebar, crosshair, selection overlay, or",
+        "reduction badge, so styling one is not lost in such a file — it simply is not",
+        "there. Ask `chart.style_compatibility_report(target=...)` for the per-chart",
+        "answer: it routes every declared style for a target and names anything that",
+        "would not survive, before any bytes exist.",
+        "",
     ]
     lines += caps.markdown_slot_table()
     lines += ["", "### Notes", ""]
diff --git a/spec/api/capability-matrix.md b/spec/api/capability-matrix.md
index 1c4b18f18..c90753cd6 100644
--- a/spec/api/capability-matrix.md
+++ b/spec/api/capability-matrix.md
@@ -14,7 +14,7 @@ which is sometimes deliberate, and the notes say which.
 ## In one line
 
 - **11** mark style properties across **21** mark kinds, drawn by all three renderers.
-- **48** stable chrome slots, CSS- and Tailwind-addressable in the browser; **10** of them reach the native writers — nine through `styles={slot: ...}` itself, and `root` through the chart-level `style=` token bag.
+- **48** stable chrome slots, CSS- and Tailwind-addressable in the browser. **24** of them name chrome a clean static export contains; **10** reach the native writers — nine through `styles={slot: ...}` itself, and `root` through the chart-level `style=` token bag. The other **24** are interaction/view chrome (tooltip, modebar, crosshair, selection, reduction badges) that a clean static file does not contain, so they are gated by an export state rather than missing.
 - **1** shipped extension point.
 - **1** known default divergence between renderers, listed below rather than left to be discovered.
 
@@ -62,56 +62,63 @@ stylesheet an exported file does not have. That boundary is
 contracted in [export.md](export.md) §9 and pinned by
 `tests/test_export_style_survival.py`.
 
-| slot | browser | native raster | native vector |
-|---|---|---|---|
-| `root` | full | partial | partial |
-| `title` | full | partial | partial |
-| `chrome` | full | none | none |
-| `canvas` | full | none | none |
-| `annotation_layer` | full | none | none |
-| `labels` | full | none | none |
-| `legend` | full | partial | partial |
-| `legend_title` | full | partial | partial |
-| `legend_item` | full | none | none |
-| `legend_swatch` | full | none | none |
-| `legend_label` | full | partial | partial |
-| `colorbar` | full | partial | partial |
-| `colorbar_bar` | full | none | none |
-| `colorbar_extension` | full | none | none |
-| `colorbar_line` | full | none | none |
-| `colorbar_tick` | full | partial | partial |
-| `colorbar_minor_tick` | full | none | none |
-| `colorbar_title` | full | partial | partial |
-| `tooltip` | full | none | none |
-| `tooltip_title` | full | none | none |
-| `tooltip_row` | full | none | none |
-| `tooltip_label` | full | none | none |
-| `tooltip_value` | full | none | none |
-| `modebar` | full | none | none |
-| `modebar_drag_handle` | full | none | none |
-| `modebar_control_group` | full | none | none |
-| `modebar_separator` | full | none | none |
-| `modebar_button` | full | none | none |
-| `modebar_icon` | full | none | none |
-| `modebar_zoom_value` | full | none | none |
-| `modebar_indicator` | full | none | none |
-| `modebar_selection_icon` | full | none | none |
-| `modebar_menu` | full | none | none |
-| `modebar_menu_separator` | full | none | none |
-| `modebar_menu_icon` | full | none | none |
-| `modebar_menu_label` | full | none | none |
-| `modebar_history_controls` | full | none | none |
-| `selection` | full | none | none |
-| `crosshair_x` | full | none | none |
-| `crosshair_y` | full | none | none |
-| `badge` | full | none | none |
-| `badge_item` | full | none | none |
-| `axis_band` | full | none | none |
-| `axis_line` | full | none | none |
-| `tick_mark` | full | none | none |
-| `tick_label` | full | partial | partial |
-| `axis_title` | full | partial | partial |
-| `annotation_label` | full | none | none |
+The *applicable in* column records which export contains the slot at all: a
+clean static export has no tooltip, modebar, crosshair, selection overlay, or
+reduction badge, so styling one is not dropped by such an export — there is
+nothing in the file to style. Per chart and target,
+`chart.style_compatibility_report()` applies this table to what was actually
+declared and names anything that would not survive.
+
+| slot | applicable in | browser | native raster | native vector |
+|---|---|---|---|---|
+| `root` | clean static | full | partial | partial |
+| `title` | clean static | full | partial | partial |
+| `chrome` | clean static | full | none | none |
+| `canvas` | clean static | full | none | none |
+| `annotation_layer` | clean static | full | none | none |
+| `labels` | clean static | full | none | none |
+| `legend` | clean static | full | partial | partial |
+| `legend_title` | clean static | full | partial | partial |
+| `legend_item` | clean static | full | none | none |
+| `legend_swatch` | clean static | full | none | none |
+| `legend_label` | clean static | full | partial | partial |
+| `colorbar` | clean static | full | partial | partial |
+| `colorbar_bar` | clean static | full | none | none |
+| `colorbar_extension` | clean static | full | none | none |
+| `colorbar_line` | clean static | full | none | none |
+| `colorbar_tick` | clean static | full | partial | partial |
+| `colorbar_minor_tick` | clean static | full | none | none |
+| `colorbar_title` | clean static | full | partial | partial |
+| `tooltip` | hover state | full | none | none |
+| `tooltip_title` | hover state | full | none | none |
+| `tooltip_row` | hover state | full | none | none |
+| `tooltip_label` | hover state | full | none | none |
+| `tooltip_value` | hover state | full | none | none |
+| `modebar` | modebar state | full | none | none |
+| `modebar_drag_handle` | modebar state | full | none | none |
+| `modebar_control_group` | modebar state | full | none | none |
+| `modebar_separator` | modebar state | full | none | none |
+| `modebar_button` | modebar state | full | none | none |
+| `modebar_icon` | modebar state | full | none | none |
+| `modebar_zoom_value` | modebar state | full | none | none |
+| `modebar_indicator` | modebar state | full | none | none |
+| `modebar_selection_icon` | modebar state | full | none | none |
+| `modebar_menu` | modebar state | full | none | none |
+| `modebar_menu_separator` | modebar state | full | none | none |
+| `modebar_menu_icon` | modebar state | full | none | none |
+| `modebar_menu_label` | modebar state | full | none | none |
+| `modebar_history_controls` | modebar state | full | none | none |
+| `selection` | selection state | full | none | none |
+| `crosshair_x` | crosshair state | full | none | none |
+| `crosshair_y` | crosshair state | full | none | none |
+| `badge` | view state | full | none | none |
+| `badge_item` | view state | full | none | none |
+| `axis_band` | clean static | full | none | none |
+| `axis_line` | clean static | full | none | none |
+| `tick_mark` | clean static | full | none | none |
+| `tick_label` | clean static | full | partial | partial |
+| `axis_title` | clean static | full | partial | partial |
+| `annotation_label` | clean static | full | none | none |
 
 ### Notes
 
diff --git a/spec/api/export.md b/spec/api/export.md
index 259e403d5..1cf8134a0 100644
--- a/spec/api/export.md
+++ b/spec/api/export.md
@@ -254,6 +254,31 @@ vector** (`_svg.to_svg`, and `_pdf.svg_to_pdf` on top of it).
 | `xy.legend(style=...)` | yes | 6 keys | 6 keys | merged with the slot and the theme token before the writers see it |
 | `xy.colorbar(style=...)` | yes | **dropped** | **dropped** | no native channel; use `styles={"colorbar_title"/"colorbar_tick": ...}` |
 
+### Asking a chart, not the table
+
+`chart.style_compatibility_report(target=..., engine=..., custom_css=...)` is
+this section applied to one concrete chart, before any bytes exist. It lists
+which styling sources the chart carries and routes every declared slot style
+into exactly one of four outcomes — `survives`, `native-subset` (with the kept
+and lost property names), `browser-only`, or `state-gated` — and mirrors the
+export path's refusals (`custom_css` with a pinned native engine, Chromium
+SVG) rather than re-deciding them. It is report-only: computing it never
+changes an export. The staged `compatibility=` modes that act on the report
+are a separate, later contract.
+
+Two properties are load-bearing. First, the report is constant-time when
+there is nothing to route: no `class_names`, no per-slot `styles`, and no
+`custom_css` means no slot walk — preflight is free exactly where exports are
+hot. Second, *state-gated is not lost*. The capability registry tags every
+slot with an applicability — present in a clean static export, or gated by an
+export state (`hover`, `selection`, `crosshair`, `modebar`, `view` for the
+reduction badges). A clean static file contains no tooltip, so a styled
+tooltip is recorded with its gating state and does not count against
+losslessness; counting it would overstate the parity gap by exactly the
+chrome a static file never contains. `tests/test_capability_registry.py`
+pins the partition (24 static, 24 state-gated today) and
+`tests/test_style_compatibility_report.py` pins the routing.
+
 ### Why two of those rows are silent, and why that is the right default
 
 `custom_css` raises because it is an author stylesheet: there is no honest
diff --git a/tests/test_capability_registry.py b/tests/test_capability_registry.py
index 88daaee29..850946ae1 100644
--- a/tests/test_capability_registry.py
+++ b/tests/test_capability_registry.py
@@ -54,6 +54,49 @@ def test_registry_covers_exactly_the_public_dom_slots() -> None:
     assert tuple(slot.id for slot in caps.CHART_SLOTS) == CHART_DOM_SLOTS
 
 
+def test_every_slot_has_exactly_one_applicability() -> None:
+    # The applicable-slot contract: a slot is either present in a clean static
+    # export or gated by exactly one export state. An unknown value here would
+    # quietly break the matrix column and the preflight routing.
+    for slot in caps.CHART_SLOTS:
+        assert slot.applicability in caps.APPLICABILITIES, slot.id
+    counts = caps.summary()
+    assert counts["chart_slots_static"] + counts["chart_slots_state_gated"] == len(caps.CHART_SLOTS)
+
+
+def test_state_gated_families_cannot_be_misfiled() -> None:
+    # A new `modebar_*` (or tooltip/crosshair/badge) slot must carry its
+    # family's state; defaulting to "static" would overstate the clean-static
+    # surface — the direction that is easy to miss.
+    families = {
+        "tooltip": "hover",
+        "modebar": "modebar",
+        "crosshair_": "crosshair",
+        "badge": "view",
+    }
+    for slot in caps.CHART_SLOTS:
+        expected = next(
+            (state for prefix, state in families.items() if slot.id.startswith(prefix)),
+            "selection" if slot.id == "selection" else "static",
+        )
+        assert slot.applicability == expected, (
+            f"{slot.id!r} is {slot.applicability!r}, expected {expected!r}"
+        )
+
+
+def test_native_paths_exist_only_for_clean_static_chrome() -> None:
+    # Today no writer draws state-gated chrome (a frozen tooltip, a modebar):
+    # the interaction-snapshot phase changes this deliberately, and this test
+    # with it. Until then, a native support level on a gated slot would claim
+    # a path that does not exist.
+    for slot in caps.CHART_SLOTS:
+        if slot.applicability != "static":
+            assert slot.support["native_raster"] == "none", slot.id
+            assert slot.support["native_vector"] == "none", slot.id
+    counts = caps.summary()
+    assert counts["static_slots_native"] == counts["slots_styleable_natively"]
+
+
 def test_axis_style_registry_covers_the_compiler_vocabulary() -> None:
     expected = (
         styles._AXIS_COLOR_PROPERTIES
diff --git a/tests/test_style_compatibility_report.py b/tests/test_style_compatibility_report.py
new file mode 100644
index 000000000..5712b3d4b
--- /dev/null
+++ b/tests/test_style_compatibility_report.py
@@ -0,0 +1,215 @@
+"""The preflight report must mirror the export paths, never re-decide them.
+
+`chart.style_compatibility_report()` is report-only (running it changes no
+export), constant-time for charts with nothing to route, and derives every
+fact from the capability registry, the writers' own honored-property
+constants, and the export module's engine resolver. These tests pin all three
+properties, plus the applicable-slot contract: state-gated chrome (tooltip,
+modebar, crosshair, selection, reduction badges) is recorded, not counted as
+a loss a clean static file never contained.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+import xy
+from xy import _svg, export
+from xy.styling import capabilities as caps
+from xy.styling import preflight as pf
+
+
+def _chart(**props):
+    return xy.scatter_chart(xy.scatter([1.0, 2.0, 3.0], [2.0, 1.0, 3.0]), **props)
+
+
+def _finding(report, slot, source):
+    matches = [f for f in report.findings if f.slot == slot and f.source == source]
+    assert len(matches) == 1, f"expected one finding for {source}[{slot!r}], got {matches!r}"
+    return matches[0]
+
+
+# -- constant-time path ------------------------------------------------------
+
+
+@pytest.mark.parametrize("target", ["png", "jpeg", "webp", "svg", "pdf", "html"])
+def test_unstyled_chart_is_lossless_with_no_findings(target: str) -> None:
+    report = _chart().style_compatibility_report(target)
+    assert report.lossless
+    assert report.findings == ()
+    assert report.losses == ()
+    assert report.error is None
+    assert not any(report.sources.values())
+
+
+def test_chart_level_style_alone_stays_on_the_constant_time_path() -> None:
+    # The chart-level token bag is read by every renderer (capability matrix,
+    # `root` row), so it is a source that can never drop — the report says the
+    # source is present and walks nothing.
+    report = _chart(style={"background": "#111"}).style_compatibility_report("png")
+    assert report.sources["chart_style"]
+    assert report.lossless
+    assert report.findings == ()
+
+
+# -- routing: class_names ----------------------------------------------------
+
+
+def test_class_on_static_slot_is_lost_natively_and_kept_in_browser_targets() -> None:
+    chart = _chart(class_names={"legend": "bg-slate-900"})
+    native = chart.style_compatibility_report("png")
+    assert not native.lossless
+    finding = _finding(native, "legend", "class_names")
+    assert finding.route == pf.ROUTE_BROWSER_ONLY
+    assert finding.lost == ("*",)
+
+    assert chart.style_compatibility_report("html").lossless
+    chromium = chart.style_compatibility_report("png", engine=export.Engine.chromium)
+    assert chromium.engine == "browser"
+    assert chromium.lossless
+
+
+def test_class_on_hover_slot_is_state_gated_not_lost() -> None:
+    # The applicable-slot contract: a clean static export contains no tooltip,
+    # so a styled tooltip is not "dropped" by one — the report records the
+    # gating state and stays lossless.
+    report = _chart(class_names={"tooltip": "rounded-xl"}).style_compatibility_report("png")
+    finding = _finding(report, "tooltip", "class_names")
+    assert finding.route == pf.ROUTE_STATE_GATED
+    assert finding.applicability == "hover"
+    assert finding.lost == ()
+    assert report.lossless
+
+
+# -- routing: per-slot styles ------------------------------------------------
+
+
+def test_subset_math_follows_the_writers_own_constants() -> None:
+    chart = _chart(styles={"tick_label": {"font_weight": 600, "letter_spacing": "0.08em"}})
+
+    raster = chart.style_compatibility_report("png")
+    finding = _finding(raster, "tick_label", "styles")
+    assert finding.route == pf.ROUTE_SUBSET
+    assert "font-weight" in finding.kept
+    assert finding.lost == ("letter-spacing",)
+    assert "letter-spacing" not in _svg.SLOT_RASTER_PROPS
+
+    vector = chart.style_compatibility_report("svg")
+    finding = _finding(vector, "tick_label", "styles")
+    assert finding.route == pf.ROUTE_SURVIVES
+    assert finding.lost == ()
+    assert "letter-spacing" in _svg.SLOT_TEXT_PROPS
+
+
+def test_pdf_inherits_the_vector_subset() -> None:
+    chart = _chart(styles={"axis_title": {"letter_spacing": "0.1em"}})
+    assert chart.style_compatibility_report("pdf").lossless
+    assert not chart.style_compatibility_report("jpeg").lossless
+
+
+def test_styles_on_a_slot_with_no_native_path_are_named_lost() -> None:
+    report = _chart(styles={"legend_swatch": {"border-radius": "2px"}})
+    report = report.style_compatibility_report("png")
+    finding = _finding(report, "legend_swatch", "styles")
+    assert finding.route == pf.ROUTE_BROWSER_ONLY
+    assert finding.lost == ("border-radius",)
+    assert not report.lossless
+
+
+def test_root_styles_point_at_the_token_bag_channel() -> None:
+    report = _chart(styles={"root": {"background": "#111"}}).style_compatibility_report("png")
+    finding = _finding(report, "root", "styles")
+    assert finding.route == pf.ROUTE_BROWSER_ONLY
+    assert "style=" in finding.detail
+
+
+def test_legend_styles_are_qualified_not_guessed() -> None:
+    # Box properties route through the merged legend declaration; until the
+    # shared IR makes that set a constant, the report qualifies rather than
+    # declaring a loss it cannot prove (or a survival it cannot prove).
+    report = _chart(styles={"legend": {"background": "black"}}).style_compatibility_report("png")
+    finding = _finding(report, "legend", "styles")
+    assert finding.route == pf.ROUTE_SUBSET
+    assert finding.lost == ()
+    assert "merged legend declaration" in finding.detail
+    assert report.lossless
+
+
+def test_state_gated_styles_do_not_block_lossless() -> None:
+    report = _chart(
+        styles={"modebar_button": {"background": "red"}, "crosshair_x": {"opacity": 0.5}}
+    ).style_compatibility_report("png")
+    routes = {f.slot: f.route for f in report.findings}
+    assert routes == {
+        "modebar_button": pf.ROUTE_STATE_GATED,
+        "crosshair_x": pf.ROUTE_STATE_GATED,
+    }
+    assert report.lossless
+
+
+# -- engine interactions -----------------------------------------------------
+
+
+def test_custom_css_routes_auto_to_browser_and_stays_lossless() -> None:
+    report = _chart(class_names={"legend": "x"}).style_compatibility_report(
+        "png", custom_css=".x{}"
+    )
+    assert report.engine == "browser"
+    assert report.lossless
+
+
+def test_refusals_are_mirrored_not_re_decided() -> None:
+    # The export path raises for these; the report carries the same message
+    # instead of predicting a different outcome.
+    pinned = _chart().style_compatibility_report(
+        "png", engine=export.Engine.default, custom_css=".x{}"
+    )
+    assert pinned.error is not None
+    assert not pinned.lossless
+    with pytest.raises(ValueError) as excinfo:
+        export._resolve_image_engine(export.Engine.default, "png", ".x{}")
+    assert pinned.error == str(excinfo.value)
+
+    svg_chromium = _chart().style_compatibility_report("svg", engine=export.Engine.chromium)
+    assert svg_chromium.error is not None
+
+
+# -- report surface ----------------------------------------------------------
+
+
+def test_explain_names_every_route() -> None:
+    text = (
+        _chart(
+            class_names={"legend": "x", "tooltip": "y"},
+            styles={"tick_label": {"letter_spacing": "0.08em"}},
+        )
+        .style_compatibility_report("png")
+        .explain()
+    )
+    assert "browser-only" in text
+    assert "state-gated" in text
+    assert "letter-spacing" in text
+    assert "loss(es)" in text
+
+
+def test_chart_report_is_the_figure_report() -> None:
+    chart = _chart(class_names={"legend": "x"})
+    via_chart = chart.style_compatibility_report("png")
+    via_figure = chart.figure().style_compatibility_report("png")
+    assert via_chart == via_figure
+
+
+def test_every_declared_style_lands_in_exactly_one_route() -> None:
+    # §28 as a property: styled slots partition into survives / subset /
+    # browser-only / state-gated. No styled slot may be absent from the
+    # report, and no route outside the vocabulary may appear.
+    styles = {slot.id: {"font-size": 10} for slot in caps.CHART_SLOTS}
+    report = _chart(styles=styles).style_compatibility_report("png")
+    assert {f.slot for f in report.findings} == {s.id for s in caps.CHART_SLOTS}
+    allowed = {
+        pf.ROUTE_SURVIVES,
+        pf.ROUTE_SUBSET,
+        pf.ROUTE_BROWSER_ONLY,
+        pf.ROUTE_STATE_GATED,
+    }
+    assert {f.route for f in report.findings} <= allowed

From cc0fab7ab2614f923005a3c0a60f5b2b5509982f Mon Sep 17 00:00:00 2001
From: Alek Petuskey <alek@reflex.dev>
Date: Tue, 4 Aug 2026 13:15:30 -0700
Subject: [PATCH 02/27] Stage the styling contract: compatibility= modes and
 the engine collision table
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Every image-export API (to_png, to_svg, to_image, write_image, and the
write_images batch, at chart, figure, and module level) accepts
compatibility=: "legacy" preserves today's behavior exactly, "warn" surfaces
every declaration the export would drop as one StyleCompatibilityWarning,
and "strict" raises StyleCompatibilityError before emission with the full
preflight report attached. "lossless" is reserved and rejected: accepting
the name before Engine.auto can actually re-route on preflight evidence
would make it a lie.

The default path pays one string comparison. The literal-"legacy"
short-circuit returns before the preflight machinery is even imported, and
export's StyleCompatibilityError/Warning aliases resolve through a module
__getattr__, so importing xy.export stays exactly as heavy as it was before
the modes existed (the preflight chain reaches the native library through
the writers' constants — eagerly aliasing it would have added the dylib
load to a module import that never had one). warn/strict pay the routing
walk only when the chart carries class or per-slot declarations and the
engine is native.

Engine selection and compatibility stay orthogonal, and an explicit engine
is a hard constraint: strict refuses on the pinned engine rather than
re-routing to Chromium, a Chromium pin renders the full cascade and gives
every mode nothing to do, and resolution errors (custom_css with a pinned
native engine, Chromium SVG) precede and outrank mode logic in every mode.
A strict batch fails whole while the plan is resolved, before any file is
written. HTML export rejects a non-default mode like the other options it
cannot honor, because a document that renders the full cascade has nothing
to check.

State-gated chrome never trips warn or strict in a clean static export: a
file with no tooltip has dropped nothing by not styling one — the
applicable-slot contract from the preflight change, now enforced rather
than only reported.

spec/process/style-compatibility-migration.md names the release each
default flips in — warn in 0.0.7, strict at the 0.1.0 minor boundary,
legacy removed in 0.2.0 — per the rule that a deprecation window is named
when it opens, not "a future release". Facet grids deliberately do not
accept the option yet rather than half-honoring it; their per-panel
preflight is tracked there too.
---
 CHANGELOG.md                                  |   9 +
 python/xy/_figure.py                          |  15 +-
 python/xy/components.py                       |  23 ++-
 python/xy/export.py                           |  61 +++++-
 python/xy/styling/preflight.py                | 152 ++++++++++++---
 spec/api/export.md                            |   9 +-
 spec/process/style-compatibility-migration.md |  64 +++++++
 tests/test_components.py                      |   4 +
 tests/test_style_compatibility_modes.py       | 173 ++++++++++++++++++
 9 files changed, 479 insertions(+), 31 deletions(-)
 create mode 100644 spec/process/style-compatibility-migration.md
 create mode 100644 tests/test_style_compatibility_modes.py

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 683641b54..995018dec 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,6 +9,15 @@ in the README).
 ## [Unreleased]
 
 ### Added
+- Every image-export API (`to_png`, `to_svg`, `to_image`, `write_image`,
+  `export.write_images`) accepts `compatibility=`: `"legacy"` (default —
+  behavior unchanged), `"warn"` (one `StyleCompatibilityWarning` naming each
+  declaration the export would drop), or `"strict"`
+  (`StyleCompatibilityError` before emission, preflight report attached).
+  Modes never re-route an explicit engine; `"lossless"` is reserved and
+  rejected until preflight routing exists. The default flips only on the
+  published schedule in `spec/process/style-compatibility-migration.md`
+  (warn in 0.0.7, strict in 0.1.0, legacy removed in 0.2.0).
 - `chart.style_compatibility_report(target=..., engine=..., custom_css=...)`:
   a report-only export preflight that routes every declared slot style into
   `survives`, `native-subset` (naming the kept and lost properties per
diff --git a/python/xy/_figure.py b/python/xy/_figure.py
index af80981fa..4c1bde653 100644
--- a/python/xy/_figure.py
+++ b/python/xy/_figure.py
@@ -2241,13 +2241,17 @@ def to_svg(
         *,
         width: Optional[int] = None,
         height: Optional[int] = None,
+        compatibility: str = "legacy",
     ) -> str:
         """Static SVG (_svg.py): a pure-Python render of the same decimated
         payload the browser client consumes — resolution-independent, tiny
         (screen-bounded regardless of source size), and dependency-free.
-        `width`/`height` override the figure's pixel size."""
+        `width`/`height` override the figure's pixel size. `compatibility`
+        stages the styling contract: "warn" surfaces any declaration this
+        vector export would drop, "strict" refuses to drop one."""
         from . import _svg
 
+        export._enforce_compatibility(self, "svg", "native", None, compatibility)
         return _svg.to_svg(self, path, width=width, height=height)
 
     def to_png(
@@ -2262,6 +2266,7 @@ def to_png(
         custom_css: Optional[str] = None,
         sandbox: bool = True,
         gl: str = "software",
+        compatibility: str = "legacy",
     ) -> bytes:
         """Static PNG (export.py). `engine=Engine.default` paints the
         decimated payload with the built-in Rust rasterizer — no browser,
@@ -2283,6 +2288,7 @@ def to_png(
             custom_css=custom_css,
             sandbox=sandbox,
             gl=gl,
+            compatibility=compatibility,
         )
 
     def to_image(
@@ -2299,13 +2305,15 @@ def to_image(
         custom_css: Optional[str] = None,
         sandbox: bool = True,
         gl: str = "software",
+        compatibility: str = "legacy",
     ) -> bytes:
         """Unified static export: PNG/JPEG/WebP/SVG/PDF bytes (export.py).
 
         `engine=Engine.auto` is deterministic — the browser-free native path
         for every format, Chromium only when `custom_css` needs a real CSS
         engine. See `export.to_image` for the format, quality, and background
-        policies."""
+        policies, and `compatibility=` ("legacy"/"warn"/"strict") for the
+        staged styling contract."""
         return export.to_image(
             self,
             format,
@@ -2319,6 +2327,7 @@ def to_image(
             custom_css=custom_css,
             sandbox=sandbox,
             gl=gl,
+            compatibility=compatibility,
         )
 
     def write_image(
@@ -2336,6 +2345,7 @@ def write_image(
         custom_css: Optional[str] = None,
         sandbox: bool = True,
         gl: str = "software",
+        compatibility: str = "legacy",
     ) -> bytes:
         """Atomic file export with extension-inferred format (export.py):
         .png/.jpg/.jpeg/.webp/.svg/.pdf, plus .html routing to `to_html`."""
@@ -2353,6 +2363,7 @@ def write_image(
             custom_css=custom_css,
             sandbox=sandbox,
             gl=gl,
+            compatibility=compatibility,
         )
 
     def memory_report(self) -> dict[str, Any]:
diff --git a/python/xy/components.py b/python/xy/components.py
index cdc3934cf..dcafe490e 100644
--- a/python/xy/components.py
+++ b/python/xy/components.py
@@ -4196,9 +4196,15 @@ def to_svg(
         *,
         width: Optional[int] = None,
         height: Optional[int] = None,
+        compatibility: str = "legacy",
     ) -> str:
-        """A static SVG render of the chart (written to ``path`` if given)."""
-        return self.figure().to_svg(path, width=width, height=height)
+        """A static SVG render of the chart (written to ``path`` if given).
+
+        ``compatibility`` stages the styling contract: ``"warn"`` surfaces
+        any declaration this export would drop, ``"strict"`` refuses to drop
+        one; the default preserves current behavior.
+        """
+        return self.figure().to_svg(path, width=width, height=height, compatibility=compatibility)
 
     def to_png(
         self,
@@ -4212,12 +4218,14 @@ def to_png(
         custom_css: Optional[str] = None,
         sandbox: bool = True,
         gl: str = "software",
+        compatibility: str = "legacy",
     ) -> bytes:
         """A PNG render of the chart, returned as bytes.
 
         ``scale`` multiplies the pixel density; ``engine`` picks the
         raster path (native or headless Chromium). Written to ``path``
-        when given.
+        when given. ``compatibility`` stages the styling contract
+        (``"legacy"``/``"warn"``/``"strict"``).
         """
         return self.figure().to_png(
             path,
@@ -4229,6 +4237,7 @@ def to_png(
             custom_css=custom_css,
             sandbox=sandbox,
             gl=gl,
+            compatibility=compatibility,
         )
 
     def _export_defaults(
@@ -4278,12 +4287,14 @@ def to_image(
         custom_css: Optional[str] = None,
         sandbox: bool = True,
         gl: str = "software",
+        compatibility: str = "legacy",
     ) -> bytes:
         """Unified static export: PNG/JPEG/WebP/SVG/PDF bytes.
 
         Omitted width/height/scale/background/quality fall back to the
         chart's `export_config` defaults; explicit arguments override them.
-        See `export.to_image` for the full format/engine/background policy."""
+        See `export.to_image` for the full format/engine/background policy
+        and `compatibility=` for the staged styling contract."""
         fmt = export._normalize_format(format)
         resolved = export._resolve_image_engine(engine, fmt, custom_css)
         return self.figure().to_image(
@@ -4293,6 +4304,7 @@ def to_image(
             custom_css=custom_css,
             sandbox=sandbox,
             gl=gl,
+            compatibility=compatibility,
             **self._export_defaults(
                 fmt,
                 width,
@@ -4319,6 +4331,7 @@ def write_image(
         custom_css: Optional[str] = None,
         sandbox: bool = True,
         gl: str = "software",
+        compatibility: str = "legacy",
     ) -> bytes:
         """Atomic file export with extension-inferred format (.png/.jpg/
         .jpeg/.webp/.svg/.pdf/.html). `export_config` defaults apply as in
@@ -4356,6 +4369,7 @@ def write_image(
                 custom_css=custom_css,
                 sandbox=sandbox,
                 gl=gl,
+                compatibility=compatibility,
             )
         return self.figure().write_image(
             path,
@@ -4365,6 +4379,7 @@ def write_image(
             custom_css=custom_css,
             sandbox=sandbox,
             gl=gl,
+            compatibility=compatibility,
             **defaults,
         )
 
diff --git a/python/xy/export.py b/python/xy/export.py
index f2f3dec12..dc124292c 100644
--- a/python/xy/export.py
+++ b/python/xy/export.py
@@ -43,6 +43,19 @@ class Engine(StrEnum):
     chromium = "chromium"
 
 
+def __getattr__(name: str) -> object:
+    # StyleCompatibilityError / StyleCompatibilityWarning are catchable from
+    # the module users already import for `Engine`, but resolved lazily: the
+    # preflight chain reaches the native library via the writers' constants,
+    # and importing this module must stay exactly as heavy as it was before
+    # the compatibility modes existed.
+    if name in ("StyleCompatibilityError", "StyleCompatibilityWarning"):
+        from .styling import preflight as _preflight
+
+        return getattr(_preflight, name)
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
 # Warn above this payload size; base64 carries a stated ~33% tax (§29).
 EMBED_WARN_BYTES = 64 * 2**20
 
@@ -649,6 +662,7 @@ def write_images(
     custom_css: Optional[str] = None,
     sandbox: bool = True,
     gl: str = "software",
+    compatibility: str = "legacy",
 ) -> list[bytes]:
     """Export many figures through ONE amortized pipeline (mixed formats OK).
 
@@ -665,7 +679,10 @@ def write_images(
     exactly as in `Chart.to_image`. Writes are atomic per file; on error,
     files already exported remain. Other options match `to_image`; quality
     applies to JPEG and Chromium WebP and is ignored by the other formats
-    (native WebP stays lossless), so mixed batches stay ergonomic."""
+    (native WebP stays lossless), so mixed batches stay ergonomic.
+    `compatibility=` applies per figure while the plan is resolved, so a
+    strict batch refuses whole — before any file is written — rather than
+    after a partial export."""
     if figures is not None:
         if figs is not None:
             raise ValueError("pass figs positionally or figures=, not both")
@@ -709,6 +726,9 @@ def write_images(
             plan.append((fig, path, fmt, "html", {}, None, None))
             continue
         resolved = _resolve_image_engine(engine, fmt, custom_css)
+        # Per figure, up front with the rest of the plan: a strict batch
+        # fails whole before any file is written, never after a partial one.
+        _enforce_compatibility(fig, fmt, resolved, custom_css, compatibility)
         if callable(getattr(obj, "_export_defaults", None)):
             settings = obj._export_defaults(
                 fmt,
@@ -792,6 +812,7 @@ def to_png(
     custom_css: Optional[str] = None,
     sandbox: bool = True,
     gl: str = "software",
+    compatibility: str = "legacy",
 ) -> bytes:
     """Rasterize `fig` to a PNG (bytes, optionally saved).
 
@@ -819,6 +840,7 @@ def to_png(
     optimize = _bool_option(optimize, "PNG optimize")
     sandbox = _bool_option(sandbox, "PNG sandbox")
     resolved_engine = _png_engine(engine)
+    _enforce_compatibility(fig, "png", resolved_engine, custom_css, compatibility)
     if resolved_engine == "native":
         if custom_css is not None:
             raise ValueError("custom_css requires engine=Engine.chromium")
@@ -899,6 +921,35 @@ def _infer_format(path: str | PathLike[str]) -> str:
         ) from None
 
 
+def _enforce_compatibility(
+    fig: "Figure",
+    fmt: str,
+    resolved_engine: str,
+    custom_css: Optional[str],
+    compatibility: str,
+) -> None:
+    """Apply the staged compatibility mode to one already-resolved export.
+
+    The literal-"legacy" short-circuit is the whole performance contract:
+    the default export path does one string comparison and never imports the
+    preflight machinery. Everything else — mode validation, the constant-time
+    unstyled path, warning versus refusing — lives in
+    `styling.preflight.enforce`. Modes never re-route an engine; they decide
+    whether to proceed, warn, or refuse on the engine the caller resolved.
+    """
+    if compatibility == "legacy":
+        return
+    from .styling import preflight as _preflight
+
+    _preflight.enforce(
+        fig,
+        fmt=fmt,
+        resolved_engine=resolved_engine,
+        custom_css=custom_css,
+        compatibility=compatibility,
+    )
+
+
 def _resolve_image_engine(engine: object, fmt: str, custom_css: Optional[str]) -> str:
     """Deterministic engine selection: -> "native" | "browser".
 
@@ -1137,6 +1188,7 @@ def to_image(
     custom_css: Optional[str] = None,
     sandbox: bool = True,
     gl: str = "software",
+    compatibility: str = "legacy",
 ) -> bytes:
     """Render `fig` to image bytes in the requested `format`.
 
@@ -1154,6 +1206,7 @@ def to_image(
     bounded rasters (the documented hybrid-vector policy)."""
     fmt = _normalize_format(format)
     resolved_engine = _resolve_image_engine(engine, fmt, custom_css)
+    _enforce_compatibility(fig, fmt, resolved_engine, custom_css, compatibility)
     quality = _validated_quality(quality, fmt, resolved_engine)
     background = _validated_background(background, fmt)
     w, h = _export_dimensions(fig, width, height)
@@ -1201,6 +1254,7 @@ def write_image(
     custom_css: Optional[str] = None,
     sandbox: bool = True,
     gl: str = "software",
+    compatibility: str = "legacy",
 ) -> bytes:
     """Export `fig` to `path`, inferring the format from the extension.
 
@@ -1221,6 +1275,10 @@ def write_image(
                 ("background", background, None),
                 ("quality", quality, None),
                 ("optimize", optimize, False),
+                # HTML renders the full cascade in the browser — nothing can
+                # drop, so a compatibility mode has nothing to check and is
+                # rejected like the other options that cannot apply.
+                ("compatibility", compatibility, "legacy"),
             )
             if value != default
         ]
@@ -1246,6 +1304,7 @@ def write_image(
         custom_css=custom_css,
         sandbox=sandbox,
         gl=gl,
+        compatibility=compatibility,
     )
     _atomic_write_bytes(path, data)
     return data
diff --git a/python/xy/styling/preflight.py b/python/xy/styling/preflight.py
index d6d3d523a..04d928fed 100644
--- a/python/xy/styling/preflight.py
+++ b/python/xy/styling/preflight.py
@@ -39,6 +39,32 @@
 ROUTE_BROWSER_ONLY = "browser-only"
 ROUTE_STATE_GATED = "state-gated"
 
+#: The staged compatibility modes, in rollout order. `legacy` is today's
+#: behavior and the default; `warn` surfaces every loss as one
+#: `StyleCompatibilityWarning`; `strict` refuses to emit bytes that drop a
+#: declaration. "lossless" is reserved for the phase that lets `Engine.auto`
+#: re-route on preflight evidence — accepting it before that phase would make
+#: the name a lie, so it is rejected now. The default flips on the schedule in
+#: `spec/process/style-compatibility-migration.md`, never silently.
+COMPATIBILITY_MODES: tuple[str, ...] = ("legacy", "warn", "strict")
+
+
+class StyleCompatibilityWarning(UserWarning):
+    """An export in `compatibility="warn"` mode dropped declared styling."""
+
+
+class StyleCompatibilityError(ValueError):
+    """An export in `compatibility="strict"` mode refused to drop styling.
+
+    Carries the full preflight `report`; the message is its `explain()` plus
+    the ways out, so the fix is in the traceback rather than a docs hunt.
+    """
+
+    def __init__(self, message: str, report: StyleCompatibilityReport) -> None:
+        super().__init__(message)
+        self.report = report
+
+
 _RASTER_FORMATS = frozenset({"png", "jpeg", "webp"})
 _VECTOR_FORMATS = frozenset({"svg", "pdf"})
 
@@ -238,39 +264,28 @@ def _styles_finding(slot: str, decls: dict[str, Any], fmt: str) -> SlotFinding:
     )
 
 
-def preflight(
+def route_resolved(
     figure: Figure,
     *,
-    target: str = "png",
-    engine: object = None,
+    fmt: str,
+    resolved_engine: str,
     custom_css: Optional[str] = None,
 ) -> StyleCompatibilityReport:
-    """Route every declared style for one export target, without exporting.
+    """The routing core, for callers that already resolved format and engine.
 
-    `engine` accepts the same values as the export APIs (`Engine`, its string
-    aliases, or None for auto). The report mirrors the export path's actual
-    behavior, including its refusals — it never predicts a different outcome
-    than running the export would produce.
+    The export paths call this with their own resolution result so the
+    resolver (and its deprecation warnings) runs exactly once per export;
+    `preflight()` wraps it with a resolution of its own for standalone use.
     """
-    fmt, resolved, error = _resolve(target, engine, custom_css)
     sources = _sources(figure, custom_css)
-    if error:
-        return StyleCompatibilityReport(
-            target=fmt,
-            engine=resolved,
-            sources=sources,
-            lossless=False,
-            losses=(error,),
-            error=error,
-        )
-    if resolved == "browser":
+    if resolved_engine == "browser":
         # The live client renders the full cascade; nothing can drop.
-        return StyleCompatibilityReport(target=fmt, engine=resolved, sources=sources)
+        return StyleCompatibilityReport(target=fmt, engine=resolved_engine, sources=sources)
     if not (figure.class_names or figure.chrome_styles):
         # The constant-time path: chart-level `style=` and mark/axis `style=`
         # are full in every renderer (see the capability matrix), so with no
         # class or per-slot declarations there is nothing that can drop.
-        return StyleCompatibilityReport(target=fmt, engine=resolved, sources=sources)
+        return StyleCompatibilityReport(target=fmt, engine=resolved_engine, sources=sources)
 
     findings: list[SlotFinding] = []
     for slot in figure.class_names:
@@ -287,7 +302,7 @@ def preflight(
     )
     return StyleCompatibilityReport(
         target=fmt,
-        engine=resolved,
+        engine=resolved_engine,
         sources=sources,
         findings=tuple(findings),
         losses=losses,
@@ -295,12 +310,105 @@ def preflight(
     )
 
 
+def preflight(
+    figure: Figure,
+    *,
+    target: str = "png",
+    engine: object = None,
+    custom_css: Optional[str] = None,
+) -> StyleCompatibilityReport:
+    """Route every declared style for one export target, without exporting.
+
+    `engine` accepts the same values as the export APIs (`Engine`, its string
+    aliases, or None for auto). The report mirrors the export path's actual
+    behavior, including its refusals — it never predicts a different outcome
+    than running the export would produce.
+    """
+    fmt, resolved, error = _resolve(target, engine, custom_css)
+    if error:
+        return StyleCompatibilityReport(
+            target=fmt,
+            engine=resolved,
+            sources=_sources(figure, custom_css),
+            lossless=False,
+            losses=(error,),
+            error=error,
+        )
+    return route_resolved(figure, fmt=fmt, resolved_engine=resolved, custom_css=custom_css)
+
+
+def validate_compatibility(value: object) -> str:
+    """The mode, or a loud error naming the vocabulary (and the reserved word)."""
+    if isinstance(value, str) and value in COMPATIBILITY_MODES:
+        return value
+    if value == "lossless":
+        raise ValueError(
+            'compatibility="lossless" is reserved for the lossless-routing phase '
+            "(spec/process/style-compatibility-migration.md); until it can re-route "
+            f"engines on preflight evidence, pick one of {COMPATIBILITY_MODES}"
+        )
+    raise ValueError(f"compatibility must be one of {COMPATIBILITY_MODES}, got {value!r}")
+
+
+def enforce(
+    figure: Figure,
+    *,
+    fmt: str,
+    resolved_engine: str,
+    custom_css: Optional[str],
+    compatibility: str,
+) -> None:
+    """Apply a compatibility mode to one already-resolved export.
+
+    `legacy` returns before doing anything at all — the default path pays
+    zero. `warn` and `strict` pay the preflight only when the chart carries
+    class or per-slot declarations and the engine is native; a lossless
+    report also returns quietly. Engines are never re-routed here: the mode
+    decides whether to proceed, warn, or refuse — never where to render
+    (spec/process/style-compatibility-migration.md pins that contract).
+    """
+    import warnings
+
+    mode = validate_compatibility(compatibility)
+    if mode == "legacy":
+        return
+    if resolved_engine == "browser" or not (figure.class_names or figure.chrome_styles):
+        return
+    report = route_resolved(figure, fmt=fmt, resolved_engine=resolved_engine, custom_css=custom_css)
+    if report.lossless:
+        return
+    if mode == "warn":
+        warnings.warn(
+            StyleCompatibilityWarning(
+                f"this {fmt} export drops declared styling — "
+                + "; ".join(report.losses)
+                + " — chart.style_compatibility_report() has the full routing; "
+                "engine=Engine.chromium or to_html() keeps everything"
+            ),
+            stacklevel=2,
+        )
+        return
+    raise StyleCompatibilityError(
+        report.explain() + "\nstrict compatibility refuses to drop declared styling; keep it with "
+        "engine=Engine.chromium or to_html(), move it into chart/mark style= or a "
+        'supported styles= subset, or export with compatibility="warn" during '
+        "migration",
+        report,
+    )
+
+
 __all__ = [
+    "COMPATIBILITY_MODES",
     "ROUTE_BROWSER_ONLY",
     "ROUTE_STATE_GATED",
     "ROUTE_SUBSET",
     "ROUTE_SURVIVES",
     "SlotFinding",
+    "StyleCompatibilityError",
     "StyleCompatibilityReport",
+    "StyleCompatibilityWarning",
+    "enforce",
     "preflight",
+    "route_resolved",
+    "validate_compatibility",
 ]
diff --git a/spec/api/export.md b/spec/api/export.md
index 1cf8134a0..5deb2dd90 100644
--- a/spec/api/export.md
+++ b/spec/api/export.md
@@ -263,8 +263,13 @@ into exactly one of four outcomes — `survives`, `native-subset` (with the kept
 and lost property names), `browser-only`, or `state-gated` — and mirrors the
 export path's refusals (`custom_css` with a pinned native engine, Chromium
 SVG) rather than re-deciding them. It is report-only: computing it never
-changes an export. The staged `compatibility=` modes that act on the report
-are a separate, later contract.
+changes an export. The staged `compatibility=` modes act on this report:
+`legacy` (the default — today's behavior, one string comparison of cost),
+`warn` (one `StyleCompatibilityWarning` naming every loss), and `strict`
+(`StyleCompatibilityError` before emission, report attached). `"lossless"`
+is reserved and rejected until preflight routing exists. Modes never
+re-route an explicit engine, and the default only flips on the schedule in
+`spec/process/style-compatibility-migration.md`.
 
 Two properties are load-bearing. First, the report is constant-time when
 there is nothing to route: no `class_names`, no per-slot `styles`, and no
diff --git a/spec/process/style-compatibility-migration.md b/spec/process/style-compatibility-migration.md
new file mode 100644
index 000000000..879ab1ea7
--- /dev/null
+++ b/spec/process/style-compatibility-migration.md
@@ -0,0 +1,64 @@
+# Style-compatibility migration
+
+The staged path from "native exports silently drop `class_names`" to "no
+renderer drops a declaration without saying so" — with the release each step
+ships in named now, so none of them can quietly become permanent. The
+programmatic foundation is `chart.style_compatibility_report()`
+(`spec/api/export.md` §9) and the `compatibility=` export option.
+
+## The modes
+
+| Mode | Behavior | Cost on the unstyled path |
+| --- | --- | --- |
+| `legacy` | Exactly today's behavior: browser-only declarations drop silently from native exports. | One string comparison; the preflight machinery is not even imported. |
+| `warn` | Every export that would drop a declaration emits one `StyleCompatibilityWarning` naming each loss. Bytes are still produced. | Zero for charts with no `class_names`/`styles`/`custom_css` (constant-time early-out). |
+| `strict` | An export that would drop a declaration raises `StyleCompatibilityError` **before emission**, carrying the full preflight report and the ways out. | Same early-out as `warn`. |
+| `lossless` | **Reserved, rejected today.** Arrives with the preflight-routing phase, where `Engine.auto` may choose a different lossless route on report evidence. Accepting the name before the routing exists would make it a lie. | — |
+
+State-gated chrome never trips `warn`/`strict` in a clean static export: a
+file with no tooltip has dropped nothing by not styling one (the
+applicable-slot contract, `spec/api/export.md` §9).
+
+## The engine contract
+
+Engine selection and compatibility are orthogonal, and **an explicit engine
+is a hard constraint — no compatibility mode may re-route it**:
+
+| Request | Behavior |
+| --- | --- |
+| `compatibility="strict"`, explicit engine | Stay on the pinned engine; fail before emission on every unsupported declaration. |
+| `compatibility="warn"` or `"legacy"`, explicit engine | Stay on the pinned engine; warn, or preserve legacy behavior, respectively. |
+| any mode, `engine=Engine.chromium` (or resolved browser) | The live client renders the full cascade; nothing can drop, so the mode has nothing to do. |
+| any mode, `custom_css` with a pinned native engine | Today's `ValueError` fires unchanged — resolution errors precede and outrank mode logic. |
+| future `"lossless"`, `engine=Engine.auto` | Native only when preflight proves lossless; otherwise Chromium where the format supports it; otherwise raise. |
+| future `"lossless"`, pinned engine | Never overridden: raise "cannot satisfy lossless natively; supply a snapshot/stylesheet or unpin the engine." |
+
+`Engine.auto`'s current rule — native for every format, Chromium only when
+`custom_css` needs a real CSS engine — is unchanged until the lossless phase,
+and changing it then requires prominent release notes (speed, determinism,
+dependency, and security posture all shift with an engine).
+
+## The schedule
+
+Pre-1.0, minor versions may break (README stability table); these are the
+concrete releases each default flips in. Moving a step **later** needs only a
+changelog note; moving one **earlier** is a breaking change and needs the
+same notice a breaking release gets.
+
+| Release | Change |
+| --- | --- |
+| 0.0.6 | `compatibility=` ships, default `legacy`. `warn`/`strict` are opt-in. Docs recommend `warn`. |
+| 0.0.7 | Default flips to `warn`: silent drops end. `legacy` silences per call site. |
+| 0.1.0 | Default flips to `strict` at the minor boundary. `warn` and `legacy` remain as opt-outs. |
+| 0.2.0 | `legacy` is **removed** (per the Phase-0 rule that the removal release is named at announcement). `warn` remains indefinitely as the non-fatal mode. |
+| lossless phase | `"lossless"` unreserved once preflight routing exists; `Engine.auto` may then take the lossless route by default, behind its own release note. |
+
+## Out of scope here, tracked
+
+- **Facet grids** keep `legacy` behavior regardless of the option until their
+  per-panel preflight lands; `FacetGrid` export does not accept
+  `compatibility=` yet rather than accepting and half-honoring it.
+- The **resolved-style snapshot** (shared IR) makes the legend slot's
+  declaration-level qualification property-exact; until then `strict` does
+  not fail on legend box properties it cannot prove either way (§28: unsure
+  is said out loud, not rounded to an error).
diff --git a/tests/test_components.py b/tests/test_components.py
index 5e0007cb2..c5fac5a38 100644
--- a/tests/test_components.py
+++ b/tests/test_components.py
@@ -1982,6 +1982,7 @@ def fake_to_png(
         custom_css=None,
         sandbox=True,
         gl="software",
+        compatibility="legacy",
     ):
         seen.update(
             {
@@ -1995,6 +1996,7 @@ def fake_to_png(
                 "custom_css": custom_css,
                 "sandbox": sandbox,
                 "gl": gl,
+                "compatibility": compatibility,
             }
         )
         return b"PNG"
@@ -2011,6 +2013,7 @@ def fake_to_png(
         custom_css=".chart { color: rebeccapurple; }",
         sandbox=False,
         gl="hardware",
+        compatibility="warn",
     )
 
     assert data == b"PNG"
@@ -2025,6 +2028,7 @@ def fake_to_png(
         "custom_css": ".chart { color: rebeccapurple; }",
         "sandbox": False,
         "gl": "hardware",
+        "compatibility": "warn",
     }
 
 
diff --git a/tests/test_style_compatibility_modes.py b/tests/test_style_compatibility_modes.py
new file mode 100644
index 000000000..a3db4f30f
--- /dev/null
+++ b/tests/test_style_compatibility_modes.py
@@ -0,0 +1,173 @@
+"""The staged `compatibility=` modes: legacy is untouched, warn says every
+loss out loud once, strict refuses before emission, and no mode ever
+re-routes an explicit engine (spec/process/style-compatibility-migration.md).
+"""
+
+from __future__ import annotations
+
+import warnings
+
+import pytest
+
+import xy
+from xy import export
+from xy.styling.preflight import (
+    StyleCompatibilityError,
+    StyleCompatibilityWarning,
+    validate_compatibility,
+)
+
+
+def _chart(**props):
+    return xy.scatter_chart(xy.scatter([1.0, 2.0, 3.0], [2.0, 1.0, 3.0]), **props)
+
+
+def _lossy_chart():
+    return _chart(class_names={"legend": "bg-slate-900"})
+
+
+# -- vocabulary --------------------------------------------------------------
+
+
+def test_unknown_modes_fail_loudly_and_lossless_is_reserved() -> None:
+    with pytest.raises(ValueError, match="legacy"):
+        _chart().to_png(compatibility="Legacy")
+    with pytest.raises(ValueError, match="reserved"):
+        _lossy_chart().to_png(compatibility="lossless")
+    # An invalid mode fails even when nothing could drop: vocabulary errors
+    # must not depend on what happens to be styled.
+    with pytest.raises(ValueError, match="compatibility"):
+        _chart().to_png(compatibility="stricted")
+    assert validate_compatibility("warn") == "warn"
+
+
+# -- legacy: byte-identical, zero machinery ----------------------------------
+
+
+def test_legacy_output_is_byte_identical_to_the_default() -> None:
+    chart = _lossy_chart()
+    assert chart.to_png() == chart.to_png(compatibility="legacy")
+    assert chart.to_svg() == chart.to_svg(compatibility="legacy")
+
+
+def test_legacy_never_warns() -> None:
+    with warnings.catch_warnings():
+        warnings.simplefilter("error", StyleCompatibilityWarning)
+        _lossy_chart().to_png()
+        _lossy_chart().to_png(compatibility="legacy")
+
+
+# -- warn --------------------------------------------------------------------
+
+
+def test_warn_names_each_loss_once_and_still_emits_bytes() -> None:
+    with pytest.warns(StyleCompatibilityWarning, match=r"class_names\['legend'\]") as caught:
+        data = _lossy_chart().to_png(compatibility="warn")
+    assert data[:8] == b"\x89PNG\r\n\x1a\n"
+    assert len([w for w in caught if w.category is StyleCompatibilityWarning]) == 1
+
+
+def test_warn_is_silent_when_nothing_drops() -> None:
+    with warnings.catch_warnings():
+        warnings.simplefilter("error", StyleCompatibilityWarning)
+        # Unstyled: the constant-time early-out.
+        _chart().to_png(compatibility="warn")
+        # State-gated only: a clean static file contains no tooltip to lose.
+        _chart(styles={"tooltip": {"color": "red"}}).to_png(compatibility="warn")
+        # Vector keeps the full text subset this declaration uses.
+        _chart(styles={"tick_label": {"letter_spacing": "0.08em"}}).to_svg(compatibility="warn")
+
+
+def test_warn_applies_to_the_vector_writers_too() -> None:
+    with pytest.warns(StyleCompatibilityWarning, match="tick_label"):
+        _chart(styles={"tick_label": {"letter_spacing": "0.08em"}}).to_png(compatibility="warn")
+
+
+# -- strict ------------------------------------------------------------------
+
+
+def test_strict_refuses_before_emission_with_the_report_attached(tmp_path) -> None:
+    target = tmp_path / "chart.png"
+    with pytest.raises(StyleCompatibilityError) as excinfo:
+        _lossy_chart().write_image(target, compatibility="strict")
+    assert not target.exists(), "strict must fail before any bytes are written"
+    report = excinfo.value.report
+    assert not report.lossless
+    assert any(f.slot == "legend" for f in report.findings)
+    assert "chromium" in str(excinfo.value).lower()
+
+
+def test_strict_passes_lossless_exports_untouched() -> None:
+    chart = _chart(styles={"title": {"font-size": 18}})
+    assert chart.to_png(compatibility="strict") == chart.to_png()
+    assert chart.to_svg(compatibility="strict") == chart.to_svg()
+
+
+def test_strict_batch_fails_whole_before_any_file(tmp_path) -> None:
+    clean, lossy = _chart(), _lossy_chart()
+    paths = [tmp_path / "a.png", tmp_path / "b.png"]
+    with pytest.raises(StyleCompatibilityError):
+        export.write_images([clean, lossy], [str(p) for p in paths], compatibility="strict")
+    assert not any(p.exists() for p in paths)
+
+
+# -- the engine contract -----------------------------------------------------
+
+
+def test_no_mode_reroutes_an_explicit_engine() -> None:
+    # Chromium pin + lossy styling: the browser renders the cascade, so every
+    # mode proceeds without warning or error — and none of them may fall back
+    # to native. Native pin + lossy styling: strict refuses rather than
+    # re-routing to Chromium.
+    chart = _lossy_chart()
+    if export.find_chromium() is not None:
+        with warnings.catch_warnings():
+            warnings.simplefilter("error", StyleCompatibilityWarning)
+            data = chart.to_png(engine=export.Engine.chromium, compatibility="strict")
+        assert data[:8] == b"\x89PNG\r\n\x1a\n"
+    with pytest.raises(StyleCompatibilityError):
+        chart.to_png(engine=export.Engine.default, compatibility="strict")
+
+
+def test_resolution_errors_precede_and_outrank_mode_logic() -> None:
+    # custom_css with a pinned native engine raises today's ValueError in
+    # every mode — never a StyleCompatibilityError, never a silent re-route.
+    for mode in ("legacy", "warn", "strict"):
+        with pytest.raises(ValueError, match="custom_css requires"):
+            _chart().to_png(engine=export.Engine.default, custom_css=".x{}", compatibility=mode)
+
+
+def test_auto_with_custom_css_is_lossless_in_every_mode() -> None:
+    if export.find_chromium() is None:
+        pytest.skip("Chromium unavailable")
+    chart = _lossy_chart()
+    with warnings.catch_warnings():
+        warnings.simplefilter("error", StyleCompatibilityWarning)
+        data = chart.to_image("png", custom_css=".x{}", compatibility="strict")
+    assert data[:8] == b"\x89PNG\r\n\x1a\n"
+
+
+# -- routing symmetry --------------------------------------------------------
+
+
+def test_every_image_entry_point_honors_the_mode(tmp_path) -> None:
+    chart = _lossy_chart()
+    with pytest.raises(StyleCompatibilityError):
+        chart.to_image("jpeg", compatibility="strict")
+    with pytest.raises(StyleCompatibilityError):
+        chart.to_svg(compatibility="strict")
+    with pytest.raises(StyleCompatibilityError):
+        chart.figure().write_image(tmp_path / "x.pdf", compatibility="strict")
+    with pytest.raises(StyleCompatibilityError):
+        export.to_png(chart.figure(), compatibility="strict")
+
+
+def test_html_rejects_a_compatibility_mode_like_other_inapplicable_options(
+    tmp_path,
+) -> None:
+    # HTML renders the full cascade; there is nothing for a mode to check, so
+    # write_image treats it like the other options HTML cannot honor.
+    with pytest.raises(ValueError, match="compatibility"):
+        _chart().write_image(tmp_path / "chart.html", compatibility="strict")
+    # The default passes through untouched.
+    _chart().write_image(tmp_path / "chart2.html")

From 0b97ae5407ce1fb996a4a93cbd4f6afb028a9d4a Mon Sep 17 00:00:00 2001
From: Alek Petuskey <alek@reflex.dev>
Date: Tue, 4 Aug 2026 13:27:06 -0700
Subject: [PATCH 03/27] Land the ResolvedStyleSnapshot: schema v1, interned,
 with a generated TS mirror
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

python/xy/styling/resolved.py defines the renderer-neutral styling IR the
compatibility program converges on: authored styling arrives from five
mechanisms and (soon) two resolvers, and renderers should consume exactly
one shape regardless of where it came from. Three contract properties, each
enforced at construction on both ends of the eventual wire:

Concrete values only. No var()/calc()/env()/inherit and no relative units:
a value that still depends on a cascade, or on metrics the consumer would
have to re-derive, is rejected loudly with the reason (§28). One unresolved
value smuggled into the IR would re-create exactly the per-renderer
divergence the IR exists to end.

Interned declarations. A snapshot stores each distinct declaration once;
instances reference it by index and carry only identity qualifiers
(e.g. ["y","major","3"]), resolved geometry, and content. Interning is
canonicalized, so a builder fed the same styling in any order emits the
same snapshot. The dense-axis fixture (400 tick labels + 60 legend rows =
460 instances, 2 declarations) serializes to ~38.6 KB against the spec's
50 KB uncompressed budget, and the test states the headroom so eating it
is a visible decision.

Closed vocabulary per version. Schema v1's property list (paint,
typography, layout, effects) is a generated constant in both languages;
growing it is a STYLE_SNAPSHOT_VERSION bump, so a snapshot's vocabulary is
always recoverable from its version field. snapshot_from_payload refuses
versions it does not know rather than guessing.

js/src/14_style_snapshot.ts is the TypeScript mirror, rendered by
scripts/gen_style_snapshot_types.py from the Python module — one schema,
two languages, and the suite runs --check so the committed mirror cannot
drift (the gen_capability_matrix.py contract, applied to types). The
client build typechecks it; nothing imports it yet.

Nothing rides the wire in this change, so PROTOCOL_VERSION stays at 12.
wire-protocol.md gains §8 documenting the payload shape and reserving the
style_snapshot_request / style_snapshot message names for the capture
change, which bumps the protocol and carries this schema as its reply.
---
 CHANGELOG.md                          |   7 +
 js/src/14_style_snapshot.ts           | 105 +++++++
 python/xy/styling/__init__.py         |   8 +-
 python/xy/styling/resolved.py         | 402 ++++++++++++++++++++++++++
 scripts/gen_style_snapshot_types.py   | 136 +++++++++
 spec/design/wire-protocol.md          |  51 ++++
 tests/test_resolved_style_snapshot.py | 209 +++++++++++++
 7 files changed, 916 insertions(+), 2 deletions(-)
 create mode 100644 js/src/14_style_snapshot.ts
 create mode 100644 python/xy/styling/resolved.py
 create mode 100644 scripts/gen_style_snapshot_types.py
 create mode 100644 tests/test_resolved_style_snapshot.py

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 995018dec..85aeb1a07 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,6 +9,13 @@ in the README).
 ## [Unreleased]
 
 ### Added
+- The renderer-neutral styling IR: `xy.styling.resolved` defines the
+  versioned, interned `ResolvedStyleSnapshot` (schema v1 — concrete values
+  only, declarations deduped, instances referencing them by index), with a
+  generated TypeScript mirror (`js/src/14_style_snapshot.ts`) that the test
+  suite pins to the Python schema. Wire shape and reserved message names:
+  `spec/design/wire-protocol.md` §8; nothing rides the wire yet, so
+  `PROTOCOL_VERSION` is unchanged.
 - Every image-export API (`to_png`, `to_svg`, `to_image`, `write_image`,
   `export.write_images`) accepts `compatibility=`: `"legacy"` (default —
   behavior unchanged), `"warn"` (one `StyleCompatibilityWarning` naming each
diff --git a/js/src/14_style_snapshot.ts b/js/src/14_style_snapshot.ts
new file mode 100644
index 000000000..4f1755410
--- /dev/null
+++ b/js/src/14_style_snapshot.ts
@@ -0,0 +1,105 @@
+// @generated by scripts/gen_style_snapshot_types.py — do not edit by hand.
+//
+// The TypeScript mirror of `python/xy/styling/resolved.py` (schema v1).
+// Concrete values only: no var()/calc(), no relative units — the Python
+// side rejects them at construction and the capture side must never
+// produce them. Wire shape: spec/design/wire-protocol.md §8.
+
+export const STYLE_SNAPSHOT_VERSION = 1 as const;
+
+export const STYLE_SNAPSHOT_PAINT_PROPERTIES = [
+  "color",
+  "fill",
+  "background",
+  "background-image",
+  "opacity",
+  "fill-opacity",
+  "stroke",
+  "stroke-opacity",
+  "stroke-width",
+  "border-color",
+  "border-style",
+  "border-width",
+  "border-radius",
+  "box-shadow",
+] as const;
+
+export const STYLE_SNAPSHOT_TYPOGRAPHY_PROPERTIES = [
+  "font-family",
+  "font-size",
+  "font-style",
+  "font-weight",
+  "letter-spacing",
+  "line-height",
+  "text-align",
+  "xy-rotation",
+] as const;
+
+export const STYLE_SNAPSHOT_LAYOUT_PROPERTIES = [
+  "padding-top",
+  "padding-right",
+  "padding-bottom",
+  "padding-left",
+  "gap",
+  "width",
+  "height",
+  "max-width",
+  "max-height",
+  "transform",
+  "clip-path",
+] as const;
+
+export const STYLE_SNAPSHOT_EFFECT_PROPERTIES = [
+  "filter",
+  "mix-blend-mode",
+  "isolation",
+  "mask",
+] as const;
+
+export const STYLE_SNAPSHOT_PROPERTIES = [
+  ...STYLE_SNAPSHOT_PAINT_PROPERTIES,
+  ...STYLE_SNAPSHOT_TYPOGRAPHY_PROPERTIES,
+  ...STYLE_SNAPSHOT_LAYOUT_PROPERTIES,
+  ...STYLE_SNAPSHOT_EFFECT_PROPERTIES,
+] as const;
+
+export type StyleSnapshotProperty = (typeof STYLE_SNAPSHOT_PROPERTIES)[number];
+
+/** One interned declaration: resolved property -> concrete value. */
+export type ResolvedDeclaration = Partial<
+  Record<StyleSnapshotProperty, string | number>
+>;
+
+/** One styled slot occurrence; `d` indexes the snapshot's declarations.
+ * Instance keys are one-letter on the wire because instances are the
+ * part that repeats with chart density (spec §8). */
+export interface StyleSnapshotInstance {
+  /** slot name (a `data-xy-slot` value) */
+  s: string;
+  /** declaration index into `declarations` */
+  d: number;
+  /** stable identity beyond the slot name, e.g. ["y", "major", "3"] */
+  q?: readonly string[];
+  /** resolved box in CSS px: [x, y, w, h] */
+  g?: readonly [number, number, number, number];
+  /** drawn text, when the slot has any */
+  c?: string;
+}
+
+export interface StyleSnapshotEnvironment {
+  width: number;
+  height: number;
+  dpr: number;
+  color_scheme: "light" | "dark";
+}
+
+export interface ResolvedStyleSnapshot {
+  version: 1;
+  style_epoch: number;
+  environment: StyleSnapshotEnvironment;
+  tokens: Record<string, string | number>;
+  states: readonly string[];
+  unrepresentable: readonly string[];
+  declarations: readonly ResolvedDeclaration[];
+  instances: readonly StyleSnapshotInstance[];
+}
diff --git a/python/xy/styling/__init__.py b/python/xy/styling/__init__.py
index 5d71f30d3..6020fd65c 100644
--- a/python/xy/styling/__init__.py
+++ b/python/xy/styling/__init__.py
@@ -8,10 +8,14 @@
 `preflight` applies that inventory to one concrete chart and export target:
 `chart.style_compatibility_report()` routes every declared style and names
 what would not survive, before any bytes exist.
+
+`resolved` is the renderer-neutral styling IR those two converge on: the
+versioned, interned `ResolvedStyleSnapshot` of concrete values that every
+resolver produces and every renderer consumes.
 """
 
 from __future__ import annotations
 
-from . import capabilities, preflight
+from . import capabilities, preflight, resolved
 
-__all__ = ["capabilities", "preflight"]
+__all__ = ["capabilities", "preflight", "resolved"]
diff --git a/python/xy/styling/resolved.py b/python/xy/styling/resolved.py
new file mode 100644
index 000000000..cf4d4261f
--- /dev/null
+++ b/python/xy/styling/resolved.py
@@ -0,0 +1,402 @@
+"""The `ResolvedStyleSnapshot`: one interned styling IR between every source
+and every renderer.
+
+Authored styling arrives from five mechanisms and two resolvers (the Python
+style compiler today, the browser's computed-style capture next); renderers
+should consume exactly one shape regardless of where it came from. That shape
+is this module: **concrete values only** — a resolved color, a pixel length,
+a settled font descriptor — never a `var()`, a `calc()`, an `em`, or anything
+else whose meaning depends on a document the renderer does not have. A value
+that still needs resolving is rejected loudly at construction (§28), because
+a snapshot that smuggles one unresolved value re-creates in the IR the exact
+per-renderer divergence the IR exists to end.
+
+Declarations are **interned**: a snapshot stores each distinct declaration
+once and instances reference it by index, so four hundred tick labels styled
+alike cost one declaration plus four hundred three-item instances — the
+size/capture budgets in the spec assume this, and
+`tests/test_resolved_style_snapshot.py` enforces it with a dense-axis
+fixture.
+
+The schema is versioned independently of the wire protocol
+(`STYLE_SNAPSHOT_VERSION`): nothing here rides the wire yet, so
+`PROTOCOL_VERSION` does not bump — the capture/transport change bumps it,
+carrying this schema as its payload (`spec/design/wire-protocol.md` §8).
+`scripts/gen_style_snapshot_types.py` renders the TypeScript mirror from
+this module, and the test suite fails when the two drift.
+"""
+
+from __future__ import annotations
+
+import json
+import math
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass, field
+from typing import Any, Optional
+
+from ..dom import CHART_DOM_SLOTS
+
+#: Bumped when the schema's shape or vocabulary changes. A consumer that sees
+#: a version it does not know must refuse, not guess.
+STYLE_SNAPSHOT_VERSION = 1
+
+#: The closed property vocabulary of schema v1, grouped the way the renderers
+#: consume it. Growing this list IS a schema change: add the property AND
+#: bump `STYLE_SNAPSHOT_VERSION`, so a snapshot's vocabulary is always
+#: recoverable from its version field alone. Names are kebab-case CSS except
+#: the `xy-` prefixed ones, which have no CSS spelling (rotation).
+PAINT_PROPERTIES_V1: tuple[str, ...] = (
+    "color",
+    "fill",
+    "background",
+    "background-image",
+    "opacity",
+    "fill-opacity",
+    "stroke",
+    "stroke-opacity",
+    "stroke-width",
+    "border-color",
+    "border-style",
+    "border-width",
+    "border-radius",
+    "box-shadow",
+)
+
+TYPOGRAPHY_PROPERTIES_V1: tuple[str, ...] = (
+    "font-family",
+    "font-size",
+    "font-style",
+    "font-weight",
+    "letter-spacing",
+    "line-height",
+    "text-align",
+    "xy-rotation",
+)
+
+LAYOUT_PROPERTIES_V1: tuple[str, ...] = (
+    "padding-top",
+    "padding-right",
+    "padding-bottom",
+    "padding-left",
+    "gap",
+    "width",
+    "height",
+    "max-width",
+    "max-height",
+    "transform",
+    "clip-path",
+)
+
+EFFECT_PROPERTIES_V1: tuple[str, ...] = (
+    "filter",
+    "mix-blend-mode",
+    "isolation",
+    "mask",
+)
+
+PROPERTIES_V1: tuple[str, ...] = (
+    PAINT_PROPERTIES_V1 + TYPOGRAPHY_PROPERTIES_V1 + LAYOUT_PROPERTIES_V1 + EFFECT_PROPERTIES_V1
+)
+
+_PROPERTY_SET = frozenset(PROPERTIES_V1)
+
+#: Constructs whose value depends on a document, a cascade, or an
+#: environment the renderer does not have. Their presence means the value is
+#: not resolved, whatever else it looks like.
+_UNRESOLVED_MARKERS: tuple[str, ...] = ("var(", "calc(", "env(", "attr(", "inherit", "unset")
+
+#: Length units a *resolved* value may not carry: every one is relative to
+#: font metrics or viewport the consumer would have to re-derive. Resolved
+#: lengths are plain numbers (CSS px).
+_RELATIVE_UNITS: tuple[str, ...] = ("em", "rem", "ex", "ch", "vw", "vh", "vmin", "vmax", "%")
+
+_COLOR_SCHEMES = frozenset({"light", "dark"})
+
+
+def assert_resolved(prop: str, value: object) -> str | float:
+    """A schema-v1 value, or a loud error saying exactly why it is not one.
+
+    Numbers pass as finite floats. Strings pass unless they carry an
+    unresolved construct or end in a relative unit — the two ways a value can
+    quietly mean something different in the consumer than it did in the
+    source. There is no silent coercion in either direction.
+    """
+    if prop not in _PROPERTY_SET:
+        raise ValueError(
+            f"{prop!r} is not in the schema-v{STYLE_SNAPSHOT_VERSION} vocabulary; "
+            "growing the vocabulary is a schema change (bump STYLE_SNAPSHOT_VERSION)"
+        )
+    if isinstance(value, bool) or not isinstance(value, (int, float, str)):
+        raise ValueError(f"{prop}: resolved values are numbers or strings, got {value!r}")
+    if isinstance(value, (int, float)):
+        number = float(value)
+        if not math.isfinite(number):
+            raise ValueError(f"{prop}: resolved numbers must be finite, got {value!r}")
+        return number
+    text = value.strip()
+    if not text:
+        raise ValueError(f"{prop}: a resolved value cannot be empty")
+    lowered = text.lower()
+    for marker in _UNRESOLVED_MARKERS:
+        if marker in lowered:
+            raise ValueError(
+                f"{prop}: {text!r} still depends on a cascade the renderer does not "
+                f"have ({marker.rstrip('(')}); resolve it before it enters the snapshot"
+            )
+    for unit in _RELATIVE_UNITS:
+        if (
+            lowered.endswith(unit)
+            and lowered[: -len(unit)].replace(".", "", 1).lstrip("+-").isdigit()
+        ):
+            raise ValueError(
+                f"{prop}: {text!r} is relative to metrics the consumer would have to "
+                "re-derive; resolved lengths are plain numbers in CSS px"
+            )
+    return text
+
+
+@dataclass(frozen=True)
+class SlotInstance:
+    """One styled occurrence of a slot, referencing an interned declaration.
+
+    `qualifiers` is the stable identity beyond the slot name — for example
+    `("y", "major", "3")` for a tick label — so repeated chrome keeps
+    per-instance identity while sharing one declaration. `geometry` is the
+    resolved box in CSS px `(x, y, w, h)` when the producer knows it;
+    `content` is the drawn text when the slot has any.
+    """
+
+    slot: str
+    declaration: int
+    qualifiers: tuple[str, ...] = ()
+    geometry: Optional[tuple[float, float, float, float]] = None
+    content: Optional[str] = None
+
+
+@dataclass(frozen=True)
+class SnapshotEnvironment:
+    """What the values were resolved against; part of every cache key."""
+
+    width: float
+    height: float
+    dpr: float = 1.0
+    color_scheme: str = "light"
+
+
+@dataclass(frozen=True)
+class ResolvedStyleSnapshot:
+    """A complete, renderer-neutral styling result for one chart state."""
+
+    environment: SnapshotEnvironment
+    declarations: tuple[dict[str, str | float], ...] = ()
+    instances: tuple[SlotInstance, ...] = ()
+    tokens: dict[str, str | float] = field(default_factory=dict)
+    states: tuple[str, ...] = ()
+    unrepresentable: tuple[str, ...] = ()
+    style_epoch: int = 0
+    version: int = STYLE_SNAPSHOT_VERSION
+
+    def to_payload(self) -> dict[str, Any]:
+        """The JSON-safe wire shape (`spec/design/wire-protocol.md` §8).
+
+        Snapshot-level keys are spelled out; the per-instance keys are the
+        one-letter spellings the spec documents, because instances are the
+        part that repeats with chart density.
+        """
+        return {
+            "version": self.version,
+            "style_epoch": self.style_epoch,
+            "environment": {
+                "width": self.environment.width,
+                "height": self.environment.height,
+                "dpr": self.environment.dpr,
+                "color_scheme": self.environment.color_scheme,
+            },
+            "tokens": dict(self.tokens),
+            "states": list(self.states),
+            "unrepresentable": list(self.unrepresentable),
+            "declarations": [dict(decl) for decl in self.declarations],
+            "instances": [
+                {
+                    "s": inst.slot,
+                    "d": inst.declaration,
+                    **({"q": list(inst.qualifiers)} if inst.qualifiers else {}),
+                    **({"g": list(inst.geometry)} if inst.geometry is not None else {}),
+                    **({"c": inst.content} if inst.content is not None else {}),
+                }
+                for inst in self.instances
+            ],
+        }
+
+    def payload_bytes(self) -> int:
+        """Uncompressed serialized size — what the spec's 50 KB budget meters."""
+        return len(json.dumps(self.to_payload(), separators=(",", ":")).encode("utf-8"))
+
+
+class SnapshotBuilder:
+    """Interning constructor: identical declarations share one record.
+
+    The producer calls `add(slot, declaration, ...)` per styled instance and
+    `build(...)` once; canonicalization (sorted property order) makes
+    interning independent of declaration insertion order, so a builder fed
+    the same styling in any order emits the same snapshot.
+    """
+
+    def __init__(self) -> None:
+        self._declarations: list[dict[str, str | float]] = []
+        self._index: dict[tuple[tuple[str, str | float], ...], int] = {}
+        self._instances: list[SlotInstance] = []
+
+    def intern(self, declaration: Mapping[str, object]) -> int:
+        """The index for this declaration, adding it only if it is new."""
+        if not declaration:
+            raise ValueError("an empty declaration styles nothing; do not intern it")
+        resolved = {prop: assert_resolved(prop, value) for prop, value in declaration.items()}
+        key = tuple(sorted(resolved.items()))
+        found = self._index.get(key)
+        if found is not None:
+            return found
+        self._index[key] = len(self._declarations)
+        self._declarations.append(dict(sorted(resolved.items())))
+        return self._index[key]
+
+    def add(
+        self,
+        slot: str,
+        declaration: Mapping[str, object],
+        *,
+        qualifiers: Sequence[str] = (),
+        geometry: Optional[Sequence[float]] = None,
+        content: Optional[str] = None,
+    ) -> int:
+        """Record one styled slot instance; returns its declaration index."""
+        if slot not in CHART_DOM_SLOTS:
+            raise ValueError(f"unknown slot {slot!r}; expected one of CHART_DOM_SLOTS")
+        geom: Optional[tuple[float, float, float, float]] = None
+        if geometry is not None:
+            values = tuple(float(v) for v in geometry)
+            if len(values) != 4 or not all(math.isfinite(v) for v in values):
+                raise ValueError(f"geometry must be four finite numbers (x, y, w, h): {geometry!r}")
+            geom = values
+        index = self.intern(declaration)
+        self._instances.append(
+            SlotInstance(
+                slot=slot,
+                declaration=index,
+                qualifiers=tuple(str(q) for q in qualifiers),
+                geometry=geom,
+                content=content,
+            )
+        )
+        return index
+
+    def build(
+        self,
+        environment: SnapshotEnvironment,
+        *,
+        tokens: Optional[Mapping[str, object]] = None,
+        states: Sequence[str] = (),
+        unrepresentable: Sequence[str] = (),
+        style_epoch: int = 0,
+    ) -> ResolvedStyleSnapshot:
+        if environment.color_scheme not in _COLOR_SCHEMES:
+            raise ValueError(f"color_scheme must be one of {sorted(_COLOR_SCHEMES)}")
+        resolved_tokens = {
+            str(name): assert_resolved_token(name, value) for name, value in (tokens or {}).items()
+        }
+        return ResolvedStyleSnapshot(
+            environment=environment,
+            declarations=tuple(self._declarations),
+            instances=tuple(self._instances),
+            tokens=resolved_tokens,
+            states=tuple(str(s) for s in states),
+            unrepresentable=tuple(str(u) for u in unrepresentable),
+            style_epoch=int(style_epoch),
+        )
+
+
+def assert_resolved_token(name: object, value: object) -> str | float:
+    """Chart tokens carry open names but the same resolved-value contract."""
+    if isinstance(value, bool) or not isinstance(value, (int, float, str)):
+        raise ValueError(f"token {name!r}: resolved values are numbers or strings, got {value!r}")
+    if isinstance(value, (int, float)):
+        number = float(value)
+        if not math.isfinite(number):
+            raise ValueError(f"token {name!r}: resolved numbers must be finite")
+        return number
+    lowered = value.lower()
+    for marker in _UNRESOLVED_MARKERS:
+        if marker in lowered:
+            raise ValueError(
+                f"token {name!r}: {value!r} still depends on a cascade "
+                f"({marker.rstrip('(')}); resolve it before it enters the snapshot"
+            )
+    return value
+
+
+def snapshot_from_payload(payload: Mapping[str, Any]) -> ResolvedStyleSnapshot:
+    """The inverse of `to_payload`, refusing versions it does not know."""
+    version = payload.get("version")
+    if version != STYLE_SNAPSHOT_VERSION:
+        raise ValueError(
+            f"style snapshot version {version!r} is not supported "
+            f"(this build reads v{STYLE_SNAPSHOT_VERSION}); refusing to guess"
+        )
+    env = payload["environment"]
+    declarations = [
+        {prop: assert_resolved(prop, value) for prop, value in decl.items()}
+        for decl in payload.get("declarations", ())
+    ]
+    instances = []
+    for raw in payload.get("instances", ()):
+        index = raw["d"]
+        if not isinstance(index, int) or not 0 <= index < len(declarations):
+            raise ValueError(f"instance {raw!r} references declaration {index!r}, which is absent")
+        geometry: Optional[tuple[float, float, float, float]] = None
+        if "g" in raw:
+            values = tuple(float(v) for v in raw["g"])
+            if len(values) != 4 or not all(math.isfinite(v) for v in values):
+                raise ValueError(f"instance {raw!r} geometry must be four finite numbers")
+            geometry = values
+        if raw["s"] not in CHART_DOM_SLOTS:
+            raise ValueError(f"instance {raw!r} names unknown slot {raw['s']!r}")
+        instances.append(
+            SlotInstance(
+                slot=raw["s"],
+                declaration=index,
+                qualifiers=tuple(str(q) for q in raw.get("q", ())),
+                geometry=geometry,
+                content=raw.get("c"),
+            )
+        )
+    return ResolvedStyleSnapshot(
+        environment=SnapshotEnvironment(
+            width=float(env["width"]),
+            height=float(env["height"]),
+            dpr=float(env.get("dpr", 1.0)),
+            color_scheme=str(env.get("color_scheme", "light")),
+        ),
+        declarations=tuple(dict(d) for d in declarations),
+        instances=tuple(instances),
+        tokens=dict(payload.get("tokens", {})),
+        states=tuple(payload.get("states", ())),
+        unrepresentable=tuple(payload.get("unrepresentable", ())),
+        style_epoch=int(payload.get("style_epoch", 0)),
+    )
+
+
+__all__ = [
+    "EFFECT_PROPERTIES_V1",
+    "LAYOUT_PROPERTIES_V1",
+    "PAINT_PROPERTIES_V1",
+    "PROPERTIES_V1",
+    "STYLE_SNAPSHOT_VERSION",
+    "TYPOGRAPHY_PROPERTIES_V1",
+    "ResolvedStyleSnapshot",
+    "SlotInstance",
+    "SnapshotBuilder",
+    "SnapshotEnvironment",
+    "assert_resolved",
+    "assert_resolved_token",
+    "snapshot_from_payload",
+]
diff --git a/scripts/gen_style_snapshot_types.py b/scripts/gen_style_snapshot_types.py
new file mode 100644
index 000000000..751e7a998
--- /dev/null
+++ b/scripts/gen_style_snapshot_types.py
@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+"""Generate `js/src/14_style_snapshot.ts` from `xy.styling.resolved`.
+
+One schema, two languages, zero drift: the Python module is the source of
+truth, this script renders the TypeScript mirror, and
+`tests/test_resolved_style_snapshot.py` runs `--check` so a committed mirror
+that falls behind the schema fails the suite — the same contract
+`gen_capability_matrix.py` established for the capability documents.
+
+    uv run python scripts/gen_style_snapshot_types.py --write
+    uv run python scripts/gen_style_snapshot_types.py --check
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT / "python"))
+
+from xy.styling import resolved  # noqa: E402
+
+TARGET = ROOT / "js" / "src" / "14_style_snapshot.ts"
+
+
+def _const_list(name: str, values: tuple[str, ...]) -> list[str]:
+    lines = [f"export const {name} = ["]
+    lines += [f'  "{value}",' for value in values]
+    lines.append("] as const;")
+    return lines
+
+
+def render() -> str:
+    lines = [
+        "// @generated by scripts/gen_style_snapshot_types.py — do not edit by hand.",
+        "//",
+        "// The TypeScript mirror of `python/xy/styling/resolved.py` (schema "
+        f"v{resolved.STYLE_SNAPSHOT_VERSION}).",
+        "// Concrete values only: no var()/calc(), no relative units — the Python",
+        "// side rejects them at construction and the capture side must never",
+        "// produce them. Wire shape: spec/design/wire-protocol.md §8.",
+        "",
+        f"export const STYLE_SNAPSHOT_VERSION = {resolved.STYLE_SNAPSHOT_VERSION} as const;",
+        "",
+    ]
+    lines += _const_list("STYLE_SNAPSHOT_PAINT_PROPERTIES", resolved.PAINT_PROPERTIES_V1)
+    lines.append("")
+    lines += _const_list("STYLE_SNAPSHOT_TYPOGRAPHY_PROPERTIES", resolved.TYPOGRAPHY_PROPERTIES_V1)
+    lines.append("")
+    lines += _const_list("STYLE_SNAPSHOT_LAYOUT_PROPERTIES", resolved.LAYOUT_PROPERTIES_V1)
+    lines.append("")
+    lines += _const_list("STYLE_SNAPSHOT_EFFECT_PROPERTIES", resolved.EFFECT_PROPERTIES_V1)
+    lines += [
+        "",
+        "export const STYLE_SNAPSHOT_PROPERTIES = [",
+        "  ...STYLE_SNAPSHOT_PAINT_PROPERTIES,",
+        "  ...STYLE_SNAPSHOT_TYPOGRAPHY_PROPERTIES,",
+        "  ...STYLE_SNAPSHOT_LAYOUT_PROPERTIES,",
+        "  ...STYLE_SNAPSHOT_EFFECT_PROPERTIES,",
+        "] as const;",
+        "",
+        "export type StyleSnapshotProperty = (typeof STYLE_SNAPSHOT_PROPERTIES)[number];",
+        "",
+        "/** One interned declaration: resolved property -> concrete value. */",
+        "export type ResolvedDeclaration = Partial<",
+        "  Record<StyleSnapshotProperty, string | number>",
+        ">;",
+        "",
+        "/** One styled slot occurrence; `d` indexes the snapshot's declarations.",
+        " * Instance keys are one-letter on the wire because instances are the",
+        " * part that repeats with chart density (spec §8). */",
+        "export interface StyleSnapshotInstance {",
+        "  /** slot name (a `data-xy-slot` value) */",
+        "  s: string;",
+        "  /** declaration index into `declarations` */",
+        "  d: number;",
+        '  /** stable identity beyond the slot name, e.g. ["y", "major", "3"] */',
+        "  q?: readonly string[];",
+        "  /** resolved box in CSS px: [x, y, w, h] */",
+        "  g?: readonly [number, number, number, number];",
+        "  /** drawn text, when the slot has any */",
+        "  c?: string;",
+        "}",
+        "",
+        "export interface StyleSnapshotEnvironment {",
+        "  width: number;",
+        "  height: number;",
+        "  dpr: number;",
+        '  color_scheme: "light" | "dark";',
+        "}",
+        "",
+        "export interface ResolvedStyleSnapshot {",
+        f"  version: {resolved.STYLE_SNAPSHOT_VERSION};",
+        "  style_epoch: number;",
+        "  environment: StyleSnapshotEnvironment;",
+        "  tokens: Record<string, string | number>;",
+        "  states: readonly string[];",
+        "  unrepresentable: readonly string[];",
+        "  declarations: readonly ResolvedDeclaration[];",
+        "  instances: readonly StyleSnapshotInstance[];",
+        "}",
+        "",
+    ]
+    return "\n".join(lines)
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--write", action="store_true", help="regenerate the committed mirror")
+    parser.add_argument("--check", action="store_true", help="fail if the mirror is stale")
+    args = parser.parse_args(argv)
+
+    document = render()
+    if args.write:
+        TARGET.write_text(document, encoding="utf-8")
+        print(f"wrote {TARGET.relative_to(ROOT)}")
+        return 0
+    if args.check:
+        current = TARGET.read_text(encoding="utf-8") if TARGET.exists() else ""
+        if current != document:
+            print(
+                f"{TARGET.relative_to(ROOT)} is stale; run "
+                "scripts/gen_style_snapshot_types.py --write",
+                file=sys.stderr,
+            )
+            return 1
+        print("style snapshot types are current")
+        return 0
+    print(document)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/spec/design/wire-protocol.md b/spec/design/wire-protocol.md
index 4f9ccd417..4625110e3 100644
--- a/spec/design/wire-protocol.md
+++ b/spec/design/wire-protocol.md
@@ -482,3 +482,54 @@ installed `xy` distribution, repairing a stale link if the install moved. The
 JS that renders a payload is therefore always the build that shipped with the
 Python that produced it. The protocol check exists for the case that survives
 this: a browser holding a cached bundle against a restarted kernel.
+
+## 8. Resolved style snapshot (schema v1, transport pending)
+
+`python/xy/styling/resolved.py` defines the renderer-neutral styling IR —
+the `ResolvedStyleSnapshot` — and `js/src/14_style_snapshot.ts` is its
+generated TypeScript mirror (`scripts/gen_style_snapshot_types.py`; the test
+suite fails when the two drift). Nothing here rides the wire yet, so
+`PROTOCOL_VERSION` stays at 12: the capture change that adds the
+`style_snapshot_request` / `style_snapshot` request-reply pair bumps it and
+carries this schema as the reply payload. The message names are reserved
+now so nothing else claims them.
+
+The schema is versioned independently (`STYLE_SNAPSHOT_VERSION = 1`),
+because a snapshot can outlive a session: it is cacheable and supplyable to
+an unmounted export, so a consumer may meet one produced by another build.
+A consumer that sees a version it does not know refuses; it never guesses.
+
+Shape (JSON-safe; spelled-out keys at snapshot level, one-letter keys on
+instances because instances are the part that repeats with chart density):
+
+```text
+{
+  version: 1,
+  style_epoch: int,                  # producer's style generation counter
+  environment: { width, height, dpr, color_scheme },   # resolution inputs
+  tokens: { name: value, ... },      # resolved chart tokens (open names)
+  states: [ "hover", ... ],          # export states included, if any
+  unrepresentable: [ property, ... ],# values with no target representation
+  declarations: [ { property: value, ... }, ... ],     # interned, deduped
+  instances: [ { s: slot, d: decl_index,
+                 q?: [qualifiers], g?: [x,y,w,h], c?: text }, ... ]
+}
+```
+
+Three contract properties, all enforced at construction on both ends of the
+eventual wire:
+
+- **Concrete values only.** No `var()`/`calc()`/`env()`/`inherit`, no
+  relative units (`em`, `%`, `vw`, …): a value that still depends on a
+  cascade or on metrics the consumer would re-derive is rejected loudly
+  (§28). This is what lets every renderer consume one shape without a CSS
+  engine.
+- **Interned declarations.** Each distinct declaration is stored once;
+  instances reference it by index and carry only identity
+  (`q`, e.g. `["y","major","3"]`), geometry, and content. A dense-axis
+  fixture (460 instances, 2 declarations, ~39 KB) pins the spec's 50 KB
+  uncompressed budget in `tests/test_resolved_style_snapshot.py`.
+- **Closed vocabulary per version.** Schema v1's property list is the
+  generated constant in both languages; growing it is a
+  `STYLE_SNAPSHOT_VERSION` bump, so a snapshot's vocabulary is always
+  recoverable from its version field alone.
diff --git a/tests/test_resolved_style_snapshot.py b/tests/test_resolved_style_snapshot.py
new file mode 100644
index 000000000..160db2ee7
--- /dev/null
+++ b/tests/test_resolved_style_snapshot.py
@@ -0,0 +1,209 @@
+"""Schema v1 of the ResolvedStyleSnapshot: interned, concrete, versioned.
+
+Three contracts, each load-bearing for a later phase: declarations intern
+(the size budget assumes repeated chrome shares records), values are
+concrete (a var()/em that slips through re-creates per-renderer divergence
+inside the IR), and the schema refuses versions and vocabulary it does not
+know (growing either is a deliberate version bump, never an accident).
+"""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+from xy.styling import resolved as rs
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def _env() -> rs.SnapshotEnvironment:
+    return rs.SnapshotEnvironment(width=640.0, height=400.0, dpr=2.0, color_scheme="dark")
+
+
+# -- interning ---------------------------------------------------------------
+
+
+def test_identical_declarations_intern_to_one_record_in_any_order() -> None:
+    builder = rs.SnapshotBuilder()
+    first = builder.add("tick_label", {"font-size": 11, "color": "#94a3b8"})
+    second = builder.add("tick_label", {"color": "#94a3b8", "font-size": 11.0})
+    assert first == second == 0
+    snapshot = builder.build(_env())
+    assert len(snapshot.declarations) == 1
+    assert len(snapshot.instances) == 2
+
+
+def test_a_dense_axis_stays_inside_the_size_budget() -> None:
+    # 400 tick labels + 60 legend rows styled alike: the spec's 50 KB
+    # uncompressed budget assumes exactly this shape. Assert with headroom so
+    # growth is a decision, not drift.
+    builder = rs.SnapshotBuilder()
+    for i in range(400):
+        builder.add(
+            "tick_label",
+            {"font-size": 11, "color": "#94a3b8", "font-weight": 500},
+            qualifiers=("x", "major", str(i)),
+            geometry=(4.0 * i, 380.0, 24.0, 12.0),
+            content=str(i),
+        )
+    for i in range(60):
+        builder.add(
+            "legend_label",
+            {"font-size": 12, "color": "#e2e8f0"},
+            qualifiers=(f"series-{i}",),
+            content=f"series {i}",
+        )
+    snapshot = builder.build(_env(), style_epoch=7)
+    assert len(snapshot.declarations) == 2
+    assert len(snapshot.instances) == 460
+    # ~38.6 KB when this landed; the spec budget is 50 KB uncompressed. The
+    # gap is the schema's headroom — a change that eats it shows up here as
+    # a decision to make, not after a capture starts failing in the field.
+    assert snapshot.payload_bytes() < 50_000
+
+
+def test_builder_output_is_insertion_order_independent() -> None:
+    a, b = rs.SnapshotBuilder(), rs.SnapshotBuilder()
+    a.add("title", {"font-size": 18, "color": "#fff"})
+    a.add("axis_title", {"font-size": 12})
+    b.add("axis_title", {"font-size": 12})
+    b.add("title", {"color": "#fff", "font-size": 18})
+    left = a.build(_env()).declarations
+    right = b.build(_env()).declarations
+    assert set(map(tuple, (d.items() for d in left))) == set(map(tuple, (d.items() for d in right)))
+
+
+def test_empty_declarations_are_refused() -> None:
+    with pytest.raises(ValueError, match="styles nothing"):
+        rs.SnapshotBuilder().intern({})
+
+
+# -- concreteness ------------------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    "value, why",
+    [
+        ("var(--chart-fg)", "cascade"),
+        ("calc(100% - 8px)", "cascade"),
+        ("env(safe-area-inset-top)", "cascade"),
+        ("inherit", "cascade"),
+        ("1.5em", "re-derive"),
+        ("120%", "re-derive"),
+        ("2rem", "re-derive"),
+        (float("nan"), "finite"),
+        (float("inf"), "finite"),
+        (True, "numbers or strings"),
+        (None, "numbers or strings"),
+        ("", "empty"),
+    ],
+)
+def test_unresolved_values_are_rejected_with_the_reason(value, why) -> None:
+    with pytest.raises(ValueError, match=why):
+        rs.assert_resolved("font-size", value)
+
+
+def test_concrete_values_pass_unchanged() -> None:
+    assert rs.assert_resolved("font-size", 11) == 11.0
+    assert rs.assert_resolved("color", "#94a3b8") == "#94a3b8"
+    assert rs.assert_resolved("stroke-width", "2px") == "2px"
+    assert rs.assert_resolved("background-image", "linear-gradient(#000, #fff)")
+    assert rs.assert_resolved("transform", "matrix(1, 0, 0, 1, 4, 8)")
+
+
+def test_vocabulary_is_closed_per_version() -> None:
+    with pytest.raises(ValueError, match="STYLE_SNAPSHOT_VERSION"):
+        rs.assert_resolved("backdrop-filter", "blur(4px)")
+    assert len(rs.PROPERTIES_V1) == len(set(rs.PROPERTIES_V1))
+
+
+def test_tokens_carry_open_names_but_the_same_value_contract() -> None:
+    builder = rs.SnapshotBuilder()
+    builder.add("title", {"font-size": 18})
+    snapshot = builder.build(_env(), tokens={"--chart-legend-bg": "#0f172a"})
+    assert snapshot.tokens["--chart-legend-bg"] == "#0f172a"
+    with pytest.raises(ValueError, match="cascade"):
+        builder.build(_env(), tokens={"--chart-legend-bg": "var(--slate-900)"})
+
+
+# -- wire round-trip ---------------------------------------------------------
+
+
+def test_payload_round_trips_exactly() -> None:
+    builder = rs.SnapshotBuilder()
+    builder.add(
+        "tick_label",
+        {"font-size": 11, "color": "#94a3b8"},
+        qualifiers=("y", "major", "3"),
+        geometry=(12.0, 40.0, 30.0, 12.0),
+        content="1,000",
+    )
+    builder.add("legend", {"background": "#0f172a", "border-radius": 6})
+    snapshot = builder.build(
+        _env(),
+        tokens={"--chart-fg": "#e2e8f0"},
+        states=("hover",),
+        unrepresentable=("backdrop-filter",),
+        style_epoch=3,
+    )
+    payload = snapshot.to_payload()
+    assert rs.snapshot_from_payload(payload).to_payload() == payload
+
+
+def test_unknown_versions_are_refused_not_guessed() -> None:
+    payload = rs.SnapshotBuilder().build(_env()).to_payload()
+    payload["version"] = rs.STYLE_SNAPSHOT_VERSION + 1
+    with pytest.raises(ValueError, match="refusing to guess"):
+        rs.snapshot_from_payload(payload)
+
+
+def test_malformed_payloads_fail_loudly() -> None:
+    builder = rs.SnapshotBuilder()
+    builder.add("title", {"font-size": 18})
+    good = builder.build(_env()).to_payload()
+
+    dangling = {**good, "instances": [{"s": "title", "d": 5}]}
+    with pytest.raises(ValueError, match="absent"):
+        rs.snapshot_from_payload(dangling)
+
+    unknown_slot = {**good, "instances": [{"s": "not_a_slot", "d": 0}]}
+    with pytest.raises(ValueError, match="unknown slot"):
+        rs.snapshot_from_payload(unknown_slot)
+
+    bad_geometry = {**good, "instances": [{"s": "title", "d": 0, "g": [1.0, 2.0]}]}
+    with pytest.raises(ValueError, match="four finite"):
+        rs.snapshot_from_payload(bad_geometry)
+
+    smuggled = {**good, "declarations": [{"color": "var(--fg)"}]}
+    with pytest.raises(ValueError, match="cascade"):
+        rs.snapshot_from_payload(smuggled)
+
+
+def test_environment_is_validated() -> None:
+    with pytest.raises(ValueError, match="color_scheme"):
+        rs.SnapshotBuilder().build(
+            rs.SnapshotEnvironment(width=100, height=100, color_scheme="sepia")
+        )
+
+
+# -- the TypeScript mirror ---------------------------------------------------
+
+
+def test_the_committed_typescript_mirror_is_regenerated_not_hand_edited() -> None:
+    result = subprocess.run(
+        [sys.executable, str(ROOT / "scripts" / "gen_style_snapshot_types.py"), "--check"],
+        capture_output=True,
+        text=True,
+    )
+    assert result.returncode == 0, result.stdout + result.stderr
+
+
+def test_the_mirror_names_every_property_and_the_version() -> None:
+    text = (ROOT / "js" / "src" / "14_style_snapshot.ts").read_text(encoding="utf-8")
+    for prop in rs.PROPERTIES_V1:
+        assert f'"{prop}"' in text
+    assert f"STYLE_SNAPSHOT_VERSION = {rs.STYLE_SNAPSHOT_VERSION}" in text

From f6617943d76165edbe08fc226cbe05069751909e Mon Sep 17 00:00:00 2001
From: Alek Petuskey <alek@reflex.dev>
Date: Tue, 4 Aug 2026 13:48:14 -0700
Subject: [PATCH 04/27] Close the preflight report's two mirror gaps and derive
 the summary counts
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Review follow-ups on the preflight change, all in the mirror-the-export
direction:

Browser-resolved targets now validate custom_css through the export path's
own _custom_css_block (type check, </style> and comment-sequence rejection),
in the export's own order — engine resolution first. The report could
previously call an export lossless that would refuse its stylesheet.

Malformed figure styling raises exactly like the export instead of being
skipped: class_names/chrome_styles are assignable, so a report can be
requested before the spec build validates them, and a silently omitted entry
would be a report hiding a declaration (§28). validate_dom_slots runs the
same check the spec build runs; a non-mapping declaration set is refused by
name.

The writer family is now classified from both format sets with a refusal
for anything unclassified, so a future format cannot silently be reported
against the vector subset. The generated summary derives the styles={...}
slot count from the registry instead of hard-coding "nine" (the
axis_style_keys lesson: prose cannot hold a count). Both public entry
points return the typed StyleCompatibilityReport rather than Any.
---
 python/xy/_figure.py                     |  7 ++-
 python/xy/components.py                  |  7 ++-
 python/xy/styling/capabilities.py        |  4 ++
 python/xy/styling/preflight.py           | 63 +++++++++++++++++++-----
 scripts/gen_capability_matrix.py         |  4 +-
 spec/api/capability-matrix.md            |  2 +-
 tests/test_style_compatibility_report.py | 32 ++++++++++++
 7 files changed, 99 insertions(+), 20 deletions(-)

diff --git a/python/xy/_figure.py b/python/xy/_figure.py
index af80981fa..98df36d40 100644
--- a/python/xy/_figure.py
+++ b/python/xy/_figure.py
@@ -12,7 +12,10 @@
 import warnings
 from collections.abc import Mapping, Sequence
 from os import PathLike
-from typing import Any, Optional, TypeAlias, Union
+from typing import TYPE_CHECKING, Any, Optional, TypeAlias, Union
+
+if TYPE_CHECKING:
+    from .styling.preflight import StyleCompatibilityReport
 
 import numpy as np
 
@@ -2223,7 +2226,7 @@ def style_compatibility_report(
         *,
         engine: Optional[export.Engine | str] = None,
         custom_css: Optional[str] = None,
-    ) -> Any:
+    ) -> StyleCompatibilityReport:
         """Route every declared style for one export target, without exporting.
 
         The programmatic answer to export.md §9: which styling sources this
diff --git a/python/xy/components.py b/python/xy/components.py
index cdc3934cf..5a457e650 100644
--- a/python/xy/components.py
+++ b/python/xy/components.py
@@ -40,7 +40,10 @@
 from dataclasses import dataclass, field, replace
 from functools import lru_cache
 from os import PathLike
-from typing import Any, Literal, Optional, TypeAlias, Union
+from typing import TYPE_CHECKING, Any, Literal, Optional, TypeAlias, Union
+
+if TYPE_CHECKING:
+    from .styling.preflight import StyleCompatibilityReport
 
 import numpy as np
 
@@ -4175,7 +4178,7 @@ def style_compatibility_report(
         *,
         engine: Optional[export.Engine | str] = None,
         custom_css: Optional[str] = None,
-    ) -> Any:
+    ) -> StyleCompatibilityReport:
         """What of this chart's styling survives an export to ``target``.
 
         Report-only preflight: lists the styling sources present, how each
diff --git a/python/xy/styling/capabilities.py b/python/xy/styling/capabilities.py
index a16b98257..fa425d920 100644
--- a/python/xy/styling/capabilities.py
+++ b/python/xy/styling/capabilities.py
@@ -465,6 +465,10 @@ def summary() -> dict[str, object]:
         "slots_styleable_natively": sum(
             1 for s in CHART_SLOTS if s.support["native_raster"] != "none"
         ),
+        # The `styles={slot: ...}` channel specifically — the writers' own
+        # STATIC_STYLED_SLOTS, counted from the registry so generated prose
+        # cannot hold a stale number (the axis_style_keys lesson).
+        "slots_via_styles": sum(1 for s in CHART_SLOTS if s.channel.startswith("styles={")),
         "extension_points_shipped": sum(1 for e in EXTENSION_POINTS if e.status == "shipped"),
         "known_renderer_divergences": len(KNOWN_RENDERER_DIVERGENCES),
     }
diff --git a/python/xy/styling/preflight.py b/python/xy/styling/preflight.py
index d6d3d523a..625a7b0a8 100644
--- a/python/xy/styling/preflight.py
+++ b/python/xy/styling/preflight.py
@@ -27,6 +27,7 @@
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, Optional
 
+from ..dom import validate_dom_slots
 from . import capabilities
 
 if TYPE_CHECKING:  # pragma: no cover - import cycle guard, typing only
@@ -114,19 +115,46 @@ def _resolve(target: str, engine: object, custom_css: Optional[str]) -> tuple[st
 
     Deferred import: `export` pulls in the browser-discovery machinery, and
     `capabilities` must stay importable from the docs generator without it.
+
+    Browser-resolved targets validate `custom_css` through the export path's
+    own `_custom_css_block` — the same type check and `</style>`/`<!--`
+    rejection the standalone document performs — in the same order the export
+    performs them (engine resolution first). A report may not say "lossless"
+    about an export that would refuse the stylesheet.
     """
     from .. import export
 
     fmt = export._normalize_format(target, allow_html=True)
     if fmt == "html":
-        return fmt, "browser", ""
-    try:
-        return fmt, export._resolve_image_engine(engine, fmt, custom_css), ""
-    except ValueError as exc:
-        return fmt, "unresolved", str(exc)
+        resolved = "browser"
+    else:
+        try:
+            resolved = export._resolve_image_engine(engine, fmt, custom_css)
+        except ValueError as exc:
+            return fmt, "unresolved", str(exc)
+    if resolved == "browser" and custom_css is not None:
+        try:
+            export._custom_css_block(custom_css)
+        except (TypeError, ValueError) as exc:
+            return fmt, resolved, str(exc)
+    return fmt, resolved, ""
+
+
+def _slot_family(fmt: str) -> str:
+    """The writer family a format belongs to, refusing formats outside both.
+
+    Membership is explicit on both sides so a format added later to
+    `export._normalize_format` cannot silently be reported against the vector
+    subset — it fails here until someone classifies it.
+    """
+    if fmt in _RASTER_FORMATS:
+        return "native_raster"
+    if fmt in _VECTOR_FORMATS:
+        return "native_vector"
+    raise ValueError(f"preflight has no writer family for format {fmt!r}")
 
 
-def _honored_props(slot: str, fmt: str) -> tuple[frozenset[str], str]:
+def _honored_props(slot: str, family: str) -> tuple[frozenset[str], str]:
     """(honored property names, qualifier) for a native-subset slot.
 
     The subsets are the writers' own constants. `legend` honors box properties
@@ -137,7 +165,7 @@ def _honored_props(slot: str, fmt: str) -> tuple[frozenset[str], str]:
     """
     from .. import _svg
 
-    text = frozenset(_svg.SLOT_RASTER_PROPS if fmt in _RASTER_FORMATS else _svg.SLOT_TEXT_PROPS)
+    text = frozenset(_svg.SLOT_RASTER_PROPS if family == "native_raster" else _svg.SLOT_TEXT_PROPS)
     if slot == "legend":
         return text, (
             "box properties (background, shadow, radius, padding) route through the "
@@ -180,7 +208,7 @@ def _class_finding(slot: str, fmt: str) -> SlotFinding:
 
 def _styles_finding(slot: str, decls: dict[str, Any], fmt: str) -> SlotFinding:
     meta = _SLOTS_BY_ID[slot]
-    family = "native_raster" if fmt in _RASTER_FORMATS else "native_vector"
+    family = _slot_family(fmt)
     props = tuple(_css_prop(name) for name in decls)
     if meta.applicability != "static":
         return SlotFinding(
@@ -203,7 +231,7 @@ def _styles_finding(slot: str, decls: dict[str, Any], fmt: str) -> SlotFinding:
             lost=props,
             detail=detail,
         )
-    honored, qualifier = _honored_props(slot, fmt)
+    honored, qualifier = _honored_props(slot, family)
     kept = tuple(p for p in props if p in honored)
     lost = tuple(p for p in props if p not in honored)
     if slot == "legend":
@@ -272,13 +300,22 @@ def preflight(
         # class or per-slot declarations there is nothing that can drop.
         return StyleCompatibilityReport(target=fmt, engine=resolved, sources=sources)
 
+    # Mirror the spec build's own validation rather than skipping entries it
+    # would refuse: `Figure.class_names`/`chrome_styles` are assignable, so a
+    # report can be requested before `_dom_spec` validates them. A silently
+    # omitted entry would be a report claiming exhaustiveness while hiding a
+    # declaration — the exact §28 failure this module exists to end.
+    validate_dom_slots(figure.class_names, "class_names")
+    validate_dom_slots(figure.chrome_styles, "chrome_styles")
     findings: list[SlotFinding] = []
     for slot in figure.class_names:
-        if slot in _SLOTS_BY_ID:
-            findings.append(_class_finding(slot, fmt))
+        findings.append(_class_finding(slot, fmt))
     for slot, decls in figure.chrome_styles.items():
-        if slot in _SLOTS_BY_ID and isinstance(decls, dict):
-            findings.append(_styles_finding(slot, decls, fmt))
+        if not isinstance(decls, dict):
+            raise ValueError(
+                f"chrome_styles[{slot!r}] must be a mapping of declarations, got {decls!r}"
+            )
+        findings.append(_styles_finding(slot, decls, fmt))
 
     losses = tuple(
         f"{finding.source}[{finding.slot!r}] -> {', '.join(finding.lost)}"
diff --git a/scripts/gen_capability_matrix.py b/scripts/gen_capability_matrix.py
index e76c38f5c..0f7369758 100644
--- a/scripts/gen_capability_matrix.py
+++ b/scripts/gen_capability_matrix.py
@@ -66,8 +66,8 @@ def render() -> str:
         "in the browser. "
         f"**{counts['chart_slots_static']}** of them name chrome a clean static export "
         f"contains; **{counts['slots_styleable_natively']}** reach the native writers — "
-        "nine through `styles={slot: ...}` itself, and `root` through the "
-        "chart-level `style=` token bag. The other "
+        f"**{counts['slots_via_styles']}** through `styles={{slot: ...}}` itself, and "
+        "`root` through the chart-level `style=` token bag. The other "
         f"**{counts['chart_slots_state_gated']}** are interaction/view chrome "
         "(tooltip, modebar, crosshair, selection, reduction badges) that a clean "
         "static file does not contain, so they are gated by an export state "
diff --git a/spec/api/capability-matrix.md b/spec/api/capability-matrix.md
index c90753cd6..81424ba41 100644
--- a/spec/api/capability-matrix.md
+++ b/spec/api/capability-matrix.md
@@ -14,7 +14,7 @@ which is sometimes deliberate, and the notes say which.
 ## In one line
 
 - **11** mark style properties across **21** mark kinds, drawn by all three renderers.
-- **48** stable chrome slots, CSS- and Tailwind-addressable in the browser. **24** of them name chrome a clean static export contains; **10** reach the native writers — nine through `styles={slot: ...}` itself, and `root` through the chart-level `style=` token bag. The other **24** are interaction/view chrome (tooltip, modebar, crosshair, selection, reduction badges) that a clean static file does not contain, so they are gated by an export state rather than missing.
+- **48** stable chrome slots, CSS- and Tailwind-addressable in the browser. **24** of them name chrome a clean static export contains; **10** reach the native writers — **9** through `styles={slot: ...}` itself, and `root` through the chart-level `style=` token bag. The other **24** are interaction/view chrome (tooltip, modebar, crosshair, selection, reduction badges) that a clean static file does not contain, so they are gated by an export state rather than missing.
 - **1** shipped extension point.
 - **1** known default divergence between renderers, listed below rather than left to be discovered.
 
diff --git a/tests/test_style_compatibility_report.py b/tests/test_style_compatibility_report.py
index 5712b3d4b..07cc73303 100644
--- a/tests/test_style_compatibility_report.py
+++ b/tests/test_style_compatibility_report.py
@@ -158,6 +158,38 @@ def test_custom_css_routes_auto_to_browser_and_stays_lossless() -> None:
     assert report.lossless
 
 
+def test_browser_targets_mirror_custom_css_validation() -> None:
+    # A browser-resolved export still validates the stylesheet itself
+    # (`export._custom_css_block`): wrong type, or a sequence that could
+    # break out of the <style> element. The report must carry the same
+    # refusal instead of calling the export lossless.
+    chart = _chart()
+    for target in ("png", "html"):
+        breakout = chart.style_compatibility_report(target, custom_css="</style><script>")
+        assert breakout.error is not None
+        assert not breakout.lossless
+        assert "</style>" in breakout.error or "style" in breakout.error
+
+        wrong_type = chart.style_compatibility_report(target, custom_css=123)  # type: ignore[arg-type]
+        assert wrong_type.error == "custom_css must be a string"
+
+
+def test_malformed_figure_styling_raises_exactly_like_the_export() -> None:
+    # class_names/chrome_styles are assignable on the figure, so a report can
+    # be requested before the spec build validates them. Skipping such an
+    # entry would hide a declaration (§28); instead the report raises the
+    # same error the export's own spec build raises.
+    fig = _chart().figure()
+    fig.class_names["not_a_slot"] = "x"
+    with pytest.raises(ValueError, match="unknown slot"):
+        fig.style_compatibility_report("png")
+
+    fig = _chart().figure()
+    fig.chrome_styles["title"] = "not-a-mapping"  # type: ignore[assignment]
+    with pytest.raises(ValueError, match="must be a mapping"):
+        fig.style_compatibility_report("png")
+
+
 def test_refusals_are_mirrored_not_re_decided() -> None:
     # The export path raises for these; the report carries the same message
     # instead of predicting a different outcome.

From 10b5030268e6c0d6bf1acfafcab05687333fbfe3 Mon Sep 17 00:00:00 2001
From: Alek Petuskey <alek@reflex.dev>
Date: Tue, 4 Aug 2026 13:51:55 -0700
Subject: [PATCH 05/27] Review follow-ups: precedence, attribution,
 remediation, and batch vocabulary
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Resolution errors now precede mode logic in to_png for styled charts too:
the custom_css/native refusal is checked right after engine resolution,
before enforcement can warn or raise, so it stays the documented ValueError
in every mode. The precedence test now feeds a lossy chart — the case that
previously slipped past it — and asserts the error is not the strict
subclass.

Compatibility warnings land on the caller's export line. The distance from
the warn call to user code varies by entry point (module function, Figure
method, Chart method), so the stacklevel is measured: walk outward from
enforce to the first frame outside the package. A test pins the attribution
for three different entry points.

Strict SVG failures no longer recommend engine=Engine.chromium, which that
format rejects; the remediation is format-aware. write_images validates the
compatibility vocabulary once up front, so a typo fails even an all-HTML
batch instead of passing silently — while HTML entries themselves stay
exempt from the mode, since a document that renders the full cascade has
nothing to check. The changelog entry now names the facet-grid exclusion
instead of overstating coverage, and the raster-drops-vector-only test is
named for what it exercises.
---
 CHANGELOG.md                            |  7 ++-
 python/xy/export.py                     | 16 +++++--
 python/xy/styling/preflight.py          | 44 +++++++++++++++---
 tests/test_style_compatibility_modes.py | 59 +++++++++++++++++++++++--
 4 files changed, 111 insertions(+), 15 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 995018dec..47364734e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,8 +9,11 @@ in the README).
 ## [Unreleased]
 
 ### Added
-- Every image-export API (`to_png`, `to_svg`, `to_image`, `write_image`,
-  `export.write_images`) accepts `compatibility=`: `"legacy"` (default —
+- Every chart-, figure-, and module-level image-export API (`to_png`,
+  `to_svg`, `to_image`, `write_image`, `export.write_images`) accepts
+  `compatibility=` — facet-grid exports deliberately do not yet (their
+  per-panel preflight is tracked in the migration document): `"legacy"`
+  (default —
   behavior unchanged), `"warn"` (one `StyleCompatibilityWarning` naming each
   declaration the export would drop), or `"strict"`
   (`StyleCompatibilityError` before emission, preflight report attached).
diff --git a/python/xy/export.py b/python/xy/export.py
index dc124292c..d97380fc6 100644
--- a/python/xy/export.py
+++ b/python/xy/export.py
@@ -682,7 +682,14 @@ def write_images(
     (native WebP stays lossless), so mixed batches stay ergonomic.
     `compatibility=` applies per figure while the plan is resolved, so a
     strict batch refuses whole — before any file is written — rather than
-    after a partial export."""
+    after a partial export. Its vocabulary is validated once up front, so an
+    invalid mode fails even an all-HTML batch; HTML entries themselves are
+    exempt from the mode, because a document that renders the full cascade
+    has nothing to check."""
+    if compatibility != "legacy":
+        from .styling.preflight import validate_compatibility
+
+        validate_compatibility(compatibility)
     if figures is not None:
         if figs is not None:
             raise ValueError("pass figs positionally or figures=, not both")
@@ -840,10 +847,13 @@ def to_png(
     optimize = _bool_option(optimize, "PNG optimize")
     sandbox = _bool_option(sandbox, "PNG sandbox")
     resolved_engine = _png_engine(engine)
+    # Resolution errors precede and outrank mode logic (the migration spec's
+    # contract): the custom_css/native refusal must stay a ValueError in
+    # every mode, so it fires before enforcement can warn or raise.
+    if resolved_engine == "native" and custom_css is not None:
+        raise ValueError("custom_css requires engine=Engine.chromium")
     _enforce_compatibility(fig, "png", resolved_engine, custom_css, compatibility)
     if resolved_engine == "native":
-        if custom_css is not None:
-            raise ValueError("custom_css requires engine=Engine.chromium")
         from . import _raster
 
         data = _raster.to_png(fig, None, width=w, height=h, scale=scale, fast=not optimize)
diff --git a/python/xy/styling/preflight.py b/python/xy/styling/preflight.py
index cb0256ed5..73246a184 100644
--- a/python/xy/styling/preflight.py
+++ b/python/xy/styling/preflight.py
@@ -414,26 +414,58 @@ class or per-slot declarations and the engine is native; a lossless
     report = route_resolved(figure, fmt=fmt, resolved_engine=resolved_engine, custom_css=custom_css)
     if report.lossless:
         return
+    # SVG is native-only (a browser screenshot cannot emit vector SVG), so
+    # recommending engine=Engine.chromium there would recommend a refusal.
+    keeps = (
+        "to_html() keeps everything (SVG is native-only, so Engine.chromium "
+        "is not a route for this format)"
+        if fmt == "svg"
+        else "engine=Engine.chromium or to_html() keeps everything"
+    )
     if mode == "warn":
         warnings.warn(
             StyleCompatibilityWarning(
                 f"this {fmt} export drops declared styling — "
                 + "; ".join(report.losses)
                 + " — chart.style_compatibility_report() has the full routing; "
-                "engine=Engine.chromium or to_html() keeps everything"
+                + keeps
             ),
-            stacklevel=2,
+            stacklevel=_caller_stacklevel(),
         )
         return
     raise StyleCompatibilityError(
-        report.explain() + "\nstrict compatibility refuses to drop declared styling; keep it with "
-        "engine=Engine.chromium or to_html(), move it into chart/mark style= or a "
-        'supported styles= subset, or export with compatibility="warn" during '
-        "migration",
+        report.explain()
+        + "\nstrict compatibility refuses to drop declared styling; "
+        + keeps
+        + ", or move it into chart/mark style= or a supported styles= subset, "
+        'or export with compatibility="warn" during migration',
         report,
     )
 
 
+def _caller_stacklevel() -> int:
+    """The stacklevel that lands the warning on the caller's export line.
+
+    The distance from `enforce` to user code varies by entry point (module
+    function, Figure method, Chart method, batch plan), so it is measured:
+    walk outward from `enforce` until the first frame outside the xy
+    package. Counted so `warnings.warn(..., stacklevel=n)` inside `enforce`
+    attributes the warning to that frame.
+    """
+    import sys
+    from pathlib import Path
+
+    package_dir = str(Path(__file__).resolve().parents[1])
+    frame = sys._getframe(1)  # enforce's frame
+    level = 1
+    while frame.f_back is not None and str(Path(frame.f_code.co_filename).resolve()).startswith(
+        package_dir
+    ):
+        frame = frame.f_back
+        level += 1
+    return level
+
+
 __all__ = [
     "COMPATIBILITY_MODES",
     "ROUTE_BROWSER_ONLY",
diff --git a/tests/test_style_compatibility_modes.py b/tests/test_style_compatibility_modes.py
index a3db4f30f..9d77077c7 100644
--- a/tests/test_style_compatibility_modes.py
+++ b/tests/test_style_compatibility_modes.py
@@ -78,11 +78,25 @@ def test_warn_is_silent_when_nothing_drops() -> None:
         _chart(styles={"tick_label": {"letter_spacing": "0.08em"}}).to_svg(compatibility="warn")
 
 
-def test_warn_applies_to_the_vector_writers_too() -> None:
+def test_warn_fires_when_the_raster_drops_a_vector_only_declaration() -> None:
+    # letter-spacing survives the vector writers but not the raster one, so
+    # the PNG path must warn where the SVG path (covered above) stays silent.
     with pytest.warns(StyleCompatibilityWarning, match="tick_label"):
         _chart(styles={"tick_label": {"letter_spacing": "0.08em"}}).to_png(compatibility="warn")
 
 
+def test_warnings_land_on_the_callers_line_not_export_plumbing() -> None:
+    # The distance from the warn call to user code differs per entry point,
+    # so the stacklevel is measured; every public route must attribute the
+    # warning to this file, not to export.py or preflight.py internals.
+    chart = _lossy_chart()
+    with pytest.warns(StyleCompatibilityWarning) as caught:
+        chart.to_png(compatibility="warn")
+        chart.figure().to_svg(compatibility="warn")
+        chart.to_image("jpeg", compatibility="warn")
+    assert [w.filename for w in caught] == [__file__] * len(caught)
+
+
 # -- strict ------------------------------------------------------------------
 
 
@@ -132,9 +146,22 @@ def test_no_mode_reroutes_an_explicit_engine() -> None:
 def test_resolution_errors_precede_and_outrank_mode_logic() -> None:
     # custom_css with a pinned native engine raises today's ValueError in
     # every mode — never a StyleCompatibilityError, never a silent re-route.
-    for mode in ("legacy", "warn", "strict"):
-        with pytest.raises(ValueError, match="custom_css requires"):
-            _chart().to_png(engine=export.Engine.default, custom_css=".x{}", compatibility=mode)
+    # The lossy chart is the load-bearing case: enforcement would otherwise
+    # run its preflight (and warn or raise) before the resolution check.
+    for chart in (_chart(), _lossy_chart()):
+        for mode in ("legacy", "warn", "strict"):
+            with warnings.catch_warnings():
+                warnings.simplefilter("error", StyleCompatibilityWarning)
+                with pytest.raises(ValueError, match="custom_css requires") as excinfo:
+                    chart.to_png(
+                        engine=export.Engine.default, custom_css=".x{}", compatibility=mode
+                    )
+            assert not isinstance(excinfo.value, StyleCompatibilityError)
+            with pytest.raises(ValueError, match="custom_css requires") as excinfo:
+                chart.to_image(
+                    "png", engine=export.Engine.default, custom_css=".x{}", compatibility=mode
+                )
+            assert not isinstance(excinfo.value, StyleCompatibilityError)
 
 
 def test_auto_with_custom_css_is_lossless_in_every_mode() -> None:
@@ -171,3 +198,27 @@ def test_html_rejects_a_compatibility_mode_like_other_inapplicable_options(
         _chart().write_image(tmp_path / "chart.html", compatibility="strict")
     # The default passes through untouched.
     _chart().write_image(tmp_path / "chart2.html")
+
+
+def test_batch_validates_the_mode_vocabulary_even_for_all_html(tmp_path) -> None:
+    # A mixed batch legitimately carries a mode for its image entries, so
+    # HTML entries are exempt rather than rejecting the whole batch — but the
+    # vocabulary is validated up front, so a typo fails an all-HTML batch too
+    # instead of passing silently.
+    chart = _lossy_chart()
+    with pytest.raises(ValueError, match="compatibility"):
+        export.write_images([chart], [str(tmp_path / "a.html")], compatibility="stricted")
+    # strict + only HTML: nothing to check, bytes written.
+    export.write_images([chart], [str(tmp_path / "b.html")], compatibility="strict")
+    assert (tmp_path / "b.html").exists()
+
+
+def test_strict_svg_remediation_does_not_recommend_a_refused_engine() -> None:
+    # SVG is native-only; a strict SVG failure must not point at
+    # engine=Engine.chromium, which that format rejects.
+    with pytest.raises(StyleCompatibilityError) as svg_err:
+        _lossy_chart().to_svg(compatibility="strict")
+    assert "SVG is native-only" in str(svg_err.value)
+    with pytest.raises(StyleCompatibilityError) as png_err:
+        _lossy_chart().to_png(compatibility="strict")
+    assert "engine=Engine.chromium or to_html()" in str(png_err.value)

From 3aa6728221971ca0019cb91b65c142454ea2ab23 Mon Sep 17 00:00:00 2001
From: Alek Petuskey <alek@reflex.dev>
Date: Tue, 4 Aug 2026 13:57:47 -0700
Subject: [PATCH 06/27] Harden the snapshot's concreteness contract and
 canonicalize its bytes
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Review follow-ups on the schema, all four in the same direction: the
contract the module claims is now the contract it enforces.

Relative units are rejected anywhere in a value, not only as a whole-string
suffix. translate(50%, 20%), a "2em 1em" shorthand, and a gradient stop at
50% all carry the same document dependency a bare "1.5em" does; the
end-anchored check let exactly those through. Cascade keywords went the
other way: inherit/unset (plus initial/revert/revert-layer) reject only as
the entire normalized value, so a face named "Inheritance Sans" is no
longer refused for containing the letters.

Tokens share the full string contract with declarations through one helper
— a token "1.5em" or an empty string smuggles what a declaration would —
and snapshot_from_payload now enforces the identical rules build() does:
environment vocabulary and finiteness, and every token through the shared
validator. The payload path is the untrusted end of the wire; a snapshot
that could only exist by bypassing the builder must not become
renderer-facing IR by arriving serialized.

build() now emits canonical bytes: declaration slots assigned by content
(instance indices remapped), instances sorted by identity. The docstring
claimed order-independence while the payload depended on insertion order,
and the old test compared declaration sets, which cannot see index drift —
it now asserts byte-equal payloads from builders fed the same styling in
different orders. Instance order carries no meaning; identity lives in
(slot, qualifiers), which is what makes a snapshot cacheable across
producers.
---
 python/xy/styling/resolved.py         | 190 +++++++++++++++++++-------
 spec/design/wire-protocol.md          |   9 +-
 tests/test_resolved_style_snapshot.py |  66 ++++++++-
 3 files changed, 206 insertions(+), 59 deletions(-)

diff --git a/python/xy/styling/resolved.py b/python/xy/styling/resolved.py
index cf4d4261f..81ec581ae 100644
--- a/python/xy/styling/resolved.py
+++ b/python/xy/styling/resolved.py
@@ -30,6 +30,7 @@
 
 import json
 import math
+import re
 from collections.abc import Mapping, Sequence
 from dataclasses import dataclass, field
 from typing import Any, Optional
@@ -100,26 +101,72 @@
 
 _PROPERTY_SET = frozenset(PROPERTIES_V1)
 
-#: Constructs whose value depends on a document, a cascade, or an
-#: environment the renderer does not have. Their presence means the value is
-#: not resolved, whatever else it looks like.
-_UNRESOLVED_MARKERS: tuple[str, ...] = ("var(", "calc(", "env(", "attr(", "inherit", "unset")
+#: Function-shaped constructs whose value depends on a document, a cascade,
+#: or an environment the renderer does not have. Matched as substrings —
+#: a `var(` buried inside a gradient is exactly as unresolved as one alone.
+_UNRESOLVED_FUNCTIONS: tuple[str, ...] = ("var(", "calc(", "env(", "attr(")
+
+#: Cascade keywords, matched only as the entire normalized value: `inherit`
+#: as a value defers to a cascade, but a face named "Inheritance Sans" is a
+#: concrete string and must not be rejected for containing the letters.
+_UNRESOLVED_KEYWORDS: frozenset[str] = frozenset(
+    {"inherit", "initial", "unset", "revert", "revert-layer"}
+)
 
 #: Length units a *resolved* value may not carry: every one is relative to
 #: font metrics or viewport the consumer would have to re-derive. Resolved
 #: lengths are plain numbers (CSS px).
-_RELATIVE_UNITS: tuple[str, ...] = ("em", "rem", "ex", "ch", "vw", "vh", "vmin", "vmax", "%")
+_RELATIVE_UNITS: tuple[str, ...] = ("vmin", "vmax", "rem", "em", "ex", "ch", "vw", "vh", "%")
+
+#: A relative-unit length *anywhere* in the value — `translate(50%, 20%)`,
+#: a `2em 1em` shorthand, a gradient stop — not only as a whole-string
+#: suffix. Mid-string relative units are precisely the ones that slipped a
+#: document dependency past the earlier end-anchored check.
+_RELATIVE_UNIT_RE = re.compile(
+    r"(?<![a-z0-9.#_-])\d*\.?\d+(?:"
+    + "|".join(map(re.escape, _RELATIVE_UNITS))
+    + r")(?![a-z0-9%])",
+    re.IGNORECASE,
+)
 
 _COLOR_SCHEMES = frozenset({"light", "dark"})
 
 
+def _assert_concrete_text(label: str, value: str) -> str:
+    """The one string contract, shared by declarations and tokens alike."""
+    text = value.strip()
+    if not text:
+        raise ValueError(f"{label}: a resolved value cannot be empty")
+    lowered = text.lower()
+    if lowered in _UNRESOLVED_KEYWORDS:
+        raise ValueError(
+            f"{label}: {text!r} defers to a cascade the renderer does not have; "
+            "resolve it before it enters the snapshot"
+        )
+    for marker in _UNRESOLVED_FUNCTIONS:
+        if marker in lowered:
+            raise ValueError(
+                f"{label}: {text!r} still depends on a cascade the renderer does not "
+                f"have ({marker.rstrip('(')}); resolve it before it enters the snapshot"
+            )
+    relative = _RELATIVE_UNIT_RE.search(lowered)
+    if relative is not None:
+        raise ValueError(
+            f"{label}: {text!r} carries {relative.group(0)!r}, which is relative to "
+            "metrics the consumer would have to re-derive; resolved lengths are "
+            "plain numbers in CSS px"
+        )
+    return text
+
+
 def assert_resolved(prop: str, value: object) -> str | float:
     """A schema-v1 value, or a loud error saying exactly why it is not one.
 
     Numbers pass as finite floats. Strings pass unless they carry an
-    unresolved construct or end in a relative unit — the two ways a value can
-    quietly mean something different in the consumer than it did in the
-    source. There is no silent coercion in either direction.
+    unresolved construct or a relative-unit length anywhere in the value —
+    the two ways a value can quietly mean something different in the
+    consumer than it did in the source. There is no silent coercion in
+    either direction.
     """
     if prop not in _PROPERTY_SET:
         raise ValueError(
@@ -133,26 +180,7 @@ def assert_resolved(prop: str, value: object) -> str | float:
         if not math.isfinite(number):
             raise ValueError(f"{prop}: resolved numbers must be finite, got {value!r}")
         return number
-    text = value.strip()
-    if not text:
-        raise ValueError(f"{prop}: a resolved value cannot be empty")
-    lowered = text.lower()
-    for marker in _UNRESOLVED_MARKERS:
-        if marker in lowered:
-            raise ValueError(
-                f"{prop}: {text!r} still depends on a cascade the renderer does not "
-                f"have ({marker.rstrip('(')}); resolve it before it enters the snapshot"
-            )
-    for unit in _RELATIVE_UNITS:
-        if (
-            lowered.endswith(unit)
-            and lowered[: -len(unit)].replace(".", "", 1).lstrip("+-").isdigit()
-        ):
-            raise ValueError(
-                f"{prop}: {text!r} is relative to metrics the consumer would have to "
-                "re-derive; resolved lengths are plain numbers in CSS px"
-            )
-    return text
+    return _assert_concrete_text(prop, value)
 
 
 @dataclass(frozen=True)
@@ -237,9 +265,12 @@ class SnapshotBuilder:
     """Interning constructor: identical declarations share one record.
 
     The producer calls `add(slot, declaration, ...)` per styled instance and
-    `build(...)` once; canonicalization (sorted property order) makes
-    interning independent of declaration insertion order, so a builder fed
-    the same styling in any order emits the same snapshot.
+    `build(...)` once. `build` emits a **canonical** snapshot: declarations
+    sorted by their property content (instance indices remapped to match)
+    and instances sorted by identity, so a builder fed the same styling in
+    any order emits byte-identical payloads. Instance order therefore
+    carries no meaning — identity lives in `(slot, qualifiers)` — which is
+    what makes a snapshot cacheable and comparable across producers.
     """
 
     def __init__(self) -> None:
@@ -299,15 +330,42 @@ def build(
         unrepresentable: Sequence[str] = (),
         style_epoch: int = 0,
     ) -> ResolvedStyleSnapshot:
-        if environment.color_scheme not in _COLOR_SCHEMES:
-            raise ValueError(f"color_scheme must be one of {sorted(_COLOR_SCHEMES)}")
+        environment = _validated_environment(
+            environment.width, environment.height, environment.dpr, environment.color_scheme
+        )
         resolved_tokens = {
             str(name): assert_resolved_token(name, value) for name, value in (tokens or {}).items()
         }
+        # Canonicalize: declaration slots by content, instances by identity,
+        # so logically identical styling is byte-identical on the wire.
+        order = sorted(
+            range(len(self._declarations)),
+            key=lambda i: tuple(self._declarations[i].items()),
+        )
+        remap = {old: new for new, old in enumerate(order)}
+        instances = sorted(
+            (
+                SlotInstance(
+                    slot=inst.slot,
+                    declaration=remap[inst.declaration],
+                    qualifiers=inst.qualifiers,
+                    geometry=inst.geometry,
+                    content=inst.content,
+                )
+                for inst in self._instances
+            ),
+            key=lambda inst: (
+                inst.slot,
+                inst.qualifiers,
+                inst.declaration,
+                inst.geometry or (),
+                inst.content or "",
+            ),
+        )
         return ResolvedStyleSnapshot(
             environment=environment,
-            declarations=tuple(self._declarations),
-            instances=tuple(self._instances),
+            declarations=tuple(self._declarations[i] for i in order),
+            instances=tuple(instances),
             tokens=resolved_tokens,
             states=tuple(str(s) for s in states),
             unrepresentable=tuple(str(u) for u in unrepresentable),
@@ -315,8 +373,35 @@ def build(
         )
 
 
+def _validated_environment(
+    width: object, height: object, dpr: object, color_scheme: object
+) -> SnapshotEnvironment:
+    """One environment contract for both construction ends of the wire."""
+    numbers = {}
+    for label, value in (("width", width), ("height", height), ("dpr", dpr)):
+        try:
+            out = float(value)  # type: ignore[arg-type]
+        except (TypeError, ValueError) as exc:
+            raise ValueError(f"environment {label} must be a finite positive number") from exc
+        if not math.isfinite(out) or out <= 0:
+            raise ValueError(f"environment {label} must be a finite positive number")
+        numbers[label] = out
+    scheme = str(color_scheme)
+    if scheme not in _COLOR_SCHEMES:
+        raise ValueError(f"color_scheme must be one of {sorted(_COLOR_SCHEMES)}")
+    return SnapshotEnvironment(
+        width=numbers["width"], height=numbers["height"], dpr=numbers["dpr"], color_scheme=scheme
+    )
+
+
 def assert_resolved_token(name: object, value: object) -> str | float:
-    """Chart tokens carry open names but the same resolved-value contract."""
+    """Chart tokens carry open names but the same resolved-value contract.
+
+    The string rules are `_assert_concrete_text`, shared with declarations —
+    a token `1.5em` smuggles the identical document dependency a declaration
+    `1.5em` would, so the two vocabularies differ only in that token *names*
+    are open while the schema property list is closed.
+    """
     if isinstance(value, bool) or not isinstance(value, (int, float, str)):
         raise ValueError(f"token {name!r}: resolved values are numbers or strings, got {value!r}")
     if isinstance(value, (int, float)):
@@ -324,14 +409,7 @@ def assert_resolved_token(name: object, value: object) -> str | float:
         if not math.isfinite(number):
             raise ValueError(f"token {name!r}: resolved numbers must be finite")
         return number
-    lowered = value.lower()
-    for marker in _UNRESOLVED_MARKERS:
-        if marker in lowered:
-            raise ValueError(
-                f"token {name!r}: {value!r} still depends on a cascade "
-                f"({marker.rstrip('(')}); resolve it before it enters the snapshot"
-            )
-    return value
+    return _assert_concrete_text(f"token {name!r}", value)
 
 
 def snapshot_from_payload(payload: Mapping[str, Any]) -> ResolvedStyleSnapshot:
@@ -369,18 +447,26 @@ def snapshot_from_payload(payload: Mapping[str, Any]) -> ResolvedStyleSnapshot:
                 content=raw.get("c"),
             )
         )
+    # The payload path is the untrusted end of the wire, so it enforces the
+    # identical contract `build()` enforces: environment vocabulary and
+    # finiteness, and every token through the shared resolved-value rules. A
+    # snapshot that could only have been made by bypassing the builder must
+    # not become renderer-facing IR by arriving serialized.
     return ResolvedStyleSnapshot(
-        environment=SnapshotEnvironment(
-            width=float(env["width"]),
-            height=float(env["height"]),
-            dpr=float(env.get("dpr", 1.0)),
-            color_scheme=str(env.get("color_scheme", "light")),
+        environment=_validated_environment(
+            env["width"],
+            env["height"],
+            env.get("dpr", 1.0),
+            env.get("color_scheme", "light"),
         ),
         declarations=tuple(dict(d) for d in declarations),
         instances=tuple(instances),
-        tokens=dict(payload.get("tokens", {})),
-        states=tuple(payload.get("states", ())),
-        unrepresentable=tuple(payload.get("unrepresentable", ())),
+        tokens={
+            str(name): assert_resolved_token(name, value)
+            for name, value in dict(payload.get("tokens", {})).items()
+        },
+        states=tuple(str(s) for s in payload.get("states", ())),
+        unrepresentable=tuple(str(u) for u in payload.get("unrepresentable", ())),
         style_epoch=int(payload.get("style_epoch", 0)),
     )
 
diff --git a/spec/design/wire-protocol.md b/spec/design/wire-protocol.md
index 4625110e3..1d365f275 100644
--- a/spec/design/wire-protocol.md
+++ b/spec/design/wire-protocol.md
@@ -524,9 +524,12 @@ eventual wire:
   cascade or on metrics the consumer would re-derive is rejected loudly
   (§28). This is what lets every renderer consume one shape without a CSS
   engine.
-- **Interned declarations.** Each distinct declaration is stored once;
-  instances reference it by index and carry only identity
-  (`q`, e.g. `["y","major","3"]`), geometry, and content. A dense-axis
+- **Interned declarations, canonically ordered.** Each distinct declaration
+  is stored once; instances reference it by index and carry only identity
+  (`q`, e.g. `["y","major","3"]`), geometry, and content. The builder emits
+  declarations sorted by content and instances sorted by identity, so
+  logically identical styling serializes byte-identically regardless of
+  production order — instance order carries no meaning. A dense-axis
   fixture (460 instances, 2 declarations, ~39 KB) pins the spec's 50 KB
   uncompressed budget in `tests/test_resolved_style_snapshot.py`.
 - **Closed vocabulary per version.** Schema v1's property list is the
diff --git a/tests/test_resolved_style_snapshot.py b/tests/test_resolved_style_snapshot.py
index 160db2ee7..0543bbdd8 100644
--- a/tests/test_resolved_style_snapshot.py
+++ b/tests/test_resolved_style_snapshot.py
@@ -66,15 +66,20 @@ def test_a_dense_axis_stays_inside_the_size_budget() -> None:
     assert snapshot.payload_bytes() < 50_000
 
 
-def test_builder_output_is_insertion_order_independent() -> None:
+def test_builders_fed_the_same_styling_in_any_order_emit_identical_bytes() -> None:
+    # Canonicalization is byte-level, not set-level: declaration slots are
+    # assigned by content and instances sorted by identity at build, so a
+    # cacheable snapshot cannot depend on which chrome happened to be walked
+    # first. Comparing payloads (not declaration sets) is what pins the
+    # instance-index remapping too.
     a, b = rs.SnapshotBuilder(), rs.SnapshotBuilder()
     a.add("title", {"font-size": 18, "color": "#fff"})
     a.add("axis_title", {"font-size": 12})
+    a.add("tick_label", {"font-size": 12}, qualifiers=("x", "0"))
+    b.add("tick_label", {"font-size": 12}, qualifiers=("x", "0"))
     b.add("axis_title", {"font-size": 12})
     b.add("title", {"color": "#fff", "font-size": 18})
-    left = a.build(_env()).declarations
-    right = b.build(_env()).declarations
-    assert set(map(tuple, (d.items() for d in left))) == set(map(tuple, (d.items() for d in right)))
+    assert a.build(_env()).to_payload() == b.build(_env()).to_payload()
 
 
 def test_empty_declarations_are_refused() -> None:
@@ -92,9 +97,17 @@ def test_empty_declarations_are_refused() -> None:
         ("calc(100% - 8px)", "cascade"),
         ("env(safe-area-inset-top)", "cascade"),
         ("inherit", "cascade"),
+        ("unset", "cascade"),
+        ("revert-layer", "cascade"),
         ("1.5em", "re-derive"),
         ("120%", "re-derive"),
         ("2rem", "re-derive"),
+        # Relative units anywhere in the value, not only as a whole-string
+        # suffix — the shapes that slipped the earlier end-anchored check.
+        ("translate(50%, 20%)", "re-derive"),
+        ("2em 1em", "re-derive"),
+        ("linear-gradient(45deg, red 50%, blue 50%)", "re-derive"),
+        ("0.5ch", "re-derive"),
         (float("nan"), "finite"),
         (float("inf"), "finite"),
         (True, "numbers or strings"),
@@ -115,6 +128,16 @@ def test_concrete_values_pass_unchanged() -> None:
     assert rs.assert_resolved("transform", "matrix(1, 0, 0, 1, 4, 8)")
 
 
+def test_cascade_keywords_reject_as_whole_values_not_substrings() -> None:
+    # `inherit` as the value defers to a cascade; a face that merely contains
+    # the letters is a concrete string. Substring matching rejected the
+    # latter; whole-value matching may not miss the former.
+    assert rs.assert_resolved("font-family", "Inheritance Sans") == "Inheritance Sans"
+    assert rs.assert_resolved("font-family", '"Unsettled Grotesk", sans-serif')
+    with pytest.raises(ValueError, match="cascade"):
+        rs.assert_resolved("font-family", "  INHERIT  ")
+
+
 def test_vocabulary_is_closed_per_version() -> None:
     with pytest.raises(ValueError, match="STYLE_SNAPSHOT_VERSION"):
         rs.assert_resolved("backdrop-filter", "blur(4px)")
@@ -128,6 +151,12 @@ def test_tokens_carry_open_names_but_the_same_value_contract() -> None:
     assert snapshot.tokens["--chart-legend-bg"] == "#0f172a"
     with pytest.raises(ValueError, match="cascade"):
         builder.build(_env(), tokens={"--chart-legend-bg": "var(--slate-900)"})
+    # The whole string contract, not just the function markers: a token
+    # `1.5em` smuggles the same document dependency a declaration would.
+    with pytest.raises(ValueError, match="re-derive"):
+        builder.build(_env(), tokens={"--chart-pad": "1.5em"})
+    with pytest.raises(ValueError, match="empty"):
+        builder.build(_env(), tokens={"--chart-pad": "  "})
 
 
 # -- wire round-trip ---------------------------------------------------------
@@ -183,11 +212,40 @@ def test_malformed_payloads_fail_loudly() -> None:
         rs.snapshot_from_payload(smuggled)
 
 
+def test_the_payload_path_enforces_the_builders_contract() -> None:
+    # from_payload is the untrusted end of the wire: a payload that could
+    # only have been made by bypassing the builder must not round-trip into
+    # renderer-facing IR. Same vocabulary, same validators, both ends.
+    builder = rs.SnapshotBuilder()
+    builder.add("title", {"font-size": 18})
+    good = builder.build(_env()).to_payload()
+
+    sepia = {**good, "environment": {**good["environment"], "color_scheme": "sepia"}}
+    with pytest.raises(ValueError, match="color_scheme"):
+        rs.snapshot_from_payload(sepia)
+
+    unresolved_token = {**good, "tokens": {"--fg": "var(--slate-50)"}}
+    with pytest.raises(ValueError, match="cascade"):
+        rs.snapshot_from_payload(unresolved_token)
+
+    relative_token = {**good, "tokens": {"--pad": "2em"}}
+    with pytest.raises(ValueError, match="re-derive"):
+        rs.snapshot_from_payload(relative_token)
+
+    non_finite = {**good, "environment": {**good["environment"], "width": float("nan")}}
+    with pytest.raises(ValueError, match="finite"):
+        rs.snapshot_from_payload(non_finite)
+
+
 def test_environment_is_validated() -> None:
     with pytest.raises(ValueError, match="color_scheme"):
         rs.SnapshotBuilder().build(
             rs.SnapshotEnvironment(width=100, height=100, color_scheme="sepia")
         )
+    with pytest.raises(ValueError, match="finite"):
+        rs.SnapshotBuilder().build(rs.SnapshotEnvironment(width=float("inf"), height=100))
+    with pytest.raises(ValueError, match="finite"):
+        rs.SnapshotBuilder().build(rs.SnapshotEnvironment(width=100, height=100, dpr=0.0))
 
 
 # -- the TypeScript mirror ---------------------------------------------------

From 4324206ae7c2951da5fe0ade10444f670642a61d Mon Sep 17 00:00:00 2001
From: Alek Petuskey <alek@reflex.dev>
Date: Tue, 4 Aug 2026 14:15:28 -0700
Subject: [PATCH 07/27] Second review round: legend property-level routing and
 payload hardening
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The legend qualification was rounding toward silence: a declaration-level
"qualified, lost=()" let a legend letter-spacing or font-family on the
raster path slip past warn and strict entirely. The writer module now owns
its merged-declaration box vocabulary (_svg.LEGEND_BOX_PROPS, next to the
alias table it already keeps), and the preflight routes legend declarations
at property level — text subset per family, plus the box set, and a name in
neither is a provable loss the modes act on.

Percentages inside rgb()/hsl() are color components against a fixed channel
range, not document-relative lengths; the repo's own color contract accepts
them and the compilers emit them, so the concreteness scan masks those
function bodies before rejecting stray percentages (lengths and gradient
stop positions still reject).

The canonical declaration sort is type-tagged: both value kinds are legal
per property, so {"font-size": 11} next to {"font-size": "11px"} must sort,
not raise. snapshot_from_payload raises ValueError for every malformed
shape (missing environment, instances without s/d, non-numeric geometry,
non-mapping declarations) — the deserialization boundary must never leak a
KeyError where callers catch ValueError.

xy.styling resolves its submodules lazily (PEP 562): capabilities reaches
the writers' constants and through them the native library, so importing
the package now costs nothing until a submodule is used — the legacy path's
zero-import guarantee extends to the package itself, with a subprocess test
pinning it. The preflight module docstring now says what the module does:
the reporting core stays report-only; enforce is the one function that acts,
and only for warn and strict.
---
 python/xy/_svg.py                        | 22 +++++++++
 python/xy/styling/__init__.py            | 21 +++++++-
 python/xy/styling/preflight.py           | 30 +++++------
 python/xy/styling/resolved.py            | 63 ++++++++++++++++++++----
 tests/test_resolved_style_snapshot.py    | 46 +++++++++++++++++
 tests/test_style_compatibility_report.py | 44 +++++++++++++++--
 6 files changed, 196 insertions(+), 30 deletions(-)

diff --git a/python/xy/_svg.py b/python/xy/_svg.py
index e436e6ff7..73543eeab 100644
--- a/python/xy/_svg.py
+++ b/python/xy/_svg.py
@@ -1406,6 +1406,28 @@ def slot_styles(spec: dict[str, Any]) -> dict[str, dict[str, Any]]:
     "row-gap": "rowGap",
 }
 
+#: The legend frame's merged-declaration vocabulary, in every accepted
+#: spelling — the box properties `legend_options_with_slot` folds and the
+#: writers honor, per the capability-matrix legend note. The preflight
+#: consumes this to route legend declarations at property level: a name in
+#: neither this set nor the text subsets has no channel to a static file
+#: and is a provable loss, not a qualified maybe. Owned by this module so
+#: the writers and the report cannot drift apart.
+LEGEND_BOX_PROPS: frozenset[str] = frozenset(
+    {
+        "background",
+        "background-color",
+        "box-shadow",
+        "boxShadow",
+        "border-radius",
+        "borderRadius",
+        "padding",
+        "row-gap",
+        "rowGap",
+        "--xy-legend-frame-alpha",
+    }
+)
+
 
 def legend_options_with_slot(spec: dict[str, Any], options: dict[str, Any]) -> dict[str, Any]:
     """Fold the chart-level legend styling into a legend's own options, so every
diff --git a/python/xy/styling/__init__.py b/python/xy/styling/__init__.py
index 6020fd65c..fcfe8b3bf 100644
--- a/python/xy/styling/__init__.py
+++ b/python/xy/styling/__init__.py
@@ -12,10 +12,29 @@
 `resolved` is the renderer-neutral styling IR those two converge on: the
 versioned, interned `ResolvedStyleSnapshot` of concrete values that every
 resolver produces and every renderer consumes.
+
+Submodules resolve lazily (PEP 562): `capabilities` reaches the writers'
+constants and, through them, the native library — so importing this package
+costs nothing until a submodule is actually used. That keeps the documented
+zero-import guarantee of the `legacy` export path true even for code that
+imports `xy.styling` itself.
 """
 
 from __future__ import annotations
 
-from . import capabilities, preflight, resolved
+import importlib
+from typing import Any
 
 __all__ = ["capabilities", "preflight", "resolved"]
+
+
+def __getattr__(name: str) -> Any:
+    if name in __all__:
+        module = importlib.import_module(f".{name}", __name__)
+        globals()[name] = module
+        return module
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+def __dir__() -> list[str]:
+    return sorted(set(globals()) | set(__all__))
diff --git a/python/xy/styling/preflight.py b/python/xy/styling/preflight.py
index 73246a184..b7df4991c 100644
--- a/python/xy/styling/preflight.py
+++ b/python/xy/styling/preflight.py
@@ -3,9 +3,11 @@
 `chart.style_compatibility_report(target=...)` answers `spec/api/export.md` §9
 programmatically, per chart, before any bytes exist: for the requested target
 and engine it lists which styling sources are present, how each styled slot
-routes, and exactly which declarations would not survive. Nothing here changes
-export behavior — the staged `compatibility=` modes that act on this report
-land separately, so this module can be trusted from any code path.
+routes, and exactly which declarations would not survive. The reporting core
+(`preflight`, `route_resolved`) changes no export behavior and can be trusted
+from any code path; `enforce` is the one function that acts on a report — it
+warns in `compatibility="warn"` and refuses in `"strict"`, and does nothing
+at all in the default `"legacy"`.
 
 Three rules keep the report honest:
 
@@ -183,19 +185,20 @@ def _slot_family(fmt: str) -> str:
 def _honored_props(slot: str, family: str) -> tuple[frozenset[str], str]:
     """(honored property names, qualifier) for a native-subset slot.
 
-    The subsets are the writers' own constants. `legend` honors box properties
-    beyond the shared text subset through its merged-declaration channel; that
-    set lives in the writer's merge logic rather than a constant yet, so the
-    report stays at declaration granularity there instead of guessing — the
-    qualifier says so, and the shared IR change makes it exact.
+    The subsets are the writers' own constants — the text properties per
+    family, plus the legend frame's merged-declaration box vocabulary
+    (`_svg.LEGEND_BOX_PROPS`, owned by the writer module). A legend property
+    in neither set has no channel into a static file and is a provable loss:
+    the earlier declaration-level qualification rounded exactly those to
+    silence, which let warn stay quiet and strict permit a drop.
     """
     from .. import _svg
 
     text = frozenset(_svg.SLOT_RASTER_PROPS if family == "native_raster" else _svg.SLOT_TEXT_PROPS)
     if slot == "legend":
-        return text, (
-            "box properties (background, shadow, radius, padding) route through the "
-            "merged legend declaration; see the capability matrix legend note"
+        return text | _svg.LEGEND_BOX_PROPS, (
+            "box properties route through the merged legend declaration; see the "
+            "capability matrix legend note"
         )
     return text, ""
 
@@ -260,10 +263,7 @@ def _styles_finding(slot: str, decls: dict[str, Any], fmt: str) -> SlotFinding:
     honored, qualifier = _honored_props(slot, family)
     kept = tuple(p for p in props if p in honored)
     lost = tuple(p for p in props if p not in honored)
-    if slot == "legend":
-        # Declaration-level: unlisted properties may still route through the
-        # merged legend channel, so they are qualified rather than declared
-        # lost (§28: unsure is said out loud, not rounded either direction).
+    if slot == "legend" and not lost:
         return SlotFinding(
             slot=slot,
             source="styles",
diff --git a/python/xy/styling/resolved.py b/python/xy/styling/resolved.py
index 81ec581ae..52a1ff02d 100644
--- a/python/xy/styling/resolved.py
+++ b/python/xy/styling/resolved.py
@@ -121,7 +121,10 @@
 #: A relative-unit length *anywhere* in the value — `translate(50%, 20%)`,
 #: a `2em 1em` shorthand, a gradient stop — not only as a whole-string
 #: suffix. Mid-string relative units are precisely the ones that slipped a
-#: document dependency past the earlier end-anchored check.
+#: document dependency past the earlier end-anchored check. Built from
+#: module constants through `re.escape`, so the non-literal-pattern lint
+#: does not apply: no untrusted text ever reaches `re.compile`, and the
+#: alternation is a fixed set of unit suffixes.
 _RELATIVE_UNIT_RE = re.compile(
     r"(?<![a-z0-9.#_-])\d*\.?\d+(?:"
     + "|".join(map(re.escape, _RELATIVE_UNITS))
@@ -129,6 +132,14 @@
     re.IGNORECASE,
 )
 
+#: Percentages inside `rgb()`/`hsl()` (and their alpha forms) are color
+#: components resolved against a fixed channel range, not against document
+#: metrics — the repo's own color contract (`_validate.css_color`) accepts
+#: `hsl(210 40% 96%)` and the style compilers emit such text. Those function
+#: bodies are masked out before the relative-unit scan; a percentage
+#: *outside* them (a length, a gradient stop position) still rejects.
+_COLOR_FUNCTION_RE = re.compile(r"(?:rgba?|hsla?)\([^()]*\)", re.IGNORECASE)
+
 _COLOR_SCHEMES = frozenset({"light", "dark"})
 
 
@@ -149,12 +160,13 @@ def _assert_concrete_text(label: str, value: str) -> str:
                 f"{label}: {text!r} still depends on a cascade the renderer does not "
                 f"have ({marker.rstrip('(')}); resolve it before it enters the snapshot"
             )
-    relative = _RELATIVE_UNIT_RE.search(lowered)
+    relative = _RELATIVE_UNIT_RE.search(_COLOR_FUNCTION_RE.sub("", lowered))
     if relative is not None:
         raise ValueError(
             f"{label}: {text!r} carries {relative.group(0)!r}, which is relative to "
             "metrics the consumer would have to re-derive; resolved lengths are "
-            "plain numbers in CSS px"
+            "plain numbers in CSS px (percentages are accepted only as "
+            "rgb()/hsl() color components)"
         )
     return text
 
@@ -340,7 +352,7 @@ def build(
         # so logically identical styling is byte-identical on the wire.
         order = sorted(
             range(len(self._declarations)),
-            key=lambda i: tuple(self._declarations[i].items()),
+            key=lambda i: _declaration_sort_key(self._declarations[i]),
         )
         remap = {old: new for new, old in enumerate(order)}
         instances = sorted(
@@ -373,6 +385,25 @@ def build(
         )
 
 
+def _declaration_sort_key(
+    declaration: Mapping[str, str | float],
+) -> tuple[tuple[str, int, float, str], ...]:
+    """A total order over declarations whose values mix numbers and strings.
+
+    `assert_resolved` accepts both value kinds for every property, so
+    `{"font-size": 11}` and `{"font-size": "11px"}` are individually legal —
+    a raw `tuple(items())` key would compare `11.0 < "11px"` and raise.
+    Type-tagging (numbers before strings per property) keeps the canonical
+    order deterministic without comparing across kinds.
+    """
+    return tuple(
+        (prop, 0, float(value), "")
+        if isinstance(value, (int, float))
+        else (prop, 1, 0.0, str(value))
+        for prop, value in declaration.items()
+    )
+
+
 def _validated_environment(
     width: object, height: object, dpr: object, color_scheme: object
 ) -> SnapshotEnvironment:
@@ -420,19 +451,33 @@ def snapshot_from_payload(payload: Mapping[str, Any]) -> ResolvedStyleSnapshot:
             f"style snapshot version {version!r} is not supported "
             f"(this build reads v{STYLE_SNAPSHOT_VERSION}); refusing to guess"
         )
+    # Deserialization failures are ValueError with the module's message
+    # style, whatever malformed shape produced them: this is the untrusted
+    # end of the wire, and a caller catching ValueError at the boundary must
+    # not meet a KeyError or TypeError instead.
+    if "environment" not in payload:
+        raise ValueError("style snapshot payload is missing 'environment'")
     env = payload["environment"]
-    declarations = [
-        {prop: assert_resolved(prop, value) for prop, value in decl.items()}
-        for decl in payload.get("declarations", ())
-    ]
+    if not isinstance(env, Mapping) or "width" not in env or "height" not in env:
+        raise ValueError(f"style snapshot environment must map width/height: {env!r}")
+    declarations = []
+    for decl in payload.get("declarations", ()):
+        if not isinstance(decl, Mapping):
+            raise ValueError(f"declaration {decl!r} must be a property mapping")
+        declarations.append({prop: assert_resolved(prop, value) for prop, value in decl.items()})
     instances = []
     for raw in payload.get("instances", ()):
+        if not isinstance(raw, Mapping) or "s" not in raw or "d" not in raw:
+            raise ValueError(f"instance {raw!r} must carry a slot ('s') and declaration ('d')")
         index = raw["d"]
         if not isinstance(index, int) or not 0 <= index < len(declarations):
             raise ValueError(f"instance {raw!r} references declaration {index!r}, which is absent")
         geometry: Optional[tuple[float, float, float, float]] = None
         if "g" in raw:
-            values = tuple(float(v) for v in raw["g"])
+            try:
+                values = tuple(float(v) for v in raw["g"])
+            except (TypeError, ValueError) as exc:
+                raise ValueError(f"instance {raw!r} geometry must be four finite numbers") from exc
             if len(values) != 4 or not all(math.isfinite(v) for v in values):
                 raise ValueError(f"instance {raw!r} geometry must be four finite numbers")
             geometry = values
diff --git a/tests/test_resolved_style_snapshot.py b/tests/test_resolved_style_snapshot.py
index 0543bbdd8..bb628936d 100644
--- a/tests/test_resolved_style_snapshot.py
+++ b/tests/test_resolved_style_snapshot.py
@@ -128,6 +128,32 @@ def test_concrete_values_pass_unchanged() -> None:
     assert rs.assert_resolved("transform", "matrix(1, 0, 0, 1, 4, 8)")
 
 
+def test_percentages_inside_color_functions_are_concrete() -> None:
+    # A % inside rgb()/hsl() is a color component against a fixed channel
+    # range — the repo's own color contract accepts it and the compilers
+    # emit it. A % outside those bodies (a length, a gradient stop) still
+    # carries a document dependency and still rejects.
+    assert rs.assert_resolved("color", "hsl(210 40% 96%)") == "hsl(210 40% 96%)"
+    assert rs.assert_resolved("fill", "rgb(100% 0% 0%)") == "rgb(100% 0% 0%)"
+    assert rs.assert_resolved("background-image", "linear-gradient(hsl(210 40% 96%), #fff)")
+    with pytest.raises(ValueError, match="re-derive"):
+        rs.assert_resolved("background-image", "linear-gradient(hsl(210 40% 96%) 50%, #fff)")
+    with pytest.raises(ValueError, match="re-derive"):
+        rs.assert_resolved("width", "50%")
+
+
+def test_mixed_value_kinds_sort_canonically_without_error() -> None:
+    # Both value kinds are legal per property, so the canonical sort key is
+    # type-tagged; a raw items() comparison would raise TypeError on
+    # {"font-size": 11} vs {"font-size": "11px"}.
+    a, b = rs.SnapshotBuilder(), rs.SnapshotBuilder()
+    a.add("title", {"font-size": 11})
+    a.add("axis_title", {"font-size": "11px"})
+    b.add("axis_title", {"font-size": "11px"})
+    b.add("title", {"font-size": 11})
+    assert a.build(_env()).to_payload() == b.build(_env()).to_payload()
+
+
 def test_cascade_keywords_reject_as_whole_values_not_substrings() -> None:
     # `inherit` as the value defers to a cascade; a face that merely contains
     # the letters is a concrete string. Substring matching rejected the
@@ -212,6 +238,26 @@ def test_malformed_payloads_fail_loudly() -> None:
         rs.snapshot_from_payload(smuggled)
 
 
+def test_malformed_payload_shapes_raise_value_error_not_key_error() -> None:
+    # The deserialization boundary raises ValueError for every malformed
+    # shape — a caller catching ValueError there must never meet a
+    # KeyError, TypeError, or AttributeError instead.
+    builder = rs.SnapshotBuilder()
+    builder.add("title", {"font-size": 18})
+    good = builder.build(_env()).to_payload()
+
+    for broken, why in [
+        ({k: v for k, v in good.items() if k != "environment"}, "missing 'environment'"),
+        ({**good, "environment": "nope"}, "width/height"),
+        ({**good, "instances": [{"d": 0}]}, "slot"),
+        ({**good, "instances": [{"s": "title"}]}, "declaration"),
+        ({**good, "instances": [{"s": "title", "d": 0, "g": ["x", 1, 2, 3]}]}, "four finite"),
+        ({**good, "declarations": ["not-a-mapping"]}, "property mapping"),
+    ]:
+        with pytest.raises(ValueError, match=why):
+            rs.snapshot_from_payload(broken)
+
+
 def test_the_payload_path_enforces_the_builders_contract() -> None:
     # from_payload is the untrusted end of the wire: a payload that could
     # only have been made by bypassing the builder must not round-trip into
diff --git a/tests/test_style_compatibility_report.py b/tests/test_style_compatibility_report.py
index 07cc73303..8c07a9a67 100644
--- a/tests/test_style_compatibility_report.py
+++ b/tests/test_style_compatibility_report.py
@@ -123,17 +123,32 @@ def test_root_styles_point_at_the_token_bag_channel() -> None:
     assert "style=" in finding.detail
 
 
-def test_legend_styles_are_qualified_not_guessed() -> None:
-    # Box properties route through the merged legend declaration; until the
-    # shared IR makes that set a constant, the report qualifies rather than
-    # declaring a loss it cannot prove (or a survival it cannot prove).
-    report = _chart(styles={"legend": {"background": "black"}}).style_compatibility_report("png")
+def test_legend_styles_route_at_property_level() -> None:
+    # Box properties route through the merged legend declaration
+    # (`_svg.LEGEND_BOX_PROPS`, writer-owned), text properties through the
+    # per-family subsets — and a property in neither set is a provable loss.
+    # The earlier declaration-level qualification rounded those to silence,
+    # which let warn stay quiet and strict permit a drop.
+    boxed = _chart(styles={"legend": {"background": "black", "border-radius": "6px"}})
+    report = boxed.style_compatibility_report("png")
     finding = _finding(report, "legend", "styles")
     assert finding.route == pf.ROUTE_SUBSET
     assert finding.lost == ()
+    assert set(finding.kept) == {"background", "border-radius"}
     assert "merged legend declaration" in finding.detail
     assert report.lossless
 
+    # letter-spacing on the raster path is in neither the raster text subset
+    # nor the box vocabulary: named lost, not qualified away.
+    lossy = _chart(styles={"legend": {"letter_spacing": "0.08em", "background": "black"}})
+    raster = lossy.style_compatibility_report("png")
+    finding = _finding(raster, "legend", "styles")
+    assert finding.lost == ("letter-spacing",)
+    assert "background" in finding.kept
+    assert not raster.lossless
+    # The same declaration survives the vector writers, which honor it.
+    assert lossy.style_compatibility_report("svg").lossless
+
 
 def test_state_gated_styles_do_not_block_lossless() -> None:
     report = _chart(
@@ -224,6 +239,25 @@ def test_explain_names_every_route() -> None:
     assert "loss(es)" in text
 
 
+def test_importing_the_styling_package_loads_no_machinery() -> None:
+    # The package resolves submodules lazily (PEP 562): `capabilities`
+    # reaches the writers' constants and through them the native library, so
+    # a bare `import xy.styling` must not pay for any of it — the legacy
+    # path's zero-import guarantee extends to the package itself.
+    import subprocess
+    import sys as _sys
+
+    probe = (
+        "import sys; import xy.styling; "
+        "print(sorted(m for m in ('xy.styling.preflight', 'xy.styling.capabilities', "
+        "'xy.styling.resolved', 'xy._svg') if m in sys.modules))"
+    )
+    result = subprocess.run(
+        [_sys.executable, "-c", probe], capture_output=True, text=True, check=True
+    )
+    assert result.stdout.strip() == "[]"
+
+
 def test_chart_report_is_the_figure_report() -> None:
     chart = _chart(class_names={"legend": "x"})
     via_chart = chart.style_compatibility_report("png")

From 24fa109b93d573bc8b2e905ace0ecb7ff22fd97a Mon Sep 17 00:00:00 2001
From: Alek Petuskey <alek@reflex.dev>
Date: Tue, 4 Aug 2026 14:28:54 -0700
Subject: [PATCH 08/27] Route the static slots through the
 ResolvedStyleSnapshot, byte-equivalently
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

xy.styling.declared.resolve_declared is the Python half of the two-resolver
architecture: one pass over a spec's per-slot declarations produces both
the byte-exact view the writers read (kebab-case normalization, authored
objects preserved — an authored int 600 must stay an int because f-string
emission spells 600 and 600.0 apart) and the interned ResolvedStyleSnapshot
of the same content for every IR consumer. _svg.slot_styles now derives its
result through the resolver, so the writers and the IR cannot disagree
about what was declared — the existing export-style-survival and image
suites pass unchanged, which is the byte-equivalence gate.

The gap between view and snapshot is exactly enumerable and tested, not
silent (§28): presentational number formatting (schema numbers are floats
by wire contract), plus the legend's em multipliers — padding/row-gap/
font-size em strings are the legend's own geometry domain (_legend_em
consumes multipliers, not CSS lengths), so schema v1 rightly refuses them
and they ride DeclaredStyling.writer_domain beside the snapshot. The
chrome-parity work moves legend geometry to resolved px and retires the
residue. Chart tokens ride the snapshot's token bag, minus var()-bearing
values the declared resolver has no cascade for — the same values a static
file already cannot honor.
---
 python/xy/_svg.py               |  20 ++---
 python/xy/styling/declared.py   | 140 ++++++++++++++++++++++++++++++++
 tests/test_declared_snapshot.py | 129 +++++++++++++++++++++++++++++
 3 files changed, 279 insertions(+), 10 deletions(-)
 create mode 100644 python/xy/styling/declared.py
 create mode 100644 tests/test_declared_snapshot.py

diff --git a/python/xy/_svg.py b/python/xy/_svg.py
index 73543eeab..aed797608 100644
--- a/python/xy/_svg.py
+++ b/python/xy/_svg.py
@@ -1383,17 +1383,17 @@ def slot_styles(spec: dict[str, Any]) -> dict[str, dict[str, Any]]:
     `chrome_styles` keeps whatever spelling the caller used (`font_size` and
     `font-size` both reach the browser, which sees the same declaration); the
     static writers match on property names, so they need one spelling.
+
+    Since the resolved-style IR landed, this view is produced by the declared
+    resolver (`xy.styling.declared.resolve_declared`), which builds the
+    interned `ResolvedStyleSnapshot` from the same normalization in the same
+    pass — the writers keep reading the byte-exact authored view, and every
+    IR consumer reads the snapshot, so the two cannot disagree about what was
+    declared.
     """
-    raw = (spec.get("dom") or {}).get("styles") or {}
-    out: dict[str, dict[str, Any]] = {}
-    for slot, decls in raw.items():
-        if not isinstance(decls, dict):
-            continue
-        out[str(slot)] = {
-            (k if str(k).startswith("--") else str(k).replace("_", "-")): v
-            for k, v in decls.items()
-        }
-    return out
+    from .styling.declared import resolve_declared
+
+    return resolve_declared(spec).slot_view()
 
 
 #: `styles={"legend": ...}` is CSS; `xy.legend(style=...)` reaches the writers
diff --git a/python/xy/styling/declared.py b/python/xy/styling/declared.py
new file mode 100644
index 000000000..cb59daeb3
--- /dev/null
+++ b/python/xy/styling/declared.py
@@ -0,0 +1,140 @@
+"""The declared-styling resolver: a figure's authored chrome styling as a
+`ResolvedStyleSnapshot`, beside the byte-exact view the writers consume.
+
+This is the Python half of the two-resolver architecture (`resolved.py`
+module docstring): the browser capture resolves the *computed* cascade; this
+module resolves what the chart *declared* — per-slot `styles=`, normalized
+to the writers' kebab-case spelling, interned per distinct declaration.
+
+Two outputs, one construction, deliberately separate:
+
+- `slot_view()` is the mapping the static writers read — byte-for-byte the
+  old `_svg.slot_styles` result, authored objects preserved (an authored
+  `600` stays `int`, so emitted attributes keep their exact spelling).
+- `snapshot` is the same declared content as IR: every schema-legal value
+  interned (numbers as floats, per the wire contract). New consumers — the
+  snapshot export path, capability tooling, the capture diff — read this.
+
+The divergence between the two is presentational number formatting plus one
+named residue (§28, recorded not smuggled): the legend's geometry runs in em
+multipliers (`_svg._legend_em` — `padding`/`row-gap`/`font-size` em strings
+are the legend's own unit domain, not CSS lengths to pre-resolve), and
+schema v1 rightly refuses relative units, so those values appear in
+`writer_domain` and the view but not the snapshot. The chrome-parity phase
+moves legend geometry to resolved px and retires both divergences;
+`tests/test_declared_snapshot.py` pins the view equivalence and enumerates
+the residue until then.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Optional
+
+from ..dom import CHART_DOM_SLOTS
+from .resolved import ResolvedStyleSnapshot, SnapshotBuilder, SnapshotEnvironment, assert_resolved
+
+
+@dataclass(frozen=True)
+class DeclaredStyling:
+    """A figure's declared chrome styling: writer view + IR snapshot."""
+
+    snapshot: ResolvedStyleSnapshot
+    writer_domain: dict[str, dict[str, Any]] = field(default_factory=dict)
+    _view: dict[str, dict[str, Any]] = field(default_factory=dict)
+
+    def slot_view(self) -> dict[str, dict[str, Any]]:
+        """The writers' mapping — identical to the pre-IR `slot_styles`."""
+        return {slot: dict(decls) for slot, decls in self._view.items()}
+
+
+def _kebab(name: object) -> str:
+    text = str(name)
+    return text if text.startswith("--") else text.replace("_", "-")
+
+
+def resolve_declared(
+    spec: dict[str, Any],
+    *,
+    width: Optional[float] = None,
+    height: Optional[float] = None,
+) -> DeclaredStyling:
+    """Resolve `spec`'s per-slot declarations into view + snapshot.
+
+    View normalization is byte-for-byte the old `_svg.slot_styles` rule —
+    kebab-case property spelling, custom properties untouched, non-mapping
+    slots skipped, unknown slots passed through (the spec build already
+    rejects them for real charts). Every schema-legal value additionally
+    interns into the snapshot; each value the schema refuses lands in
+    `writer_domain` instead, so nothing declared is dropped in either
+    direction and the not-yet-IR remainder is exactly enumerable.
+    """
+    dom = spec.get("dom") or {}
+    raw = dom.get("styles") or {}
+    style = dom.get("style") or {}
+    builder = SnapshotBuilder()
+    view: dict[str, dict[str, Any]] = {}
+    writer_domain: dict[str, dict[str, Any]] = {}
+    for slot, decls in raw.items():
+        if not isinstance(decls, dict):
+            continue
+        slot_name = str(slot)
+        normalized = {_kebab(prop): value for prop, value in decls.items()}
+        view[slot_name] = normalized
+        if slot_name not in CHART_DOM_SLOTS:
+            writer_domain[slot_name] = dict(normalized)
+            continue
+        legal: dict[str, Any] = {}
+        residue: dict[str, Any] = {}
+        for name, value in normalized.items():
+            try:
+                assert_resolved(name, value)
+            except ValueError:
+                residue[name] = value
+            else:
+                legal[name] = value
+        if legal:
+            builder.add(slot_name, legal)
+        if residue:
+            writer_domain[slot_name] = residue
+    environment = SnapshotEnvironment(
+        width=_dimension(width, spec.get("width"), 800.0),
+        height=_dimension(height, spec.get("height"), 500.0),
+    )
+    snapshot = builder.build(environment, tokens=_concrete_tokens(style))
+    return DeclaredStyling(snapshot=snapshot, writer_domain=writer_domain, _view=view)
+
+
+def _dimension(override: Optional[float], declared: Any, fallback: float) -> float:
+    for candidate in (override, declared):
+        if isinstance(candidate, (int, float)) and not isinstance(candidate, bool):
+            value = float(candidate)
+            if value > 0:
+                return value
+    return fallback
+
+
+def _concrete_tokens(style: Any) -> dict[str, Any]:
+    """The chart token bag, minus values the schema cannot carry yet.
+
+    The bag is already renderer-neutral (every writer reads it), so almost
+    everything passes; a var()-bearing token is browser-resolved chrome the
+    declared resolver has no cascade for, and stays out of the snapshot the
+    same way it stays out of a static file today.
+    """
+    from .resolved import assert_resolved_token
+
+    if not isinstance(style, dict):
+        return {}
+    out: dict[str, Any] = {}
+    for name, value in style.items():
+        if isinstance(value, bool) or not isinstance(value, (str, int, float)):
+            continue
+        try:
+            out[str(name)] = assert_resolved_token(name, value)
+        except ValueError:
+            continue
+    return out
+
+
+__all__ = ["DeclaredStyling", "resolve_declared"]
diff --git a/tests/test_declared_snapshot.py b/tests/test_declared_snapshot.py
new file mode 100644
index 000000000..c6524d020
--- /dev/null
+++ b/tests/test_declared_snapshot.py
@@ -0,0 +1,129 @@
+"""The declared resolver: one pass, two outputs, zero drift between them.
+
+`slot_view()` must be byte-for-byte the old `_svg.slot_styles` normalization
+(the writers' output bytes depend on it), the snapshot must carry every
+schema-legal declared value, and the difference between the two must be
+exactly the enumerable writer-domain residue — nothing silent in the gap.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+import xy
+from xy import _svg
+from xy.styling.declared import resolve_declared
+
+
+def _spec(**props):
+    chart = xy.scatter_chart(xy.scatter([1.0, 2.0, 3.0], [2.0, 1.0, 3.0]), **props)
+    spec, _buffers = chart.figure().build_payload()
+    return spec
+
+
+def _legacy_slot_styles(spec):
+    # The pre-IR normalization, verbatim — the equivalence oracle.
+    raw = (spec.get("dom") or {}).get("styles") or {}
+    out = {}
+    for slot, decls in raw.items():
+        if not isinstance(decls, dict):
+            continue
+        out[str(slot)] = {
+            (k if str(k).startswith("--") else str(k).replace("_", "-")): v
+            for k, v in decls.items()
+        }
+    return out
+
+
+STYLES = {
+    "tick_label": {"font_weight": 600, "letter_spacing": "0.08em", "color": "#94a3b8"},
+    "legend": {"background": "black", "padding": "1.2em", "row_gap": "0.4em"},
+    "title": {"font-size": 18, "fill": "rgb(100% 0% 0%)"},
+    "tooltip_title": {"color": "red"},
+}
+
+
+def test_slot_view_is_byte_equivalent_to_the_old_normalization() -> None:
+    spec = _spec(styles=STYLES, style={"background": "#111"})
+    view = _svg.slot_styles(spec)
+    legacy = _legacy_slot_styles(spec)
+    assert view == legacy
+    # Object fidelity, not just equality: an authored int must stay an int,
+    # because the writers' f-string emission spells 600 and 600.0 apart.
+    assert isinstance(view["tick_label"]["font-weight"], int)
+
+
+def test_snapshot_carries_every_schema_legal_declaration() -> None:
+    styling = resolve_declared(_spec(styles=STYLES))
+    by_slot = {
+        inst.slot: styling.snapshot.declarations[inst.declaration]
+        for inst in styling.snapshot.instances
+    }
+    assert by_slot["tick_label"]["font-weight"] == 600.0
+    assert by_slot["tick_label"]["color"] == "#94a3b8"
+    assert by_slot["title"]["fill"] == "rgb(100% 0% 0%)"
+    assert by_slot["legend"]["background"] == "black"
+    assert by_slot["tooltip_title"]["color"] == "red"
+
+
+def test_the_residue_is_exactly_the_writer_domain_values() -> None:
+    # The gap between view and snapshot is enumerable and named: legend em
+    # multipliers (the legend's own unit domain) and nothing else here.
+    styling = resolve_declared(_spec(styles=STYLES))
+    assert styling.writer_domain == {
+        "tick_label": {"letter-spacing": "0.08em"},
+        "legend": {"padding": "1.2em", "row-gap": "0.4em"},
+    }
+    # view = snapshot declarations ∪ residue, per slot.
+    view = styling.slot_view()
+    for slot, residue in styling.writer_domain.items():
+        for prop in residue:
+            assert prop in view[slot]
+
+
+def test_identical_slot_declarations_intern_once() -> None:
+    spec = _spec(
+        styles={
+            "axis_title": {"font-size": 12, "color": "#e2e8f0"},
+            "legend_title": {"color": "#e2e8f0", "font-size": 12},
+        }
+    )
+    styling = resolve_declared(spec)
+    assert len(styling.snapshot.declarations) == 1
+    assert len(styling.snapshot.instances) == 2
+
+
+def test_chart_tokens_ride_the_snapshot() -> None:
+    styling = resolve_declared(_spec(style={"background": "#111", "--chart-fg": "#e2e8f0"}))
+    assert styling.snapshot.tokens["background"] == "#111"
+    assert styling.snapshot.tokens["--chart-fg"] == "#e2e8f0"
+
+
+def test_unstyled_chart_resolves_to_an_empty_snapshot() -> None:
+    styling = resolve_declared(_spec())
+    assert styling.snapshot.declarations == ()
+    assert styling.snapshot.instances == ()
+    assert styling.slot_view() == {}
+    assert styling.writer_domain == {}
+
+
+def test_export_bytes_are_unchanged_by_the_routing() -> None:
+    # The real gate: styled exports through the routed slot_styles are
+    # deterministic and carry the styling the writers honored before.
+    chart = xy.scatter_chart(
+        xy.scatter([1.0, 2.0, 3.0], [2.0, 1.0, 3.0]),
+        title="t",
+        styles={"tick_label": {"font_weight": 600}, "title": {"font-size": 18.0}},
+    )
+    svg = chart.to_svg()
+    assert 'font-weight="600"' in svg
+    assert svg == chart.to_svg()
+    png = chart.to_png()
+    assert png == chart.to_png()
+
+
+@pytest.mark.parametrize("bad", [None, "x", 7])
+def test_non_mapping_slot_entries_are_skipped_like_before(bad) -> None:
+    spec = _spec()
+    spec.setdefault("dom", {})["styles"] = {"title": bad, "legend": {"background": "black"}}
+    assert _svg.slot_styles(spec) == {"legend": {"background": "black"}}

From d7c964f088d4f64a31b98f40a013a6c0f0729d89 Mon Sep 17 00:00:00 2001
From: Alek Petuskey <alek@reflex.dev>
Date: Tue, 4 Aug 2026 14:59:56 -0700
Subject: [PATCH 09/27] Capture the live cascade and export it natively (wire
 protocol v13)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Phase 2 of the styling-compatibility program: the browser resolves the
cascade once, and the native writers reproduce it ever after.

The client half (js/src/16_style_capture.ts) walks every rendered
data-xy-slot element after fonts and layout settle (setTimeout ticks, not
rAF — headless hosts throttle rAF on unfocused pages) and reads the
schema's allowlisted computed properties, interned per distinct
declaration. Two capture rules exist because the browser-oracle smoke
failed without them, in order: the computed `background` shorthand
serializes position/size tokens (`0% 0% / auto`) the concreteness gate
rightly refuses, so capture reads the `background-color` longhand under
the schema's name; and SVG presentation properties compute on every
element, so an HTML tick label reports a phantom `fill: rgb(0, 0, 0)` the
writers would prefer over its real `color` — SVG-only paints are captured
from SVG elements alone.

The transport is the reserved v13 pair: style_snapshot_request out,
style_snapshot (or an error, so the kernel future never dangles) back;
FigureWidget.capture_style_snapshot is asynchronous by contract and
validates every reply through snapshot_from_payload at the boundary. A
cached v12 client would silently ignore the request, so the protocol
bumps rather than leaving a timeout mystery.

Exports consume the capture: style_snapshot= on to_png/to_svg/to_image/
write_image overlays the snapshot's declarations for the render (first
instance per slot until chrome parity brings per-instance geometry),
restored after. A supplied snapshot is the lossless remedy the modes
recommend — strict passes with one where it refuses without one — and the
Chromium engine rejects the combination as the contradiction it is.

scripts/style_capture_smoke.py is the browser-as-oracle loop with no
notebook in it: render standalone HTML in headless Chromium, capture via
the public window.xy.captureStyleSnapshot, validate through the Python
schema, and assert an exact custom_css-resolved color lands in a native
SVG export. 51 instances, 36 declarations, ~18 KB against the 50 KB
budget on the smoke chart.
---
 CHANGELOG.md                           |  16 ++
 js/src/00_header.ts                    |   2 +-
 js/src/16_style_capture.ts             | 161 ++++++++++++++++++++
 js/src/54_kernel.ts                    |  25 ++++
 js/src/60_entries.ts                   |   5 +
 python/xy/_figure.py                   |  11 ++
 python/xy/channel.py                   |  14 ++
 python/xy/components.py                |  29 +++-
 python/xy/config.py                    |   6 +-
 python/xy/export.py                    | 100 +++++++++++--
 python/xy/widget.py                    |  47 ++++++
 scripts/style_capture_smoke.py         | 141 +++++++++++++++++
 spec/api/export.md                     |  16 ++
 spec/design/wire-protocol.md           |  33 ++--
 tests/test_style_snapshot_transport.py | 200 +++++++++++++++++++++++++
 15 files changed, 779 insertions(+), 27 deletions(-)
 create mode 100644 js/src/16_style_capture.ts
 create mode 100644 scripts/style_capture_smoke.py
 create mode 100644 tests/test_style_snapshot_transport.py

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e1789617d..6435e8e1c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,6 +9,22 @@ in the README).
 ## [Unreleased]
 
 ### Added
+- Live style capture and snapshot-fed export (wire protocol v13). A mounted
+  chart's `await chart.capture_style_snapshot()` returns the browser's
+  resolved cascade as a validated `ResolvedStyleSnapshot` (the client
+  captures every rendered slot's allowlisted computed properties after
+  fonts/layout settle; replies are validated through the schema at the
+  boundary). Passing it to `to_png(style_snapshot=...)` / `to_svg` /
+  `to_image` / `write_image` makes the native writers reproduce what the
+  browser resolved — host theme, classes, dark mode — with no browser in
+  the export path; `compatibility="strict"` passes with a snapshot where it
+  refuses without one. Standalone documents expose the same capture as
+  `window.xy.captureStyleSnapshot`, and
+  `scripts/style_capture_smoke.py` pins the browser-oracle loop end to end.
+- The declared-styling resolver (`xy.styling.declared`): the writers' slot
+  view now derives from the same pass that builds the interned
+  `ResolvedStyleSnapshot`, byte-equivalently, with the legend's em-domain
+  values as a named, tested residue.
 - The renderer-neutral styling IR: `xy.styling.resolved` defines the
   versioned, interned `ResolvedStyleSnapshot` (schema v1 — concrete values
   only, declarations deduped, instances referencing them by index), with a
diff --git a/js/src/00_header.ts b/js/src/00_header.ts
index 9f1482eb4..9a17e9c26 100644
--- a/js/src/00_header.ts
+++ b/js/src/00_header.ts
@@ -46,7 +46,7 @@
 // v12: polar angular axes carry `sector`/`grid_shape`, and radial axes carry
 // `hole`/`r_origin`. A v11 client would accept those fields but silently draw
 // full circular, centre-origin geometry.
-export const PROTOCOL = 12;
+export const PROTOCOL = 13;
 
 // Every GL buffer field a built trace — or a drill / sample-overlay clone of
 // one — can own. Teardown reads this list instead of a hand-kept subset: the
diff --git a/js/src/16_style_capture.ts b/js/src/16_style_capture.ts
new file mode 100644
index 000000000..ac51eec5e
--- /dev/null
+++ b/js/src/16_style_capture.ts
@@ -0,0 +1,161 @@
+// Browser computed-style capture: the live cascade as a ResolvedStyleSnapshot.
+//
+// The client-side half of the two-resolver architecture (wire-protocol §8):
+// walk every rendered `data-xy-slot` element, read the allowlisted computed
+// properties (concrete used values by definition — no var(), no relative
+// units survive getComputedStyle), intern identical declarations, and emit
+// the same payload shape `python/xy/styling/resolved.py` validates on
+// arrival. Never called from the hover or animation path: the kernel invokes
+// it only for an explicit `style_snapshot_request`, after fonts and layout
+// settle (54_kernel.ts).
+
+import type { ResolvedStyleSnapshot, StyleSnapshotInstance } from "./14_style_snapshot";
+import { STYLE_SNAPSHOT_PROPERTIES, STYLE_SNAPSHOT_VERSION } from "./14_style_snapshot";
+
+// Computed values that carry no styling information for a slot: recording
+// them would bloat declarations without distinguishing anything (interning
+// still works, but the payload budget is finite and "none" says nothing).
+// Fully-transparent background is the browser's spelling of "unpainted",
+// which is exactly the writers' default — absence, not a declaration.
+const SKIP_VALUES = new Set(["", "none", "normal", "auto", "rgba(0, 0, 0, 0)"]);
+
+// Schema properties whose computed form is a shorthand serialization: the
+// computed `background` carries position/size tokens (`0% 0% / auto`) that
+// are serialization sugar, not styling — the schema's concreteness gate
+// rightly refuses them (the smoke caught exactly this). Capture reads the
+// concrete longhand and records it under the schema's name.
+const CAPTURE_SOURCE: Record<string, string> = { background: "background-color" };
+
+// SVG presentation properties compute on EVERY element — an HTML tick label
+// reports `fill: rgb(0, 0, 0)` (the SVG initial paint) it never uses. The
+// writers prefer `fill` over `color`, so capturing that phantom black would
+// outrank the element's real text color (the smoke caught exactly this).
+// These properties are real styling only on SVG elements.
+const SVG_ONLY_PROPERTIES = new Set([
+  "fill",
+  "fill-opacity",
+  "stroke",
+  "stroke-opacity",
+  "stroke-width",
+]);
+
+// Chart tokens ride the snapshot's token bag; they live as custom
+// properties on the chart root.
+const TOKEN_PREFIXES = ["--chart-", "--xy-"];
+
+function num(value: number): number {
+  // Geometry to 1/100 px: sub-centipixel noise is rendering jitter, and
+  // stable payload bytes matter more (canonical-ordering contract).
+  return Math.round(value * 100) / 100;
+}
+
+export function captureStyleSnapshot(
+  root: HTMLElement,
+  opts?: { styleEpoch?: number; states?: readonly string[] },
+): ResolvedStyleSnapshot {
+  const doc = root.ownerDocument;
+  const win = doc.defaultView;
+  if (!win) throw new Error("style capture needs a live window");
+  const rootRect = root.getBoundingClientRect();
+  const rootStyle = win.getComputedStyle(root);
+
+  const declarations: Record<string, string | number>[] = [];
+  const index = new Map<string, number>();
+  const instances: StyleSnapshotInstance[] = [];
+  const perSlotCount = new Map<string, number>();
+
+  const elements = root.querySelectorAll<HTMLElement>("[data-xy-slot]");
+  for (const el of elements) {
+    const slot = el.dataset.xySlot;
+    if (!slot) continue;
+    // Only chrome the document is actually rendering: a hidden tooltip or a
+    // closed modebar menu has no boxes, and a clean capture must not invent
+    // state-gated chrome that is not on screen.
+    if (el.getClientRects().length === 0) continue;
+    const style = win.getComputedStyle(el);
+    const isSvg = el instanceof win.SVGElement;
+    const decl: Record<string, string | number> = {};
+    for (const prop of STYLE_SNAPSHOT_PROPERTIES) {
+      if (!isSvg && SVG_ONLY_PROPERTIES.has(prop)) continue;
+      const value = style.getPropertyValue(CAPTURE_SOURCE[prop] ?? prop).trim();
+      if (!value || SKIP_VALUES.has(value)) continue;
+      decl[prop] = value;
+    }
+    const key = JSON.stringify(
+      Object.keys(decl)
+        .sort()
+        .map((k) => [k, decl[k]]),
+    );
+    let at = index.get(key);
+    if (at === undefined) {
+      at = declarations.length;
+      index.set(key, at);
+      declarations.push(decl);
+    }
+    const nth = perSlotCount.get(slot) ?? 0;
+    perSlotCount.set(slot, nth + 1);
+    const rect = el.getBoundingClientRect();
+    const instance: StyleSnapshotInstance = {
+      s: slot,
+      d: at,
+      q: [String(nth)],
+      g: [
+        num(rect.left - rootRect.left),
+        num(rect.top - rootRect.top),
+        num(rect.width),
+        num(rect.height),
+      ],
+    };
+    if (el.childElementCount === 0) {
+      const text = (el.textContent ?? "").trim();
+      if (text) (instance as { c?: string }).c = text.slice(0, 200);
+    }
+    instances.push(instance);
+  }
+
+  const tokens: Record<string, string | number> = {};
+  for (const prefix of TOKEN_PREFIXES) {
+    // Inline root tokens are the authored/theme values the client applied;
+    // computed custom properties are not enumerable, so read the ones the
+    // chart itself declares on its root style attribute.
+    for (const name of Array.from(root.style)) {
+      if (name.startsWith(prefix)) {
+        const value = rootStyle.getPropertyValue(name).trim();
+        if (value) tokens[name] = value;
+      }
+    }
+  }
+
+  const dpr = win.devicePixelRatio || 1;
+  const scheme = rootStyle.colorScheme.includes("dark") ? "dark" : "light";
+  return {
+    version: STYLE_SNAPSHOT_VERSION,
+    style_epoch: opts?.styleEpoch ?? 0,
+    environment: {
+      width: num(rootRect.width),
+      height: num(rootRect.height),
+      dpr,
+      color_scheme: scheme as "light" | "dark",
+    },
+    tokens,
+    states: opts?.states ?? [],
+    unrepresentable: [],
+    declarations,
+    instances,
+  };
+}
+
+// Layout/fonts settle barrier for capture: fonts.ready, then two macrotask
+// ticks. setTimeout rather than requestAnimationFrame — headless capture
+// hosts throttle rAF on unfocused pages, and a capture must settle there
+// exactly like it settles in a notebook.
+export async function styleCaptureSettled(doc: Document): Promise<void> {
+  try {
+    await doc.fonts?.ready;
+  } catch {
+    // A document without FontFaceSet still captures; there is nothing to
+    // wait for.
+  }
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  await new Promise((resolve) => setTimeout(resolve, 0));
+}
diff --git a/js/src/54_kernel.ts b/js/src/54_kernel.ts
index 638bc5024..e29797816 100644
--- a/js/src/54_kernel.ts
+++ b/js/src/54_kernel.ts
@@ -1,5 +1,6 @@
 import { payloadBuffers } from "./00_header";
 import { buildLutData } from "./10_colormaps";
+import { captureStyleSnapshot, styleCaptureSettled } from "./16_style_capture";
 import { parseColor } from "./20_theme";
 import {
   lodAggregateStands, lodAggregateStepWindow, lodApplyDensityUpdate, lodApplyDrill,
@@ -908,6 +909,30 @@ Object.assign(ChartView.prototype, {
       if (msg.op === "reset") this._navReset(msg.axes);
     } else if (msg.type === "selection_rows") {
       this._applyRowsSelection(msg, buffers);
+    } else if (msg.type === "style_snapshot_request") {
+      this._replyStyleSnapshot(msg);
+    }
+  },
+
+  // Capture the live cascade and reply (wire-protocol §8). Explicitly
+  // requested only — never on the hover or animation path — and settled
+  // first: fonts.ready plus two macrotask ticks, so the values are the
+  // document's, not a mid-layout frame's. Errors reply as errors: a request
+  // must never dangle a kernel-side future (§28: the outcome is said).
+  async _replyStyleSnapshot(msg) {
+    try {
+      await styleCaptureSettled(this.root.ownerDocument);
+      if (this._destroyed) return;
+      const snapshot = captureStyleSnapshot(this.root, {
+        styleEpoch: typeof msg.style_epoch === "number" ? msg.style_epoch : 0,
+      });
+      this.comm.send({ type: "style_snapshot", request_id: msg.request_id, snapshot });
+    } catch (err) {
+      this.comm.send({
+        type: "style_snapshot",
+        request_id: msg.request_id,
+        error: String((err && (err as Error).message) || err),
+      });
     }
   },
 
diff --git a/js/src/60_entries.ts b/js/src/60_entries.ts
index 0c780c999..344182785 100644
--- a/js/src/60_entries.ts
+++ b/js/src/60_entries.ts
@@ -97,4 +97,9 @@ export function renderStandalone(el, spec, arrayBuffer) {
 // these directly; the IIFE bundle (static/standalone.js) exposes the same
 // namespace as `window.xy`.
 export { decodeFrame, ChartView, MARK_KINDS, markOf };
+// The capture half of wire-protocol §8, public so a standalone document (no
+// kernel, no comm) can produce the same snapshot a widget request does —
+// which is also what lets the browser-oracle smoke validate the payload
+// against the Python schema without a notebook in the loop.
+export { captureStyleSnapshot, styleCaptureSettled } from "./16_style_capture";
 export default { render, decodeFrame };
diff --git a/python/xy/_figure.py b/python/xy/_figure.py
index 284da8249..415cf0d2f 100644
--- a/python/xy/_figure.py
+++ b/python/xy/_figure.py
@@ -2245,6 +2245,7 @@ def to_svg(
         width: Optional[int] = None,
         height: Optional[int] = None,
         compatibility: str = "legacy",
+        style_snapshot: Optional[Any] = None,
     ) -> str:
         """Static SVG (_svg.py): a pure-Python render of the same decimated
         payload the browser client consumes — resolution-independent, tiny
@@ -2254,6 +2255,10 @@ def to_svg(
         vector export would drop, "strict" refuses to drop one."""
         from . import _svg
 
+        if style_snapshot is not None:
+            snapshot = export._coerce_style_snapshot(style_snapshot)
+            with export._snapshot_styles(self, snapshot):
+                return _svg.to_svg(self, path, width=width, height=height)
         export._enforce_compatibility(self, "svg", "native", None, compatibility)
         return _svg.to_svg(self, path, width=width, height=height)
 
@@ -2270,6 +2275,7 @@ def to_png(
         sandbox: bool = True,
         gl: str = "software",
         compatibility: str = "legacy",
+        style_snapshot: Optional[Any] = None,
     ) -> bytes:
         """Static PNG (export.py). `engine=Engine.default` paints the
         decimated payload with the built-in Rust rasterizer — no browser,
@@ -2292,6 +2298,7 @@ def to_png(
             sandbox=sandbox,
             gl=gl,
             compatibility=compatibility,
+            style_snapshot=style_snapshot,
         )
 
     def to_image(
@@ -2309,6 +2316,7 @@ def to_image(
         sandbox: bool = True,
         gl: str = "software",
         compatibility: str = "legacy",
+        style_snapshot: Optional[Any] = None,
     ) -> bytes:
         """Unified static export: PNG/JPEG/WebP/SVG/PDF bytes (export.py).
 
@@ -2331,6 +2339,7 @@ def to_image(
             sandbox=sandbox,
             gl=gl,
             compatibility=compatibility,
+            style_snapshot=style_snapshot,
         )
 
     def write_image(
@@ -2349,6 +2358,7 @@ def write_image(
         sandbox: bool = True,
         gl: str = "software",
         compatibility: str = "legacy",
+        style_snapshot: Optional[Any] = None,
     ) -> bytes:
         """Atomic file export with extension-inferred format (export.py):
         .png/.jpg/.jpeg/.webp/.svg/.pdf, plus .html routing to `to_html`."""
@@ -2367,6 +2377,7 @@ def write_image(
             sandbox=sandbox,
             gl=gl,
             compatibility=compatibility,
+            style_snapshot=style_snapshot,
         )
 
     def memory_report(self) -> dict[str, Any]:
diff --git a/python/xy/channel.py b/python/xy/channel.py
index 12639d07b..cb1b6fccb 100644
--- a/python/xy/channel.py
+++ b/python/xy/channel.py
@@ -104,6 +104,12 @@ class ChannelCallbacks:
     on_view_change: Optional[Callable[[dict[str, Any]], None]] = None
     on_animation_start: Optional[Callable[[dict[str, Any]], None]] = None
     on_animation_end: Optional[Callable[[dict[str, Any]], None]] = None
+    #: The `style_snapshot` reply to a kernel-initiated capture request
+    #: (wire-protocol §8). Receives the raw reply content — request_id plus
+    #: either `snapshot` or `error` — so the transport can settle whatever
+    #: it used to track the request; validation belongs to the consumer
+    #: (`resolved.snapshot_from_payload`), not the dispatcher.
+    on_style_snapshot: Optional[Callable[[dict[str, Any]], None]] = None
 
 
 _NO_CALLBACKS = ChannelCallbacks()
@@ -216,6 +222,14 @@ def handle_message(
                 event["cancelled"] = content["cancelled"]
             callback(event)
         return None
+    if kind == "style_snapshot":
+        # Reply to a kernel-initiated capture request (wire-protocol §8):
+        # callback-only, no wire reply. The transport that sent the request
+        # settles its pending future; a message with no listener is a
+        # request nobody is waiting on anymore and drops harmlessly.
+        if callbacks.on_style_snapshot is not None:
+            callbacks.on_style_snapshot(content)
+        return None
     if kind == "view":
         # Zoom/pan crossed what the shipped decimation can serve: recompute
         # for the visible window only (§28), stale-while-revalidate on the
diff --git a/python/xy/components.py b/python/xy/components.py
index 5439d56dc..b16b7fbbe 100644
--- a/python/xy/components.py
+++ b/python/xy/components.py
@@ -4130,6 +4130,17 @@ def view_state(self) -> dict[str, Any]:
         """Last committed durable view state (kernel-side cache)."""
         return self.widget().view_state()
 
+    async def capture_style_snapshot(self, *, timeout: float = 10.0) -> Any:
+        """The mounted chart's live cascade as a `ResolvedStyleSnapshot`.
+
+        Asynchronous by contract (the reply rides the same comm the request
+        leaves on); pass the result to `to_png(style_snapshot=...)` and the
+        native writers reproduce what the browser resolved — host theme,
+        classes, dark mode — with no browser in the export path. See
+        `FigureWidget.capture_style_snapshot`.
+        """
+        return await self.widget().capture_style_snapshot(timeout=timeout)
+
     def _ipython_display_(self) -> None:
         from IPython.display import display  # type: ignore[import-not-found]
 
@@ -4200,14 +4211,22 @@ def to_svg(
         width: Optional[int] = None,
         height: Optional[int] = None,
         compatibility: str = "legacy",
+        style_snapshot: Optional[Any] = None,
     ) -> str:
         """A static SVG render of the chart (written to ``path`` if given).
 
         ``compatibility`` stages the styling contract: ``"warn"`` surfaces
         any declaration this export would drop, ``"strict"`` refuses to drop
-        one; the default preserves current behavior.
+        one; the default preserves current behavior. ``style_snapshot``
+        feeds a captured live cascade to the vector writer.
         """
-        return self.figure().to_svg(path, width=width, height=height, compatibility=compatibility)
+        return self.figure().to_svg(
+            path,
+            width=width,
+            height=height,
+            compatibility=compatibility,
+            style_snapshot=style_snapshot,
+        )
 
     def to_png(
         self,
@@ -4222,6 +4241,7 @@ def to_png(
         sandbox: bool = True,
         gl: str = "software",
         compatibility: str = "legacy",
+        style_snapshot: Optional[Any] = None,
     ) -> bytes:
         """A PNG render of the chart, returned as bytes.
 
@@ -4241,6 +4261,7 @@ def to_png(
             sandbox=sandbox,
             gl=gl,
             compatibility=compatibility,
+            style_snapshot=style_snapshot,
         )
 
     def _export_defaults(
@@ -4291,6 +4312,7 @@ def to_image(
         sandbox: bool = True,
         gl: str = "software",
         compatibility: str = "legacy",
+        style_snapshot: Optional[Any] = None,
     ) -> bytes:
         """Unified static export: PNG/JPEG/WebP/SVG/PDF bytes.
 
@@ -4308,6 +4330,7 @@ def to_image(
             sandbox=sandbox,
             gl=gl,
             compatibility=compatibility,
+            style_snapshot=style_snapshot,
             **self._export_defaults(
                 fmt,
                 width,
@@ -4335,6 +4358,7 @@ def write_image(
         sandbox: bool = True,
         gl: str = "software",
         compatibility: str = "legacy",
+        style_snapshot: Optional[Any] = None,
     ) -> bytes:
         """Atomic file export with extension-inferred format (.png/.jpg/
         .jpeg/.webp/.svg/.pdf/.html). `export_config` defaults apply as in
@@ -4383,6 +4407,7 @@ def write_image(
             sandbox=sandbox,
             gl=gl,
             compatibility=compatibility,
+            style_snapshot=style_snapshot,
             **defaults,
         )
 
diff --git a/python/xy/config.py b/python/xy/config.py
index 8579700c2..ce18a6e9d 100644
--- a/python/xy/config.py
+++ b/python/xy/config.py
@@ -40,7 +40,11 @@
 # v12 adds polar sector/grid-shape metadata on the angular axis and hole/origin
 # metadata on the radial axis. A v11 client would silently draw a full circular
 # grid with a centre-origin radius, so the new geometry must fail the handshake.
-PROTOCOL_VERSION = 12
+# v13 adds the style_snapshot_request/style_snapshot capture pair (wire
+# protocol §8). A cached v12 client silently ignores the request, dangling the
+# kernel's awaited capture until its timeout — a slow mystery instead of the
+# loud version mismatch the handshake exists to produce.
+PROTOCOL_VERSION = 13
 
 # Mark kinds the polar transform renders correctly today. Everything else is
 # refused by Figure._validate_coords rather than approximated: the rect, area,
diff --git a/python/xy/export.py b/python/xy/export.py
index d97380fc6..23a4a2a75 100644
--- a/python/xy/export.py
+++ b/python/xy/export.py
@@ -15,7 +15,7 @@
 import sys
 import tempfile
 import warnings
-from contextlib import suppress
+from contextlib import contextmanager, nullcontext, suppress
 from enum import StrEnum
 from os import PathLike
 from pathlib import Path
@@ -820,6 +820,7 @@ def to_png(
     sandbox: bool = True,
     gl: str = "software",
     compatibility: str = "legacy",
+    style_snapshot: Optional[Any] = None,
 ) -> bytes:
     """Rasterize `fig` to a PNG (bytes, optionally saved).
 
@@ -852,11 +853,19 @@ def to_png(
     # every mode, so it fires before enforcement can warn or raise.
     if resolved_engine == "native" and custom_css is not None:
         raise ValueError("custom_css requires engine=Engine.chromium")
-    _enforce_compatibility(fig, "png", resolved_engine, custom_css, compatibility)
+    snapshot = _coerce_style_snapshot(style_snapshot) if style_snapshot is not None else None
+    if snapshot is not None and resolved_engine != "native":
+        raise ValueError(
+            "style_snapshot feeds the native writers; the Chromium engine renders "
+            "the live cascade itself — drop one of the two"
+        )
+    if snapshot is None:
+        _enforce_compatibility(fig, "png", resolved_engine, custom_css, compatibility)
     if resolved_engine == "native":
         from . import _raster
 
-        data = _raster.to_png(fig, None, width=w, height=h, scale=scale, fast=not optimize)
+        with _snapshot_styles(fig, snapshot) if snapshot is not None else nullcontext():
+            data = _raster.to_png(fig, None, width=w, height=h, scale=scale, fast=not optimize)
     else:
         doc = to_html(fig, custom_css=custom_css, animation_progress=1.0)
         data = html_to_png(
@@ -931,6 +940,55 @@ def _infer_format(path: str | PathLike[str]) -> str:
         ) from None
 
 
+def _coerce_style_snapshot(value: object) -> Any:
+    """A validated ResolvedStyleSnapshot from either accepted spelling.
+
+    Accepts the object a capture returned, or its payload dict (a cached
+    snapshot round-trips through JSON); anything else is refused by the
+    schema's own validator, so an out-of-contract snapshot never reaches a
+    writer.
+    """
+    from .styling.resolved import ResolvedStyleSnapshot, snapshot_from_payload
+
+    if isinstance(value, ResolvedStyleSnapshot):
+        return value
+    if isinstance(value, dict):
+        return snapshot_from_payload(value)
+    raise ValueError(
+        "style_snapshot must be a ResolvedStyleSnapshot (from "
+        "capture_style_snapshot()) or its payload dict"
+    )
+
+
+@contextmanager
+def _snapshot_styles(fig: "Figure", snapshot: Any) -> "Iterator[None]":
+    """Feed a captured snapshot to the native writers for one export.
+
+    The writers read per-slot styling from the figure's chrome_styles (via
+    the declared resolver), so the snapshot overlays there for the duration
+    of the render: captured declarations win over declared ones — computed
+    values ARE the declared values after the cascade the user asked to
+    capture — and the token bag gains the snapshot's tokens the same way.
+    Per-slot granularity for now: multiple instances of one slot use the
+    first instance's declaration until the chrome-parity work gives writers
+    per-instance geometry. Restored on exit; exports are synchronous, and a
+    figure is not shared across threads mid-export.
+    """
+    slot_overlay: dict[str, dict[str, Any]] = {}
+    for inst in snapshot.instances:
+        if inst.slot not in slot_overlay:
+            slot_overlay[inst.slot] = dict(snapshot.declarations[inst.declaration])
+    saved_styles = fig.chrome_styles
+    saved_style = fig.style
+    fig.chrome_styles = {**saved_styles, **slot_overlay}
+    fig.style = {**saved_style, **dict(snapshot.tokens)}
+    try:
+        yield
+    finally:
+        fig.chrome_styles = saved_styles
+        fig.style = saved_style
+
+
 def _enforce_compatibility(
     fig: "Figure",
     fmt: str,
@@ -1199,6 +1257,7 @@ def to_image(
     sandbox: bool = True,
     gl: str = "software",
     compatibility: str = "legacy",
+    style_snapshot: Optional[Any] = None,
 ) -> bytes:
     """Render `fig` to image bytes in the requested `format`.
 
@@ -1216,7 +1275,17 @@ def to_image(
     bounded rasters (the documented hybrid-vector policy)."""
     fmt = _normalize_format(format)
     resolved_engine = _resolve_image_engine(engine, fmt, custom_css)
-    _enforce_compatibility(fig, fmt, resolved_engine, custom_css, compatibility)
+    snapshot = _coerce_style_snapshot(style_snapshot) if style_snapshot is not None else None
+    if snapshot is not None and resolved_engine == "browser":
+        raise ValueError(
+            "style_snapshot feeds the native writers; the Chromium engine renders "
+            "the live cascade itself — drop one of the two"
+        )
+    if snapshot is None:
+        # A supplied snapshot IS the lossless remedy the modes recommend:
+        # the captured cascade carries what class_names would drop, so there
+        # is nothing left for warn/strict to catch on this export.
+        _enforce_compatibility(fig, fmt, resolved_engine, custom_css, compatibility)
     quality = _validated_quality(quality, fmt, resolved_engine)
     background = _validated_background(background, fmt)
     w, h = _export_dimensions(fig, width, height)
@@ -1225,16 +1294,17 @@ def to_image(
     sandbox = _bool_option(sandbox, "export sandbox")
     gl = _gl_option(gl)
     if resolved_engine == "native":
-        return _native_image(
-            fig,
-            fmt,
-            width=w,
-            height=h,
-            scale=scale,
-            background=background,
-            quality=quality,
-            optimize=optimize,
-        )
+        with _snapshot_styles(fig, snapshot) if snapshot is not None else nullcontext():
+            return _native_image(
+                fig,
+                fmt,
+                width=w,
+                height=h,
+                scale=scale,
+                background=background,
+                quality=quality,
+                optimize=optimize,
+            )
     with _browser_session(gl=gl, sandbox=sandbox) as session:
         return _browser_image(
             session,
@@ -1265,6 +1335,7 @@ def write_image(
     sandbox: bool = True,
     gl: str = "software",
     compatibility: str = "legacy",
+    style_snapshot: Optional[Any] = None,
 ) -> bytes:
     """Export `fig` to `path`, inferring the format from the extension.
 
@@ -1315,6 +1386,7 @@ def write_image(
         sandbox=sandbox,
         gl=gl,
         compatibility=compatibility,
+        style_snapshot=style_snapshot,
     )
     _atomic_write_bytes(path, data)
     return data
diff --git a/python/xy/widget.py b/python/xy/widget.py
index ec662f79a..2bbc67a26 100644
--- a/python/xy/widget.py
+++ b/python/xy/widget.py
@@ -71,6 +71,7 @@ def __init__(
         **kwargs: Any,
     ) -> None:
         self._figure = figure
+        self._pending_style_snapshots: dict[str, Any] = {}
         self._callbacks = ChannelCallbacks(
             on_hover=on_hover,
             on_click=on_click,
@@ -79,6 +80,7 @@ def __init__(
             on_view_change=on_view_change,
             on_animation_start=on_animation_start,
             on_animation_end=on_animation_end,
+            on_style_snapshot=self._settle_style_snapshot,
         )
         spec, bufs = figure.build_payload_split()
         self._configure_transport(spec)
@@ -150,6 +152,51 @@ def reset_view(self, axes: Any = None) -> None:
         """Navigate to the home ranges (None = the configured reset_axes)."""
         self.send(self._figure.view_nav_message(axes))
 
+    # -- live style capture (wire-protocol §8) --------------------------------
+
+    async def capture_style_snapshot(self, *, timeout: float = 10.0) -> Any:
+        """The mounted chart's live cascade as a `ResolvedStyleSnapshot`.
+
+        Asynchronous by contract: the reply arrives on the same comm the
+        request leaves on, so a synchronous wait inside the kernel would
+        deadlock against its own channel. The client captures after fonts
+        and layout settle; the reply payload is validated on arrival by
+        `resolved.snapshot_from_payload`, so an out-of-contract capture
+        raises here rather than becoming renderer-facing IR. A client-side
+        capture failure raises RuntimeError with the client's message; a
+        silent timeout raises instead of dangling (§28).
+        """
+        import asyncio
+        import uuid
+
+        request_id = uuid.uuid4().hex
+        loop = asyncio.get_running_loop()
+        future: Any = loop.create_future()
+        self._pending_style_snapshots[request_id] = future
+        try:
+            self.send(
+                {
+                    "type": "style_snapshot_request",
+                    "request_id": request_id,
+                    "style_epoch": int(getattr(self._figure, "style_epoch", 0) or 0),
+                }
+            )
+            content = await asyncio.wait_for(future, timeout)
+        finally:
+            self._pending_style_snapshots.pop(request_id, None)
+        if content.get("error") is not None:
+            raise RuntimeError(f"style capture failed in the client: {content['error']}")
+        from .styling.resolved import snapshot_from_payload
+
+        return snapshot_from_payload(content.get("snapshot") or {})
+
+    def _settle_style_snapshot(self, content: dict[str, Any]) -> None:
+        request_id = str(content.get("request_id", ""))
+        future = self._pending_style_snapshots.get(request_id)
+        if future is None or future.done():
+            return
+        future.set_result(content)
+
     def select(
         self,
         *,
diff --git a/scripts/style_capture_smoke.py b/scripts/style_capture_smoke.py
new file mode 100644
index 000000000..50bde6b0c
--- /dev/null
+++ b/scripts/style_capture_smoke.py
@@ -0,0 +1,141 @@
+#!/usr/bin/env python3
+"""Browser-oracle smoke for the style capture (wire-protocol §8).
+
+Renders a styled chart's standalone HTML in headless Chromium, runs the
+public `window.xy.captureStyleSnapshot` against the live document, and
+validates the captured payload through the Python schema — the same
+`snapshot_from_payload` gate a widget reply passes. The assertion that
+matters: a value only the browser can resolve (a `custom_css` class rule)
+comes back as a concrete computed value, lands in the snapshot, and a
+native export fed that snapshot reproduces it. That is the browser-as-
+oracle loop with no notebook in it.
+
+    uv run python scripts/style_capture_smoke.py [chromium-path]
+"""
+
+from __future__ import annotations
+
+import json
+import shutil
+import sys
+import time
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT / "python"))
+
+from xy._chromium import ChromiumSession  # noqa: E402
+from xy.styling.resolved import snapshot_from_payload  # noqa: E402
+
+CHROMIUM_CANDIDATES = [
+    "chrome-headless-shell",
+    "chromium",
+    "chromium-browser",
+    "chrome",
+    "google-chrome",
+    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+]
+
+#: The class rule only a real CSS engine resolves; the capture must return
+#: its computed form. Solid and exact on purpose: rgb(7, 89, 133) either
+#: round-trips or the smoke fails.
+CUSTOM_CSS = ".smoke-tick { color: rgb(7, 89, 133) !important; }"
+
+CAPTURE = """
+(async () => {
+  // The standalone client mounts after load (decode + first paint), so the
+  // capture waits for the root the same way a user's eye does.
+  const until = Date.now() + 60000;
+  let root = null;
+  while (!(root = document.querySelector('[data-xy-slot="root"]'))) {
+    if (Date.now() > until) return JSON.stringify({error: "no chart root"});
+    await new Promise((r) => setTimeout(r, 50));
+  }
+  await window.xy.styleCaptureSettled(document);
+  const snapshot = window.xy.captureStyleSnapshot(root, {styleEpoch: 7});
+  return JSON.stringify({snapshot});
+})()
+"""
+
+
+def find_chromium() -> str:
+    if len(sys.argv) > 1:
+        return sys.argv[1]
+    for c in CHROMIUM_CANDIDATES:
+        if Path(c).is_file() or shutil.which(c):
+            return c
+    raise SystemExit("no chromium found")
+
+
+def main() -> None:
+    import xy
+
+    chart = xy.scatter_chart(
+        xy.scatter([1.0, 2.0, 3.0], [2.0, 1.0, 3.0]),
+        title="capture smoke",
+        class_names={"tick_label": "smoke-tick"},
+    )
+    document = chart.to_html(custom_css=CUSTOM_CSS)
+
+    deadline = time.monotonic() + 120.0
+
+    def remaining() -> float:
+        value = deadline - time.monotonic()
+        if value <= 0:
+            raise TimeoutError("capture smoke did not finish in 120s")
+        return value
+
+    with ChromiumSession(
+        find_chromium(), gl="software", sandbox=False, launch_timeout_s=remaining()
+    ) as session:
+        _, sid, page_path = session._page_session(document, remaining())
+        session._call(
+            "Page.navigate",
+            {"url": page_path.as_uri()},
+            session_id=sid,
+            timeout_s=remaining(),
+        )
+        session._wait_event("Page.loadEventFired", session_id=sid, timeout_s=remaining())
+        reply = session._call(
+            "Runtime.evaluate",
+            {"expression": CAPTURE, "awaitPromise": True, "returnByValue": True},
+            session_id=sid,
+            timeout_s=remaining(),
+        )
+    if reply.get("exceptionDetails"):
+        raise SystemExit(f"capture failed in page: {reply['exceptionDetails']}")
+    result = json.loads(reply["result"]["value"])
+    if result.get("error"):
+        raise SystemExit(f"capture failed: {result['error']}")
+
+    # The Python schema is the door every wire snapshot passes.
+    snapshot = snapshot_from_payload(result["snapshot"])
+    assert snapshot.style_epoch == 7
+    slots = {inst.slot for inst in snapshot.instances}
+    assert "tick_label" in slots, f"no tick_label captured; saw {sorted(slots)}"
+
+    tick_decls = [
+        snapshot.declarations[inst.declaration]
+        for inst in snapshot.instances
+        if inst.slot == "tick_label"
+    ]
+    colors = {decl.get("color") for decl in tick_decls}
+    assert "rgb(7, 89, 133)" in colors, (
+        f"custom_css class did not reach the capture; tick colors: {colors}"
+    )
+
+    # The oracle loop closes: a native export fed the capture reproduces the
+    # browser-resolved value with no browser in the export path.
+    svg = chart.to_svg(style_snapshot=snapshot)
+    assert 'fill="rgb(7, 89, 133)"' in svg, "captured color did not survive native export"
+
+    print(
+        f"style capture smoke ok: {len(snapshot.instances)} instances, "
+        f"{len(snapshot.declarations)} declarations, "
+        f"{snapshot.payload_bytes()} bytes; browser-resolved rgb(7, 89, 133) "
+        "round-tripped into a native SVG"
+    )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/spec/api/export.md b/spec/api/export.md
index 5deb2dd90..0be54cc33 100644
--- a/spec/api/export.md
+++ b/spec/api/export.md
@@ -254,6 +254,22 @@ vector** (`_svg.to_svg`, and `_pdf.svg_to_pdf` on top of it).
 | `xy.legend(style=...)` | yes | 6 keys | 6 keys | merged with the slot and the theme token before the writers see it |
 | `xy.colorbar(style=...)` | yes | **dropped** | **dropped** | no native channel; use `styles={"colorbar_title"/"colorbar_tick": ...}` |
 
+### Exporting what the browser resolved: `style_snapshot=`
+
+`to_png` / `to_svg` / `to_image` / `write_image` accept `style_snapshot=` —
+the `ResolvedStyleSnapshot` a mounted chart's `capture_style_snapshot()`
+returned (or its payload dict; a cached snapshot round-trips through JSON).
+The native writers then consume the captured cascade: host theme, classes,
+Tailwind, dark mode — resolved by the real browser once, exported natively
+ever after. A supplied snapshot is the lossless remedy the compatibility
+modes recommend, so `strict` passes with one where it refuses without one;
+the Chromium engine rejects the combination (it renders the live cascade
+itself, so feeding it a capture is a contradiction). Snapshots overlay
+per-slot for now — first instance per slot — until the chrome-parity work
+gives the writers per-instance geometry. `scripts/style_capture_smoke.py`
+is the browser-oracle loop: capture in headless Chromium, validate through
+the schema, reproduce natively, assert the exact color.
+
 ### Asking a chart, not the table
 
 `chart.style_compatibility_report(target=..., engine=..., custom_css=...)` is
diff --git a/spec/design/wire-protocol.md b/spec/design/wire-protocol.md
index 1d365f275..4758e38f8 100644
--- a/spec/design/wire-protocol.md
+++ b/spec/design/wire-protocol.md
@@ -420,9 +420,9 @@ The reassembled bytes are identical to the source blob, which is what keeps
 
 Two independent version constants:
 
-- **Renderer/spec protocol.** `PROTOCOL_VERSION = 12` (`python/xy/config.py`)
+- **Renderer/spec protocol.** `PROTOCOL_VERSION = 13` (`python/xy/config.py`)
   rides every first-paint spec as `spec["protocol"]`; the client's
-  `PROTOCOL = 12` (`js/src/00_header.ts`) is checked in the `ChartView`
+  `PROTOCOL = 13` (`js/src/00_header.ts`) is checked in the `ChartView`
   constructor. A mismatch replaces the chart element with "update the xy
   package and restart the kernel" and throws. Requests and replies carry no
   version of their own — the handshake happens once, at first paint, before
@@ -469,7 +469,10 @@ Two independent version constants:
   v11 client would silently draw a full circular, centre-origin view and route
   those grid/segment traces through their Cartesian paths. The v12 handshake
   rejects that stale bundle before any of those compatible-looking wrong
-  pictures can appear.
+  pictures can appear. v13 adds the `style_snapshot_request` /
+  `style_snapshot` capture pair (§8): a cached v12 client silently ignores
+  the request, so the kernel's awaited capture dies as a slow timeout
+  instead of the loud handshake failure the version exists to produce.
 - **Transport frame.** `FRAME_MAGIC` `"XYBF"` with `FRAME_VERSION = 1`
   versions the binary envelope separately, so the transport and the renderer
   can evolve without coupling.
@@ -483,16 +486,28 @@ JS that renders a payload is therefore always the build that shipped with the
 Python that produced it. The protocol check exists for the case that survives
 this: a browser holding a cached bundle against a restarted kernel.
 
-## 8. Resolved style snapshot (schema v1, transport pending)
+## 8. Resolved style snapshot (schema v1)
 
 `python/xy/styling/resolved.py` defines the renderer-neutral styling IR —
 the `ResolvedStyleSnapshot` — and `js/src/14_style_snapshot.ts` is its
 generated TypeScript mirror (`scripts/gen_style_snapshot_types.py`; the test
-suite fails when the two drift). Nothing here rides the wire yet, so
-`PROTOCOL_VERSION` stays at 12: the capture change that adds the
-`style_snapshot_request` / `style_snapshot` request-reply pair bumps it and
-carries this schema as the reply payload. The message names are reserved
-now so nothing else claims them.
+suite fails when the two drift).
+
+Transport (v13): the kernel sends `style_snapshot_request { request_id,
+style_epoch }`; the client settles (fonts.ready plus two macrotask ticks —
+setTimeout, not rAF, because headless hosts throttle rAF on unfocused
+pages), captures the live cascade (`js/src/16_style_capture.ts`: every
+rendered `data-xy-slot` element's allowlisted computed properties, interned;
+hidden state-gated chrome has no boxes and is skipped), and replies
+`style_snapshot { request_id, snapshot }` — or `{ request_id, error }` on a
+capture failure, so the kernel's awaited future never dangles (§28).
+`FigureWidget.capture_style_snapshot()` is asynchronous by contract (a
+synchronous wait inside the kernel deadlocks against its own comm) and
+validates the reply through `resolved.snapshot_from_payload` at the
+boundary, so an out-of-contract capture raises rather than becoming
+renderer-facing IR. A standalone document exposes the same capture as
+`window.xy.captureStyleSnapshot` — no kernel, same payload shape — which is
+also the browser-oracle path the smoke test uses.
 
 The schema is versioned independently (`STYLE_SNAPSHOT_VERSION = 1`),
 because a snapshot can outlive a session: it is cacheable and supplyable to
diff --git a/tests/test_style_snapshot_transport.py b/tests/test_style_snapshot_transport.py
new file mode 100644
index 000000000..af1fe8e42
--- /dev/null
+++ b/tests/test_style_snapshot_transport.py
@@ -0,0 +1,200 @@
+"""The v13 capture pair: request out, snapshot back, validated at the door.
+
+Headless like the rest of the widget-boundary tests: the client's half is
+covered by the standalone capture smoke; here the kernel's half must send a
+well-formed request, settle exactly its own future, validate the reply
+through the schema (an out-of-contract capture raises, never becomes IR),
+and feed a captured snapshot to the native writers on export.
+"""
+
+from __future__ import annotations
+
+import asyncio
+
+import numpy as np
+import pytest
+
+import xy
+from xy._figure import Figure
+from xy.channel import ChannelCallbacks, handle_message
+from xy.styling.preflight import StyleCompatibilityError
+from xy.styling.resolved import ResolvedStyleSnapshot, SnapshotBuilder, SnapshotEnvironment
+from xy.widget import FigureWidget
+
+
+def _figure() -> Figure:
+    return Figure().scatter(np.arange(10.0), np.arange(10.0))
+
+
+def _widget():
+    widget = FigureWidget(_figure())
+    sent = []
+    widget.send = lambda content, buffers=None: sent.append((content, buffers))
+    return widget, sent
+
+
+def _snapshot_payload(**decl):
+    builder = SnapshotBuilder()
+    builder.add("tick_label", decl or {"color": "rgb(226, 232, 240)", "font-size": "13px"})
+    return builder.build(SnapshotEnvironment(width=640, height=400)).to_payload()
+
+
+# -- channel dispatch ---------------------------------------------------------
+
+
+def test_style_snapshot_reply_is_callback_only() -> None:
+    fig = _figure()
+    seen = []
+    callbacks = ChannelCallbacks(on_style_snapshot=seen.append)
+    content = {"type": "style_snapshot", "request_id": "r1", "snapshot": {}}
+    assert handle_message(fig, content, None, callbacks=callbacks) is None
+    assert seen == [content]
+    # No listener: drops harmlessly, still no wire reply.
+    assert handle_message(fig, content, None) is None
+
+
+# -- widget round trip --------------------------------------------------------
+
+
+def test_capture_round_trip_validates_at_the_boundary() -> None:
+    widget, sent = _widget()
+
+    async def run():
+        task = asyncio.ensure_future(widget.capture_style_snapshot(timeout=5.0))
+        await asyncio.sleep(0)
+        request = sent[-1][0]
+        assert request["type"] == "style_snapshot_request"
+        assert request["request_id"]
+        widget._on_custom_msg(
+            widget,
+            {
+                "type": "style_snapshot",
+                "request_id": request["request_id"],
+                "snapshot": _snapshot_payload(),
+            },
+            None,
+        )
+        return await task
+
+    snapshot = asyncio.run(run())
+    assert isinstance(snapshot, ResolvedStyleSnapshot)
+    assert snapshot.instances[0].slot == "tick_label"
+    assert widget._pending_style_snapshots == {}
+
+
+def test_client_capture_errors_raise_instead_of_dangling() -> None:
+    widget, sent = _widget()
+
+    async def run():
+        task = asyncio.ensure_future(widget.capture_style_snapshot(timeout=5.0))
+        await asyncio.sleep(0)
+        request = sent[-1][0]
+        widget._on_custom_msg(
+            widget,
+            {
+                "type": "style_snapshot",
+                "request_id": request["request_id"],
+                "error": "capture needs a live window",
+            },
+            None,
+        )
+        with pytest.raises(RuntimeError, match="live window"):
+            await task
+
+    asyncio.run(run())
+
+
+def test_out_of_contract_replies_never_become_ir() -> None:
+    widget, sent = _widget()
+
+    async def run():
+        task = asyncio.ensure_future(widget.capture_style_snapshot(timeout=5.0))
+        await asyncio.sleep(0)
+        request = sent[-1][0]
+        bad = _snapshot_payload()
+        bad["version"] = 99
+        widget._on_custom_msg(
+            widget,
+            {"type": "style_snapshot", "request_id": request["request_id"], "snapshot": bad},
+            None,
+        )
+        with pytest.raises(ValueError, match="refusing to guess"):
+            await task
+
+    asyncio.run(run())
+
+
+def test_capture_times_out_loudly() -> None:
+    widget, _sent = _widget()
+
+    async def run():
+        with pytest.raises(asyncio.TimeoutError):
+            await widget.capture_style_snapshot(timeout=0.05)
+
+    asyncio.run(run())
+    assert widget._pending_style_snapshots == {}
+
+
+def test_stale_or_unknown_request_ids_are_ignored() -> None:
+    widget, _sent = _widget()
+    widget._on_custom_msg(
+        widget,
+        {"type": "style_snapshot", "request_id": "never-sent", "snapshot": {}},
+        None,
+    )
+    assert widget._pending_style_snapshots == {}
+
+
+# -- snapshot-fed export ------------------------------------------------------
+
+
+def _chart(**props):
+    return xy.scatter_chart(xy.scatter([1.0, 2.0, 3.0], [2.0, 1.0, 3.0]), **props)
+
+
+def test_export_reproduces_captured_values_natively() -> None:
+    chart = _chart()
+    payload = _snapshot_payload()
+    svg = chart.to_svg(style_snapshot=payload)
+    assert 'fill="rgb(226, 232, 240)"' in svg
+    assert 'font-size="13"' in svg
+    # Object form is equivalent to payload form.
+    from xy.styling.resolved import snapshot_from_payload
+
+    assert chart.to_svg(style_snapshot=snapshot_from_payload(payload)) == svg
+    # PNG path renders under the same overlay without error.
+    assert chart.to_png(style_snapshot=payload)[:8] == b"\x89PNG\r\n\x1a\n"
+
+
+def test_the_overlay_is_transient() -> None:
+    chart = _chart(styles={"title": {"font-size": 18}})
+    fig = chart.figure()
+    before_styles = dict(fig.chrome_styles)
+    before_style = dict(fig.style)
+    fig.to_svg(style_snapshot=_snapshot_payload())
+    assert fig.chrome_styles == before_styles
+    assert fig.style == before_style
+
+
+def test_snapshot_is_the_lossless_remedy_strict_recommends() -> None:
+    # class_names would drop natively — that is exactly what a captured
+    # snapshot carries, so strict passes with one and refuses without one.
+    chart = _chart(class_names={"legend": "bg-slate-900"})
+    with pytest.raises(StyleCompatibilityError):
+        chart.to_png(compatibility="strict")
+    data = chart.to_png(compatibility="strict", style_snapshot=_snapshot_payload())
+    assert data[:8] == b"\x89PNG\r\n\x1a\n"
+
+
+def test_snapshot_rejects_the_browser_engine() -> None:
+    with pytest.raises(ValueError, match="renders the live cascade"):
+        _chart().to_png(engine=xy.Engine.chromium, style_snapshot=_snapshot_payload())
+    with pytest.raises(ValueError, match="renders the live cascade"):
+        _chart().to_image("png", custom_css=".x{}", style_snapshot=_snapshot_payload())
+
+
+def test_malformed_snapshots_are_refused_before_any_render() -> None:
+    with pytest.raises(ValueError, match="style_snapshot must be"):
+        _chart().to_png(style_snapshot=42)
+    with pytest.raises(ValueError, match="refusing to guess"):
+        _chart().to_png(style_snapshot={"version": 99, "environment": {}})

From 4748e24f3867d2066a0465939087892a33644c81 Mon Sep 17 00:00:00 2001
From: Alek Petuskey <alek@reflex.dev>
Date: Tue, 4 Aug 2026 15:07:34 -0700
Subject: [PATCH 10/27] Update the four version-locked tests for protocol v13

The protocol-pin assertions exist to force exactly this conscious update
at every bump (sankey spec pin, the polar client lock, the tick-side
lockstep check), and the Chart-to-Figure delegation contract grew the
style_snapshot kwarg with the snapshot-fed export path. All four now
assert the v13 reality the capture pair shipped in.
---
 tests/pyplot/test_tick_side_rendering.py | 2 +-
 tests/test_components.py                 | 3 +++
 tests/test_polar_phase7_api.py           | 4 ++--
 tests/test_sankey.py                     | 2 +-
 4 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/tests/pyplot/test_tick_side_rendering.py b/tests/pyplot/test_tick_side_rendering.py
index 8df54519f..bb9165a7d 100644
--- a/tests/pyplot/test_tick_side_rendering.py
+++ b/tests/pyplot/test_tick_side_rendering.py
@@ -120,7 +120,7 @@ def test_tick_sides_bump_wire_protocol_and_client_in_lockstep() -> None:
     client = (ROOT / "js" / "src" / "50_chartview.ts").read_text(encoding="utf-8")
 
     assert spec["x_axis"]["tick_sides"] == ["bottom", "top"]
-    assert spec["protocol"] == PROTOCOL_VERSION == 12
+    assert spec["protocol"] == PROTOCOL_VERSION == 13
     assert f"PROTOCOL = {PROTOCOL_VERSION};" in header
     # The point is that the client reads PROTOCOL from the header, not the exact
     # spelling of the import list — which grows whenever the header gains another
diff --git a/tests/test_components.py b/tests/test_components.py
index c5fac5a38..09d6237c4 100644
--- a/tests/test_components.py
+++ b/tests/test_components.py
@@ -1983,6 +1983,7 @@ def fake_to_png(
         sandbox=True,
         gl="software",
         compatibility="legacy",
+        style_snapshot=None,
     ):
         seen.update(
             {
@@ -1997,6 +1998,7 @@ def fake_to_png(
                 "sandbox": sandbox,
                 "gl": gl,
                 "compatibility": compatibility,
+                "style_snapshot": style_snapshot,
             }
         )
         return b"PNG"
@@ -2029,6 +2031,7 @@ def fake_to_png(
         "sandbox": False,
         "gl": "hardware",
         "compatibility": "warn",
+        "style_snapshot": None,
     }
 
 
diff --git a/tests/test_polar_phase7_api.py b/tests/test_polar_phase7_api.py
index 89995abca..92b6d126d 100644
--- a/tests/test_polar_phase7_api.py
+++ b/tests/test_polar_phase7_api.py
@@ -28,9 +28,9 @@ def _spec(*children: xy.Component) -> dict:
     return spec
 
 
-def test_protocol_v12_is_locked_to_the_client() -> None:
+def test_protocol_v13_is_locked_to_the_client() -> None:
     header = Path(__file__).parents[1] / "js" / "src" / "00_header.ts"
-    assert PROTOCOL_VERSION == 12
+    assert PROTOCOL_VERSION == 13
     assert f"PROTOCOL = {PROTOCOL_VERSION};" in header.read_text()
 
 
diff --git a/tests/test_sankey.py b/tests/test_sankey.py
index fa277ef67..6d3571052 100644
--- a/tests/test_sankey.py
+++ b/tests/test_sankey.py
@@ -227,7 +227,7 @@ def test_sankey_chart_builds_ribbon_traces_only() -> None:
     # ribbon's internal placement (its target span), never a data readout.
     for row in (exact_link, exact_node):
         assert "x" not in row and "y" not in row
-    assert spec["protocol"] == PROTOCOL_VERSION == 12
+    assert spec["protocol"] == PROTOCOL_VERSION == 13
 
 
 # -- resolved paints and per-trace styles ------------------------------------

From 844803d3b3d8445cdba91960e4af4f2abaddd193 Mon Sep 17 00:00:00 2001
From: Alek Petuskey <alek@reflex.dev>
Date: Tue, 4 Aug 2026 15:33:53 -0700
Subject: [PATCH 11/27] Resolve classes and author CSS natively: the xy-cascade
 extension
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Phase 3 of the styling-compatibility program: a chart styled with classes
and self-contained custom CSS exports natively — no mount, no browser —
with the live browser retained as the oracle it should be.

The extension (cascade/, its own ~3.8 MB cdylib in the same workspace,
lightningcss pinned exact) parses and normalizes stylesheets; the resolver
cascades the published profile over the synthetic slot DOM: class /
[data-xy-slot=…] / universal / :root selectors with descendant and child
combinators, importance-specificity-order cascade, custom properties with
fallbacks to a depth-capped fixpoint, em/rem against the font-size cascade
(parent-based for font-size itself, own-based for everything else),
prefers-color-scheme media, and the inherited text properties flowing
top-down after each node's own cascade. Everything outside the profile —
pseudo-classes, other at-rules, sibling combinators, percentage lengths —
lands in an `unsupported` list with its reason, never in a guessed value
(§28). The synthetic tree is browser evidence, not a guess: every parent a
rendered chart mounts was probed from a live headless-Chromium DOM, and
the remainder follows the client mount sites.

python/xy/styling/cascade.py is the lazy ctypes boundary (JSON in/out, one
free function, panics caught at the ABI): imported only when a
native-cascade export is requested, absent-extension raises with the build
command, box shorthands split to the schema's longhands. Exports:
style_source="native_cascade" on to_png/to_svg/to_image/write_image at
chart, figure, and module level. The cascade IS the CSS engine there, so
custom_css is consumed natively instead of forcing Chromium; unsupported
constructs surface as one StyleCompatibilityWarning by default and refuse
in strict — a brand-new surface has no legacy silence to preserve. The
snapshot and the cascade are mutually exclusive sources, and a Chromium
pin rejects the combination.

Packaging: the workspace builds both cdylibs in one cargo invocation;
hatch_build force-includes the cascade beside the core when present and
announces a wheel built without it. scripts/cascade_differential_smoke.py
is the exit gate in executable form: the same chart and stylesheet
resolved by headless Chromium (live capture) and by the mount-free cascade
agree on the shared profile, colors compared parsed since Lightning CSS
normalizes spellings the browser does not.
---
 CHANGELOG.md                          |   10 +
 Cargo.lock                            | 1009 +++++++++++++++++++++++++
 Cargo.toml                            |    8 +
 cascade/Cargo.toml                    |   20 +
 cascade/src/lib.rs                    |   78 ++
 cascade/src/resolve.rs                |  729 ++++++++++++++++++
 hatch_build.py                        |   16 +
 python/xy/_figure.py                  |   21 +
 python/xy/components.py               |   16 +-
 python/xy/export.py                   |   70 ++
 python/xy/styling/__init__.py         |    5 +-
 python/xy/styling/cascade.py          |  287 +++++++
 scripts/cascade_differential_smoke.py |  176 +++++
 spec/api/export.md                    |   10 +-
 tests/test_components.py              |    3 +
 tests/test_native_cascade.py          |  150 ++++
 16 files changed, 2603 insertions(+), 5 deletions(-)
 create mode 100644 cascade/Cargo.toml
 create mode 100644 cascade/src/lib.rs
 create mode 100644 cascade/src/resolve.rs
 create mode 100644 python/xy/styling/cascade.py
 create mode 100644 scripts/cascade_differential_smoke.py
 create mode 100644 tests/test_native_cascade.py

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6435e8e1c..fac85aa0e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,6 +9,16 @@ in the README).
 ## [Unreleased]
 
 ### Added
+- The mount-free native cascade (optional `xy-cascade` extension, ~3.8 MB
+  cdylib built from the same workspace): `chart.to_png(custom_css=css,
+  style_source="native_cascade")` resolves classes and self-contained author
+  CSS natively — Lightning CSS parsing; class/slot/descendant selectors,
+  `!important`/specificity/order, custom properties with fallbacks,
+  `em`/`rem` against the font-size cascade, `prefers-color-scheme` — and
+  exports with no browser in the path. Every out-of-profile construct is
+  reported through the compatibility modes (warn by default, refusal in
+  strict), never guessed. `scripts/cascade_differential_smoke.py` pins the
+  cascade against a live Chromium oracle.
 - Live style capture and snapshot-fed export (wire protocol v13). A mounted
   chart's `await chart.capture_style_snapshot()` returns the browser's
   resolved cascade as a validated `ResolvedStyleSnapshot` (the client
diff --git a/Cargo.lock b/Cargo.lock
index 8afdf0f54..dd4242c07 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -8,18 +8,112 @@ version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
 
+[[package]]
+name = "ahash"
+version = "0.7.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "891477e0c6a8957309ee5c45a6368af3ae14bb510732d2684ffa19af310920f9"
+dependencies = [
+ "getrandom 0.2.17",
+ "once_cell",
+ "version_check",
+]
+
+[[package]]
+name = "ahash"
+version = "0.8.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75"
+dependencies = [
+ "cfg-if",
+ "getrandom 0.3.4",
+ "once_cell",
+ "version_check",
+ "zerocopy",
+]
+
+[[package]]
+name = "base64-simd"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "781dd20c3aff0bd194fe7d2a977dd92f21c173891f3a03b677359e5fa457e5d5"
+dependencies = [
+ "simd-abstraction",
+]
+
 [[package]]
 name = "bitflags"
 version = "2.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b4388bee8683e3d04af747c73422af53102d2bd24d9eadb6cbc100baef4b43f8"
 
+[[package]]
+name = "bitvec"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ddcec3d12c579d40898fe0a9a358a803c23e9c52ca3c425707f81c9436211837"
+dependencies = [
+ "funty",
+ "radium",
+ "tap",
+ "wyz",
+]
+
+[[package]]
+name = "bumpalo"
+version = "3.20.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649"
+
+[[package]]
+name = "bytecheck"
+version = "0.6.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23cdc57ce23ac53c931e88a43d06d070a6fd142f2617be5855eb75efc9beb1c2"
+dependencies = [
+ "bytecheck_derive",
+ "ptr_meta",
+ "simdutf8",
+]
+
+[[package]]
+name = "bytecheck_derive"
+version = "0.6.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3db406d29fbcd95542e92559bed4d8ad92636d1ca8b3b72ede10b4bcc010e659"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "bytes"
+version = "1.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc652a48c352aef3ea3aed32080501cf3ef6ed5da78602a020c991775b0aff04"
+
 [[package]]
 name = "cfg-if"
 version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
+[[package]]
+name = "const-str"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18f12cc9948ed9604230cdddc7c86e270f9401ccbe3c2e98a4378c5e7632212f"
+
+[[package]]
+name = "convert_case"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec182b0ca2f35d8fc196cf3404988fd8b8c739a4d270ff118a398feb0cbec1ca"
+dependencies = [
+ "unicode-segmentation",
+]
+
 [[package]]
 name = "crc32fast"
 version = "1.5.0"
@@ -29,6 +123,124 @@ dependencies = [
  "cfg-if",
 ]
 
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5181e0de7b61eb03a81e347d6dd8797bae9da5146707b51077e2d71a54ec0ceb"
+dependencies = [
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d6914041f254d6e9176c01941b21115dcfb7089e55135a35411081bd106ef3f"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61803da095bee82a81bb1a452ecc25d3b2f1416d1897eb86430c6159ef717c17"
+
+[[package]]
+name = "cssparser"
+version = "0.37.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c9cdaae01d5ed7882b04d795e7f752f46ff52d2fa3b50a20d28c464510bba98"
+dependencies = [
+ "cssparser-macros",
+ "dtoa-short",
+ "itoa",
+ "phf 0.13.1",
+ "smallvec",
+]
+
+[[package]]
+name = "cssparser-color"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbaa233e1dcd9c13a5d3e3a8a2c0f5a727bac380398345dbcb31db4597edc86b"
+dependencies = [
+ "cssparser",
+]
+
+[[package]]
+name = "cssparser-macros"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "10a2a99df6e410a8ff4245aa2006499ea662245f967cc7c0a38c83ef8eb44dbf"
+dependencies = [
+ "quote",
+ "syn 2.0.119",
+]
+
+[[package]]
+name = "dashmap"
+version = "5.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "978747c1d849a7d2ee5e8adc0159961c48fb7e5db2f06af6723b80123bb53856"
+dependencies = [
+ "cfg-if",
+ "hashbrown 0.14.5",
+ "lock_api",
+ "once_cell",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "data-encoding"
+version = "2.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4583a4551df46e2792f82ceeac45e850d2e2d5debba0b91f102385cda5b11f06"
+
+[[package]]
+name = "data-url"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a30bfce702bcfa94e906ef82421f2c0e61c076ad76030c16ee5d2e9a32fe193"
+dependencies = [
+ "matches",
+]
+
+[[package]]
+name = "dtoa"
+version = "1.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c3cf4824e2d5f025c7b531afcb2325364084a16806f6d47fbc1f5fbd9960590"
+
+[[package]]
+name = "dtoa-short"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd1511a7b6a56299bd043a9c167a6d2bfb37bf84a6dfceaba651168adfb43c87"
+dependencies = [
+ "dtoa",
+]
+
+[[package]]
+name = "either"
+version = "1.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e5e8f6c15a24b9a3ee5efec809ccd006d3b30e8b3bb63c39af737c7f87daa1d"
+
+[[package]]
+name = "equivalent"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
+[[package]]
+name = "fastrand"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223"
+
 [[package]]
 name = "fdeflate"
 version = "0.3.7"
@@ -48,6 +260,197 @@ dependencies = [
  "miniz_oxide",
 ]
 
+[[package]]
+name = "funty"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
+
+[[package]]
+name = "futures-core"
+version = "0.3.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2cd50c473c80f6d7c3670a752354b8e569b1a7cbfdc0419ec88e5edad85e0dc7"
+
+[[package]]
+name = "futures-task"
+version = "0.3.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b231ed28831efb4a61a08580c4bc233ec56bc009f4cd8f52da2c3cb97df0c109"
+
+[[package]]
+name = "futures-util"
+version = "0.3.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a77a90a256fce34da66415271e30f94ee91c57b04b8a2c042d9cf3220179deaa"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "pin-project-lite",
+ "slab",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi",
+ "wasip2",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+dependencies = [
+ "ahash 0.7.8",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.14.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
+
+[[package]]
+name = "hashbrown"
+version = "0.17.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
+
+[[package]]
+name = "indexmap"
+version = "2.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9"
+dependencies = [
+ "equivalent",
+ "hashbrown 0.17.1",
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "itertools"
+version = "0.10.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
+
+[[package]]
+name = "js-sys"
+version = "0.3.103"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53b44bfcdb3f8d5837a46dae1ca9660a837176eee74a28b229bc626816589102"
+dependencies = [
+ "cfg-if",
+ "futures-util",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+
+[[package]]
+name = "libc"
+version = "0.2.189"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"
+
+[[package]]
+name = "lightningcss"
+version = "1.0.0-alpha.72"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d31b760f96e8fdfe1d0c295e4bf76c503d6f15d2d470d53bd8cd1f7aa8c7d934"
+dependencies = [
+ "ahash 0.8.12",
+ "bitflags",
+ "const-str",
+ "cssparser",
+ "cssparser-color",
+ "dashmap",
+ "data-encoding",
+ "getrandom 0.3.4",
+ "indexmap",
+ "itertools",
+ "lazy_static",
+ "lightningcss-derive",
+ "parcel_selectors",
+ "parcel_sourcemap",
+ "pastey",
+ "pathdiff",
+ "rayon",
+ "serde",
+ "serde-content",
+ "smallvec",
+]
+
+[[package]]
+name = "lightningcss-derive"
+version = "1.0.0-alpha.43"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "84c12744d1279367caed41739ef094c325d53fb0ffcd4f9b84a368796f870252"
+dependencies = [
+ "convert_case",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "lock_api"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
+dependencies = [
+ "scopeguard",
+]
+
+[[package]]
+name = "log"
+version = "0.4.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ceec5bc11778974d1bcb055b18002eba7f4b3518b6a0081b3af5f21666da9ad"
+
+[[package]]
+name = "matches"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2532096657941c2fea9c289d370a250971c689d4f143798ff67113ec042024a5"
+
+[[package]]
+name = "memchr"
+version = "2.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
+
 [[package]]
 name = "miniz_oxide"
 version = "0.8.9"
@@ -58,6 +461,160 @@ dependencies = [
  "simd-adler32",
 ]
 
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+
+[[package]]
+name = "outref"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f222829ae9293e33a9f5e9f440c6760a3d450a64affe1846486b140db81c1f4"
+
+[[package]]
+name = "parcel_selectors"
+version = "0.28.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d05f71e01edca03d245ab0a9f7ce13a974ceb79baaae8faf2ba0b11de6b90913"
+dependencies = [
+ "bitflags",
+ "cssparser",
+ "log",
+ "phf 0.11.3",
+ "phf_codegen",
+ "precomputed-hash",
+ "rustc-hash",
+ "smallvec",
+]
+
+[[package]]
+name = "parcel_sourcemap"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "485b74d7218068b2b7c0e3ff12fbc61ae11d57cb5d8224f525bd304c6be05bbb"
+dependencies = [
+ "base64-simd",
+ "data-url",
+ "rkyv",
+ "serde",
+ "serde_json",
+ "vlq",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.9.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "redox_syscall",
+ "smallvec",
+ "windows-link",
+]
+
+[[package]]
+name = "pastey"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "35fb2e5f958ec131621fdd531e9fc186ed768cbe395337403ae56c17a74c68ec"
+
+[[package]]
+name = "pathdiff"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df94ce210e5bc13cb6651479fa48d14f601d9858cfe0467f43ae157023b938d3"
+
+[[package]]
+name = "phf"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd6780a80ae0c52cc120a26a1a42c1ae51b247a253e4e06113d23d2c2edd078"
+dependencies = [
+ "phf_shared 0.11.3",
+]
+
+[[package]]
+name = "phf"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1562dc717473dbaa4c1f85a36410e03c047b2e7df7f45ee938fbef64ae7fadf"
+dependencies = [
+ "phf_macros",
+ "phf_shared 0.13.1",
+ "serde",
+]
+
+[[package]]
+name = "phf_codegen"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aef8048c789fa5e851558d709946d6d79a8ff88c0440c587967f8e94bfb1216a"
+dependencies = [
+ "phf_generator 0.11.3",
+ "phf_shared 0.11.3",
+]
+
+[[package]]
+name = "phf_generator"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c80231409c20246a13fddb31776fb942c38553c51e871f8cbd687a4cfb5843d"
+dependencies = [
+ "phf_shared 0.11.3",
+ "rand",
+]
+
+[[package]]
+name = "phf_generator"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "135ace3a761e564ec88c03a77317a7c6b80bb7f7135ef2544dbe054243b89737"
+dependencies = [
+ "fastrand",
+ "phf_shared 0.13.1",
+]
+
+[[package]]
+name = "phf_macros"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "812f032b54b1e759ccd5f8b6677695d5268c588701effba24601f6932f8269ef"
+dependencies = [
+ "phf_generator 0.13.1",
+ "phf_shared 0.13.1",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
+
+[[package]]
+name = "phf_shared"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67eabc2ef2a60eb7faa00097bd1ffdb5bd28e62bf39990626a582201b7a754e5"
+dependencies = [
+ "siphasher",
+]
+
+[[package]]
+name = "phf_shared"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e57fef6bc5981e38c2ce2d63bfa546861309f875b8a75f092d1d54ae2d64f266"
+dependencies = [
+ "siphasher",
+]
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
+
 [[package]]
 name = "png"
 version = "0.18.1"
@@ -71,15 +628,467 @@ dependencies = [
  "miniz_oxide",
 ]
 
+[[package]]
+name = "precomputed-hash"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.107"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "ptr_meta"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0738ccf7ea06b608c10564b31debd4f5bc5e197fc8bfe088f68ae5ce81e7a4f1"
+dependencies = [
+ "ptr_meta_derive",
+]
+
+[[package]]
+name = "ptr_meta_derive"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "16b845dbfca988fa33db069c0e230574d15a3088f147a87b64c7589eb662c9ac"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
+[[package]]
+name = "radium"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
+
+[[package]]
+name = "rand"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22f6172bdec972074665ed81ed53b71da00bfc44b65a753cfde883ec4c702a1a"
+dependencies = [
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+
+[[package]]
+name = "rayon"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fb39b166781f92d482534ef4b4b1b2568f42613b53e5b6c160e24cfbfa30926d"
+dependencies = [
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"
+dependencies = [
+ "crossbeam-deque",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.5.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "rend"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "71fe3824f5629716b1589be05dacd749f6aa084c87e00e016714a8cdfccc997c"
+dependencies = [
+ "bytecheck",
+]
+
+[[package]]
+name = "rkyv"
+version = "0.7.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2297bf9c81a3f0dc96bc9521370b88f054168c29826a75e89c55ff196e7ed6a1"
+dependencies = [
+ "bitvec",
+ "bytecheck",
+ "bytes",
+ "hashbrown 0.12.3",
+ "ptr_meta",
+ "rend",
+ "rkyv_derive",
+ "seahash",
+ "tinyvec",
+ "uuid",
+]
+
+[[package]]
+name = "rkyv_derive"
+version = "0.7.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "84d7b42d4b8d06048d3ac8db0eb31bcb942cbeb709f0b5f2b2ebde398d3038f5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "rustc-hash"
+version = "2.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b1e7f9a428571be2dc5bc0505c13fb6bf936822b894ec87abf8a08a4e51742d"
+
+[[package]]
+name = "rustversion"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"
+
+[[package]]
+name = "scopeguard"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+
+[[package]]
+name = "seahash"
+version = "4.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c107b6f4780854c8b126e228ea8869f4d7b71260f962fefb57b996b8959ba6b"
+
+[[package]]
+name = "serde"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde-content"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3753ca04f350fa92d00b6146a3555e63c55388c9ef2e11e09bce2ff1c0b509c6"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.3",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.151"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14"
+dependencies = [
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
+[[package]]
+name = "simd-abstraction"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9cadb29c57caadc51ff8346233b5cec1d240b68ce55cf1afc764818791876987"
+dependencies = [
+ "outref",
+]
+
 [[package]]
 name = "simd-adler32"
 version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "703d5c7ef118737c72f1af64ad2f6f8c5e1921f818cdcb97b8fe6fc69bf66214"
 
+[[package]]
+name = "simdutf8"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e"
+
+[[package]]
+name = "siphasher"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ee5873ec9cce0195efcb7a4e9507a04cd49aec9c83d0389df45b1ef7ba2e649"
+
+[[package]]
+name = "slab"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"
+
+[[package]]
+name = "smallvec"
+version = "1.15.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ed6a63f02c8539c91a8685a86f4099661ba3da017932f6ebbea6de3f0fa7c90"
+
+[[package]]
+name = "syn"
+version = "1.0.109"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.119"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn"
+version = "3.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53e9bae58849f64dfa4f5d5ae372c8341f7305f82a3868709269343628b659a3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "tap"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
+
+[[package]]
+name = "tinyvec"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb4ebadaa0af04fab11ae01eb5f9fdb5f9c5b875506e210e71c07873528baa7f"
+dependencies = [
+ "tinyvec_macros",
+]
+
+[[package]]
+name = "tinyvec_macros"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "unicode-segmentation"
+version = "1.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6f5d3c3b1bf09027a88a6bc961fc00497d651009560b5463668dc81b0fa87a8"
+
+[[package]]
+name = "uuid"
+version = "1.24.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf3923a6f5c4c6382e0b653c4117f48d631ea17f38ed86e2a828e6f7412f5239"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "vlq"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "65dd7eed29412da847b0f78bcec0ac98588165988a8cfe41d4ea1d429f8ccfff"
+
+[[package]]
+name = "wasi"
+version = "0.11.1+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
+
+[[package]]
+name = "wasip2"
+version = "1.0.4+wasi-0.2.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b67efb37e106e55ce722a510d6b5f9c17f083e5fc79afc2badeb12cc313d9487"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.126"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b067c0c11094aef6b7a801c1e34a26affafdf3d051dba08456b868789aaf9a4"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.126"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "167ce5e579f6bcf889c4f7175a8a5a585de84e8ff93976ce393efa5f2837aab1"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.126"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3997c7839262f4ef12cf90b818d6340c18e80f263f1a94bf157d0ec4420380e"
+dependencies = [
+ "bumpalo",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.126"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc1b4cb0cc549fcf58d7dfc081778139b3d283a081644e833e84682ad71cea24"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "wit-bindgen"
+version = "0.57.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e"
+
+[[package]]
+name = "wyz"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
+dependencies = [
+ "tap",
+]
+
+[[package]]
+name = "xy-cascade"
+version = "0.1.0"
+dependencies = [
+ "lightningcss",
+ "parcel_selectors",
+ "serde",
+ "serde_json",
+]
+
 [[package]]
 name = "xy-core"
 version = "0.1.0"
 dependencies = [
  "png",
 ]
+
+[[package]]
+name = "zerocopy"
+version = "0.8.55"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5a105cd7b140f6eeec8acff2ea38135d3cab283ada58540f629fe51e46696eb"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.55"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fe976fb70c78cd64cccfe3a6fc142244e8a77b70959b30faf9d0ac37ee228eb"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
+
+[[package]]
+name = "zmij"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"
diff --git a/Cargo.toml b/Cargo.toml
index 1a2946b4c..2a133907f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,3 +1,11 @@
+# Workspace: the core stays the root package; `cascade` is the optional
+# style-cascade extension (its own cdylib, loaded lazily and only when a
+# native-cascade export is requested — the §33 install budget and the
+# import-weight contract are measured with both, but the core never links it).
+[workspace]
+members = [".", "cascade"]
+default-members = [".", "cascade"]
+
 [package]
 name = "xy-core"
 version = "0.1.0"
diff --git a/cascade/Cargo.toml b/cascade/Cargo.toml
new file mode 100644
index 000000000..21fe83c96
--- /dev/null
+++ b/cascade/Cargo.toml
@@ -0,0 +1,20 @@
+[package]
+name = "xy-cascade"
+version = "0.1.0"
+edition = "2021"
+description = "Optional mount-free CSS cascade for xy: Lightning CSS parsing plus a profile-scoped resolver over the synthetic chart DOM"
+license = "Apache-2.0"
+
+[lib]
+name = "xy_cascade"
+crate-type = ["cdylib"]
+
+# Lightning CSS does the real parsing/normalization; the matcher/cascade over
+# the synthetic slot DOM is profile-scoped and lives here. Everything outside
+# the published profile is reported, never guessed (§28). Pinned exactly:
+# the resolver's output is part of a deterministic export path.
+[dependencies]
+lightningcss = "=1.0.0-alpha.72"
+parcel_selectors = "=0.28.3"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
diff --git a/cascade/src/lib.rs b/cascade/src/lib.rs
new file mode 100644
index 000000000..a3052437f
--- /dev/null
+++ b/cascade/src/lib.rs
@@ -0,0 +1,78 @@
+//! Mount-free CSS cascade for xy (wire-protocol §8, migration doc "native
+//! cascade"): Lightning CSS parses and normalizes author stylesheets; this
+//! crate matches them against the synthetic chart DOM and cascades to
+//! concrete per-node declarations — the values the ResolvedStyleSnapshot
+//! carries and the native writers consume.
+//!
+//! Profile-scoped on purpose. The published profile is: style rules;
+//! class / `[data-xy-slot=…]` attribute / universal / `:root` simple
+//! selectors with descendant and child combinators; `@media
+//! (prefers-color-scheme: …)`; custom properties with `var()` fallbacks;
+//! `em`/`rem` lengths (resolved against the font-size cascade); the
+//! inherited text properties. Everything else — other at-rules, pseudo
+//! classes/elements, sibling combinators, percentage lengths — lands in the
+//! reply's `unsupported` list with the reason, never in a guessed value
+//! (§28). The Python side surfaces that list through the preflight.
+//!
+//! C ABI: JSON in, JSON out, one free function. The boundary stays this
+//! narrow so the extension is loadable lazily and replaceable wholesale
+//! (the plan's Stylo endgame swaps the resolver, not the contract).
+
+mod resolve;
+
+use std::panic::{catch_unwind, AssertUnwindSafe};
+
+pub const CASCADE_ABI_VERSION: u32 = 1;
+
+#[no_mangle]
+pub extern "C" fn xy_cascade_abi_version() -> u32 {
+    CASCADE_ABI_VERSION
+}
+
+/// Resolve `css` against the synthetic document `doc` (JSON; see
+/// `resolve::Document`). Writes a malloc'd JSON reply to `out`/`out_len`;
+/// returns 0 on success, 1 when the reply is `{"error": …}`, 2 on a caught
+/// panic (reply is a static error JSON). The caller frees the reply with
+/// `xy_cascade_free` in every case.
+///
+/// # Safety
+/// `css_ptr`/`doc_ptr` must reference `css_len`/`doc_len` readable bytes;
+/// `out`/`out_len` must be writable.
+#[no_mangle]
+pub unsafe extern "C" fn xy_cascade_resolve(
+    css_ptr: *const u8,
+    css_len: usize,
+    doc_ptr: *const u8,
+    doc_len: usize,
+    out: *mut *mut u8,
+    out_len: *mut usize,
+) -> i32 {
+    let css = std::slice::from_raw_parts(css_ptr, css_len);
+    let doc = std::slice::from_raw_parts(doc_ptr, doc_len);
+    let result = catch_unwind(AssertUnwindSafe(|| resolve::resolve_json(css, doc)));
+    let (code, payload) = match result {
+        Ok(Ok(json)) => (0, json),
+        Ok(Err(message)) => (
+            1,
+            serde_json::to_string(&serde_json::json!({ "error": message }))
+                .unwrap_or_else(|_| "{\"error\":\"unserializable error\"}".to_string()),
+        ),
+        Err(_) => (2, "{\"error\":\"panic in xy_cascade_resolve\"}".to_string()),
+    };
+    let boxed = payload.into_bytes().into_boxed_slice();
+    let len = boxed.len();
+    *out = Box::into_raw(boxed) as *mut u8;
+    *out_len = len;
+    code
+}
+
+/// Free a reply produced by `xy_cascade_resolve`.
+///
+/// # Safety
+/// `ptr`/`len` must be exactly a pair returned through `out`/`out_len`.
+#[no_mangle]
+pub unsafe extern "C" fn xy_cascade_free(ptr: *mut u8, len: usize) {
+    if !ptr.is_null() {
+        drop(Box::from_raw(std::ptr::slice_from_raw_parts_mut(ptr, len)));
+    }
+}
diff --git a/cascade/src/resolve.rs b/cascade/src/resolve.rs
new file mode 100644
index 000000000..32c18430d
--- /dev/null
+++ b/cascade/src/resolve.rs
@@ -0,0 +1,729 @@
+//! The profile-scoped resolver: parse → match → cascade → concrete values.
+//!
+//! Correctness order inside one node's cascade, mirroring CSS: importance,
+//! then specificity, then source order. No layers in the profile (an
+//! `@layer` is reported). Custom properties resolve after the cascade with
+//! inheritance; `em`/`rem` resolve after font-size does; the inherited text
+//! properties flow parent-to-child last, so a child's own cascade always
+//! outranks what it inherits.
+
+use std::collections::BTreeMap;
+
+use lightningcss::printer::PrinterOptions;
+use lightningcss::properties::Property;
+use lightningcss::rules::CssRule;
+use lightningcss::selector::{Component, Selector};
+use lightningcss::stylesheet::{ParserOptions, StyleSheet};
+use lightningcss::traits::ToCss;
+use serde::{Deserialize, Serialize};
+
+#[derive(Deserialize)]
+struct Document {
+    env: Env,
+    nodes: Vec<Node>,
+}
+
+#[derive(Deserialize)]
+struct Env {
+    #[serde(default = "default_scheme")]
+    color_scheme: String,
+    #[serde(default = "default_root_font")]
+    root_font_size: f64,
+}
+
+fn default_scheme() -> String {
+    "light".to_string()
+}
+
+fn default_root_font() -> f64 {
+    16.0
+}
+
+#[derive(Deserialize)]
+struct Node {
+    slot: String,
+    #[serde(default)]
+    classes: Vec<String>,
+    /// Index into `nodes`; parents precede children. `null` for the root.
+    parent: Option<usize>,
+}
+
+#[derive(Serialize, Deserialize)]
+struct Reply {
+    nodes: Vec<NodeReply>,
+    unsupported: Vec<String>,
+}
+
+#[derive(Serialize, Deserialize)]
+struct NodeReply {
+    slot: String,
+    declarations: BTreeMap<String, String>,
+}
+
+/// Text properties that inherit down the synthetic tree — the CSS inherited
+/// set restricted to the snapshot vocabulary the writers consume.
+const INHERITED: &[&str] = &[
+    "color",
+    "font-family",
+    "font-size",
+    "font-style",
+    "font-weight",
+    "letter-spacing",
+    "line-height",
+    "text-align",
+];
+
+/// One matched declaration awaiting cascade.
+struct Candidate {
+    specificity: u32,
+    order: u32,
+    important: bool,
+    value: String,
+}
+
+fn better(a: &Candidate, b: &Candidate) -> bool {
+    (a.important, a.specificity, a.order) > (b.important, b.specificity, b.order)
+}
+
+/// A parsed profile selector: compounds right-to-left, combinator before
+/// each non-subject compound (descendant or child only).
+struct ProfileSelector {
+    /// (compound, child_combinator_to_previous) — subject compound first.
+    compounds: Vec<(Vec<Simple>, bool)>,
+    specificity: u32,
+}
+
+enum Simple {
+    Class(String),
+    SlotAttr(String),
+    Root,
+    Universal,
+}
+
+pub fn resolve_json(css: &[u8], doc: &[u8]) -> Result<String, String> {
+    let css = std::str::from_utf8(css).map_err(|e| format!("stylesheet is not UTF-8: {e}"))?;
+    let doc: Document = serde_json::from_slice(doc).map_err(|e| format!("document JSON: {e}"))?;
+    for (i, node) in doc.nodes.iter().enumerate() {
+        if let Some(p) = node.parent {
+            if p >= i {
+                return Err(format!(
+                    "node {i} ({}) references parent {p}; parents must precede children",
+                    node.slot
+                ));
+            }
+        }
+    }
+
+    let mut unsupported: Vec<String> = Vec::new();
+    let sheet = StyleSheet::parse(css, ParserOptions::default())
+        .map_err(|e| format!("stylesheet parse error: {e}"))?;
+
+    // node -> property -> best candidate; custom properties cascade the
+    // same way but resolve later.
+    let n = doc.nodes.len();
+    let mut winners: Vec<BTreeMap<String, Candidate>> = (0..n).map(|_| BTreeMap::new()).collect();
+    let mut order: u32 = 0;
+    collect_rules(
+        &sheet.rules.0,
+        &doc,
+        &mut winners,
+        &mut order,
+        &mut unsupported,
+        true,
+    );
+
+    // Custom-property chains: parent map extended by own winners.
+    let mut custom: Vec<BTreeMap<String, String>> = Vec::with_capacity(n);
+    for (i, node) in doc.nodes.iter().enumerate() {
+        let mut map = node.parent.map(|p| custom[p].clone()).unwrap_or_default();
+        for (name, cand) in winners[i].iter() {
+            if name.starts_with("--") {
+                map.insert(name.clone(), cand.value.trim().to_string());
+            }
+        }
+        custom.push(map);
+    }
+
+    // Substitute var(), resolve font-size chain, then remaining lengths,
+    // then inheritance.
+    let mut resolved: Vec<BTreeMap<String, String>> = Vec::with_capacity(n);
+    let mut font_sizes: Vec<f64> = Vec::with_capacity(n);
+    for (i, node) in doc.nodes.iter().enumerate() {
+        let parent_font = node
+            .parent
+            .map(|p| font_sizes[p])
+            .unwrap_or(doc.env.root_font_size);
+        let mut out: BTreeMap<String, String> = BTreeMap::new();
+        // font-size first: em/rem lengths on this node resolve against it.
+        let own_font = match winners[i].get("font-size") {
+            Some(cand) => match substituted(&cand.value, &custom[i]) {
+                Ok(value) => {
+                    match resolve_length(&value, parent_font, doc.env.root_font_size, parent_font) {
+                        Ok(px) => {
+                            out.insert("font-size".into(), fmt_px(px));
+                            px
+                        }
+                        Err(why) => {
+                            unsupported.push(format!(
+                                "{}: font-size: {} — {}",
+                                node.slot, cand.value, why
+                            ));
+                            parent_font
+                        }
+                    }
+                }
+                Err(why) => {
+                    unsupported.push(format!("{}: font-size — {}", node.slot, why));
+                    parent_font
+                }
+            },
+            None => parent_font,
+        };
+        font_sizes.push(own_font);
+
+        for (name, cand) in winners[i].iter() {
+            if name == "font-size" || name.starts_with("--") {
+                continue;
+            }
+            let value = match substituted(&cand.value, &custom[i]) {
+                Ok(v) => v,
+                Err(why) => {
+                    unsupported.push(format!("{}: {} — {}", node.slot, name, why));
+                    continue;
+                }
+            };
+            match concrete_value(&value, own_font, doc.env.root_font_size) {
+                Ok(v) => {
+                    out.insert(name.clone(), v);
+                }
+                Err(why) => {
+                    unsupported.push(format!("{}: {}: {} — {}", node.slot, name, value, why));
+                }
+            }
+        }
+        resolved.push(out);
+    }
+
+    // Inheritance, top-down; a node's own cascade already sits in `resolved`.
+    for i in 0..n {
+        if let Some(p) = doc.nodes[i].parent {
+            for &prop in INHERITED {
+                if !resolved[i].contains_key(prop) {
+                    if let Some(v) = resolved[p].get(prop).cloned() {
+                        resolved[i].insert(prop.to_string(), v);
+                    }
+                }
+            }
+        }
+    }
+
+    let reply = Reply {
+        nodes: doc
+            .nodes
+            .iter()
+            .zip(resolved)
+            .map(|(node, declarations)| NodeReply {
+                slot: node.slot.clone(),
+                declarations,
+            })
+            .collect(),
+        unsupported,
+    };
+    serde_json::to_string(&reply).map_err(|e| format!("reply serialization: {e}"))
+}
+
+fn collect_rules(
+    rules: &[CssRule],
+    doc: &Document,
+    winners: &mut [BTreeMap<String, Candidate>],
+    order: &mut u32,
+    unsupported: &mut Vec<String>,
+    media_active: bool,
+) {
+    for rule in rules {
+        match rule {
+            CssRule::Style(style) => {
+                let decls: Vec<(String, String, bool)> = declaration_texts(style, unsupported);
+                for selector in &style.selectors.0 {
+                    let profile = match profile_selector(selector) {
+                        Ok(p) => p,
+                        Err(why) => {
+                            unsupported.push(format!(
+                                "selector `{}` — {}",
+                                selector_text(selector),
+                                why
+                            ));
+                            continue;
+                        }
+                    };
+                    if !media_active {
+                        continue;
+                    }
+                    for (i, _node) in doc.nodes.iter().enumerate() {
+                        if matches(&profile, doc, i) {
+                            for (name, value, important) in &decls {
+                                let cand = Candidate {
+                                    specificity: profile.specificity,
+                                    order: *order,
+                                    important: *important,
+                                    value: value.clone(),
+                                };
+                                match winners[i].get(name.as_str()) {
+                                    Some(existing) if !better(&cand, existing) => {}
+                                    _ => {
+                                        winners[i].insert(name.clone(), cand);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                *order += 1;
+            }
+            CssRule::Media(media) => {
+                let query = media
+                    .query
+                    .to_css_string(PrinterOptions::default())
+                    .unwrap_or_default();
+                match scheme_match(&query, &doc.env.color_scheme) {
+                    Some(active) => collect_rules(
+                        &media.rules.0,
+                        doc,
+                        winners,
+                        order,
+                        unsupported,
+                        media_active && active,
+                    ),
+                    None => unsupported.push(format!(
+                        "@media {query} — only (prefers-color-scheme: …) is in the profile"
+                    )),
+                }
+            }
+            other => {
+                let text = other
+                    .to_css_string(PrinterOptions::default())
+                    .unwrap_or_else(|_| "<unprintable rule>".into());
+                let head: String = text.chars().take(60).collect();
+                unsupported.push(format!("rule `{head}` — outside the style/media profile"));
+            }
+        }
+    }
+}
+
+fn declaration_texts(
+    style: &lightningcss::rules::style::StyleRule,
+    unsupported: &mut Vec<String>,
+) -> Vec<(String, String, bool)> {
+    let mut out = Vec::new();
+    let mut push = |prop: &Property, important: bool, unsupported: &mut Vec<String>| {
+        let name = prop.property_id().name().to_string();
+        match prop.value_to_css_string(PrinterOptions::default()) {
+            Ok(value) => out.push((name, value, important)),
+            Err(e) => unsupported.push(format!("declaration {name} — unserializable: {e}")),
+        }
+    };
+    for prop in &style.declarations.declarations {
+        push(prop, false, unsupported);
+    }
+    for prop in &style.declarations.important_declarations {
+        push(prop, true, unsupported);
+    }
+    out
+}
+
+fn selector_text(selector: &Selector) -> String {
+    selector
+        .to_css_string(PrinterOptions::default())
+        .unwrap_or_else(|_| "<unprintable>".into())
+}
+
+/// Lower a parsed selector into the profile, or say exactly why not.
+fn profile_selector(selector: &Selector) -> Result<ProfileSelector, String> {
+    use lightningcss::selector::Combinator;
+
+    let mut compounds: Vec<(Vec<Simple>, bool)> = Vec::new();
+    let mut current: Vec<Simple> = Vec::new();
+    let mut child_next = false;
+    let mut iter = selector.iter();
+    loop {
+        for component in &mut iter {
+            match component {
+                Component::Class(name) => current.push(Simple::Class(name.to_string())),
+                Component::AttributeInNoNamespace {
+                    local_name,
+                    operator,
+                    value,
+                    ..
+                } => {
+                    if local_name.as_ref() != "data-xy-slot" {
+                        return Err(format!(
+                            "attribute selector [{local_name}] — only [data-xy-slot=…] is in the profile"
+                        ));
+                    }
+                    if !matches!(
+                        operator,
+                        parcel_selectors::attr::AttrSelectorOperator::Equal
+                    ) {
+                        return Err("only [data-xy-slot=\"…\"] equality is in the profile".into());
+                    }
+                    current.push(Simple::SlotAttr(value.to_string()));
+                }
+                Component::ExplicitUniversalType => current.push(Simple::Universal),
+                Component::Root => current.push(Simple::Root),
+                other => {
+                    return Err(format!(
+                        "component {:?} — outside the class/slot/universal/:root profile",
+                        component_kind(other)
+                    ));
+                }
+            }
+        }
+        compounds.push((std::mem::take(&mut current), child_next));
+        match iter.next_sequence() {
+            Some(Combinator::Descendant) => child_next = false,
+            Some(Combinator::Child) => child_next = true,
+            Some(other) => {
+                return Err(format!(
+                    "combinator {other:?} — only descendant and child are in the profile"
+                ))
+            }
+            None => break,
+        }
+    }
+    Ok(ProfileSelector {
+        compounds,
+        specificity: selector.specificity(),
+    })
+}
+
+fn component_kind(component: &Component) -> &'static str {
+    match component {
+        Component::ID(..) => "#id",
+        Component::LocalName(..) => "type selector",
+        Component::NonTSPseudoClass(..) => "pseudo-class",
+        Component::PseudoElement(..) => "pseudo-element",
+        Component::Negation(..) => ":not()",
+        Component::Is(..) => ":is()",
+        Component::Where(..) => ":where()",
+        _ => "unsupported selector component",
+    }
+}
+
+fn compound_matches(compound: &[Simple], doc: &Document, index: usize) -> bool {
+    let node = &doc.nodes[index];
+    compound.iter().all(|simple| match simple {
+        Simple::Class(name) => node.classes.iter().any(|c| c == name),
+        Simple::SlotAttr(slot) => node.slot == *slot,
+        Simple::Root => node.parent.is_none(),
+        Simple::Universal => true,
+    })
+}
+
+fn matches(profile: &ProfileSelector, doc: &Document, index: usize) -> bool {
+    // Subject compound first, then walk ancestors per combinator.
+    let mut compounds = profile.compounds.iter();
+    let Some((subject, _)) = compounds.next() else {
+        return false;
+    };
+    if !compound_matches(subject, doc, index) {
+        return false;
+    }
+    let mut position = index;
+    for (compound, child) in compounds {
+        if *child {
+            match doc.nodes[position].parent {
+                Some(p) if compound_matches(compound, doc, p) => position = p,
+                _ => return false,
+            }
+        } else {
+            let mut cursor = doc.nodes[position].parent;
+            loop {
+                match cursor {
+                    Some(p) => {
+                        if compound_matches(compound, doc, p) {
+                            position = p;
+                            break;
+                        }
+                        cursor = doc.nodes[p].parent;
+                    }
+                    None => return false,
+                }
+            }
+        }
+    }
+    true
+}
+
+/// `(prefers-color-scheme: X)` → Some(X == env); anything else → None.
+fn scheme_match(query: &str, scheme: &str) -> Option<bool> {
+    let q: String = query
+        .chars()
+        .filter(|c| !c.is_whitespace())
+        .collect::<String>()
+        .to_ascii_lowercase();
+    match q.as_str() {
+        "(prefers-color-scheme:dark)" => Some(scheme == "dark"),
+        "(prefers-color-scheme:light)" => Some(scheme == "light"),
+        _ => None,
+    }
+}
+
+/// Substitute var() with the node's custom-property chain, fallbacks
+/// honored, to a fixpoint with a depth cap.
+fn substituted(value: &str, custom: &BTreeMap<String, String>) -> Result<String, String> {
+    let mut text = value.to_string();
+    for _ in 0..8 {
+        let Some(at) = text.find("var(") else {
+            return Ok(text);
+        };
+        let body_start = at + 4;
+        let mut depth = 1usize;
+        let mut end = None;
+        for (offset, ch) in text[body_start..].char_indices() {
+            match ch {
+                '(' => depth += 1,
+                ')' => {
+                    depth -= 1;
+                    if depth == 0 {
+                        end = Some(body_start + offset);
+                        break;
+                    }
+                }
+                _ => {}
+            }
+        }
+        let end = end.ok_or_else(|| "unbalanced var(".to_string())?;
+        let body = &text[body_start..end];
+        let (name, fallback) = match body.find(',') {
+            Some(comma) => (body[..comma].trim(), Some(body[comma + 1..].trim())),
+            None => (body.trim(), None),
+        };
+        let replacement = match custom.get(name) {
+            Some(v) => v.clone(),
+            None => fallback
+                .map(str::to_string)
+                .ok_or_else(|| format!("var({name}) has no value and no fallback"))?,
+        };
+        text.replace_range(at..=end, &replacement);
+    }
+    Err("var() nesting exceeded the resolver's depth cap".into())
+}
+
+fn fmt_px(px: f64) -> String {
+    if (px - px.round()).abs() < 1e-9 {
+        format!("{}px", px.round() as i64)
+    } else {
+        format!("{px}px")
+    }
+}
+
+/// Resolve one bare length. `own_font` is the em base (parent font for the
+/// font-size property itself, own font for everything else).
+fn resolve_length(
+    value: &str,
+    em_base: f64,
+    rem_base: f64,
+    _parent_font: f64,
+) -> Result<f64, String> {
+    let v = value.trim();
+    if let Some(number) = v.strip_suffix("px") {
+        return number
+            .trim()
+            .parse::<f64>()
+            .map_err(|_| format!("unparseable px length `{v}`"));
+    }
+    if let Some(number) = v.strip_suffix("rem") {
+        return number
+            .trim()
+            .parse::<f64>()
+            .map(|n| n * rem_base)
+            .map_err(|_| format!("unparseable rem length `{v}`"));
+    }
+    if let Some(number) = v.strip_suffix("em") {
+        return number
+            .trim()
+            .parse::<f64>()
+            .map(|n| n * em_base)
+            .map_err(|_| format!("unparseable em length `{v}`"));
+    }
+    if let Ok(number) = v.parse::<f64>() {
+        return Ok(number);
+    }
+    Err("not a px/em/rem length".into())
+}
+
+/// Make one declaration value concrete: resolve em/rem tokens against the
+/// font-size cascade; refuse percentages outside color functions and
+/// anything still cascade-dependent. Values with no length tokens pass
+/// through as Lightning CSS normalized them.
+fn concrete_value(value: &str, own_font: f64, rem_base: f64) -> Result<String, String> {
+    let lowered = value.to_ascii_lowercase();
+    if lowered.contains("calc(") || lowered.contains("env(") || lowered.contains("attr(") {
+        return Err("still depends on a cascade/environment the writers do not have".into());
+    }
+    if lowered == "inherit" || lowered == "initial" || lowered == "unset" || lowered == "revert" {
+        return Err("cascade keyword".into());
+    }
+    // Token-wise em/rem resolution; % outside color functions is refused.
+    let masked = mask_color_functions(&lowered);
+    if masked.contains('%') {
+        return Err("percentage length — resolved lengths are px (percentages are accepted only as rgb()/hsl() color components)".into());
+    }
+    let mut out = String::with_capacity(value.len());
+    let mut token = String::new();
+    let flush = |token: &mut String, out: &mut String| -> Result<(), String> {
+        if token.is_empty() {
+            return Ok(());
+        }
+        let t = std::mem::take(token);
+        let lower = t.to_ascii_lowercase();
+        if lower.ends_with("em") && lower[..lower.len() - 2].parse::<f64>().is_ok()
+            || lower.ends_with("rem") && lower[..lower.len() - 3].parse::<f64>().is_ok()
+        {
+            let px = resolve_length(&lower, own_font, rem_base, own_font)?;
+            out.push_str(&fmt_px(px));
+        } else {
+            out.push_str(&t);
+        }
+        Ok(())
+    };
+    for ch in value.chars() {
+        if ch.is_whitespace() || ch == ',' || ch == '(' || ch == ')' {
+            flush(&mut token, &mut out)?;
+            out.push(ch);
+        } else {
+            token.push(ch);
+        }
+    }
+    flush(&mut token, &mut out)?;
+    Ok(out)
+}
+
+/// Blank out rgb()/rgba()/hsl()/hsla() bodies so their % components do not
+/// trip the percentage refusal — the same exemption the Python schema makes.
+fn mask_color_functions(text: &str) -> String {
+    let mut out = String::with_capacity(text.len());
+    let bytes = text.as_bytes();
+    let mut i = 0;
+    while i < bytes.len() {
+        let rest = &text[i..];
+        let head = ["rgba(", "rgb(", "hsla(", "hsl("]
+            .iter()
+            .find(|h| rest.starts_with(**h));
+        if let Some(h) = head {
+            let start = i + h.len();
+            if let Some(close) = text[start..].find(')') {
+                out.push_str(h);
+                out.push(')');
+                i = start + close + 1;
+                continue;
+            }
+        }
+        out.push(text[i..].chars().next().unwrap());
+        i += text[i..].chars().next().unwrap().len_utf8();
+    }
+    out
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn doc() -> String {
+        serde_json::json!({
+            "env": {"color_scheme": "dark", "root_font_size": 16.0},
+            "nodes": [
+                {"slot": "root", "classes": ["dark"], "parent": null},
+                {"slot": "chrome", "classes": [], "parent": 0},
+                {"slot": "tick_label", "classes": ["smoke-tick"], "parent": 1},
+                {"slot": "legend", "classes": [], "parent": 1},
+            ]
+        })
+        .to_string()
+    }
+
+    fn run(css: &str) -> Reply {
+        let json = resolve_json(css.as_bytes(), doc().as_bytes()).unwrap();
+        serde_json::from_str(&json).unwrap()
+    }
+
+    fn decls<'r>(reply: &'r Reply, slot: &str) -> &'r BTreeMap<String, String> {
+        &reply
+            .nodes
+            .iter()
+            .find(|n| n.slot == slot)
+            .unwrap()
+            .declarations
+    }
+
+    #[test]
+    fn class_and_slot_selectors_cascade_by_specificity_and_order() {
+        let reply = run(".smoke-tick { color: rgb(7, 89, 133); }\n\
+             [data-xy-slot=\"tick_label\"] { color: red; font-weight: 600; }\n\
+             .dark .smoke-tick { color: rgb(1, 2, 3); }");
+        let d = decls(&reply, "tick_label");
+        // Two class selectors (0,2,0) beat one attribute (0,1,0); later of
+        // equal specificity wins. Lightning CSS normalizes color spellings
+        // (rgb -> #hex); the differential smoke compares colors parsed, not
+        // as strings, for exactly this reason.
+        assert_eq!(d["color"], "#010203");
+        assert_eq!(d["font-weight"], "600");
+    }
+
+    #[test]
+    fn important_outranks_specificity() {
+        let reply = run("[data-xy-slot=\"tick_label\"] { color: red !important; }\n\
+             .dark .smoke-tick { color: blue; }");
+        assert_eq!(decls(&reply, "tick_label")["color"], "red");
+    }
+
+    #[test]
+    fn var_chain_inherits_and_falls_back() {
+        let reply = run(":root { --fg: rgb(9, 9, 9); }\n\
+             .smoke-tick { color: var(--fg); background: var(--missing, rgb(4, 5, 6)); }");
+        let d = decls(&reply, "tick_label");
+        assert_eq!(d["color"], "#090909");
+        assert_eq!(d["background"], "#040506"); // fallbacks normalize like any color
+    }
+
+    #[test]
+    fn em_resolves_against_the_font_size_cascade() {
+        let reply = run(":root { font-size: 20px; }\n\
+             [data-xy-slot=\"tick_label\"] { font-size: 0.5em; letter-spacing: 0.1em; }");
+        let d = decls(&reply, "tick_label");
+        // font-size em uses the PARENT size (root 20px -> 10px); other
+        // lengths use the node's OWN resolved size (10px -> 1px).
+        assert_eq!(d["font-size"], "10px");
+        assert_eq!(d["letter-spacing"], "1px");
+    }
+
+    #[test]
+    fn media_scheme_gates_and_inheritance_flows() {
+        let reply = run(
+            "@media (prefers-color-scheme: dark) { :root { color: rgb(8, 8, 8); } }\n\
+             @media (prefers-color-scheme: light) { :root { color: rgb(7, 7, 7); } }",
+        );
+        // env is dark; color inherits to every descendant.
+        assert_eq!(decls(&reply, "legend")["color"], "#080808");
+    }
+
+    #[test]
+    fn out_of_profile_constructs_are_reported_not_guessed() {
+        let reply = run(".smoke-tick:hover { color: red; }\n\
+             @keyframes spin { from { opacity: 0; } }\n\
+             .smoke-tick { width: 50%; }");
+        assert!(decls(&reply, "tick_label").get("color").is_none());
+        assert_eq!(reply.unsupported.len(), 3, "{:?}", reply.unsupported);
+    }
+
+    #[test]
+    fn child_combinator_requires_direct_parent() {
+        let reply = run(
+            "[data-xy-slot=\"root\"] > [data-xy-slot=\"tick_label\"] { color: red; }\n\
+             [data-xy-slot=\"chrome\"] > [data-xy-slot=\"tick_label\"] { font-weight: 700; }",
+        );
+        let d = decls(&reply, "tick_label");
+        assert!(d.get("color").is_none(), "root is not the direct parent");
+        assert_eq!(d["font-weight"], "700");
+    }
+}
diff --git a/hatch_build.py b/hatch_build.py
index 901621fec..0cea6631e 100644
--- a/hatch_build.py
+++ b/hatch_build.py
@@ -180,6 +180,22 @@ def initialize(self, version: str, build_data: dict[str, Any]) -> None:
             build_data.setdefault("force_include", {})[str(native_src)] = (
                 f"xy/_native_lib/{lib_name}"
             )
+            # The optional cascade extension builds in the same workspace
+            # cargo invocation (default-members) and lands beside the core.
+            # Ship it when present; a wheel without it still imports and
+            # exports — only style_source="native_cascade" raises, with the
+            # build instruction (§28: optional is announced, not silent).
+            cascade_name = lib_name.replace("xy_core", "xy_cascade")
+            cascade_src = native_src.parent / cascade_name
+            if cascade_src.is_file():
+                build_data["force_include"][str(cascade_src)] = f"xy/_native_lib/{cascade_name}"
+            else:
+                print(
+                    "xy: wheel built WITHOUT the optional xy-cascade extension "
+                    f"({cascade_src} not found); style_source='native_cascade' "
+                    "will raise with the build instruction.",
+                    file=sys.stderr,
+                )
         else:
             # No toolchain / build skipped: ship a pure-Python wheel (the JS
             # client is included via committed package data). There is no NumPy
diff --git a/python/xy/_figure.py b/python/xy/_figure.py
index 415cf0d2f..b14153a92 100644
--- a/python/xy/_figure.py
+++ b/python/xy/_figure.py
@@ -2246,6 +2246,7 @@ def to_svg(
         height: Optional[int] = None,
         compatibility: str = "legacy",
         style_snapshot: Optional[Any] = None,
+        style_source: str = "declared",
     ) -> str:
         """Static SVG (_svg.py): a pure-Python render of the same decimated
         payload the browser client consumes — resolution-independent, tiny
@@ -2255,6 +2256,20 @@ def to_svg(
         vector export would drop, "strict" refuses to drop one."""
         from . import _svg
 
+        if style_source not in ("declared", "native_cascade"):
+            raise ValueError(
+                f'style_source must be "declared" or "native_cascade", got {style_source!r}'
+            )
+        if style_source == "native_cascade":
+            if style_snapshot is not None:
+                raise ValueError(
+                    "style_snapshot and style_source='native_cascade' are two "
+                    "sources for the same values; pass one"
+                )
+            # Classes-only here: to_svg carries no custom_css parameter, so
+            # author stylesheets ride to_image("svg", custom_css=...,
+            # style_source="native_cascade") instead.
+            style_snapshot = export._cascade_snapshot(self, None, compatibility)
         if style_snapshot is not None:
             snapshot = export._coerce_style_snapshot(style_snapshot)
             with export._snapshot_styles(self, snapshot):
@@ -2276,6 +2291,7 @@ def to_png(
         gl: str = "software",
         compatibility: str = "legacy",
         style_snapshot: Optional[Any] = None,
+        style_source: str = "declared",
     ) -> bytes:
         """Static PNG (export.py). `engine=Engine.default` paints the
         decimated payload with the built-in Rust rasterizer — no browser,
@@ -2299,6 +2315,7 @@ def to_png(
             gl=gl,
             compatibility=compatibility,
             style_snapshot=style_snapshot,
+            style_source=style_source,
         )
 
     def to_image(
@@ -2317,6 +2334,7 @@ def to_image(
         gl: str = "software",
         compatibility: str = "legacy",
         style_snapshot: Optional[Any] = None,
+        style_source: str = "declared",
     ) -> bytes:
         """Unified static export: PNG/JPEG/WebP/SVG/PDF bytes (export.py).
 
@@ -2340,6 +2358,7 @@ def to_image(
             gl=gl,
             compatibility=compatibility,
             style_snapshot=style_snapshot,
+            style_source=style_source,
         )
 
     def write_image(
@@ -2359,6 +2378,7 @@ def write_image(
         gl: str = "software",
         compatibility: str = "legacy",
         style_snapshot: Optional[Any] = None,
+        style_source: str = "declared",
     ) -> bytes:
         """Atomic file export with extension-inferred format (export.py):
         .png/.jpg/.jpeg/.webp/.svg/.pdf, plus .html routing to `to_html`."""
@@ -2378,6 +2398,7 @@ def write_image(
             gl=gl,
             compatibility=compatibility,
             style_snapshot=style_snapshot,
+            style_source=style_source,
         )
 
     def memory_report(self) -> dict[str, Any]:
diff --git a/python/xy/components.py b/python/xy/components.py
index b16b7fbbe..b4cb87f31 100644
--- a/python/xy/components.py
+++ b/python/xy/components.py
@@ -4212,6 +4212,7 @@ def to_svg(
         height: Optional[int] = None,
         compatibility: str = "legacy",
         style_snapshot: Optional[Any] = None,
+        style_source: str = "declared",
     ) -> str:
         """A static SVG render of the chart (written to ``path`` if given).
 
@@ -4226,6 +4227,7 @@ def to_svg(
             height=height,
             compatibility=compatibility,
             style_snapshot=style_snapshot,
+            style_source=style_source,
         )
 
     def to_png(
@@ -4242,6 +4244,7 @@ def to_png(
         gl: str = "software",
         compatibility: str = "legacy",
         style_snapshot: Optional[Any] = None,
+        style_source: str = "declared",
     ) -> bytes:
         """A PNG render of the chart, returned as bytes.
 
@@ -4262,6 +4265,7 @@ def to_png(
             gl=gl,
             compatibility=compatibility,
             style_snapshot=style_snapshot,
+            style_source=style_source,
         )
 
     def _export_defaults(
@@ -4313,6 +4317,7 @@ def to_image(
         gl: str = "software",
         compatibility: str = "legacy",
         style_snapshot: Optional[Any] = None,
+        style_source: str = "declared",
     ) -> bytes:
         """Unified static export: PNG/JPEG/WebP/SVG/PDF bytes.
 
@@ -4321,7 +4326,10 @@ def to_image(
         See `export.to_image` for the full format/engine/background policy
         and `compatibility=` for the staged styling contract."""
         fmt = export._normalize_format(format)
-        resolved = export._resolve_image_engine(engine, fmt, custom_css)
+        # native_cascade consumes custom_css itself; the defaults pre-resolution
+        # must not route it to a browser the export will never use.
+        precheck_css = None if style_source == "native_cascade" else custom_css
+        resolved = export._resolve_image_engine(engine, fmt, precheck_css)
         return self.figure().to_image(
             format,
             engine=engine,
@@ -4331,6 +4339,7 @@ def to_image(
             gl=gl,
             compatibility=compatibility,
             style_snapshot=style_snapshot,
+            style_source=style_source,
             **self._export_defaults(
                 fmt,
                 width,
@@ -4359,6 +4368,7 @@ def write_image(
         gl: str = "software",
         compatibility: str = "legacy",
         style_snapshot: Optional[Any] = None,
+        style_source: str = "declared",
     ) -> bytes:
         """Atomic file export with extension-inferred format (.png/.jpg/
         .jpeg/.webp/.svg/.pdf/.html). `export_config` defaults apply as in
@@ -4369,7 +4379,8 @@ def write_image(
             else export._infer_format(path)
         )
         if fmt != "html":
-            resolved = export._resolve_image_engine(engine, fmt, custom_css)
+            precheck_css = None if style_source == "native_cascade" else custom_css
+            resolved = export._resolve_image_engine(engine, fmt, precheck_css)
             defaults = self._export_defaults(
                 fmt,
                 width,
@@ -4408,6 +4419,7 @@ def write_image(
             gl=gl,
             compatibility=compatibility,
             style_snapshot=style_snapshot,
+            style_source=style_source,
             **defaults,
         )
 
diff --git a/python/xy/export.py b/python/xy/export.py
index 23a4a2a75..2126909a1 100644
--- a/python/xy/export.py
+++ b/python/xy/export.py
@@ -821,6 +821,7 @@ def to_png(
     gl: str = "software",
     compatibility: str = "legacy",
     style_snapshot: Optional[Any] = None,
+    style_source: str = "declared",
 ) -> bytes:
     """Rasterize `fig` to a PNG (bytes, optionally saved).
 
@@ -847,6 +848,22 @@ def to_png(
     scale = _positive_finite_float(scale, "PNG scale")
     optimize = _bool_option(optimize, "PNG optimize")
     sandbox = _bool_option(sandbox, "PNG sandbox")
+    if style_source not in ("declared", "native_cascade"):
+        raise ValueError(
+            f'style_source must be "declared" or "native_cascade", got {style_source!r}'
+        )
+    if style_source == "native_cascade":
+        if style_snapshot is not None:
+            raise ValueError(
+                "style_snapshot and style_source='native_cascade' are two sources "
+                "for the same values; pass one"
+            )
+        if engine not in (Engine.auto, "auto", None, Engine.default, "default"):
+            raise ValueError(
+                "style_source='native_cascade' is a native path; drop engine=Engine.chromium"
+            )
+        style_snapshot = _cascade_snapshot(fig, custom_css, compatibility)
+        custom_css = None  # consumed by the cascade, not by a browser
     resolved_engine = _png_engine(engine)
     # Resolution errors precede and outrank mode logic (the migration spec's
     # contract): the custom_css/native refusal must stay a ValueError in
@@ -989,6 +1006,41 @@ def _snapshot_styles(fig: "Figure", snapshot: Any) -> "Iterator[None]":
         fig.style = saved_style
 
 
+def _cascade_snapshot(
+    fig: "Figure",
+    custom_css: Optional[str],
+    compatibility: str,
+) -> Any:
+    """Resolve classes + author CSS through the native cascade for export.
+
+    The cascade is the CSS engine here, so `custom_css` is consumed by it —
+    not routed to Chromium — and its `unsupported` report goes through the
+    compatibility contract: strict refuses on any unsupported construct,
+    every other mode surfaces the list as one StyleCompatibilityWarning.
+    A brand-new surface has no legacy silence to preserve (§28).
+    """
+    import warnings as _warnings
+
+    from .styling import cascade as _cascade
+    from .styling.preflight import StyleCompatibilityError, StyleCompatibilityWarning
+
+    snapshot, unsupported = _cascade.resolve_for_figure(fig, custom_css=custom_css or "")
+    if unsupported:
+        summary = "; ".join(unsupported)
+        if compatibility == "strict":
+            from .styling.preflight import route_resolved
+
+            raise StyleCompatibilityError(
+                f"native cascade could not honor: {summary}",
+                route_resolved(fig, fmt="png", resolved_engine="native", custom_css=None),
+            )
+        _warnings.warn(
+            StyleCompatibilityWarning(f"native cascade could not honor: {summary}"),
+            stacklevel=2,
+        )
+    return snapshot
+
+
 def _enforce_compatibility(
     fig: "Figure",
     fmt: str,
@@ -1258,6 +1310,7 @@ def to_image(
     gl: str = "software",
     compatibility: str = "legacy",
     style_snapshot: Optional[Any] = None,
+    style_source: str = "declared",
 ) -> bytes:
     """Render `fig` to image bytes in the requested `format`.
 
@@ -1274,6 +1327,21 @@ def to_image(
     PDF keeps text/axes/marks as vectors; density and heatmap layers embed as
     bounded rasters (the documented hybrid-vector policy)."""
     fmt = _normalize_format(format)
+    if style_source not in ("declared", "native_cascade"):
+        raise ValueError(
+            f'style_source must be "declared" or "native_cascade", got {style_source!r}'
+        )
+    if style_source == "native_cascade":
+        if style_snapshot is not None:
+            raise ValueError(
+                "style_snapshot and style_source='native_cascade' are two sources for the same values; pass one"
+            )
+        if engine not in (Engine.auto, "auto", None, Engine.default, "default"):
+            raise ValueError(
+                "style_source='native_cascade' is a native path; drop engine=Engine.chromium"
+            )
+        style_snapshot = _cascade_snapshot(fig, custom_css, compatibility)
+        custom_css = None  # consumed by the cascade, not by a browser
     resolved_engine = _resolve_image_engine(engine, fmt, custom_css)
     snapshot = _coerce_style_snapshot(style_snapshot) if style_snapshot is not None else None
     if snapshot is not None and resolved_engine == "browser":
@@ -1336,6 +1404,7 @@ def write_image(
     gl: str = "software",
     compatibility: str = "legacy",
     style_snapshot: Optional[Any] = None,
+    style_source: str = "declared",
 ) -> bytes:
     """Export `fig` to `path`, inferring the format from the extension.
 
@@ -1387,6 +1456,7 @@ def write_image(
         gl=gl,
         compatibility=compatibility,
         style_snapshot=style_snapshot,
+        style_source=style_source,
     )
     _atomic_write_bytes(path, data)
     return data
diff --git a/python/xy/styling/__init__.py b/python/xy/styling/__init__.py
index fcfe8b3bf..0e46f77aa 100644
--- a/python/xy/styling/__init__.py
+++ b/python/xy/styling/__init__.py
@@ -13,6 +13,9 @@
 versioned, interned `ResolvedStyleSnapshot` of concrete values that every
 resolver produces and every renderer consumes.
 
+`cascade` is the mount-free resolver over the optional native extension:
+classes and author CSS cascaded to concrete values with no browser.
+
 Submodules resolve lazily (PEP 562): `capabilities` reaches the writers'
 constants and, through them, the native library — so importing this package
 costs nothing until a submodule is actually used. That keeps the documented
@@ -25,7 +28,7 @@
 import importlib
 from typing import Any
 
-__all__ = ["capabilities", "preflight", "resolved"]
+__all__ = ["capabilities", "cascade", "preflight", "resolved"]
 
 
 def __getattr__(name: str) -> Any:
diff --git a/python/xy/styling/cascade.py b/python/xy/styling/cascade.py
new file mode 100644
index 000000000..b7cb8737b
--- /dev/null
+++ b/python/xy/styling/cascade.py
@@ -0,0 +1,287 @@
+"""The mount-free native cascade: classes and author CSS resolved without a
+browser, through the optional `xy-cascade` extension.
+
+The extension (cascade/, its own cdylib) parses stylesheets with Lightning
+CSS and cascades the published profile over the synthetic chart DOM below;
+this module is the lazy ctypes boundary plus the snapshot construction. It
+is imported only when a native-cascade export is requested — the core
+import-weight contract does not pay for it — and a missing extension
+raises with the build instruction rather than degrading silently.
+
+Everything the resolver cannot honor arrives in an `unsupported` list with
+the reason (out-of-profile selector, at-rule, percentage length, …) and is
+surfaced through the compatibility machinery: warn mode says it, strict
+mode refuses on it. Nothing outside the profile resolves to a guess (§28).
+"""
+
+from __future__ import annotations
+
+import ctypes
+import json
+import os
+from pathlib import Path
+from typing import Any, Optional
+
+from ..dom import CHART_DOM_SLOTS
+from .resolved import ResolvedStyleSnapshot, SnapshotBuilder, SnapshotEnvironment, assert_resolved
+
+#: The synthetic slot tree the cascade matches against — (slot, parent),
+#: parents before children. Provenance: the parent of every slot a rendered
+#: scatter+colorbar+annotation chart mounts was probed from a live headless
+#: Chromium DOM (el.parentElement.closest('[data-xy-slot]')); the slots that
+#: fixture does not render (legend family, tooltip/badge parts, colorbar
+#: extension/line/minor, crosshairs) follow their client mount sites
+#: (js/src/50_chartview.ts, 52_tooltip.ts, 53_interaction.ts). A slot whose
+#: client nesting changes must change here — the differential smoke compares
+#: cascade output against live-browser capture and catches a drifted parent
+#: through any descendant selector that crosses it.
+SYNTHETIC_TREE: tuple[tuple[str, Optional[str]], ...] = (
+    ("root", None),
+    ("title", "root"),
+    ("chrome", "root"),
+    ("canvas", "root"),
+    ("annotation_layer", "root"),
+    ("labels", "root"),
+    ("axis_band", "root"),
+    ("axis_line", "labels"),
+    ("tick_mark", "labels"),
+    ("tick_label", "labels"),
+    ("axis_title", "labels"),
+    ("annotation_label", "labels"),
+    ("legend", "root"),
+    ("legend_title", "legend"),
+    ("legend_item", "legend"),
+    ("legend_swatch", "legend_item"),
+    ("legend_label", "legend_item"),
+    ("colorbar", "root"),
+    ("colorbar_bar", "colorbar"),
+    ("colorbar_extension", "colorbar"),
+    ("colorbar_line", "colorbar"),
+    ("colorbar_tick", "colorbar"),
+    ("colorbar_minor_tick", "colorbar"),
+    ("colorbar_title", "colorbar"),
+    ("tooltip", "root"),
+    ("tooltip_title", "tooltip"),
+    ("tooltip_row", "tooltip"),
+    ("tooltip_label", "tooltip_row"),
+    ("tooltip_value", "tooltip_row"),
+    ("modebar", "root"),
+    ("modebar_drag_handle", "modebar"),
+    ("modebar_control_group", "modebar"),
+    ("modebar_separator", "modebar"),
+    ("modebar_button", "modebar"),
+    ("modebar_icon", "modebar_button"),
+    ("modebar_zoom_value", "modebar_button"),
+    ("modebar_indicator", "modebar_button"),
+    ("modebar_selection_icon", "modebar_button"),
+    ("modebar_menu", "modebar"),
+    ("modebar_menu_separator", "modebar_menu"),
+    ("modebar_menu_icon", "modebar_button"),
+    ("modebar_menu_label", "modebar_button"),
+    ("modebar_history_controls", "modebar_menu"),
+    ("selection", "root"),
+    ("crosshair_x", "root"),
+    ("crosshair_y", "root"),
+    ("badge", "root"),
+    ("badge_item", "badge"),
+)
+
+_LIB_ENV = "XY_CASCADE_LIB"
+
+
+def _lib_filename() -> str:
+    import sys
+
+    if sys.platform == "darwin":
+        return "libxy_cascade.dylib"
+    if sys.platform == "win32":
+        return "xy_cascade.dll"
+    return "libxy_cascade.so"
+
+
+def _find_library() -> Path:
+    override = os.environ.get(_LIB_ENV)
+    if override:
+        path = Path(override)
+        if path.is_file():
+            return path
+        raise FileNotFoundError(f"{_LIB_ENV}={override} does not exist")
+    name = _lib_filename()
+    candidates = [
+        Path(__file__).parents[1] / "_native_lib" / name,  # packaged beside the core lib
+        Path(__file__).parents[3] / "target" / "release" / name,  # source checkout
+    ]
+    for candidate in candidates:
+        if candidate.is_file():
+            return candidate
+    raise FileNotFoundError(
+        "the xy-cascade extension is not built. From a source checkout run "
+        "`cargo build --release -p xy-cascade` (or set "
+        f"{_LIB_ENV}=/path/to/{name}); published wheels ship it prebuilt."
+    )
+
+
+_CASCADE_ABI = 1
+_lib: Optional[ctypes.CDLL] = None
+
+
+def _load() -> ctypes.CDLL:
+    global _lib
+    if _lib is not None:
+        return _lib
+    lib = ctypes.CDLL(str(_find_library()))
+    lib.xy_cascade_abi_version.restype = ctypes.c_uint32
+    got = int(lib.xy_cascade_abi_version())
+    if got != _CASCADE_ABI:
+        raise RuntimeError(
+            f"xy-cascade ABI {got} does not match this xy build (wants {_CASCADE_ABI}); "
+            "rebuild the extension from the same checkout"
+        )
+    lib.xy_cascade_resolve.restype = ctypes.c_int32
+    lib.xy_cascade_resolve.argtypes = [
+        ctypes.c_char_p,
+        ctypes.c_size_t,
+        ctypes.c_char_p,
+        ctypes.c_size_t,
+        ctypes.POINTER(ctypes.POINTER(ctypes.c_uint8)),
+        ctypes.POINTER(ctypes.c_size_t),
+    ]
+    lib.xy_cascade_free.restype = None
+    lib.xy_cascade_free.argtypes = [ctypes.POINTER(ctypes.c_uint8), ctypes.c_size_t]
+    _lib = lib
+    return lib
+
+
+def _call(css: str, document: dict[str, Any]) -> dict[str, Any]:
+    lib = _load()
+    css_bytes = css.encode("utf-8")
+    doc_bytes = json.dumps(document, separators=(",", ":")).encode("utf-8")
+    out = ctypes.POINTER(ctypes.c_uint8)()
+    out_len = ctypes.c_size_t()
+    code = lib.xy_cascade_resolve(
+        css_bytes,
+        len(css_bytes),
+        doc_bytes,
+        len(doc_bytes),
+        ctypes.byref(out),
+        ctypes.byref(out_len),
+    )
+    try:
+        payload = bytes(bytearray(out[i] for i in range(out_len.value)))
+    finally:
+        lib.xy_cascade_free(out, out_len)
+    reply = json.loads(payload.decode("utf-8"))
+    if code != 0:
+        detail = reply.get("error") or repr(payload[:200])
+        raise ValueError(f"native cascade failed: {detail}")
+    return reply
+
+
+def _expand_shorthands(declarations: dict[str, Any]) -> dict[str, Any]:
+    """Split the box shorthands the schema carries as longhands.
+
+    The cascade hands back `padding` as authored; schema v1 speaks
+    `padding-top/right/bottom/left` so every consumer sees one spelling.
+    Longhands present alongside the shorthand win (they cascaded later or
+    more specifically — the resolver already decided that per property).
+    """
+    out: dict[str, Any] = {}
+    for prop, value in declarations.items():
+        if prop == "padding" and isinstance(value, str):
+            parts = value.split()
+            if 1 <= len(parts) <= 4:
+                top = parts[0]
+                right = parts[1] if len(parts) > 1 else top
+                bottom = parts[2] if len(parts) > 2 else top
+                left = parts[3] if len(parts) > 3 else right
+                for name, side in (
+                    ("padding-top", top),
+                    ("padding-right", right),
+                    ("padding-bottom", bottom),
+                    ("padding-left", left),
+                ):
+                    out.setdefault(name, side)
+                continue
+        out[prop] = value
+    return out
+
+
+def resolve_for_figure(
+    figure: Any,
+    *,
+    custom_css: str = "",
+    stylesheets: tuple[str, ...] = (),
+    color_scheme: str = "light",
+    root_font_size: float = 16.0,
+    width: Optional[float] = None,
+    height: Optional[float] = None,
+) -> tuple[ResolvedStyleSnapshot, tuple[str, ...]]:
+    """Resolve the figure's classes against the supplied stylesheets.
+
+    Returns the snapshot plus the `unsupported` report — every construct the
+    profile could not honor, with its reason. Stylesheet order is cascade
+    order: earlier sheets are wider (the Tailwind-core manifest, a project
+    bundle), `custom_css` is the narrowest author sheet and comes last.
+    """
+    class_names = {str(k): str(v) for k, v in (figure.class_names or {}).items()}
+    root_class = ""
+    dom_class = getattr(figure, "class_name", None)
+    if isinstance(dom_class, str):
+        root_class = dom_class
+    nodes = []
+    index: dict[str, int] = {}
+    for slot, parent in SYNTHETIC_TREE:
+        classes = [c for c in class_names.get(slot, "").split() if c]
+        if slot == "root" and root_class:
+            classes = [c for c in root_class.split() if c] + classes
+        index[slot] = len(nodes)
+        nodes.append(
+            {
+                "slot": slot,
+                "classes": classes,
+                "parent": index[parent] if parent is not None else None,
+            }
+        )
+    css = "\n".join((*stylesheets, custom_css)) if (stylesheets or custom_css) else ""
+    reply = _call(
+        css,
+        {
+            "env": {"color_scheme": color_scheme, "root_font_size": float(root_font_size)},
+            "nodes": nodes,
+        },
+    )
+    unsupported = [str(u) for u in reply.get("unsupported", ())]
+    builder = SnapshotBuilder()
+    for node in reply.get("nodes", ()):
+        slot = node.get("slot")
+        declarations = node.get("declarations") or {}
+        if slot not in CHART_DOM_SLOTS or not declarations:
+            continue
+        legal: dict[str, Any] = {}
+        for prop, value in _expand_shorthands(declarations).items():
+            try:
+                assert_resolved(prop, value)
+            except ValueError as exc:
+                unsupported.append(f"{slot}: {exc}")
+            else:
+                legal[prop] = value
+        if legal:
+            builder.add(slot, legal)
+
+    def _dim(override: Optional[float], declared: Any, fallback: float) -> float:
+        for candidate in (override, declared):
+            numeric = isinstance(candidate, (int, float)) and not isinstance(candidate, bool)
+            if numeric and float(candidate) > 0:
+                return float(candidate)
+        return fallback  # fluid ("100%") sizes fall back, as exports do
+
+    environment = SnapshotEnvironment(
+        width=_dim(width, getattr(figure, "width", None), 800.0),
+        height=_dim(height, getattr(figure, "height", None), 500.0),
+        color_scheme=color_scheme,
+    )
+    snapshot = builder.build(environment)
+    return snapshot, tuple(unsupported)
+
+
+__all__ = ["SYNTHETIC_TREE", "resolve_for_figure"]
diff --git a/scripts/cascade_differential_smoke.py b/scripts/cascade_differential_smoke.py
new file mode 100644
index 000000000..a5eba6543
--- /dev/null
+++ b/scripts/cascade_differential_smoke.py
@@ -0,0 +1,176 @@
+#!/usr/bin/env python3
+"""Differential smoke: the native cascade against the browser, same inputs.
+
+The Phase-3 exit gate in executable form: one chart, one stylesheet,
+resolved twice — once by headless Chromium through the live capture, once
+by the mount-free native cascade — and the shared profile properties must
+agree. Colors compare parsed (Lightning CSS normalizes `rgb(7, 89, 133)`
+to `#075985`; the browser computes `rgb(7, 89, 133)` — same color, two
+spellings), lengths compare as px numbers.
+
+    uv run python scripts/cascade_differential_smoke.py [chromium-path]
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import shutil
+import sys
+import time
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT / "python"))
+
+from xy._chromium import ChromiumSession  # noqa: E402
+from xy.styling import cascade  # noqa: E402
+from xy.styling.resolved import snapshot_from_payload  # noqa: E402
+
+CHROMIUM_CANDIDATES = [
+    "chrome-headless-shell",
+    "chromium",
+    "chromium-browser",
+    "chrome",
+    "google-chrome",
+    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+]
+
+CSS = (
+    ".smoke-tick { color: rgb(7, 89, 133); font-weight: 600; letter-spacing: 2px; }\n"
+    ".smoke-title { color: rgb(120, 20, 20); }"
+)
+
+CAPTURE = """
+(async () => {
+  const until = Date.now() + 60000;
+  let root = null;
+  while (!(root = document.querySelector('[data-xy-slot="root"]'))) {
+    if (Date.now() > until) return JSON.stringify({error: "no chart root"});
+    await new Promise((r) => setTimeout(r, 50));
+  }
+  await window.xy.styleCaptureSettled(document);
+  return JSON.stringify({snapshot: window.xy.captureStyleSnapshot(root)});
+})()
+"""
+
+
+def find_chromium() -> str:
+    if len(sys.argv) > 1:
+        return sys.argv[1]
+    for c in CHROMIUM_CANDIDATES:
+        if Path(c).is_file() or shutil.which(c):
+            return c
+    raise SystemExit("no chromium found")
+
+
+def color_rgba(value: str) -> tuple[int, int, int, float]:
+    """Any concrete color spelling to an exact rgba tuple."""
+    v = value.strip().lower()
+    if v.startswith("#"):
+        digits = v[1:]
+        if len(digits) == 3:
+            digits = "".join(c * 2 for c in digits)
+        if len(digits) == 6:
+            digits += "ff"
+        r, g, b, a = (int(digits[i : i + 2], 16) for i in (0, 2, 4, 6))
+        return r, g, b, round(a / 255.0, 4)
+    m = re.match(r"rgba?\(([^)]+)\)", v)
+    if m:
+        parts = [p.strip() for p in re.split(r"[,/]", m.group(1)) if p.strip()]
+        r, g, b = (int(float(p)) for p in parts[:3])
+        a = float(parts[3]) if len(parts) > 3 else 1.0
+        return r, g, b, round(a, 4)
+    raise AssertionError(f"unparseable color {value!r}")
+
+
+def px(value: str) -> float:
+    return float(str(value).strip().removesuffix("px"))
+
+
+def slot_decls(snapshot, slot: str) -> dict:
+    for inst in snapshot.instances:
+        if inst.slot == slot:
+            return dict(snapshot.declarations[inst.declaration])
+    return {}
+
+
+def main() -> None:
+    import xy
+
+    chart = xy.scatter_chart(
+        xy.scatter([1.0, 2.0, 3.0], [2.0, 1.0, 3.0]),
+        title="differential",
+        class_names={"tick_label": "smoke-tick", "title": "smoke-title"},
+    )
+
+    # Arm 1: the browser.
+    document = chart.to_html(custom_css=CSS)
+    deadline = time.monotonic() + 120.0
+
+    def remaining() -> float:
+        value = deadline - time.monotonic()
+        if value <= 0:
+            raise TimeoutError("differential smoke did not finish in 120s")
+        return value
+
+    with ChromiumSession(
+        find_chromium(), gl="software", sandbox=False, launch_timeout_s=remaining()
+    ) as session:
+        _, sid, page_path = session._page_session(document, remaining())
+        session._call(
+            "Page.navigate", {"url": page_path.as_uri()}, session_id=sid, timeout_s=remaining()
+        )
+        session._wait_event("Page.loadEventFired", session_id=sid, timeout_s=remaining())
+        reply = session._call(
+            "Runtime.evaluate",
+            {"expression": CAPTURE, "awaitPromise": True, "returnByValue": True},
+            session_id=sid,
+            timeout_s=remaining(),
+        )
+    result = json.loads(reply["result"]["value"])
+    if result.get("error"):
+        raise SystemExit(f"browser capture failed: {result['error']}")
+    browser = snapshot_from_payload(result["snapshot"])
+
+    # Arm 2: the mount-free cascade over the same inputs.
+    native, unsupported = cascade.resolve_for_figure(chart.figure(), custom_css=CSS)
+    assert unsupported == (), f"profile CSS reported unsupported: {unsupported}"
+
+    disagreements: list[str] = []
+    for slot, prop, kind in (
+        ("tick_label", "color", "color"),
+        ("tick_label", "font-weight", "number"),
+        ("tick_label", "letter-spacing", "px"),
+        ("title", "color", "color"),
+    ):
+        b = slot_decls(browser, slot).get(prop)
+        n = slot_decls(native, slot).get(prop)
+        if b is None or n is None:
+            disagreements.append(f"{slot}.{prop}: browser={b!r} native={n!r} (missing)")
+            continue
+        try:
+            if kind == "color":
+                same = color_rgba(str(b)) == color_rgba(str(n))
+            elif kind == "px":
+                same = abs(px(str(b)) - px(str(n))) < 0.01
+            else:
+                same = float(str(b).removesuffix("px")) == float(str(n).removesuffix("px"))
+        except (AssertionError, ValueError) as exc:
+            disagreements.append(f"{slot}.{prop}: {exc}")
+            continue
+        if not same:
+            disagreements.append(f"{slot}.{prop}: browser={b!r} native={n!r}")
+    if disagreements:
+        raise SystemExit(
+            "cascade disagrees with the browser oracle:\n  " + "\n  ".join(disagreements)
+        )
+
+    print(
+        "cascade differential smoke ok: browser and mount-free cascade agree on "
+        "tick color/weight/letter-spacing and title color for the shared profile"
+    )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/spec/api/export.md b/spec/api/export.md
index 0be54cc33..e6bf5c1ff 100644
--- a/spec/api/export.md
+++ b/spec/api/export.md
@@ -249,7 +249,7 @@ vector** (`_svg.to_svg`, and `_pdf.svg_to_pdf` on top of it).
 | `style={...}` on an axis | yes | yes | yes | validated vocabulary, `styles.compile_axis_style` |
 | `style={...}` on the chart (token bag) | yes | yes | yes | `spec["dom"]["style"]`, read at `_svg.py:767,1481` and `_raster.py:662` |
 | `styles={slot: {...}}` (per-slot inline) | yes, all 48 slots | text subset, 9 slots | text subset, 9 slots | `_svg.STATIC_STYLED_SLOTS`; the rest is live-only chrome |
-| `class_names={slot: "..."}` | yes, all 48 slots | **dropped** | **dropped** | silent — the SVG writer emits no `class` at all |
+| `class_names={slot: "..."}` | yes, all 48 slots | **dropped** (or resolved via `style_source="native_cascade"` / a captured `style_snapshot=`) | same | silent by default during migration; both opt-in routes are lossless for the published profile |
 | `custom_css="..."` | yes (HTML + Chromium capture) | **raises** | **raises** | `_resolve_image_engine`, `export.py:812` |
 | `xy.legend(style=...)` | yes | 6 keys | 6 keys | merged with the slot and the theme token before the writers see it |
 | `xy.colorbar(style=...)` | yes | **dropped** | **dropped** | no native channel; use `styles={"colorbar_title"/"colorbar_tick": ...}` |
@@ -304,7 +304,13 @@ pins the partition (24 static, 24 state-gated today) and
 
 `custom_css` raises because it is an author stylesheet: there is no honest
 partial application of it, and the caller can switch to `Engine.chromium` in one
-edit. The message says so. SVG rejects it for *every* engine, because a browser
+edit — or keep the export native with `style_source="native_cascade"`, which
+resolves the published CSS profile through the optional `xy-cascade` extension
+(Lightning CSS parsing; class/slot/descendant selectors, custom properties,
+`em`/`rem`, `prefers-color-scheme`) and reports every out-of-profile construct
+through the compatibility modes instead of guessing. The browser remains the
+oracle: `scripts/cascade_differential_smoke.py` asserts the cascade and a live
+Chromium agree on the shared profile. The message says so. SVG rejects it for *every* engine, because a browser
 screenshot cannot produce vector output — that row is a hard "never", not a
 default.
 
diff --git a/tests/test_components.py b/tests/test_components.py
index 09d6237c4..0abcb7b3a 100644
--- a/tests/test_components.py
+++ b/tests/test_components.py
@@ -1984,6 +1984,7 @@ def fake_to_png(
         gl="software",
         compatibility="legacy",
         style_snapshot=None,
+        style_source="declared",
     ):
         seen.update(
             {
@@ -1999,6 +2000,7 @@ def fake_to_png(
                 "gl": gl,
                 "compatibility": compatibility,
                 "style_snapshot": style_snapshot,
+                "style_source": style_source,
             }
         )
         return b"PNG"
@@ -2032,6 +2034,7 @@ def fake_to_png(
         "gl": "hardware",
         "compatibility": "warn",
         "style_snapshot": None,
+        "style_source": "declared",
     }
 
 
diff --git a/tests/test_native_cascade.py b/tests/test_native_cascade.py
new file mode 100644
index 000000000..6841e3fb3
--- /dev/null
+++ b/tests/test_native_cascade.py
@@ -0,0 +1,150 @@
+"""The mount-free native cascade: profile resolution without a browser.
+
+Skips cleanly when the optional extension is not built (CI builds it; a
+contributor who has not run `cargo build --release -p xy-cascade` gets a
+skip naming the command, not a red suite). Everything here mirrors a
+browser-verifiable behavior; the differential smoke
+(`scripts/cascade_differential_smoke.py`) compares against live Chromium.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+import xy
+from xy.styling.preflight import StyleCompatibilityError, StyleCompatibilityWarning
+
+cascade = pytest.importorskip("xy.styling.cascade")
+
+try:
+    cascade._find_library()
+except FileNotFoundError:
+    pytest.skip(
+        "xy-cascade extension not built (cargo build --release -p xy-cascade)",
+        allow_module_level=True,
+    )
+
+
+def _chart(**props):
+    return xy.scatter_chart(xy.scatter([1.0, 2.0, 3.0], [2.0, 1.0, 3.0]), **props)
+
+
+def _decls(snapshot, slot):
+    for inst in snapshot.instances:
+        if inst.slot == slot:
+            return dict(snapshot.declarations[inst.declaration])
+    return {}
+
+
+# -- resolver semantics -------------------------------------------------------
+
+
+def test_classes_resolve_with_specificity_inheritance_and_units() -> None:
+    chart = _chart(class_names={"tick_label": "smoke-tick", "legend": "frame"})
+    snapshot, unsupported = cascade.resolve_for_figure(
+        chart.figure(),
+        custom_css=(
+            ":root { font-size: 20px; color: #111111; }\n"
+            ".smoke-tick { color: rgb(7, 89, 133); letter-spacing: 0.1em; font-size: 0.5em; }\n"
+            ".frame { background: #0f172a; }"
+        ),
+    )
+    assert unsupported == ()
+    tick = _decls(snapshot, "tick_label")
+    assert tick["color"] == "#075985"
+    assert tick["font-size"] == "10px"  # 0.5em of the root's 20px
+    assert tick["letter-spacing"] == "1px"  # 0.1em of the OWN 10px
+    assert _decls(snapshot, "legend")["background"] == "#0f172a"
+    # :root color inherits to slots with no own declaration.
+    assert _decls(snapshot, "title").get("color") == "#111"  # lightningcss shortens hex
+
+
+def test_dark_scheme_media_gates_like_a_browser() -> None:
+    chart = _chart(class_names={"tick_label": "t"})
+    css = (
+        "@media (prefers-color-scheme: dark) { .t { color: #e2e8f0; } }\n"
+        "@media (prefers-color-scheme: light) { .t { color: #0f172a; } }"
+    )
+    dark, _ = cascade.resolve_for_figure(chart.figure(), custom_css=css, color_scheme="dark")
+    light, _ = cascade.resolve_for_figure(chart.figure(), custom_css=css, color_scheme="light")
+    assert _decls(dark, "tick_label")["color"] == "#e2e8f0"
+    assert _decls(light, "tick_label")["color"] == "#0f172a"
+
+
+def test_out_of_profile_constructs_are_reported_never_guessed() -> None:
+    chart = _chart(class_names={"tick_label": "t"})
+    snapshot, unsupported = cascade.resolve_for_figure(
+        chart.figure(),
+        custom_css=(
+            ".t:hover { color: red; }\n@keyframes spin { from { opacity: 0; } }\n.t { width: 50%; }"
+        ),
+    )
+    assert _decls(snapshot, "tick_label").get("color") is None
+    assert len(unsupported) == 3
+    assert any("pseudo-class" in u for u in unsupported)
+    assert any("percentage" in u for u in unsupported)
+
+
+def test_stylesheet_order_is_cascade_order() -> None:
+    # Earlier sheets are wider (a manifest); custom_css is narrowest-last.
+    chart = _chart(class_names={"legend": "frame"})
+    snapshot, _ = cascade.resolve_for_figure(
+        chart.figure(),
+        stylesheets=(".frame { background: #111111; padding: 4px; }",),
+        custom_css=".frame { background: #222222; }",
+    )
+    legend = _decls(snapshot, "legend")
+    assert legend["background"] == "#222"
+    assert legend["padding-top"] == "4px"  # shorthand splits to schema longhands
+    assert legend["padding-left"] == "4px"
+
+
+def test_synthetic_tree_covers_every_slot_exactly_once() -> None:
+    from xy.dom import CHART_DOM_SLOTS
+
+    slots = [slot for slot, _parent in cascade.SYNTHETIC_TREE]
+    assert sorted(slots) == sorted(CHART_DOM_SLOTS)
+    seen: set[str] = set()
+    for slot, parent in cascade.SYNTHETIC_TREE:
+        assert parent is None or parent in seen, f"{slot} before its parent {parent}"
+        seen.add(slot)
+
+
+# -- export integration -------------------------------------------------------
+
+
+def test_class_styled_charts_export_natively_across_formats(tmp_path) -> None:
+    chart = _chart(class_names={"tick_label": "smoke-tick"})
+    css = ".smoke-tick { color: rgb(7, 89, 133); }"
+    svg = chart.to_image("svg", custom_css=css, style_source="native_cascade")
+    assert b"#075985" in svg
+    png = chart.to_png(custom_css=css, style_source="native_cascade")
+    assert png[:8] == b"\x89PNG\r\n\x1a\n"
+    pdf = chart.write_image(tmp_path / "c.pdf", custom_css=css, style_source="native_cascade")
+    assert pdf[:4] == b"%PDF"
+
+
+def test_unsupported_constructs_warn_by_default_and_refuse_in_strict() -> None:
+    chart = _chart(class_names={"tick_label": "t"})
+    css = ".t:hover { color: red; }"
+    with pytest.warns(StyleCompatibilityWarning, match="could not honor"):
+        chart.to_image("svg", custom_css=css, style_source="native_cascade")
+    with pytest.raises(StyleCompatibilityError, match="could not honor"):
+        chart.to_image("svg", custom_css=css, style_source="native_cascade", compatibility="strict")
+
+
+def test_cascade_and_snapshot_are_mutually_exclusive_sources() -> None:
+    from xy.styling.resolved import SnapshotBuilder, SnapshotEnvironment
+
+    builder = SnapshotBuilder()
+    builder.add("title", {"font-size": 18})
+    snap = builder.build(SnapshotEnvironment(width=100, height=100))
+    with pytest.raises(ValueError, match="two sources"):
+        _chart().to_image("png", style_snapshot=snap, style_source="native_cascade")
+    with pytest.raises(ValueError, match="native path"):
+        _chart().to_image("png", engine=xy.Engine.chromium, style_source="native_cascade")
+
+
+def test_vocabulary_is_closed() -> None:
+    with pytest.raises(ValueError, match="style_source"):
+        _chart().to_image("png", style_source="browser")

From 88c1f0359972e2b4a8244599807b508c3bff7bda Mon Sep 17 00:00:00 2001
From: Alek Petuskey <alek@reflex.dev>
Date: Tue, 4 Aug 2026 15:45:19 -0700
Subject: [PATCH 12/27] Static-chrome parity P0: PDF honors the vector text
 subset, raster routes emphasis
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Phase 4 prerequisites, both live-bug fixes found by the parity recon and
probe-verified before a line changed.

PDF text attributes: _pdf's closed subset rejected font-style, font-family,
letter-spacing, and opacity, so to_image("pdf") RAISED today for an italic
title or a letter-spaced label — contradicting the SLOT_TEXT_PROPS contract
that PDF honors the vector subset via the same markup. The whitelist now
speaks all four: font-style selects the oblique base-14 faces (all four
Helvetica faces registered on demand), letter-spacing becomes Tc with the
anchor width counting the len-1 inter-glyph gaps Tc actually renders and an
explicit 0 Tc reset because text state persists past ET, opacity multiplies
into the composed ExtGState alpha beside fill-opacity and the paint's own
alpha, and a declared font-family maps deterministically onto the Helvetica
family — metrically exact for anchoring, recorded in the module contract
note rather than silent, until the font registry lands. The closed-subset
doctrine is unchanged: everything the converter does not speak still fails
loudly (tested).

Raster emphasis routing: SLOT_RASTER_PROPS claims font-weight/font-style and
the glyph atlas carries bold and italic faces, but only title and axis_title
routed through _native_font_emphasis. legend_title, legend_label,
tick_label, colorbar_tick, and colorbar_title now pass emphasis into their
text ops, slot-driven exactly like the SVG side so the two writers read the
same source. Per-slot pixel-change verified for all five; unstyled output
stays byte-identical (the standing parity gate) and the survival suite is
untouched. The capability note that still described a paint-and-size-only
raster glyph primitive now tells the truth the atlas has supported since the
faces were baked.
---
 docs/styling/capabilities.md                  |  16 +-
 python/xy/_pdf.py                             |  75 ++++++-
 python/xy/_raster.py                          |  44 ++++
 python/xy/styling/capabilities.py             |  12 +-
 spec/api/capability-matrix.md                 |  16 +-
 .../static-chrome-parity-plan-2026-08-04.md   | 212 ++++++++++++++++++
 tests/test_pdf_text_subset.py                 |  96 ++++++++
 7 files changed, 440 insertions(+), 31 deletions(-)
 create mode 100644 spec/process/static-chrome-parity-plan-2026-08-04.md
 create mode 100644 tests/test_pdf_text_subset.py

diff --git a/docs/styling/capabilities.md b/docs/styling/capabilities.md
index 9d79c0e72..bb428aaf7 100644
--- a/docs/styling/capabilities.md
+++ b/docs/styling/capabilities.md
@@ -115,15 +115,15 @@ would not survive, before any bytes exist.
 ### Notes
 
 - **`root`** (via `chart style=`) — `styles={'root': ...}` is browser-only, but the chart-level `style=` token bag targets the same element and every renderer reads it (`spec['dom']['style']`). Prefer it for anything that must survive export.
-- **`title`** (via `styles={'title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`). The raster writer's glyph primitive takes a size and one RGBA paint and nothing else, so it honors font-size and the paint only — font-weight, font-style, font-family, letter-spacing and opacity are vector-only rather than silently approximated. Properties outside the subset stay browser-only.
+- **`title`** (via `styles={'title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
 - **`legend`** (via `styles={'legend': ...} / xy.legend(style=...) / --chart-legend-bg`) — The frame box. Both spellings and the theme token now converge on one merged declaration block before the writers see it, so what agrees in the browser agrees in a PNG. `background`, `boxShadow`, `borderRadius`, `--xy-legend-frame-alpha`, and `padding`/`rowGap` in `em` are honored; an explicit background paints opaque, as it does in the browser.
-- **`legend_title`** (via `styles={'legend_title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`). The raster writer's glyph primitive takes a size and one RGBA paint and nothing else, so it honors font-size and the paint only — font-weight, font-style, font-family, letter-spacing and opacity are vector-only rather than silently approximated. Properties outside the subset stay browser-only.
-- **`legend_label`** (via `styles={'legend_label': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`). The raster writer's glyph primitive takes a size and one RGBA paint and nothing else, so it honors font-size and the paint only — font-weight, font-style, font-family, letter-spacing and opacity are vector-only rather than silently approximated. Properties outside the subset stay browser-only.
-- **`colorbar`** (via `styles={'colorbar': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`). The raster writer's glyph primitive takes a size and one RGBA paint and nothing else, so it honors font-size and the paint only — font-weight, font-style, font-family, letter-spacing and opacity are vector-only rather than silently approximated. Properties outside the subset stay browser-only.
-- **`colorbar_tick`** (via `styles={'colorbar_tick': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`). The raster writer's glyph primitive takes a size and one RGBA paint and nothing else, so it honors font-size and the paint only — font-weight, font-style, font-family, letter-spacing and opacity are vector-only rather than silently approximated. Properties outside the subset stay browser-only.
-- **`colorbar_title`** (via `styles={'colorbar_title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`). The raster writer's glyph primitive takes a size and one RGBA paint and nothing else, so it honors font-size and the paint only — font-weight, font-style, font-family, letter-spacing and opacity are vector-only rather than silently approximated. Properties outside the subset stay browser-only.
-- **`tick_label`** (via `styles={'tick_label': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`). The raster writer's glyph primitive takes a size and one RGBA paint and nothing else, so it honors font-size and the paint only — font-weight, font-style, font-family, letter-spacing and opacity are vector-only rather than silently approximated. Properties outside the subset stay browser-only.
-- **`axis_title`** (via `styles={'axis_title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`). The raster writer's glyph primitive takes a size and one RGBA paint and nothing else, so it honors font-size and the paint only — font-weight, font-style, font-family, letter-spacing and opacity are vector-only rather than silently approximated. Properties outside the subset stay browser-only.
+- **`legend_title`** (via `styles={'legend_title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
+- **`legend_label`** (via `styles={'legend_label': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
+- **`colorbar`** (via `styles={'colorbar': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
+- **`colorbar_tick`** (via `styles={'colorbar_tick': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
+- **`colorbar_title`** (via `styles={'colorbar_title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
+- **`tick_label`** (via `styles={'tick_label': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
+- **`axis_title`** (via `styles={'axis_title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
 
 ## Extension points
 
diff --git a/python/xy/_pdf.py b/python/xy/_pdf.py
index c4dc813ec..d25e38a64 100644
--- a/python/xy/_pdf.py
+++ b/python/xy/_pdf.py
@@ -17,12 +17,20 @@
   (``fill-opacity``/``stroke-opacity``/``opacity`` and rgba() color alpha)
   become deduplicated ExtGStates (/ca /CA). The generator only ever emits the
   default nonzero winding rule, so even-odd variants are never produced.
-- Text stays text: BT/Tf/Tm/Tj/ET with the base-14 Helvetica family
-  (weight >= 600 selects Helvetica-Bold) in WinAnsiEncoding, using the
-  standard AFM width tables so ``text-anchor="middle"/"end"`` offsets come
-  from real metrics. Characters outside WinAnsi are replaced with "?"
-  (``cp1252`` + ``errors="replace"``) — a deterministic, locale-independent
-  substitution policy.
+- Text stays text: BT/Tf/Tm/Tj/ET with the base-14 Helvetica family — four
+  faces: weight >= 600 selects the bold face, ``font-style: italic|oblique``
+  the oblique one — in WinAnsiEncoding, using the standard AFM width tables
+  so ``text-anchor="middle"/"end"`` offsets come from real metrics.
+  ``letter-spacing`` becomes ``Tc`` (reset after each run — text state
+  persists past ET), with the anchor width counting the len-1 inter-glyph
+  gaps ``Tc`` actually renders. ``opacity`` on text multiplies into the
+  ExtGState alpha alongside fill-opacity and the paint's own alpha. A
+  declared ``font-family`` is accepted and maps to the Helvetica family:
+  deterministic and metrically exact for the anchor math, recorded here
+  rather than silent (§28) — exact custom faces arrive with the font
+  registry. Characters outside WinAnsi are replaced with "?" (``cp1252`` +
+  ``errors="replace"``) — a deterministic, locale-independent substitution
+  policy.
 - ``<linearGradient>`` becomes an axial shading (/ShadingType 2; exponential
   function for 2 stops, stitching for more) painted inside the gradient
   geometry's clip; per-stop alpha becomes a luminosity soft mask.
@@ -202,7 +210,20 @@ def _rgba(css: str) -> tuple[float, float, float, float]:
     "polyline": frozenset({"points"}) | _PAINT_ATTRS,
     "polygon": frozenset({"points"}) | _PAINT_ATTRS,
     "text": frozenset(
-        {"x", "y", "transform", "text-anchor", "font-size", "font-weight", "fill", "fill-opacity"}
+        {
+            "x",
+            "y",
+            "transform",
+            "text-anchor",
+            "font-size",
+            "font-weight",
+            "font-style",
+            "font-family",
+            "letter-spacing",
+            "opacity",
+            "fill",
+            "fill-opacity",
+        }
     ),
     "tspan": frozenset({"x", "y"}),
     "image": frozenset({"x", "y", "width", "height", "preserveAspectRatio", "style", "href"}),
@@ -678,8 +699,20 @@ def _set_stroke_params(
 
     # -- resource registration ---------------------------------------------
 
-    def _font(self, bold: bool) -> str:
-        base = "Helvetica-Bold" if bold else "Helvetica"
+    def _font(self, bold: bool, italic: bool = False) -> str:
+        # The four Helvetica base-14 faces. Any declared font-family maps to
+        # this family for now — deterministic, and the anchor math stays
+        # exact because _text_width_px speaks Helvetica metrics. The mapping
+        # is recorded in the module contract note, not silent (§28); exact
+        # custom faces arrive with the font registry.
+        if bold and italic:
+            base = "Helvetica-BoldOblique"
+        elif bold:
+            base = "Helvetica-Bold"
+        elif italic:
+            base = "Helvetica-Oblique"
+        else:
+            base = "Helvetica"
         if base not in self.fonts:
             num = self.pdf.reserve()
             name = f"F{len(self.fonts) + 1}"
@@ -1063,6 +1096,16 @@ def _render_text(self, el: ET.Element, state: _State) -> None:
         _check_attrs(el, "text", _ALLOWED_ATTRS["text"])
         font_size = _float(el.get("font-size"), state.font_size, "font-size")
         bold = _weight(el.get("font-weight"), state.font_weight) >= 600
+        # font-style selects the oblique base-14 face; font-family is
+        # accepted and maps to the Helvetica family (module contract note) —
+        # the attribute must not be a crash, because the SVG writer emits it
+        # for any declared family and PDF inherits SVG's markup.
+        italic = str(el.get("font-style", "")).strip().lower() in ("italic", "oblique")
+        # The writer emits letter-spacing either as a bare number (author
+        # gave a number; normalized to px) or as an "Npx" string passed
+        # verbatim — both are px by the styling contract.
+        spacing_raw = str(el.get("letter-spacing") or "0").strip().removesuffix("px")
+        letter_spacing = _float(spacing_raw, 0.0, "letter-spacing")
         anchor = el.get("text-anchor", "start")
         if anchor not in ("start", "middle", "end"):
             _unsupported(f"text-anchor {anchor!r}")
@@ -1073,6 +1116,7 @@ def _render_text(self, el: ET.Element, state: _State) -> None:
         ca = (
             state.opacity
             * _float(el.get("fill-opacity"), state.fill_opacity, "fill-opacity")
+            * _float(el.get("opacity"), 1.0, "opacity")
             * alpha
         )
 
@@ -1110,7 +1154,7 @@ def _render_text(self, el: ET.Element, state: _State) -> None:
                 (_float(el.get("x"), 0.0, "x"), _float(el.get("y"), 0.0, "y"), el.text or "")
             )
 
-        font_name = self._font(bold)
+        font_name = self._font(bold, italic)
         theta = math.radians(angle)
         cos_t, sin_t = math.cos(theta), math.sin(theta)
         for x, y, s in runs:
@@ -1124,7 +1168,12 @@ def _render_text(self, el: ET.Element, state: _State) -> None:
                     cx + cos_t * (x - cx) - sin_t * (y - cy),
                     cy + sin_t * (x - cx) + cos_t * (y - cy),
                 )
+            # Letter-spacing widens every advance, including after the last
+            # glyph in SVG's model — anchor math must match what Tc renders,
+            # which spaces between glyphs only, so count len-1 gaps.
             width = _text_width_px(data, font_size, bold)
+            if letter_spacing:
+                width += letter_spacing * max(0, len(data) - 1)
             dx = -width / 2.0 if anchor == "middle" else (-width if anchor == "end" else 0.0)
             tx = x + dx * cos_t
             ty = y + dx * sin_t
@@ -1134,10 +1183,16 @@ def _render_text(self, el: ET.Element, state: _State) -> None:
             # rotation is the SVG angle (clockwise in screen space).
             self.ops.append("BT")
             self.ops.append(f"/{font_name} {_f(font_size)} Tf")
+            if letter_spacing:
+                # Text state persists past ET; reset below so a spaced run
+                # never leaks into a later unspaced one.
+                self.ops.append(f"{_f(letter_spacing)} Tc")
             self.ops.append(
                 f"{_f(cos_t)} {_f(sin_t)} {_f(sin_t)} {_f(-cos_t)} {_f(tx)} {_f(ty)} Tm"
             )
             self.ops.append(f"{_pdf_string(data)} Tj")
+            if letter_spacing:
+                self.ops.append("0 Tc")
             self.ops.append("ET")
 
     # -- images -------------------------------------------------------------
diff --git a/python/xy/_raster.py b/python/xy/_raster.py
index e1a9a9ee8..a44c27017 100644
--- a/python/xy/_raster.py
+++ b/python/xy/_raster.py
@@ -1337,6 +1337,12 @@ def emit_tick_labels(
             else slot_paint("tick_label", default_text)
         )
         font_size = slot_font_size(slots.get("tick_label") or {}, _axis_tick_font_size(axis))
+        tick_italic, tick_bold = _native_font_emphasis(
+            {
+                "font_style": (slots.get("tick_label") or {}).get("font-style"),
+                "font_weight": (slots.get("tick_label") or {}).get("font-weight", 400),
+            }
+        )
         baseline_shift = _axis_tick_label_baseline_shift(axis)
         # An explicit tick_label_anchor (axis spec or style) overrides the
         # side-derived default, matching the browser client and SVG export.
@@ -1394,6 +1400,8 @@ def emit_tick_labels(
                     tick_color,
                     item["text"],
                     angle=float(item["angle"]),
+                    italic=tick_italic,
+                    bold=tick_bold,
                 )
 
     if polar is not None:
@@ -3110,6 +3118,12 @@ def _emit_legend(
         # the final edge is silently dropped for both square and rounded frames.
         cmd.stroke(frame_points, 1.0, border, closed=True)
     if title:
+        title_italic, title_bold = _native_font_emphasis(
+            {
+                "font_style": title_slot.get("font-style"),
+                "font_weight": title_slot.get("font-weight", 400),
+            }
+        )
         cmd.text(
             x + box_w / 2,
             y + pad / 2 + font_size * 0.82,
@@ -3117,6 +3131,8 @@ def _emit_legend(
             slot_font_size(title_slot, font_size),
             _parse_color(slot_text_color(title_slot, text_color)),
             str(title),
+            italic=title_italic,
+            bold=title_bold,
         )
     for i, t in enumerate(named[: legend["visible_count"]]):
         style = t.get("style") or {}
@@ -3171,6 +3187,12 @@ def _emit_legend(
                     str(hatch),
                     _parse_color(_css(style.get("hatch_color"), "#222222")),
                 )
+        label_italic, label_bold = _native_font_emphasis(
+            {
+                "font_style": label_slot.get("font-style"),
+                "font_weight": label_slot.get("font-weight", 400),
+            }
+        )
         cmd.text(
             hx1 + gap,
             ry + font_size * 0.82,
@@ -3178,6 +3200,8 @@ def _emit_legend(
             slot_font_size(label_slot, font_size),
             _parse_color(slot_text_color(label_slot, text_color)),
             legend["names"][i],
+            italic=label_italic,
+            bold=label_bold,
         )
 
 
@@ -3284,6 +3308,18 @@ def _emit_colorbar(
     title_paint = _parse_color(slot_text_color(title_slot, text_color))
     tick_size = slot_font_size(tick_slot, COLORBAR_FONT_SIZE)
     tick_paint = _parse_color(slot_text_color(tick_slot, text_color))
+    cb_title_italic, cb_title_bold = _native_font_emphasis(
+        {
+            "font_style": title_slot.get("font-style"),
+            "font_weight": title_slot.get("font-weight", 400),
+        }
+    )
+    cb_tick_italic, cb_tick_bold = _native_font_emphasis(
+        {
+            "font_style": tick_slot.get("font-style"),
+            "font_weight": tick_slot.get("font-weight", 400),
+        }
+    )
     from ._svg import _colorbar_tick_target, _fmt_log, _linear_ticks, _log_ticks, _lut
 
     orientation = options.get("orientation", "vertical")
@@ -3452,6 +3488,8 @@ def tick_text(value: float) -> str:
                 tick_size,
                 tick_paint,
                 tick_text(value),
+                italic=cb_tick_italic,
+                bold=cb_tick_bold,
             )
         if options.get("label"):
             cmd.text(
@@ -3461,6 +3499,8 @@ def tick_text(value: float) -> str:
                 title_size,
                 title_paint,
                 str(options["label"]),
+                italic=cb_title_italic,
+                bold=cb_title_bold,
             )
     else:
         tick_positions = (
@@ -3491,6 +3531,8 @@ def tick_text(value: float) -> str:
                 tick_size,
                 tick_paint,
                 tick_text(value),
+                italic=cb_tick_italic,
+                bold=cb_tick_bold,
             )
         # Matplotlib rotates a vertical colorbar's label 90° CCW and centers it
         # alongside the bar, outboard of the tick labels. The native glyph
@@ -3508,6 +3550,8 @@ def tick_text(value: float) -> str:
                 title_size,
                 title_paint,
                 str(options["label"]),
+                italic=cb_title_italic,
+                bold=cb_title_bold,
             )
 
 
diff --git a/python/xy/styling/capabilities.py b/python/xy/styling/capabilities.py
index fa425d920..05461efe8 100644
--- a/python/xy/styling/capabilities.py
+++ b/python/xy/styling/capabilities.py
@@ -266,11 +266,13 @@ class ExtensionPoint:
 #: and has nothing in a file to style.
 _SLOT_SUBSET_NOTE = (
     "Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, "
-    "letter-spacing, opacity and the text paint (`fill`, or `color`). The raster "
-    "writer's glyph primitive takes a size and one RGBA paint and nothing else, "
-    "so it honors font-size and the paint only — font-weight, font-style, "
-    "font-family, letter-spacing and opacity are vector-only rather than "
-    "silently approximated. Properties outside the subset stay browser-only."
+    "letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps "
+    "any declared family onto the base-14 Helvetica faces (regular/bold/"
+    "oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster "
+    "atlas carries regular, bold and italic faces, so font-size, the paint, "
+    "font-weight and font-style survive there too — font-family, "
+    "letter-spacing and opacity remain vector-only rather than silently "
+    "approximated. Properties outside the subset stay browser-only."
 )
 
 _SLOT_EXCEPTIONS: dict[str, tuple[str, str, str]] = {
diff --git a/spec/api/capability-matrix.md b/spec/api/capability-matrix.md
index 81424ba41..863a51e98 100644
--- a/spec/api/capability-matrix.md
+++ b/spec/api/capability-matrix.md
@@ -123,15 +123,15 @@ declared and names anything that would not survive.
 ### Notes
 
 - **`root`** (via `chart style=`) — `styles={'root': ...}` is browser-only, but the chart-level `style=` token bag targets the same element and every renderer reads it (`spec['dom']['style']`). Prefer it for anything that must survive export.
-- **`title`** (via `styles={'title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`). The raster writer's glyph primitive takes a size and one RGBA paint and nothing else, so it honors font-size and the paint only — font-weight, font-style, font-family, letter-spacing and opacity are vector-only rather than silently approximated. Properties outside the subset stay browser-only.
+- **`title`** (via `styles={'title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
 - **`legend`** (via `styles={'legend': ...} / xy.legend(style=...) / --chart-legend-bg`) — The frame box. Both spellings and the theme token now converge on one merged declaration block before the writers see it, so what agrees in the browser agrees in a PNG. `background`, `boxShadow`, `borderRadius`, `--xy-legend-frame-alpha`, and `padding`/`rowGap` in `em` are honored; an explicit background paints opaque, as it does in the browser.
-- **`legend_title`** (via `styles={'legend_title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`). The raster writer's glyph primitive takes a size and one RGBA paint and nothing else, so it honors font-size and the paint only — font-weight, font-style, font-family, letter-spacing and opacity are vector-only rather than silently approximated. Properties outside the subset stay browser-only.
-- **`legend_label`** (via `styles={'legend_label': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`). The raster writer's glyph primitive takes a size and one RGBA paint and nothing else, so it honors font-size and the paint only — font-weight, font-style, font-family, letter-spacing and opacity are vector-only rather than silently approximated. Properties outside the subset stay browser-only.
-- **`colorbar`** (via `styles={'colorbar': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`). The raster writer's glyph primitive takes a size and one RGBA paint and nothing else, so it honors font-size and the paint only — font-weight, font-style, font-family, letter-spacing and opacity are vector-only rather than silently approximated. Properties outside the subset stay browser-only.
-- **`colorbar_tick`** (via `styles={'colorbar_tick': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`). The raster writer's glyph primitive takes a size and one RGBA paint and nothing else, so it honors font-size and the paint only — font-weight, font-style, font-family, letter-spacing and opacity are vector-only rather than silently approximated. Properties outside the subset stay browser-only.
-- **`colorbar_title`** (via `styles={'colorbar_title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`). The raster writer's glyph primitive takes a size and one RGBA paint and nothing else, so it honors font-size and the paint only — font-weight, font-style, font-family, letter-spacing and opacity are vector-only rather than silently approximated. Properties outside the subset stay browser-only.
-- **`tick_label`** (via `styles={'tick_label': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`). The raster writer's glyph primitive takes a size and one RGBA paint and nothing else, so it honors font-size and the paint only — font-weight, font-style, font-family, letter-spacing and opacity are vector-only rather than silently approximated. Properties outside the subset stay browser-only.
-- **`axis_title`** (via `styles={'axis_title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`). The raster writer's glyph primitive takes a size and one RGBA paint and nothing else, so it honors font-size and the paint only — font-weight, font-style, font-family, letter-spacing and opacity are vector-only rather than silently approximated. Properties outside the subset stay browser-only.
+- **`legend_title`** (via `styles={'legend_title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
+- **`legend_label`** (via `styles={'legend_label': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
+- **`colorbar`** (via `styles={'colorbar': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
+- **`colorbar_tick`** (via `styles={'colorbar_tick': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
+- **`colorbar_title`** (via `styles={'colorbar_title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
+- **`tick_label`** (via `styles={'tick_label': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
+- **`axis_title`** (via `styles={'axis_title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
 
 ## Extension points
 
diff --git a/spec/process/static-chrome-parity-plan-2026-08-04.md b/spec/process/static-chrome-parity-plan-2026-08-04.md
new file mode 100644
index 000000000..cd486bac4
--- /dev/null
+++ b/spec/process/static-chrome-parity-plan-2026-08-04.md
@@ -0,0 +1,212 @@
+# Static-Chrome Parity: Unified Implementation Plan (SVG + raster writers)
+
+## 0. Family order and rationale
+
+Primary key: how much geometry/measurement machinery the two writers already share (more shared = earlier, because the family needs only recording points and emitters, not new layout code). Secondary key: blast radius of the change.
+
+| Phase | Family | Shared machinery today | Dominant risk |
+|---|---|---|---|
+| P0 | Cross-cutting prerequisites | — | PDF whitelist is a live-bug fix, must land first |
+| P1 | root / title / chrome / canvas | `layout()` shared (`_svg.py:2574-2681`, imported `_raster.py:71`); root/chrome/canvas boxes derivable with zero new measurement | fast_png white-init trap; 3-way background precedence |
+| P2 | axis chrome (axis_band, axis_line, tick_mark, tick_label, axis_title) | ALL geometry helpers imported by raster (`_raster.py:38-80`); only emission loops duplicated | layout-room coupling; per-instance volume; rotated-box PDF lowering |
+| P3 | annotation chrome (annotation_label, annotation_layer, labels; badge/badge_item excluded) | placement/baseline/radius/text-width helpers imported (`_raster.py:28-83`); full box code already exists per writer (`_svg_text_box` / `_emit_text_box`) — the template the shared primitive is extracted from | two-vocabulary collision; labels-container stacking (verified conflict, flag D) |
+| P4 | legend (legend, legend_title, legend_item, legend_swatch, legend_label) | `_legend_layout` shared (`_raster.py:54`) but must be widened; frame box already drawn in both writers | em-residue contract retirement; any box-size change moves legends everywhere (pyplot `_axes.py:8472-8486`, `_legendfit.py:74-79`) |
+| P5 | colorbar (all 7 slots) | LEAST shared: bar geometry duplicated verbatim (`_svg.py:6811-6838` vs `_raster.py:3292-3312`), container geometry exists nowhere in Python, deliberate off-by-N placement divergences | must build new shared layout before any box work; default-border and extension-existence decisions |
+
+Legend is deliberately after annotation despite good sharing: it is the only family whose change moves layout in three downstream consumers and retires a pinned residue contract (`declared.py:18-26`, `tests/test_declared_snapshot.py`). Colorbar is last because it is the only family where consolidation (new shared machinery) is a prerequisite to parity work.
+
+---
+
+## 1. The shared primitives
+
+### 1.1 Shared chrome-layout record (`ChromeBox`)
+
+One dataclass/dict shape, produced once per slot instance by the family's layout resolver, consumed by (a) the SVG box emitter, (b) the raster box rasterizer, (c) `SnapshotBuilder.add(geometry=...)` (`styling/resolved.py:199-214, 306-334` — the `SlotInstance.geometry` field that `declared.py:97` currently leaves `None` on every declaration, all four surveys agree it is dead weight today):
+
+```
+ChromeBox:
+  slot: str
+  qualifiers: tuple            # (axis_id, side, major|minor, tick index, row, col) — SlotInstance.qualifiers carrier
+  x, y, w, h: float            # CSS px, pre-scale — the SlotInstance.geometry 4-float
+  angle: float; cx, cy: float  # rotation pose (axis y-title, vertical colorbar title); 0 for most slots
+  fill: RGBA | None            # resolved solid paint; gradients recorded separately
+  fill_opacity: float
+  border: (RGBA, width, dash_pattern | None) | None   # border-style lowered to dasharray; dotted/double = recorded approximation (§28)
+  radius: float                # single symmetric rx, clamped ≤ min(w,h)/2 (PDF accepts rx only, never ry — all four surveys, probe-verified)
+  shadow: (dx, dy, RGBA) | None  # offset-rect approximation; blur/spread recorded unrepresentable (no blur primitive in raster opcodes _raster.py:85-106, no <filter> in _pdf.py:1236-1253)
+  padding: (t, r, b, l)        # consumed by layout/room functions, NOT by the emitters
+  clip: none | rect | rounded  # rounded = SVG/PDF path clip only; raster partial until new opcode
+```
+
+Value source: the resolved per-slot declaration via `resolve_declared` (`styling/declared.py:56-105`), read at `slot_styles` (`_svg.py:1380-1396`; call sites `_svg.py:3924`, `_raster.py:1315`). Shorthand expansion (`padding`, `row-gap`, `border`) happens in `resolve_declared` (`declared.py:89-99`) because schema v1 carries only longhands (`resolved.py:77-89`). Px only — em/relative values stay `writer_domain` (`resolved.py:119-133`); the legend em-multiplier geometry must not be copied into any new family (family-1 and family-2 surveys agree).
+
+### 1.2 SVG rect emitter — one function
+
+`_slot_box_svg(box: ChromeBox) -> str` in `_svg.py`, placed next to `_rounded_rect_path` (`_svg.py:1795-1817`). Emits, in order: shadow rect, background rect (`x y width height rx fill fill-opacity stroke stroke-width stroke-opacity stroke-dasharray`), nothing else. Rules baked in:
+
+- every attribute exactly once (the duplicate-attr XML trap, `_svg.py:1494-1498` — parser keeps first value silently);
+- always an explicit `fill` (rects inside the labels `<g fill=default_text>` at `_svg.py:4590` inherit otherwise);
+- all numbers through `_num` (`_svg.py:1644`);
+- asymmetric per-corner radii lowered to a `<path>` via `_rounded_rect_path`, never `ry` (PDF rejects `ry`, probe-verified);
+- rotated boxes: see flag E below — one lowering must be pinned repo-wide;
+- stays inside the PDF closed subset: `<rect>` accepts x/y/width/height/rx + fill/fill-opacity/opacity/stroke/stroke-width/stroke-opacity/stroke-dasharray/stroke-linecap/stroke-linejoin (`_pdf.py:174-186, 198`, rx lowered `386-402`), rejects transform/filter/ry.
+
+### 1.3 Raster box rasterizer — one function
+
+`_emit_slot_box(cmd, box: ChromeBox)` in `_raster.py`, placed next to `_round_rect_pts` (`_raster.py:744-772`). Emits: shadow `cmd.fill(_round_rect_pts(offset...), rgba)`, background `cmd.fill(_round_rect_pts(...))`, border `cmd.stroke(pts, width, rgba, closed=True, dash=...)`. Rules:
+
+- slot opacity folded into every RGBA (no group compositing exists in the display list `_raster.py:193-700`); double-blend on overlapping translucent children recorded per §28;
+- rotated boxes: corners pre-rotated in Python (cmd.fill takes any quad; no transform primitive);
+- rounded CLIPPING is not representable (cmd.clip is rect-only, `_raster.py:216-221`; `_POLAR_CLIP` `223-236`) — record unrepresentable until a new opcode lands in `src/raster.rs` + ABI bump in `src/lib.rs` AND `python/xy/_native.py` together.
+
+### 1.4 Refactor targets that fold onto the pair
+
+The three existing duplicated box sites, converted per phase (not up front): legend frame (`_svg.py:6597-6623` / `_raster.py:3088-3111`, P4), annotation text box (`_svg.py:5007-5058` / `_raster.py:1875-1920`, P3), background composition (`_svg.py:4554-4571` / `_raster.py:951-986`, P1 — preserving the deliberate raster white-plot-fill fallback at `_raster.py:978-979`).
+
+---
+
+## 2. Phase 0 — cross-cutting prerequisites (blocking)
+
+**0.1 PDF text-subset extension (live-bug fix).** All four surveys independently probe-verified: `_pdf._ALLOWED_ATTRS['text']` (`_pdf.py:204-206`) rejects `font-style`, `font-family`, `letter-spacing`, `opacity`, so `to_image(format='pdf')` RAISES today for an italic title, a letter-spaced legend_label, an italic tick_label/colorbar_tick, and mathtext annotations (nested tspan, `_pdf.py:1099-1100`). The `SLOT_TEXT_PROPS` docstring claim that PDF honors the vector subset (`_svg.py:1331-1332`) is false; the capability-matrix tick_label PDF note is also wrong.
+Edits: `_ALLOWED_ATTRS['text']` + `_render_text` (`_pdf.py:1062-1141`); Helvetica-Oblique/BoldOblique into `_font()` (`_pdf.py:681-691`, today regular/bold only, bold cutoff weight>=600 at `1065`); letter-spacing via `Tc`; text opacity multiplied into `ca` ExtGState; nested-tspan mathtext either supported or explicitly fenced. `font-family` beyond base-14 is policy-refused, not guessed.
+Acceptance: `styles={'title':{'font_style':'italic'}}`, `{'legend_label':{'letter_spacing':'2px'}}`, `{'tick_label':{'font_style':'italic'}}`, `{'colorbar_tick':{'font_style':'italic'}}` each round-trip `to_svg -> svg_to_pdf` without ValueError; a mathtext annotation exports to PDF (or raises a documented, tested policy error). Closed-subset contract note (`_pdf.py:7-10, 63-64`) updated in the same change.
+
+**0.2 Raster emphasis-routing gap fix (contract violation).** `SLOT_RASTER_PROPS` (`_svg.py:1350-1356`) claims font-weight/font-style are honored, but only `title` (`_raster.py:1431-1436`) and `axis_title` (`1497-1505`) route through `_native_font_emphasis` (`_raster.py:1645-1655`). Wire it into: legend_title (`_raster.py:3113-3120`), legend_label (`3174-3181`), tick_label (`1388-1397`), colorbar_tick (`3447-3455`, `3486-3494`), colorbar_title (`3456-3464`, `3503-3511`). `cmd.text` already supports italic/bold (`_raster.py:662-700`).
+Acceptance per slot: `font_weight: 700` selects the bold atlas face, `font_style: italic` the italic face, in raster PNG; the pinned vector-minus-raster property set `{font-family, letter-spacing, opacity}` in `tests/test_export_style_survival.py:209-220` and `capabilities.py:267-274` updated in the same commit.
+
+**0.3 Shared primitives** (§1 above): `ChromeBox` lowering + `_slot_box_svg` + `_emit_slot_box` + shorthand expansion in `resolve_declared` (`declared.py:89-99`). Resolve the legend shadow constants while extracting, don't copy them (flag A/I below).
+Acceptance: unit tests on the lowering (border shorthand, per-side padding, radius clamp, shadow parse); golden SVG/PNG for one synthetic box exercising every field; PDF round-trip of the emitted rect.
+
+**0.4 Registry/preflight plumbing pattern.** Every slot added to writers must, in the same commit: join `STATIC_STYLED_SLOTS` (`_svg.py:1367-1377`); update `capabilities.py` (`264-296`, `332-345`) and `tests/test_capability_registry.py`; update preflight honored-props (`preflight.py:185-203, 197, 253-262`). Add a shared `SLOT_BOX_PROPS` constant (pattern: `LEGEND_BOX_PROPS`, `_svg.py:1416-1429`) so writers/registry/preflight cannot drift.
+
+**0.5 Standing gate:** unstyled output stays byte-identical (`tests/test_export_style_survival.py:140-146`). Every phase's emission is strictly conditional on a declaration being present. This gate is the acceptance floor for every edit below.
+
+---
+
+## 3. Phase 1 — root / title / chrome / canvas
+
+Geometry is free: root = chrome = (0,0,width,height); canvas = plot rect from `layout()` (`_svg.py:2665-2678`). Only the title needs a new helper.
+
+**Edits, in order:**
+
+1. **`title_box(entry, plot, wrap_width) -> ChromeBox`** next to `_title_metrics` (`_svg.py:2550-2558`), replacing the anchor math duplicated at `_svg.py:4245-4258` / `_raster.py:1465-1479` (entry titles) and `_svg.py:4226-4227` / `_raster.py:1443-1453` (legacy), mirrored a third time in JS (`50_chartview.ts:940-963`). Hoist BEFORE drawing boxes — the survey is explicit that adding box extents in each copy independently will drift. Box width = measured `TextBlock` width + padding (`_textblock.py:31-43`), NOT `title_wrap_width` (browser box is the shrink-to-fit div, `50_chartview.ts:2455-2468`).
+2. **`_title_room` grows** for padding/border (`_svg.py:2561-2571`) with the JS mirror (`50_chartview.ts:709-720`) in the same change, or native and browser disagree on `plot.y`.
+3. **Title box emission**: SVG rects appended to `chrome` immediately before the `<text>` at `_svg.py:4230` and `4265`; raster `_emit_slot_box` before `_emit_text_block` at `_raster.py:1443-1453` and `1476-1488` (chrome phase already unclipped, clip reset at `_raster.py:1108`). Populate `SlotInstance.geometry` at `declared.py:97`.
+4. **root slot**: SVG in the backgrounds assembly `_svg.py:4554-4571` (stays first-painted content per browser CSS border-below-descendants; the alternative post-chrome anchor at `4593` rejected); raster extends `_raster.py:949-986` (fill, then border stroke, before plot fill at `982-986`). Fix the fast_png skip condition (`_raster.py:956-965`) to account for border-radius breaking full-coverage. Define the three-source precedence ONCE: `styles.root.background` vs `dom.style['background']` vs `apply_export_background` override (`_svg.py:1513-1531` — root must join the override contract or `background='transparent'` exports keep a painted root box). Registry/preflight flip (`capabilities.py:289-296`, `preflight.py:253-254`).
+5. **chrome slot** (recommend the survey's own hedge: background/opacity only, rest recorded unrepresentable §28): SVG rect between `backgrounds` and the grid `<g>` (`_svg.py:4576-4584`, seam at 4581/4582); raster after plot fill `982-986`, BEFORE `cmd.clip` at `_raster.py:1008`. Record the title-stacking divergence (DOM appends chrome canvas after title divs, `50_chartview.ts:2455-2474`) in `KNOWN_RENDERER_DIVERGENCES` (`capabilities.py:249-259`).
+6. **canvas slot**: background at the ABOVE-grid seam — SVG after grid `</g>` (`4584`) before the clipped marks `<g>` (`4585`); raster `_raster.py:1056-1063` (after grid loops, before traces, inside the plot clip). Do NOT hook the existing `--chart-bg` anchor (below-grid): the paint-order divergence is the family's central trap. Border composes with spines (`_svg.py:4392-4407` / `_raster.py:1158-1183`). Radius = a THIRD clipPath id in the SVG defs (`_svg.py:3882-3906`) — never mutate `clip_id`/`marks_clip_id` (polar legends vanish, comment `3883-3893`); raster radius recorded unrepresentable until the new opcode. Opacity = group opacity on the marks `<g>` (PDF-legal on `<g>`, `_pdf.py:197`); unrepresentable per-command in raster. `apply_export_background` must also override a canvas-slot background.
+
+**Per-slot acceptance:**
+- root: styled bg+border+radius renders in both writers; radius corners show underlay (not native-white) on transparent fast_png export; `background='transparent'` kills the root paint; root shadow/outset border recorded unrepresentable (outside viewBox `_svg.py:4578-4579` / canvas `_raster.py:1582`), never grows the canvas; unstyled bytes identical; PDF round-trip.
+- title: box under text above all other chrome; `title_room` grows so the box clears `top_axis_room`; box width = block width + padding; entry-style-over-slot merge follows `_title_metrics` (`_svg.py:2556`); per-entry background divergence vs the browser's per-entry allowlist (`50_chartview.ts:2462-2466`) recorded; italic-title PDF passes (P0.1).
+- chrome: rgba background composites above root bg, below grid, in both writers; divergence entry present; unstyled bytes identical.
+- canvas: styled background HIDES the grid (browser parity); rounded clip works in SVG+PDF (path clip, `_pdf.py:836-875`), preflight reports raster radius partial; canvas opacity gated strictly on declaration (large PDF byte diff otherwise); transparent-export override honored.
+
+---
+
+## 4. Phase 2 — axis chrome
+
+**Edits, in order:**
+
+1. **Extract shared `tick_span`** — literal near-duplicate (`_svg.py:4433-4440` returns (in,out,width) vs `_raster.py:1205-1212` returns (in,out)). The survey calls it the obvious first extraction; unify on the 3-tuple.
+2. **Per-instance ChromeBox production** with qualifiers (axis_id, major|minor, side, tick index) filling `SlotInstance.qualifiers` (`resolved.py:209-211`, empty today).
+3. **axis_line**: read the slot at the existing `slot_styles` sites (`_svg.py:3924` / `_raster.py:1315`); convert `<line>`/`cmd.stroke` to box emission at `_svg.py:4392-4431` (paint-order slot `4589`) and `_raster.py:1158-1203`, GATED on box styling present (browser insets right/bottom spines — `50_chartview.ts:7008, 7028` — writers center on the edge; matching the browser unstyled would break the byte pin). Polar keeps stroke semantics (browser has the same limit, `50_chartview.ts:6991-6993` — verified: "spines are background-coloured DIVs and cannot express a circle"); recorded. Axis-level `axis_color` stays the narrower selector.
+4. **tick_mark**: box conversion in the loops `_svg.py:4442-4547` / `_raster.py:1214-1313`; intern the attribute string once per declaration (`resolved.py:14-19` design); explicit rule: no shadow on zero-area boxes (`tick_length` defaults 0, `_svg.py:4434`); do not invent a length — preflight note instead. Geometry parity here is exact (browser centers rect at x−width/2, same pixels as centered stroke).
+5. **tick_label boxes**: SVG rect immediately before its `<text>` in the labels list at `_svg.py:4060-4065` (explicit fill mandatory — group fill at `4590`); inputs already in scope at `4025-4059`; polar hook `_svg.py:3811-3868`; raster box before `_emit_text_block` at `_raster.py:1388-1397`, polar `874-923`. Room functions learn the box model in the SAME change: `_y_tick_label_room` (`_svg.py:2227-2252`), `_x_tick_label_room` (`2338-2396`) — both measure at axis font size only today while emitters draw at slot size (`4004` / `1339`), a pre-existing overflow the box work must not worsen. Letter-spacing folded into width estimation or qualified (§28).
+6. **axis_title boxes**: compute the real box in `_axis_label_geometry` (`_svg.py:3251-3320`, already shared via `_raster.py:57`); SVG emission into chrome before the `<text>` at `_svg.py:4296-4304`; raster at `_raster.py:1506-1521` with Python-side corner rotation. Rooms `_x_axis_title_room` (`2305-2337`) / `_y_title_baseline` (`2190-2226`) learn padding/border. Fix the `4289-4295` branch that drops slot letter-spacing/opacity wholesale when the axis authors family/style — per-property merge, with precedence documented (note the existing knot: paint is narrower-wins but font-size runs the other way, `_svg.py:4296` / `_raster.py:1511`).
+7. **axis_band** (last — pure policy): existence decision first (browser creates it only when navigable, `57_viewstate.ts:295, 272-279`; see flag F), z-order decision pinned (band z-index:2 paints ABOVE labels live, `57_viewstate.ts:299` — copy it or record "never obscure text"), OUT=24/IN=6 mirrored via generated constant or spec pin (`57_viewstate.ts:314-315`), polar: no bands, recorded.
+
+**Per-slot acceptance:**
+- axis_line: box renders only when box props declared; unstyled bytes identical; edge-inset choice pinned by golden; polar divergence recorded; `axis_color`-narrower test still green.
+- tick_mark: styled marks with `tick_length>0` render boxes; `tick_length=0` renders nothing (+preflight note test); dense-axis (200 ticks) SVG size and display-list length within budget; qualifiers land in snapshot.
+- tick_label: padded boxes don't clip at canvas edge (room growth test both orientations); rotated label boxes rotate with text and pass PDF (flag E lowering); the 15-vs-16px SVG/raster bottom-gap offset (`_raster.py:1347-1349`) documented as pre-existing in the parity test tolerance; interned attrs (one declaration string, N instances).
+- axis_title: rotated y-title box passes PDF; slot letter-spacing survives axis `label_font_family` being authored; precedence table test; DejaVu-measured box vs authored-family text misfit qualified (§28).
+
+---
+
+## 5. Phase 3 — annotation chrome
+
+**Edits, in order:**
+
+1. **Wire the dead slot channel**: thread `slots` (in scope since `_svg.py:3924`) into `_annotation_svg`'s signature at `_svg.py:4357-4361`; raster: hoist `slot_styles(spec)` from `_raster.py:1315` above both `_emit_annotations` calls (`1105`, `1111`).
+2. **Merge point**: fold the slot declaration UNDER `ann['style']` at `_svg.py:4867-4875` and `_raster.py:1786-1803` (narrower-wins, patterns: tick_label `_svg.py:3994-4005`, `legend_options_with_slot` `1432-1460`). Define the two-vocabulary translation ONCE (per-annotation shorthand `border`/`padding`/`border_radius`/`font_size` vs snapshot kebab longhands, `resolved.py:49-100`).
+3. **Converge the box pair onto the shared primitive**: `_svg_text_box` (`_svg.py:5007-5058`) and `_emit_text_box` (`_raster.py:1875-1920`) become adapters over `ChromeBox`; in the process fix per-side padding (both parsers read tokens [0]/[1] only — 4-value CSS silently misreads, `_svg.py:5021-5030` / `_raster.py:1890-1899`), add border-style→dasharray, box opacity, shadow. Text attrs at `_svg.py:4952-4956` must MERGE with `_svg_font_attrs` (`4961-4970`) and the always-emitted font-size (`4953`) — each attribute exactly once (the PR #325 lesson).
+4. **annotation_layer**: wrap annotation marks in their own `<g>` at `_svg.py:4357-4361` (contiguous tail of marks — pure wrap) for group opacity (PDF-legal); layer background geometry decision pinned BEFORE implementation (full-bleed vs plot-clipped — the browser canvas is inset:0 but SVG's clipped shapes live inside the marks clip group); raster: fold layer alpha per-primitive at `_raster.py:1696`, temporary full-canvas clip pattern from `1731-1733`/`1781-1784`; double-blend divergence recorded (§28). Do not conflate slot opacity with the per-annotation shape-alpha rule (`_svg.py:4897-4901`, `51_annotations.ts:860-875`).
+5. **labels container**: slot color/opacity ride the `<g>` at `_svg.py:4590` (PDF `<g>` accepts fill/fill-opacity/opacity, NOT font-* — probe-verified); container background rect at the `4589`/`4590` seam SUBJECT TO flag D below; typography materialized per-`<text>` at each emission site with cascade labels-slot < specific slot < axis/annotation style; raster `default_text` takeover at `_raster.py:1001` / `1315-1320` with byte-exact fallback.
+6. **badge / badge_item**: NO writer work — view-gated by the applicability partition (`capabilities.py:327-328`, `299-329`); any change is a spec decision first. Only requirement: keep the shared box primitive annotation-agnostic, since badge_item's default rendering is a full box model and would need it if ever exported.
+
+**Per-slot acceptance:**
+- annotation_label: `styles={'annotation_label': {...}}` now leaves a trace (today verified zero-trace); slot-under-ann-style precedence tested both directions; 4-value padding correct; border-style dashed renders dasharray in SVG and dash in raster; mathtext-annotation PDF passes or raises the documented fence (P0.1); em-valued slot declarations either honored via the merged view or explicitly refused — never silently dropped by a snapshot-only path.
+- annotation_layer: group opacity in SVG/PDF; raster per-primitive fold with an overlapping-shapes test documenting the double-blend delta; geometry decision golden.
+- labels: container color changes every label's default in both writers with byte-exact unstyled fallback; stacking decision from flag D pinned by golden; per-text typography cascade test (labels < tick_label < axis style).
+- badge/badge_item: preflight reports view-gated, no writer emission; capability partition test unchanged.
+
+---
+
+## 6. Phase 4 — legend
+
+**Edits, in order:**
+
+1. **`_legend_layout` returns per-slot ChromeBoxes** (frame, title row, item[i], swatch[i], label[i] — formulas in the survey, all terms already in the return dict `_svg.py:6542-6568`); signature widened to accept title_slot/label_slot font sizes + letter-spacing (`6377`; callers `_svg.py:6583`, `_raster.py:3074`, `pyplot/_axes.py:8486`); `_legendfit.legend_footprint` (`74-79`) tracks any size change.
+2. **Retire the em residue**: px `padding`/per-side padding, px `row-gap`/`gap`, kebab `font-size` honored via resolved declarations; `declared.py:18-26` and `tests/test_declared_snapshot.py` enumeration updated in the same change; shorthand expansion per P0.3. em spellings keep working through the writer view.
+3. **Frame onto the shared primitive** (`_svg.py:6597-6623` / `_raster.py:3088-3111`): honor the authored border-radius VALUE (both writers pin 4 today — probe-verified `border-radius:12px` still emits rx="4"), border-width/style, kebab `border-color` (today camelCase-only, and absent from `LEGEND_BOX_PROPS` `1416-1429` so preflight misreports), parsed box-shadow (offset/color; blur recorded), whole-slot opacity (raster: premultiplied, divergence recorded). Preserve `background=="transparent"` dropping the frame entirely (frameon=False parity, `_svg.py:6597` / `_raster.py:3087-3088`). Resolve — do not copy — the shadow divergences (flags A, I).
+4. **legend_title / legend_label**: boxes via the per-row records (SVG hooks: after `6623` for the title row, before the `<text>` at `6690` for labels; raster: `3111`/`3112` and before `3174`); measurement integrity — feed slot font-size and letter-spacing into `_legend_layout`'s char_width/text_widths (`6398-6400`, `6444-6467`) so drawn size == measured size (today an oversized slot title/label escapes the frame); text-align honored using the row-box width.
+5. **legend_item / legend_swatch — new slots**: `STATIC_STYLED_SLOTS` + threading through `_legend`/`_emit_legend` signatures (`_svg.py:6571-6580`, `_raster.py:3062-3071`) + read beside `legend_label_slot` (`_svg.py:4313-4314`, `_raster.py:1566-1567`). Row box: SVG inside the item loop after `6642-6644` before the kind branches at `6645`; raster after `3128-3130` before `3131`. Swatch box: before the kind branches (`6645` / `3132`); authored radius replaces the literal `rx="2"` at `6677` (raster patch branch `3152-3162` via `_round_rect_pts`). Precedence: slot overrides win over trace paint (browser `_applySlot` runs after paint vars, `50_chartview.ts:2881`). Swatch clips only if authored (browser keeps overflow visible for oversized markers).
+
+**Per-slot acceptance:**
+- legend: `border-radius:12px` → rx=12 both writers (regression vs today's pinned 4); px padding moves the frame identically in render, pyplot reservation, and best-loc scoring (three-consumer test); `background:'transparent'` still drops the frame; kebab `border-color` honored and preflight truthful; whole-slot opacity raster-premultiply divergence documented; unstyled bytes identical; PDF round-trip (frame rects fully in-subset).
+- legend_title / legend_label: raster emphasis (P0.2 regression test); box under text over frame; oversized slot font no longer escapes the frame (measurement test); text-align left/right; letter-spacing feeds advances; glyph-marker `<text font-family dominant-baseline>` PDF breakage (`_svg.py:6720-6726`) fenced or fixed — pre-existing.
+- legend_item: row background under that row's swatch/label, over frame and title; row padding changes pitch consistently everywhere; O(rows) instances within snapshot budget (`resolved.py:14-19`).
+- legend_swatch: slot background/stroke wins over trace color (browser-precedence test); radius honored on patch swatches; dash on swatch border in both writers.
+
+---
+
+## 7. Phase 5 — colorbar
+
+**Edits, in order:**
+
+1. **New shared `_colorbar_layout`** in `_svg.py`, folding: the verbatim-duplicated bar box (`_svg.py:6811-6838` / `_raster.py:3292-3312`), tick/title placement, discrete band fractions (`_svg.py:7040-7057` / `_raster.py:3315-3340`), extension polygons (`6949-6975` / `3385-3411`), line markers (`6976-7002` / `3412-3425`), minor ticks (`6913-6945` / `3432-3446`, `3471-3485`), title pose — AND the container box, which exists nowhere in Python (mirror `50_chartview.ts:3631-3648`; PIN the non-compact form — writers have no container-width signal for the compact mode at `3621, 3649-3687`). Reconcile the deliberate off-by-N divergences (SVG tick baseline +12 vs raster +13, `_svg.py:6906` / `_raster.py:3450`; title +22 vs +26, `6846` / `3459`) — resolve to one number, don't copy. Returns ChromeBoxes for all 7 slots. No em blockers in this family (survey-confirmed).
+2. **Split the `or`-fallback into a cascade** at `_svg.py:4352-4353` / `_raster.py:1578-1579`: box props stay on the container, text props (color/font-size, per `20_theme.ts:132`) inherit into title/tick — otherwise a container `background` wrongly paints per-text backgrounds once box props are honored. Widen the call sites (`_svg.py:4345-4355`, `_raster.py:1571-1580`) to pass the whole slots map.
+3. **Container box** via the shared primitive: first node of the returned string (`_svg.py:7003-7008`); raster before band fills (`3341-3355`); geometry from `_colorbar_layout` only (a second computation reintroduces the 1px-class divergences).
+4. **colorbar_bar**: border/radius/opacity on the rects at `_svg.py:7016-7039`/`7058-7075` and `_raster.py:3341-3355`; rounded discrete bar = `<g clip-path>` in SVG/PDF, raster partial (rect-clip-only); the +0.5px seam overlap (`7065`/`7073`, `3351`/`3355`) must be inset from border/radius edges; the browser's DEFAULT 1px `currentColor` border (`20_theme.ts:133`) vs writers' none is an explicit default-parity decision, never a silent flip (byte pin); background override must not disturb gradient-id dedup (`_colormap_key` `_svg.py:1240-1246`).
+5. **colorbar_extension / colorbar_line / colorbar_minor_tick**: paint-level overrides at `_svg.py:6949-6975`/`6976-7002`/`6928-6945` and `_raster.py:3385-3411`/`3412-3425`/`3441-3446`+`3480-3485`. State the resolved-paints precedence rule (payload over/under-color and per-line color/width/dash vs slot declaration) to match the browser (payload sets vars, slot overrides). Extension existence divergence settled first (browser creates them only for line_only, `50_chartview.ts:3479`; writers always). border-style dotted→dash approximation recorded (§28). Map the browser's border-* vocabulary onto stroke attrs consistently for line + minor_tick.
+6. **colorbar_tick / colorbar_title boxes** (emphasis already fixed in P0.2): tick pills need text width (`_textblock.measure`/`_estimated_text_width`); per-tick SlotInstances with qualifiers+geometry (`resolved.py:306-334`). Rotated vertical-title box: see flag E — the colorbar survey prescribes pre-rotated `<polygon>`; unify with the axis-family lowering. Three rotation implementations (`50_chartview.ts:3605`, `_svg.py:6842`, `_raster.py:3507`) must consume the one shared pose from `_colorbar_layout`.
+
+**Per-slot acceptance:**
+- colorbar: container box renders under bar/ticks/text, over the plot; container background does NOT leak into per-text backgrounds (cascade test); non-compact pin documented; PDF round-trip.
+- colorbar_bar: border/radius on continuous and discrete bars; band seams stay inside the border; raster radius reported partial; default-border decision golden; two-colorbar gradient dedup unchanged.
+- colorbar_extension: slot fill/stroke override with payload-precedence test; existence-policy golden.
+- colorbar_line / colorbar_minor_tick: width/style/color overrides in both writers; dotted approximation recorded and tested.
+- colorbar_tick / colorbar_title: emphasis (P0.2); boxes in both writers; rotated title box byte-identical geometry across SVG/PDF/raster (single pose source); metrics-divergent pill widths recorded (§28: AFM vs atlas vs browser font).
+
+---
+
+## 8. Survey disagreements (flagged, not papered over)
+
+Three I verified against the code in this pass; the rest need a look before the affected phase.
+
+- **A. Legend shadow radius (RESOLVED BY CODE — family-2 correct, family-1 wrong).** Family-1 says both writers hard-code radius 4 for the legend shadow+frame. Code: SVG shadow is `rx="4"` unconditional (`_svg.py:6600-6601`), while the raster shadow radius is `4.0 if borderRadius else 0.0` (`_raster.py:3089-3092`) — conditional. The frame is 4-or-0 in both. P4.3 must unify the shadow rule.
+- **B. Legend border "hard-coded 1px #cccccc" (RESOLVED BY CODE — family-1 overstates).** Family-1 calls the frame border hard-coded; family-2 says camelCase `borderColor` IS honored with #cccccc default. Code confirms family-2: `_svg.py:6618`, `_raster.py:3108`. Only width (1px) and style (solid) are hard-coded. Additional nuance neither survey states: the SVG frame stroke rides `stroke-opacity=alpha` from the frame-alpha logic (`_svg.py:6622`) and the raster folds the same alpha into the border RGBA (`3108`) — the border dims with the frame; the new lowering must decide whether that coupling survives.
+- **C. What the annotation box pair shares (RESOLVED BY CODE — family-1 undercounts).** Family-1: they share "only `_box_corner_radius`". Family-4: `_estimated_text_width` is also shared. Code: `_raster.py:52` imports `_estimated_text_width`. Family-4 correct.
+- **D. Labels/baselines stacking (REAL CONFLICT, both surveys partially right — must be resolved before P3.5).** The axis family asserts the writers' order (baselines above marks, below the labels group) "matches the browser" (`50_chartview.ts:6948-6952`). The annotation family asserts the browser keeps spine/rule DIVs INSIDE the labels container so a labels-slot background cannot sit under baselines and above marks without reordering. Code (verified): `rule()` appends spine/tick DIVs to `this.labels` (`50_chartview.ts:6988-6989`). Both claims describe the same DOM: relative z of rules-vs-marks matches, but a labels-container BACKGROUND paints under the rules live and above them in the writers. The axis family's "matches the browser" is true only for slot ink, not for the container box. Decide and record before implementing the labels background.
+- **E. Rotated-box PDF lowering (CONFLICTING PRESCRIPTIONS).** Axis family: `<polygon>` (loses radius) OR `<path>` with arcs (keeps it), leaning toward pinning path-with-arcs since rotated y-titles are the common case. Colorbar family: pre-rotated `<polygon>` "so SVG, PDF and raster share one geometry" — no radius. Pick ONE repo-wide lowering in P0.3 (recommendation: pre-rotated polygon when radius==0, path-with-arcs when radius>0) and make both families consume it.
+- **F. axis_band applicability policy (CROSS-FAMILY PRINCIPLE CONFLICT).** The axis family plans full box support for axis_band and notes `capability-matrix.md:116` claims it applicable in clean static. The annotation family's badge rationale (`capabilities.py:299-329`: clean static exports contain no state-gated chrome) argues the opposite for interaction-gated chrome — and the band exists live ONLY when the axis is navigable (`57_viewstate.ts:295, 272-279`), i.e., it is interaction-gated. Either the band is deemed structural chrome (draw it, full support) or interaction chrome (view-gate it like badge). Spec decision before P2.7; the surveys point different directions.
+- **G. chrome-slot scope (SELF-HEDGED, needs a call).** Family-1 lists full box-model gaps for `chrome`, then recommends background/opacity-only with the rest unrepresentable. Its proposed static anchor (below grid) matches live compositing per its own analysis but contradicts DOM order for titles (chrome canvas appended after title divs). The plan adopts the hedge (P1.5) — that adoption is a decision, not a survey consensus.
+- **H. Shadow alpha constants (framing conflict).** Family-1 presents SVG 0.22 / raster 55/255 as one policy ("alpha 0.22/55"); family-2 flags them as a divergence to resolve, not copy (0.22 vs ≈0.2157). The plan follows family-2 (P0.3/P4.3 unify).
+- **I. Raster `_raster.py` import-line citations vary across surveys** (25-45, 28-83, 38-80, 52, 54, 65, 71) — not contradictory (different subsets of the same import block), no action.
+- **J. Root geometry producers (recorded risk, not a survey conflict, but only family-1 raises it):** browser capture reports root geometry including host padding; native snapshot uses spec width/height (`declared.py:100-103`). Two producers must agree or capture-diff tooling flags every chart — needs a stated normalization rule when snapshot geometry starts being populated (P1.3+).
+
+---
+
+## 9. Cross-phase invariants (every edit above is subject to)
+
+1. Unstyled output byte-identical (`tests/test_export_style_survival.py:140-146`) — all emission strictly declaration-gated.
+2. Any new SVG attribute reaching PDF extends `_pdf._ALLOWED_ATTRS` in the same change (closed-subset contract, `_pdf.py:7-10`), or export goes from silently-unstyled to raising.
+3. Every attribute emitted exactly once per element (`_svg.py:1494-1498`).
+4. `_num` for all SVG numbers; `_Cmd` fixed-point for raster; stable attribute order (PDF determinism, `_pdf.py:35-36`).
+5. Radius is single symmetric rx (or path lowering); never `ry`.
+6. Box-shadow = deterministic offset-rect; blur/spread recorded unrepresentable (§28).
+7. Every approximation or renderer divergence recorded (§28 / `KNOWN_RENDERER_DIVERGENCES`), never silent.
+8. `STATIC_STYLED_SLOTS` growth moves `capabilities.py` + `preflight.py` + their tests in the same commit.
+9. Raster rounded clipping and group compositing stay recorded-unrepresentable until a `src/raster.rs` opcode lands with the dual ABI bump (`src/lib.rs` + `python/xy/_native.py`).
+10. em/relative units: snapshot rejects, writer view carries; no new slot may silently drop them (the legend-residue lesson).
\ No newline at end of file
diff --git a/tests/test_pdf_text_subset.py b/tests/test_pdf_text_subset.py
new file mode 100644
index 000000000..8e5bacd81
--- /dev/null
+++ b/tests/test_pdf_text_subset.py
@@ -0,0 +1,96 @@
+"""PDF honors the vector text subset (static-chrome parity, phase 0.1).
+
+Before this change `_pdf._ALLOWED_ATTRS["text"]` rejected `font-style`,
+`font-family`, `letter-spacing`, and `opacity`, so a PDF export of an
+italic title — or any chart whose declared styling reached those
+attributes — raised `ValueError`, contradicting the `SLOT_TEXT_PROPS`
+contract that PDF honors the vector subset via the same markup. These
+tests are that contract, executable.
+"""
+
+from __future__ import annotations
+
+import re
+import zlib
+
+import pytest
+
+import xy
+
+
+def _content(pdf: bytes) -> bytes:
+    """All content streams, decompressed where flate-encoded."""
+    out = b""
+    for stream in re.findall(rb"stream\r?\n(.*?)endstream", pdf, re.S):
+        body = stream.strip()
+        try:
+            out += zlib.decompress(body)
+        except zlib.error:
+            out += body
+    return out
+
+
+def _chart(**styles):
+    return xy.line_chart(xy.line([1.0, 2.0, 3.0], [2.0, 1.0, 3.0]), title="t", styles=styles)
+
+
+def test_italic_title_selects_the_oblique_face() -> None:
+    pdf = _chart(title={"font_style": "italic"}).to_image("pdf")
+    assert pdf[:4] == b"%PDF"
+    assert b"Helvetica-Oblique" in pdf
+
+
+def test_bold_italic_composes_to_the_bold_oblique_face() -> None:
+    pdf = _chart(title={"font_style": "italic", "font_weight": 700}).to_image("pdf")
+    assert b"Helvetica-BoldOblique" in pdf
+
+
+@pytest.mark.parametrize("slot", ["tick_label", "axis_title", "colorbar_tick"])
+def test_italic_survives_on_every_vector_text_slot(slot) -> None:
+    chart = xy.scatter_chart(
+        xy.scatter([1.0, 2.0, 3.0], [2.0, 1.0, 3.0], color=[0.1, 0.5, 0.9]),
+        xy.colorbar(title="c"),
+        xy.x_axis(label="X"),
+        styles={slot: {"font_style": "italic"}},
+    )
+    pdf = chart.to_image("pdf")
+    assert b"Helvetica-Oblique" in pdf
+
+
+def test_letter_spacing_becomes_tc_and_resets() -> None:
+    pdf = _chart(tick_label={"letter_spacing": "2px"}).to_image("pdf")
+    content = _content(pdf)
+    assert b" Tc" in content
+    # Text state persists past ET; every spaced run must reset, so the
+    # count of sets equals the count of resets.
+    sets = len(re.findall(rb"[0-9.]+ Tc", content)) - content.count(b"\n0 Tc")
+    resets = content.count(b"\n0 Tc")
+    assert sets == resets > 0
+
+
+def test_text_opacity_folds_into_the_extgstate() -> None:
+    # `title` is the slot whose vector emission carries `opacity` today
+    # (slot_text_attrs); the axis family joins in the axis-chrome phase.
+    faded = _chart(title={"opacity": 0.5}).to_image("pdf")
+    assert faded[:4] == b"%PDF"
+    # The declared 0.5 multiplies the paint's own 0.85 alpha: one composed
+    # ExtGState, not two stacked ones.
+    assert b"/ca 0.425" in faded
+
+
+def test_declared_font_family_maps_to_base14_not_a_crash() -> None:
+    pdf = _chart(tick_label={"font_family": "Inter, system-ui, sans-serif"}).to_image("pdf")
+    assert pdf[:4] == b"%PDF"
+    assert b"Helvetica" in pdf
+
+
+def test_the_closed_subset_still_refuses_what_it_does_not_speak() -> None:
+    # The whitelist grew deliberately; everything else keeps failing loudly
+    # (the closed-subset contract that makes generator drift visible).
+    from xy import _pdf
+
+    with pytest.raises(ValueError, match="unsupported SVG feature"):
+        _pdf.svg_to_pdf(
+            '<svg xmlns="http://www.w3.org/2000/svg" width="10" height="10">'
+            '<text x="1" y="1" text-decoration="underline">t</text></svg>'
+        )

From 0a5ca9269e250de0bce53e53039a7c595ddbe8e9 Mon Sep 17 00:00:00 2001
From: Alek Petuskey <alek@reflex.dev>
Date: Tue, 4 Aug 2026 15:49:31 -0700
Subject: [PATCH 13/27] Static-chrome parity P0.3: the shared box model and its
 two emitters
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

python/xy/_chromebox.py is the single lowering from a resolved slot
declaration to a ChromeBox — background, border (style lowered to the
dash construction both writers already use for data strokes), symmetric
radius clamped like CSS (rx only; PDF rejects ry), the offset-rect shadow
this codebase has always drawn, and opacity. Every request the model
cannot draw lands in an `unrepresentable` ledger with its reason —
gradients until the effect phase, blur/spread with no blur primitive,
asymmetric radii until a path lowering, multiple/inset shadows — so
nothing rounds to silence (§28). The shadow parser tokenizes
paren-aware, because rgba()'s own commas are not shadow separators.

_svg._slot_box_svg and _raster._emit_slot_box are the writer halves: same
decisions, two encodings. The SVG emitter guards the duplicate-attribute
XML trap (every attribute exactly once per rect, tested by parsing, not
substring counting), always writes an explicit fill so a rect inside the
labels group cannot inherit the text paint, and stays inside the PDF
closed subset (round-tripped in the tests). The raster emitter folds slot
opacity into every RGBA (the display list has no group compositing) and
strokes borders closed so the final edge is not silently dropped. Both
emit nothing for a box that paints nothing — the unstyled-bytes gate,
enforced at the primitive itself.

The three pre-existing duplicated box drawers (legend frame, annotation
text box, background composition) fold onto this pair family by family in
the parity phases, per spec/process/static-chrome-parity-plan-2026-08-04.md
— the recon plan now committed beside the work it orders.
---
 python/xy/_chromebox.py | 222 ++++++++++++++++++++++++++++++++++++++++
 python/xy/_raster.py    |  34 ++++++
 python/xy/_svg.py       |  40 ++++++++
 tests/test_chromebox.py | 168 ++++++++++++++++++++++++++++++
 4 files changed, 464 insertions(+)
 create mode 100644 python/xy/_chromebox.py
 create mode 100644 tests/test_chromebox.py

diff --git a/python/xy/_chromebox.py b/python/xy/_chromebox.py
new file mode 100644
index 000000000..94af40b95
--- /dev/null
+++ b/python/xy/_chromebox.py
@@ -0,0 +1,222 @@
+"""The shared chrome-box model: one lowering, two emitters, zero drift.
+
+Static-chrome parity gives every applicable slot a real box (background,
+border, radius, shadow, opacity) in both native writers. The three box
+drawers that existed before this module — the legend frame, the annotation
+text box, and the background composition — were each written twice and
+drifted twice (hard-coded shadow constants, different radius geometry);
+this module is the single lowering from a resolved declaration to a
+`ChromeBox`, consumed by `_svg._slot_box_svg` and `_raster._emit_slot_box`
+so a box drawn in one writer cannot mean something else in the other.
+
+Contract notes, each load-bearing:
+
+- Values are resolved px/colors (the snapshot contract); the lowering
+  parses spellings, it never resolves cascades.
+- `radius` is one symmetric `rx` clamped to `min(w, h) / 2` — PDF accepts
+  `rx` and rejects `ry` (probe-verified), so asymmetric corner radii are
+  outside the model until a path lowering exists.
+- `shadow` is the offset-rect approximation this codebase has always drawn
+  (no blur primitive exists in the raster opcodes and PDF rejects
+  `filter`); a blur/spread request is recorded in `unrepresentable`, never
+  silently blurless (§28).
+- `border-style` lowers `dashed`/`dotted` to dash arrays scaled by width —
+  the same construction both writers already use for data strokes; `double`
+  and friends are recorded unrepresentable.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from typing import Any, Optional
+
+__all__ = ["ChromeBox", "lower_box"]
+
+_LENGTH_RE = re.compile(r"^\s*(-?\d+(?:\.\d+)?)(?:px)?\s*$")
+
+
+@dataclass(frozen=True)
+class ChromeBox:
+    """One slot instance's resolved box, ready for either writer."""
+
+    slot: str
+    x: float
+    y: float
+    w: float
+    h: float
+    fill: Optional[str] = None  # resolved CSS color text, writer-parsed
+    fill_opacity: float = 1.0
+    border_color: Optional[str] = None
+    border_width: float = 0.0
+    border_dash: Optional[tuple[float, ...]] = None
+    radius: float = 0.0
+    shadow: Optional[tuple[float, float, str]] = None  # (dx, dy, color)
+    opacity: float = 1.0
+    unrepresentable: tuple[str, ...] = field(default_factory=tuple)
+
+    @property
+    def paints_anything(self) -> bool:
+        return self.fill is not None or (self.border_color is not None and self.border_width > 0)
+
+
+def _px(value: Any) -> Optional[float]:
+    if isinstance(value, bool):
+        return None
+    if isinstance(value, (int, float)):
+        return float(value)
+    if isinstance(value, str):
+        m = _LENGTH_RE.match(value)
+        if m:
+            return float(m.group(1))
+    return None
+
+
+def _opacity(value: Any, fallback: float = 1.0) -> float:
+    try:
+        out = float(value)
+    except (TypeError, ValueError):
+        return fallback
+    return min(1.0, max(0.0, out))
+
+
+def _border_dash(style: str, width: float) -> Optional[tuple[float, ...]]:
+    if style == "dashed":
+        return (3.7 * width, 1.6 * width)
+    if style == "dotted":
+        return (width, width)
+    return None
+
+
+def _parse_shadow(value: str) -> tuple[Optional[tuple[float, float, str]], Optional[str]]:
+    """`box-shadow` to the offset-rect model, or the reason it cannot be.
+
+    Accepted: `<dx> <dy> [color]` and `<dx> <dy> 0 [0] [color]` (explicit
+    zero blur/spread). Anything with real blur/spread, insets, or multiple
+    shadows is unrepresentable in the offset-rect model.
+    """
+    text = value.strip()
+    if not text or text == "none":
+        return None, None
+    # Multiple shadows split on top-level commas; a color's own commas
+    # (rgba(0, 0, 0, .2)) live inside parens and must not count.
+    depth = 0
+    for ch in text:
+        if ch == "(":
+            depth += 1
+        elif ch == ")":
+            depth -= 1
+        elif ch == "," and depth == 0:
+            return None, "multiple shadows"
+    if "inset" in text:
+        return None, "inset shadow"
+    parts: list[str] = []
+    depth = 0
+    token = ""
+    for ch in text:
+        if ch == "(":
+            depth += 1
+        elif ch == ")":
+            depth -= 1
+        if ch.isspace() and depth == 0:
+            if token:
+                parts.append(token)
+                token = ""
+        else:
+            token += ch
+    if token:
+        parts.append(token)
+    lengths: list[float] = []
+    color = ""
+    for part in parts:
+        px = _px(part)
+        if px is not None and not color:
+            lengths.append(px)
+        else:
+            color = f"{color} {part}".strip()
+    if len(lengths) < 2:
+        return None, "shadow needs dx and dy"
+    if any(v != 0.0 for v in lengths[2:4]):
+        return None, "shadow blur/spread (no blur primitive in the native writers)"
+    return (lengths[0], lengths[1], color or "rgba(0, 0, 0, 0.22)"), None
+
+
+def lower_box(
+    slot: str,
+    declaration: dict[str, Any],
+    *,
+    x: float,
+    y: float,
+    w: float,
+    h: float,
+) -> ChromeBox:
+    """Lower one resolved declaration onto a geometry rectangle.
+
+    Reads only the box vocabulary; text properties ride the existing text
+    emitters. Every request the model cannot draw lands in
+    `unrepresentable` with its reason — the preflight and the tests read
+    that list, so nothing rounds to silence.
+    """
+    unrepresentable: list[str] = []
+
+    fill = declaration.get("background")
+    if fill is None:
+        fill = declaration.get("background-color")
+    if isinstance(fill, str) and ("gradient(" in fill or "url(" in fill):
+        unrepresentable.append(f"background {fill!r} (box gradients land with the effect phase)")
+        fill = None
+    if fill is not None and not isinstance(fill, str):
+        fill = str(fill)
+    if isinstance(fill, str) and fill.strip().lower() in ("", "none", "transparent"):
+        fill = None
+
+    border_width = _px(declaration.get("border-width")) or 0.0
+    border_color = declaration.get("border-color")
+    border_style = str(declaration.get("border-style", "solid") or "solid").strip().lower()
+    if border_color is not None and border_width == 0.0:
+        border_width = 1.0  # CSS medium is 3px, but chrome borders here have always drawn 1px
+    if border_style in ("none", "hidden"):
+        border_color, border_width = None, 0.0
+        dash = None
+    elif border_style in ("solid", "dashed", "dotted"):
+        dash = _border_dash(border_style, max(border_width, 1.0))
+    else:
+        unrepresentable.append(f"border-style {border_style!r}")
+        dash = None
+    if border_color is not None:
+        border_color = str(border_color)
+
+    radius = _px(declaration.get("border-radius")) or 0.0
+    if (
+        isinstance(declaration.get("border-radius"), str)
+        and " " in str(declaration["border-radius"]).strip()
+    ):
+        unrepresentable.append(
+            "asymmetric border-radius (PDF accepts symmetric rx only; path lowering pending)"
+        )
+        radius = 0.0
+    radius = max(0.0, min(radius, w / 2.0, h / 2.0))
+
+    shadow = None
+    raw_shadow = declaration.get("box-shadow")
+    if isinstance(raw_shadow, str):
+        shadow, why = _parse_shadow(raw_shadow)
+        if why is not None:
+            unrepresentable.append(f"box-shadow: {why}")
+
+    return ChromeBox(
+        slot=slot,
+        x=float(x),
+        y=float(y),
+        w=float(w),
+        h=float(h),
+        fill=fill,
+        fill_opacity=_opacity(declaration.get("fill-opacity"), 1.0),
+        border_color=border_color,
+        border_width=border_width,
+        border_dash=dash,
+        radius=radius,
+        shadow=shadow,
+        opacity=_opacity(declaration.get("opacity"), 1.0),
+        unrepresentable=tuple(unrepresentable),
+    )
diff --git a/python/xy/_raster.py b/python/xy/_raster.py
index a44c27017..cc2646643 100644
--- a/python/xy/_raster.py
+++ b/python/xy/_raster.py
@@ -770,6 +770,40 @@ def _round_rect_pts(
     return pts
 
 
+def _emit_slot_box(cmd: "_Cmd", box: Any) -> None:
+    """One chrome box in the raster display list — `_slot_box_svg`'s twin.
+
+    Slot opacity folds into every RGBA (the display list has no group
+    compositing); rounded corners go through `_round_rect_pts`; the border
+    strokes closed so the final edge is not silently dropped. Emits nothing
+    for a box that paints nothing — the unstyled-bytes gate.
+    """
+    if not box.paints_anything and box.shadow is None:
+        return
+
+    def pts(x: float, y: float) -> list[tuple[float, float]]:
+        if box.radius > 0:
+            return _round_rect_pts(x, y, box.w, box.h, box.radius)
+        return _rect_pts(x, y, box.w, box.h)
+
+    if box.shadow is not None:
+        dx, dy, color = box.shadow
+        cmd.fill(pts(box.x + dx, box.y + dy), _parse_color(color, opacity=box.opacity))
+    if box.fill is not None:
+        cmd.fill(
+            pts(box.x, box.y),
+            _parse_color(box.fill, opacity=box.opacity * box.fill_opacity),
+        )
+    if box.border_color is not None and box.border_width > 0:
+        cmd.stroke(
+            pts(box.x, box.y),
+            box.border_width,
+            _parse_color(box.border_color, opacity=box.opacity),
+            closed=True,
+            dash=list(box.border_dash) if box.border_dash else None,
+        )
+
+
 def _grad_line(
     space: str,
     direction: str,
diff --git a/python/xy/_svg.py b/python/xy/_svg.py
index aed797608..8f523c09e 100644
--- a/python/xy/_svg.py
+++ b/python/xy/_svg.py
@@ -1817,6 +1817,46 @@ def _rounded_rect_path(
     return " ".join(s for s in p if s)
 
 
+def _slot_box_svg(box: Any) -> str:
+    """One chrome box as SVG rects — the writer half of `_chromebox`.
+
+    Shadow first, then the background/border rect; every attribute exactly
+    once (the duplicate-attribute XML trap: parsers keep the first value
+    silently), always an explicit `fill` (a rect inside the labels group
+    would inherit the text paint otherwise), radius as symmetric `rx` only
+    (PDF rejects `ry`). Emits nothing for a box that paints nothing, so the
+    unstyled document stays byte-identical.
+    """
+    if not box.paints_anything and box.shadow is None:
+        return ""
+    parts: list[str] = []
+    common_opacity = f' opacity="{_num(box.opacity)}"' if box.opacity < 1.0 else ""
+    radius_attr = f' rx="{_num(box.radius)}"' if box.radius > 0 else ""
+    if box.shadow is not None:
+        dx, dy, color = box.shadow
+        parts.append(
+            f'<rect x="{_num(box.x + dx)}" y="{_num(box.y + dy)}" '
+            f'width="{_num(box.w)}" height="{_num(box.h)}"{radius_attr} '
+            f'fill="{_escape_attr(color)}"{common_opacity}/>'
+        )
+    fill = _escape_attr(box.fill) if box.fill is not None else "none"
+    stroke = ""
+    if box.border_color is not None and box.border_width > 0:
+        stroke = (
+            f' stroke="{_escape_attr(box.border_color)}" stroke-width="{_num(box.border_width)}"'
+        )
+        if box.border_dash:
+            dashes = " ".join(_num(v) for v in box.border_dash)
+            stroke += f' stroke-dasharray="{dashes}"'
+    fill_opacity = f' fill-opacity="{_num(box.fill_opacity)}"' if box.fill_opacity < 1.0 else ""
+    parts.append(
+        f'<rect x="{_num(box.x)}" y="{_num(box.y)}" '
+        f'width="{_num(box.w)}" height="{_num(box.h)}"{radius_attr} '
+        f'fill="{fill}"{fill_opacity}{stroke}{common_opacity}/>'
+    )
+    return "".join(parts)
+
+
 def _poly_path(px: np.ndarray, py: np.ndarray) -> str:
     return _native.svg_poly_path(px, py)
 
diff --git a/tests/test_chromebox.py b/tests/test_chromebox.py
new file mode 100644
index 000000000..a2c967891
--- /dev/null
+++ b/tests/test_chromebox.py
@@ -0,0 +1,168 @@
+"""The shared chrome-box model: one lowering, two emitters, zero drift.
+
+Every box the parity phases draw goes through `lower_box` and one of the
+two emitters, so these tests are the floor under all of them: parsing
+edge cases, the §28 unrepresentable ledger, emitter output shape, PDF
+round-trip, and the emit-nothing-when-unstyled gate.
+"""
+
+from __future__ import annotations
+
+from xy import _raster, _svg
+from xy._chromebox import ChromeBox, lower_box
+from xy._pdf import svg_to_pdf
+
+
+def _box(decl, **geom):
+    geom = {"x": 10.0, "y": 20.0, "w": 100.0, "h": 40.0, **geom}
+    return lower_box("legend", decl, **geom)
+
+
+# -- lowering -----------------------------------------------------------------
+
+
+def test_full_declaration_lowers_every_field() -> None:
+    box = _box(
+        {
+            "background": "#0f172a",
+            "border-color": "#334155",
+            "border-width": "2px",
+            "border-style": "dashed",
+            "border-radius": "6px",
+            "box-shadow": "2px 3px rgba(0, 0, 0, 0.22)",
+            "opacity": 0.9,
+            "fill-opacity": 0.8,
+        }
+    )
+    assert box.fill == "#0f172a"
+    assert box.border_color == "#334155"
+    assert box.border_width == 2.0
+    assert box.border_dash == (7.4, 3.2)
+    assert box.radius == 6.0
+    assert box.shadow == (2.0, 3.0, "rgba(0, 0, 0, 0.22)")
+    assert box.opacity == 0.9
+    assert box.fill_opacity == 0.8
+    assert box.unrepresentable == ()
+
+
+def test_radius_clamps_to_the_box_like_css() -> None:
+    assert _box({"background": "#111", "border-radius": "500px"}).radius == 20.0
+
+
+def test_transparent_and_none_fills_paint_nothing() -> None:
+    for fill in ("transparent", "none", ""):
+        box = _box({"background": fill})
+        assert box.fill is None
+        assert not box.paints_anything
+
+
+def test_border_color_alone_implies_the_one_px_chrome_border() -> None:
+    box = _box({"border-color": "#ccc"})
+    assert box.border_width == 1.0
+    assert box.paints_anything
+
+
+def test_unrepresentable_requests_are_ledgered_with_reasons() -> None:
+    box = _box(
+        {
+            "background": "linear-gradient(#000, #fff)",
+            "border-style": "double",
+            "border-radius": "4px 8px",
+            "box-shadow": "0 4px 12px rgba(0, 0, 0, 0.3)",
+        }
+    )
+    assert box.fill is None and box.radius == 0.0 and box.shadow is None
+    reasons = " | ".join(box.unrepresentable)
+    assert "gradient" in reasons
+    assert "border-style 'double'" in reasons
+    assert "asymmetric border-radius" in reasons
+    assert "blur" in reasons
+
+
+def test_shadow_parses_zero_blur_and_rejects_multiples() -> None:
+    ok = _box({"box-shadow": "1px 2px 0 0 #000"})
+    assert ok.shadow == (1.0, 2.0, "#000")
+    multi = _box({"box-shadow": "1px 2px #000, 3px 4px #111"})
+    assert multi.shadow is None
+    assert any("multiple" in u for u in multi.unrepresentable)
+
+
+# -- emitters -----------------------------------------------------------------
+
+
+def test_svg_emitter_shape_and_attribute_uniqueness() -> None:
+    svg = _svg._slot_box_svg(
+        _box(
+            {
+                "background": "#0f172a",
+                "border-color": "#334155",
+                "border-width": "2px",
+                "border-radius": "6px",
+                "box-shadow": "2px 2px rgba(0, 0, 0, 0.22)",
+                "opacity": 0.9,
+            }
+        )
+    )
+    import re
+
+    rects = svg.split("<rect")[1:]
+    assert len(rects) == 2  # shadow under the frame
+    for rect in rects:
+        names = re.findall(r'([\w-]+)="', rect)
+        # every attribute exactly once per rect — the duplicate-attr trap:
+        # the XML parser keeps the first value and drops the author's.
+        assert len(names) == len(set(names)), rect
+    shadow, frame = rects
+    assert 'fill="rgba(0, 0, 0, 0.22)"' in shadow and "stroke" not in shadow
+    for attr in ("stroke=", "stroke-width=", "rx=", "opacity="):
+        assert attr in frame, (attr, frame)
+
+
+def test_svg_emitter_is_silent_for_a_paintless_box() -> None:
+    assert _svg._slot_box_svg(_box({})) == ""
+    assert _svg._slot_box_svg(_box({"background": "transparent"})) == ""
+
+
+def test_emitted_rects_stay_inside_the_pdf_closed_subset() -> None:
+    svg = _svg._slot_box_svg(
+        _box(
+            {
+                "background": "rgba(15, 23, 42, 0.9)",
+                "border-color": "#334155",
+                "border-width": "1px",
+                "border-style": "dashed",
+                "border-radius": "4px",
+            }
+        )
+    )
+    pdf = svg_to_pdf(
+        f'<svg xmlns="http://www.w3.org/2000/svg" width="200" height="100">{svg}</svg>'
+    )
+    assert pdf[:4] == b"%PDF"
+
+
+def test_raster_emitter_mirrors_the_svg_decisions() -> None:
+    cmd = _raster._Cmd(1.0)
+    _raster._emit_slot_box(
+        cmd,
+        _box(
+            {
+                "background": "#0f172a",
+                "border-color": "#334155",
+                "border-width": "2px",
+                "border-radius": "6px",
+                "box-shadow": "2px 2px rgba(0, 0, 0, 0.22)",
+            }
+        ),
+    )
+    painted = bytes(cmd.buf)
+    assert painted  # shadow fill + background fill + border stroke landed
+    empty = _raster._Cmd(1.0)
+    _raster._emit_slot_box(empty, _box({}))
+    assert bytes(empty.buf) == b""  # the unstyled-bytes gate, at the primitive
+
+
+def test_direct_chromebox_construction_defaults_paint_nothing() -> None:
+    box = ChromeBox(slot="title", x=0, y=0, w=10, h=10)
+    assert not box.paints_anything
+    assert _svg._slot_box_svg(box) == ""

From 2be0b187f1a6f6fb182e368e47a34efa468dfa83 Mon Sep 17 00:00:00 2001
From: Alek Petuskey <alek@reflex.dev>
Date: Tue, 4 Aug 2026 15:58:30 -0700
Subject: [PATCH 14/27] Ship the Tailwind-core manifest: utilities export
 natively, palette vendored
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

tailwind_profile="core-v1" prepends one generated stylesheet to the native
cascade, so chart.to_png(style_source="native_cascade",
tailwind_profile="core-v1") resolves bg-/text-/border- across the full
default palette plus the spacing, type, weight, radius, border-width and
tracking scales — with no Tailwind engine anywhere. The palette is vendored
from tailwindcss@3.4.17 (scripts/tailwind_palette_v3.json carries the
provenance) because a hand-typed hex that is slightly wrong is the worst
silent failure this program exists to end; scale values are the published
rem/em/px spellings, resolved through the cascade's own font-size chain so
tracking-wide on a text-sm label is 0.35px of ITS 14px, not of a guess.

The manifest is generated (scripts/gen_tailwind_core.py, --check pinned in
tests) and emitted as ruff-stable double-quoted literals — a generated file
the formatter rewrites is permanently stale to its own drift gate. The
cascade normalizes the background-color longhand onto the schema's
`background` exactly as the browser capture does, and the resolver's px
formatter now rounds the binary-float tail (0.025em × 14px is 0.35px).
Project Tailwind builds ride stylesheets=; profile inputs without the
cascade source are refused; unknown profiles name what this build ships.
Everything outside the manifest stays a reported unknown, never a guess.
---
 CHANGELOG.md                        |   8 ++
 cascade/src/resolve.rs              |  10 +-
 python/xy/_figure.py                |  18 ++-
 python/xy/components.py             |  16 +++
 python/xy/export.py                 |  35 ++++-
 python/xy/styling/_tailwind_core.py |  14 ++
 python/xy/styling/cascade.py        |  21 ++-
 scripts/gen_tailwind_core.py        | 203 ++++++++++++++++++++++++++++
 scripts/tailwind_palette_v3.json    |   1 +
 tests/test_components.py            |   6 +
 tests/test_tailwind_manifest.py     | 119 ++++++++++++++++
 11 files changed, 443 insertions(+), 8 deletions(-)
 create mode 100644 python/xy/styling/_tailwind_core.py
 create mode 100644 scripts/gen_tailwind_core.py
 create mode 100644 scripts/tailwind_palette_v3.json
 create mode 100644 tests/test_tailwind_manifest.py

diff --git a/CHANGELOG.md b/CHANGELOG.md
index fac85aa0e..6f9b63966 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,6 +9,14 @@ in the README).
 ## [Unreleased]
 
 ### Added
+- The versioned Tailwind-core manifest (`tailwind_profile="core-v1"`):
+  `chart.to_png(style_source="native_cascade", tailwind_profile="core-v1")`
+  resolves the core utilities natively — the full default color palette
+  (vendored from tailwindcss@3.4.17 with provenance, never hand-typed
+  hexes), the spacing/type/weight/radius/border/tracking scales in their
+  published rem/em/px values, resolved through the cascade's own font-size
+  chain. Project Tailwind builds ride `stylesheets=`; unmatched utilities
+  are reported, never guessed.
 - The mount-free native cascade (optional `xy-cascade` extension, ~3.8 MB
   cdylib built from the same workspace): `chart.to_png(custom_css=css,
   style_source="native_cascade")` resolves classes and self-contained author
diff --git a/cascade/src/resolve.rs b/cascade/src/resolve.rs
index 32c18430d..a16e265cd 100644
--- a/cascade/src/resolve.rs
+++ b/cascade/src/resolve.rs
@@ -510,10 +510,14 @@ fn substituted(value: &str, custom: &BTreeMap<String, String>) -> Result<String,
 }
 
 fn fmt_px(px: f64) -> String {
-    if (px - px.round()).abs() < 1e-9 {
-        format!("{}px", px.round() as i64)
+    // Round to 1/10000 px and trim zeros: 0.025em * 14px is 0.35px, not the
+    // binary-float tail — computed values compare stringly downstream.
+    let rounded = (px * 10000.0).round() / 10000.0;
+    if (rounded - rounded.round()).abs() < 1e-9 {
+        format!("{}px", rounded.round() as i64)
     } else {
-        format!("{px}px")
+        let text = format!("{rounded:.4}");
+        format!("{}px", text.trim_end_matches('0').trim_end_matches('.'))
     }
 }
 
diff --git a/python/xy/_figure.py b/python/xy/_figure.py
index b14153a92..9751ee308 100644
--- a/python/xy/_figure.py
+++ b/python/xy/_figure.py
@@ -2247,6 +2247,8 @@ def to_svg(
         compatibility: str = "legacy",
         style_snapshot: Optional[Any] = None,
         style_source: str = "declared",
+        stylesheets: tuple[str, ...] = (),
+        tailwind_profile: Optional[str] = None,
     ) -> str:
         """Static SVG (_svg.py): a pure-Python render of the same decimated
         payload the browser client consumes — resolution-independent, tiny
@@ -2269,7 +2271,9 @@ def to_svg(
             # Classes-only here: to_svg carries no custom_css parameter, so
             # author stylesheets ride to_image("svg", custom_css=...,
             # style_source="native_cascade") instead.
-            style_snapshot = export._cascade_snapshot(self, None, compatibility)
+            style_snapshot = export._cascade_snapshot(
+                self, None, compatibility, tuple(stylesheets), tailwind_profile
+            )
         if style_snapshot is not None:
             snapshot = export._coerce_style_snapshot(style_snapshot)
             with export._snapshot_styles(self, snapshot):
@@ -2292,6 +2296,8 @@ def to_png(
         compatibility: str = "legacy",
         style_snapshot: Optional[Any] = None,
         style_source: str = "declared",
+        stylesheets: tuple[str, ...] = (),
+        tailwind_profile: Optional[str] = None,
     ) -> bytes:
         """Static PNG (export.py). `engine=Engine.default` paints the
         decimated payload with the built-in Rust rasterizer — no browser,
@@ -2316,6 +2322,8 @@ def to_png(
             compatibility=compatibility,
             style_snapshot=style_snapshot,
             style_source=style_source,
+            stylesheets=stylesheets,
+            tailwind_profile=tailwind_profile,
         )
 
     def to_image(
@@ -2335,6 +2343,8 @@ def to_image(
         compatibility: str = "legacy",
         style_snapshot: Optional[Any] = None,
         style_source: str = "declared",
+        stylesheets: tuple[str, ...] = (),
+        tailwind_profile: Optional[str] = None,
     ) -> bytes:
         """Unified static export: PNG/JPEG/WebP/SVG/PDF bytes (export.py).
 
@@ -2359,6 +2369,8 @@ def to_image(
             compatibility=compatibility,
             style_snapshot=style_snapshot,
             style_source=style_source,
+            stylesheets=stylesheets,
+            tailwind_profile=tailwind_profile,
         )
 
     def write_image(
@@ -2379,6 +2391,8 @@ def write_image(
         compatibility: str = "legacy",
         style_snapshot: Optional[Any] = None,
         style_source: str = "declared",
+        stylesheets: tuple[str, ...] = (),
+        tailwind_profile: Optional[str] = None,
     ) -> bytes:
         """Atomic file export with extension-inferred format (export.py):
         .png/.jpg/.jpeg/.webp/.svg/.pdf, plus .html routing to `to_html`."""
@@ -2399,6 +2413,8 @@ def write_image(
             compatibility=compatibility,
             style_snapshot=style_snapshot,
             style_source=style_source,
+            stylesheets=stylesheets,
+            tailwind_profile=tailwind_profile,
         )
 
     def memory_report(self) -> dict[str, Any]:
diff --git a/python/xy/components.py b/python/xy/components.py
index b4cb87f31..82dee2361 100644
--- a/python/xy/components.py
+++ b/python/xy/components.py
@@ -4213,6 +4213,8 @@ def to_svg(
         compatibility: str = "legacy",
         style_snapshot: Optional[Any] = None,
         style_source: str = "declared",
+        stylesheets: tuple[str, ...] = (),
+        tailwind_profile: Optional[str] = None,
     ) -> str:
         """A static SVG render of the chart (written to ``path`` if given).
 
@@ -4228,6 +4230,8 @@ def to_svg(
             compatibility=compatibility,
             style_snapshot=style_snapshot,
             style_source=style_source,
+            stylesheets=stylesheets,
+            tailwind_profile=tailwind_profile,
         )
 
     def to_png(
@@ -4245,6 +4249,8 @@ def to_png(
         compatibility: str = "legacy",
         style_snapshot: Optional[Any] = None,
         style_source: str = "declared",
+        stylesheets: tuple[str, ...] = (),
+        tailwind_profile: Optional[str] = None,
     ) -> bytes:
         """A PNG render of the chart, returned as bytes.
 
@@ -4266,6 +4272,8 @@ def to_png(
             compatibility=compatibility,
             style_snapshot=style_snapshot,
             style_source=style_source,
+            stylesheets=stylesheets,
+            tailwind_profile=tailwind_profile,
         )
 
     def _export_defaults(
@@ -4318,6 +4326,8 @@ def to_image(
         compatibility: str = "legacy",
         style_snapshot: Optional[Any] = None,
         style_source: str = "declared",
+        stylesheets: tuple[str, ...] = (),
+        tailwind_profile: Optional[str] = None,
     ) -> bytes:
         """Unified static export: PNG/JPEG/WebP/SVG/PDF bytes.
 
@@ -4340,6 +4350,8 @@ def to_image(
             compatibility=compatibility,
             style_snapshot=style_snapshot,
             style_source=style_source,
+            stylesheets=stylesheets,
+            tailwind_profile=tailwind_profile,
             **self._export_defaults(
                 fmt,
                 width,
@@ -4369,6 +4381,8 @@ def write_image(
         compatibility: str = "legacy",
         style_snapshot: Optional[Any] = None,
         style_source: str = "declared",
+        stylesheets: tuple[str, ...] = (),
+        tailwind_profile: Optional[str] = None,
     ) -> bytes:
         """Atomic file export with extension-inferred format (.png/.jpg/
         .jpeg/.webp/.svg/.pdf/.html). `export_config` defaults apply as in
@@ -4420,6 +4434,8 @@ def write_image(
             compatibility=compatibility,
             style_snapshot=style_snapshot,
             style_source=style_source,
+            stylesheets=stylesheets,
+            tailwind_profile=tailwind_profile,
             **defaults,
         )
 
diff --git a/python/xy/export.py b/python/xy/export.py
index 2126909a1..b1809b2e4 100644
--- a/python/xy/export.py
+++ b/python/xy/export.py
@@ -822,6 +822,8 @@ def to_png(
     compatibility: str = "legacy",
     style_snapshot: Optional[Any] = None,
     style_source: str = "declared",
+    stylesheets: tuple[str, ...] = (),
+    tailwind_profile: Optional[str] = None,
 ) -> bytes:
     """Rasterize `fig` to a PNG (bytes, optionally saved).
 
@@ -862,8 +864,15 @@ def to_png(
             raise ValueError(
                 "style_source='native_cascade' is a native path; drop engine=Engine.chromium"
             )
-        style_snapshot = _cascade_snapshot(fig, custom_css, compatibility)
+        style_snapshot = _cascade_snapshot(
+            fig, custom_css, compatibility, tuple(stylesheets), tailwind_profile
+        )
         custom_css = None  # consumed by the cascade, not by a browser
+    elif stylesheets or tailwind_profile is not None:
+        raise ValueError(
+            "stylesheets/tailwind_profile are native-cascade inputs; pass "
+            'style_source="native_cascade"'
+        )
     resolved_engine = _png_engine(engine)
     # Resolution errors precede and outrank mode logic (the migration spec's
     # contract): the custom_css/native refusal must stay a ValueError in
@@ -1010,6 +1019,8 @@ def _cascade_snapshot(
     fig: "Figure",
     custom_css: Optional[str],
     compatibility: str,
+    stylesheets: tuple[str, ...] = (),
+    tailwind_profile: Optional[str] = None,
 ) -> Any:
     """Resolve classes + author CSS through the native cascade for export.
 
@@ -1024,7 +1035,12 @@ def _cascade_snapshot(
     from .styling import cascade as _cascade
     from .styling.preflight import StyleCompatibilityError, StyleCompatibilityWarning
 
-    snapshot, unsupported = _cascade.resolve_for_figure(fig, custom_css=custom_css or "")
+    snapshot, unsupported = _cascade.resolve_for_figure(
+        fig,
+        custom_css=custom_css or "",
+        stylesheets=tuple(stylesheets),
+        tailwind_profile=tailwind_profile,
+    )
     if unsupported:
         summary = "; ".join(unsupported)
         if compatibility == "strict":
@@ -1311,6 +1327,8 @@ def to_image(
     compatibility: str = "legacy",
     style_snapshot: Optional[Any] = None,
     style_source: str = "declared",
+    stylesheets: tuple[str, ...] = (),
+    tailwind_profile: Optional[str] = None,
 ) -> bytes:
     """Render `fig` to image bytes in the requested `format`.
 
@@ -1340,8 +1358,15 @@ def to_image(
             raise ValueError(
                 "style_source='native_cascade' is a native path; drop engine=Engine.chromium"
             )
-        style_snapshot = _cascade_snapshot(fig, custom_css, compatibility)
+        style_snapshot = _cascade_snapshot(
+            fig, custom_css, compatibility, tuple(stylesheets), tailwind_profile
+        )
         custom_css = None  # consumed by the cascade, not by a browser
+    elif stylesheets or tailwind_profile is not None:
+        raise ValueError(
+            "stylesheets/tailwind_profile are native-cascade inputs; pass "
+            'style_source="native_cascade"'
+        )
     resolved_engine = _resolve_image_engine(engine, fmt, custom_css)
     snapshot = _coerce_style_snapshot(style_snapshot) if style_snapshot is not None else None
     if snapshot is not None and resolved_engine == "browser":
@@ -1405,6 +1430,8 @@ def write_image(
     compatibility: str = "legacy",
     style_snapshot: Optional[Any] = None,
     style_source: str = "declared",
+    stylesheets: tuple[str, ...] = (),
+    tailwind_profile: Optional[str] = None,
 ) -> bytes:
     """Export `fig` to `path`, inferring the format from the extension.
 
@@ -1457,6 +1484,8 @@ def write_image(
         compatibility=compatibility,
         style_snapshot=style_snapshot,
         style_source=style_source,
+        stylesheets=stylesheets,
+        tailwind_profile=tailwind_profile,
     )
     _atomic_write_bytes(path, data)
     return data
diff --git a/python/xy/styling/_tailwind_core.py b/python/xy/styling/_tailwind_core.py
new file mode 100644
index 000000000..bd408f95f
--- /dev/null
+++ b/python/xy/styling/_tailwind_core.py
@@ -0,0 +1,14 @@
+"""The Tailwind-core manifest, as one generated stylesheet.
+
+@generated by scripts/gen_tailwind_core.py — do not edit by hand.
+Palette provenance: tailwindcss@3.4.17 require("tailwindcss/colors").
+The native cascade prepends this sheet when an export names
+`tailwind_profile="core-v1"`; unmatched utilities are reported by
+the cascade, never guessed (§28).
+"""
+
+from __future__ import annotations
+
+TAILWIND_CORE_VERSION = "core-v1"
+
+TAILWIND_CORE_CSS = ".bg-amber-100{background-color:#fef3c7}\n.text-amber-100{color:#fef3c7}\n.border-amber-100{border-color:#fef3c7}\n.bg-amber-200{background-color:#fde68a}\n.text-amber-200{color:#fde68a}\n.border-amber-200{border-color:#fde68a}\n.bg-amber-300{background-color:#fcd34d}\n.text-amber-300{color:#fcd34d}\n.border-amber-300{border-color:#fcd34d}\n.bg-amber-400{background-color:#fbbf24}\n.text-amber-400{color:#fbbf24}\n.border-amber-400{border-color:#fbbf24}\n.bg-amber-50{background-color:#fffbeb}\n.text-amber-50{color:#fffbeb}\n.border-amber-50{border-color:#fffbeb}\n.bg-amber-500{background-color:#f59e0b}\n.text-amber-500{color:#f59e0b}\n.border-amber-500{border-color:#f59e0b}\n.bg-amber-600{background-color:#d97706}\n.text-amber-600{color:#d97706}\n.border-amber-600{border-color:#d97706}\n.bg-amber-700{background-color:#b45309}\n.text-amber-700{color:#b45309}\n.border-amber-700{border-color:#b45309}\n.bg-amber-800{background-color:#92400e}\n.text-amber-800{color:#92400e}\n.border-amber-800{border-color:#92400e}\n.bg-amber-900{background-color:#78350f}\n.text-amber-900{color:#78350f}\n.border-amber-900{border-color:#78350f}\n.bg-amber-950{background-color:#451a03}\n.text-amber-950{color:#451a03}\n.border-amber-950{border-color:#451a03}\n.bg-black{background-color:#000}\n.text-black{color:#000}\n.border-black{border-color:#000}\n.bg-blue-100{background-color:#dbeafe}\n.text-blue-100{color:#dbeafe}\n.border-blue-100{border-color:#dbeafe}\n.bg-blue-200{background-color:#bfdbfe}\n.text-blue-200{color:#bfdbfe}\n.border-blue-200{border-color:#bfdbfe}\n.bg-blue-300{background-color:#93c5fd}\n.text-blue-300{color:#93c5fd}\n.border-blue-300{border-color:#93c5fd}\n.bg-blue-400{background-color:#60a5fa}\n.text-blue-400{color:#60a5fa}\n.border-blue-400{border-color:#60a5fa}\n.bg-blue-50{background-color:#eff6ff}\n.text-blue-50{color:#eff6ff}\n.border-blue-50{border-color:#eff6ff}\n.bg-blue-500{background-color:#3b82f6}\n.text-blue-500{color:#3b82f6}\n.border-blue-500{border-color:#3b82f6}\n.bg-blue-600{background-color:#2563eb}\n.text-blue-600{color:#2563eb}\n.border-blue-600{border-color:#2563eb}\n.bg-blue-700{background-color:#1d4ed8}\n.text-blue-700{color:#1d4ed8}\n.border-blue-700{border-color:#1d4ed8}\n.bg-blue-800{background-color:#1e40af}\n.text-blue-800{color:#1e40af}\n.border-blue-800{border-color:#1e40af}\n.bg-blue-900{background-color:#1e3a8a}\n.text-blue-900{color:#1e3a8a}\n.border-blue-900{border-color:#1e3a8a}\n.bg-blue-950{background-color:#172554}\n.text-blue-950{color:#172554}\n.border-blue-950{border-color:#172554}\n.bg-cyan-100{background-color:#cffafe}\n.text-cyan-100{color:#cffafe}\n.border-cyan-100{border-color:#cffafe}\n.bg-cyan-200{background-color:#a5f3fc}\n.text-cyan-200{color:#a5f3fc}\n.border-cyan-200{border-color:#a5f3fc}\n.bg-cyan-300{background-color:#67e8f9}\n.text-cyan-300{color:#67e8f9}\n.border-cyan-300{border-color:#67e8f9}\n.bg-cyan-400{background-color:#22d3ee}\n.text-cyan-400{color:#22d3ee}\n.border-cyan-400{border-color:#22d3ee}\n.bg-cyan-50{background-color:#ecfeff}\n.text-cyan-50{color:#ecfeff}\n.border-cyan-50{border-color:#ecfeff}\n.bg-cyan-500{background-color:#06b6d4}\n.text-cyan-500{color:#06b6d4}\n.border-cyan-500{border-color:#06b6d4}\n.bg-cyan-600{background-color:#0891b2}\n.text-cyan-600{color:#0891b2}\n.border-cyan-600{border-color:#0891b2}\n.bg-cyan-700{background-color:#0e7490}\n.text-cyan-700{color:#0e7490}\n.border-cyan-700{border-color:#0e7490}\n.bg-cyan-800{background-color:#155e75}\n.text-cyan-800{color:#155e75}\n.border-cyan-800{border-color:#155e75}\n.bg-cyan-900{background-color:#164e63}\n.text-cyan-900{color:#164e63}\n.border-cyan-900{border-color:#164e63}\n.bg-cyan-950{background-color:#083344}\n.text-cyan-950{color:#083344}\n.border-cyan-950{border-color:#083344}\n.bg-emerald-100{background-color:#d1fae5}\n.text-emerald-100{color:#d1fae5}\n.border-emerald-100{border-color:#d1fae5}\n.bg-emerald-200{background-color:#a7f3d0}\n.text-emerald-200{color:#a7f3d0}\n.border-emerald-200{border-color:#a7f3d0}\n.bg-emerald-300{background-color:#6ee7b7}\n.text-emerald-300{color:#6ee7b7}\n.border-emerald-300{border-color:#6ee7b7}\n.bg-emerald-400{background-color:#34d399}\n.text-emerald-400{color:#34d399}\n.border-emerald-400{border-color:#34d399}\n.bg-emerald-50{background-color:#ecfdf5}\n.text-emerald-50{color:#ecfdf5}\n.border-emerald-50{border-color:#ecfdf5}\n.bg-emerald-500{background-color:#10b981}\n.text-emerald-500{color:#10b981}\n.border-emerald-500{border-color:#10b981}\n.bg-emerald-600{background-color:#059669}\n.text-emerald-600{color:#059669}\n.border-emerald-600{border-color:#059669}\n.bg-emerald-700{background-color:#047857}\n.text-emerald-700{color:#047857}\n.border-emerald-700{border-color:#047857}\n.bg-emerald-800{background-color:#065f46}\n.text-emerald-800{color:#065f46}\n.border-emerald-800{border-color:#065f46}\n.bg-emerald-900{background-color:#064e3b}\n.text-emerald-900{color:#064e3b}\n.border-emerald-900{border-color:#064e3b}\n.bg-emerald-950{background-color:#022c22}\n.text-emerald-950{color:#022c22}\n.border-emerald-950{border-color:#022c22}\n.bg-fuchsia-100{background-color:#fae8ff}\n.text-fuchsia-100{color:#fae8ff}\n.border-fuchsia-100{border-color:#fae8ff}\n.bg-fuchsia-200{background-color:#f5d0fe}\n.text-fuchsia-200{color:#f5d0fe}\n.border-fuchsia-200{border-color:#f5d0fe}\n.bg-fuchsia-300{background-color:#f0abfc}\n.text-fuchsia-300{color:#f0abfc}\n.border-fuchsia-300{border-color:#f0abfc}\n.bg-fuchsia-400{background-color:#e879f9}\n.text-fuchsia-400{color:#e879f9}\n.border-fuchsia-400{border-color:#e879f9}\n.bg-fuchsia-50{background-color:#fdf4ff}\n.text-fuchsia-50{color:#fdf4ff}\n.border-fuchsia-50{border-color:#fdf4ff}\n.bg-fuchsia-500{background-color:#d946ef}\n.text-fuchsia-500{color:#d946ef}\n.border-fuchsia-500{border-color:#d946ef}\n.bg-fuchsia-600{background-color:#c026d3}\n.text-fuchsia-600{color:#c026d3}\n.border-fuchsia-600{border-color:#c026d3}\n.bg-fuchsia-700{background-color:#a21caf}\n.text-fuchsia-700{color:#a21caf}\n.border-fuchsia-700{border-color:#a21caf}\n.bg-fuchsia-800{background-color:#86198f}\n.text-fuchsia-800{color:#86198f}\n.border-fuchsia-800{border-color:#86198f}\n.bg-fuchsia-900{background-color:#701a75}\n.text-fuchsia-900{color:#701a75}\n.border-fuchsia-900{border-color:#701a75}\n.bg-fuchsia-950{background-color:#4a044e}\n.text-fuchsia-950{color:#4a044e}\n.border-fuchsia-950{border-color:#4a044e}\n.bg-gray-100{background-color:#f3f4f6}\n.text-gray-100{color:#f3f4f6}\n.border-gray-100{border-color:#f3f4f6}\n.bg-gray-200{background-color:#e5e7eb}\n.text-gray-200{color:#e5e7eb}\n.border-gray-200{border-color:#e5e7eb}\n.bg-gray-300{background-color:#d1d5db}\n.text-gray-300{color:#d1d5db}\n.border-gray-300{border-color:#d1d5db}\n.bg-gray-400{background-color:#9ca3af}\n.text-gray-400{color:#9ca3af}\n.border-gray-400{border-color:#9ca3af}\n.bg-gray-50{background-color:#f9fafb}\n.text-gray-50{color:#f9fafb}\n.border-gray-50{border-color:#f9fafb}\n.bg-gray-500{background-color:#6b7280}\n.text-gray-500{color:#6b7280}\n.border-gray-500{border-color:#6b7280}\n.bg-gray-600{background-color:#4b5563}\n.text-gray-600{color:#4b5563}\n.border-gray-600{border-color:#4b5563}\n.bg-gray-700{background-color:#374151}\n.text-gray-700{color:#374151}\n.border-gray-700{border-color:#374151}\n.bg-gray-800{background-color:#1f2937}\n.text-gray-800{color:#1f2937}\n.border-gray-800{border-color:#1f2937}\n.bg-gray-900{background-color:#111827}\n.text-gray-900{color:#111827}\n.border-gray-900{border-color:#111827}\n.bg-gray-950{background-color:#030712}\n.text-gray-950{color:#030712}\n.border-gray-950{border-color:#030712}\n.bg-green-100{background-color:#dcfce7}\n.text-green-100{color:#dcfce7}\n.border-green-100{border-color:#dcfce7}\n.bg-green-200{background-color:#bbf7d0}\n.text-green-200{color:#bbf7d0}\n.border-green-200{border-color:#bbf7d0}\n.bg-green-300{background-color:#86efac}\n.text-green-300{color:#86efac}\n.border-green-300{border-color:#86efac}\n.bg-green-400{background-color:#4ade80}\n.text-green-400{color:#4ade80}\n.border-green-400{border-color:#4ade80}\n.bg-green-50{background-color:#f0fdf4}\n.text-green-50{color:#f0fdf4}\n.border-green-50{border-color:#f0fdf4}\n.bg-green-500{background-color:#22c55e}\n.text-green-500{color:#22c55e}\n.border-green-500{border-color:#22c55e}\n.bg-green-600{background-color:#16a34a}\n.text-green-600{color:#16a34a}\n.border-green-600{border-color:#16a34a}\n.bg-green-700{background-color:#15803d}\n.text-green-700{color:#15803d}\n.border-green-700{border-color:#15803d}\n.bg-green-800{background-color:#166534}\n.text-green-800{color:#166534}\n.border-green-800{border-color:#166534}\n.bg-green-900{background-color:#14532d}\n.text-green-900{color:#14532d}\n.border-green-900{border-color:#14532d}\n.bg-green-950{background-color:#052e16}\n.text-green-950{color:#052e16}\n.border-green-950{border-color:#052e16}\n.bg-indigo-100{background-color:#e0e7ff}\n.text-indigo-100{color:#e0e7ff}\n.border-indigo-100{border-color:#e0e7ff}\n.bg-indigo-200{background-color:#c7d2fe}\n.text-indigo-200{color:#c7d2fe}\n.border-indigo-200{border-color:#c7d2fe}\n.bg-indigo-300{background-color:#a5b4fc}\n.text-indigo-300{color:#a5b4fc}\n.border-indigo-300{border-color:#a5b4fc}\n.bg-indigo-400{background-color:#818cf8}\n.text-indigo-400{color:#818cf8}\n.border-indigo-400{border-color:#818cf8}\n.bg-indigo-50{background-color:#eef2ff}\n.text-indigo-50{color:#eef2ff}\n.border-indigo-50{border-color:#eef2ff}\n.bg-indigo-500{background-color:#6366f1}\n.text-indigo-500{color:#6366f1}\n.border-indigo-500{border-color:#6366f1}\n.bg-indigo-600{background-color:#4f46e5}\n.text-indigo-600{color:#4f46e5}\n.border-indigo-600{border-color:#4f46e5}\n.bg-indigo-700{background-color:#4338ca}\n.text-indigo-700{color:#4338ca}\n.border-indigo-700{border-color:#4338ca}\n.bg-indigo-800{background-color:#3730a3}\n.text-indigo-800{color:#3730a3}\n.border-indigo-800{border-color:#3730a3}\n.bg-indigo-900{background-color:#312e81}\n.text-indigo-900{color:#312e81}\n.border-indigo-900{border-color:#312e81}\n.bg-indigo-950{background-color:#1e1b4b}\n.text-indigo-950{color:#1e1b4b}\n.border-indigo-950{border-color:#1e1b4b}\n.bg-lime-100{background-color:#ecfccb}\n.text-lime-100{color:#ecfccb}\n.border-lime-100{border-color:#ecfccb}\n.bg-lime-200{background-color:#d9f99d}\n.text-lime-200{color:#d9f99d}\n.border-lime-200{border-color:#d9f99d}\n.bg-lime-300{background-color:#bef264}\n.text-lime-300{color:#bef264}\n.border-lime-300{border-color:#bef264}\n.bg-lime-400{background-color:#a3e635}\n.text-lime-400{color:#a3e635}\n.border-lime-400{border-color:#a3e635}\n.bg-lime-50{background-color:#f7fee7}\n.text-lime-50{color:#f7fee7}\n.border-lime-50{border-color:#f7fee7}\n.bg-lime-500{background-color:#84cc16}\n.text-lime-500{color:#84cc16}\n.border-lime-500{border-color:#84cc16}\n.bg-lime-600{background-color:#65a30d}\n.text-lime-600{color:#65a30d}\n.border-lime-600{border-color:#65a30d}\n.bg-lime-700{background-color:#4d7c0f}\n.text-lime-700{color:#4d7c0f}\n.border-lime-700{border-color:#4d7c0f}\n.bg-lime-800{background-color:#3f6212}\n.text-lime-800{color:#3f6212}\n.border-lime-800{border-color:#3f6212}\n.bg-lime-900{background-color:#365314}\n.text-lime-900{color:#365314}\n.border-lime-900{border-color:#365314}\n.bg-lime-950{background-color:#1a2e05}\n.text-lime-950{color:#1a2e05}\n.border-lime-950{border-color:#1a2e05}\n.bg-neutral-100{background-color:#f5f5f5}\n.text-neutral-100{color:#f5f5f5}\n.border-neutral-100{border-color:#f5f5f5}\n.bg-neutral-200{background-color:#e5e5e5}\n.text-neutral-200{color:#e5e5e5}\n.border-neutral-200{border-color:#e5e5e5}\n.bg-neutral-300{background-color:#d4d4d4}\n.text-neutral-300{color:#d4d4d4}\n.border-neutral-300{border-color:#d4d4d4}\n.bg-neutral-400{background-color:#a3a3a3}\n.text-neutral-400{color:#a3a3a3}\n.border-neutral-400{border-color:#a3a3a3}\n.bg-neutral-50{background-color:#fafafa}\n.text-neutral-50{color:#fafafa}\n.border-neutral-50{border-color:#fafafa}\n.bg-neutral-500{background-color:#737373}\n.text-neutral-500{color:#737373}\n.border-neutral-500{border-color:#737373}\n.bg-neutral-600{background-color:#525252}\n.text-neutral-600{color:#525252}\n.border-neutral-600{border-color:#525252}\n.bg-neutral-700{background-color:#404040}\n.text-neutral-700{color:#404040}\n.border-neutral-700{border-color:#404040}\n.bg-neutral-800{background-color:#262626}\n.text-neutral-800{color:#262626}\n.border-neutral-800{border-color:#262626}\n.bg-neutral-900{background-color:#171717}\n.text-neutral-900{color:#171717}\n.border-neutral-900{border-color:#171717}\n.bg-neutral-950{background-color:#0a0a0a}\n.text-neutral-950{color:#0a0a0a}\n.border-neutral-950{border-color:#0a0a0a}\n.bg-orange-100{background-color:#ffedd5}\n.text-orange-100{color:#ffedd5}\n.border-orange-100{border-color:#ffedd5}\n.bg-orange-200{background-color:#fed7aa}\n.text-orange-200{color:#fed7aa}\n.border-orange-200{border-color:#fed7aa}\n.bg-orange-300{background-color:#fdba74}\n.text-orange-300{color:#fdba74}\n.border-orange-300{border-color:#fdba74}\n.bg-orange-400{background-color:#fb923c}\n.text-orange-400{color:#fb923c}\n.border-orange-400{border-color:#fb923c}\n.bg-orange-50{background-color:#fff7ed}\n.text-orange-50{color:#fff7ed}\n.border-orange-50{border-color:#fff7ed}\n.bg-orange-500{background-color:#f97316}\n.text-orange-500{color:#f97316}\n.border-orange-500{border-color:#f97316}\n.bg-orange-600{background-color:#ea580c}\n.text-orange-600{color:#ea580c}\n.border-orange-600{border-color:#ea580c}\n.bg-orange-700{background-color:#c2410c}\n.text-orange-700{color:#c2410c}\n.border-orange-700{border-color:#c2410c}\n.bg-orange-800{background-color:#9a3412}\n.text-orange-800{color:#9a3412}\n.border-orange-800{border-color:#9a3412}\n.bg-orange-900{background-color:#7c2d12}\n.text-orange-900{color:#7c2d12}\n.border-orange-900{border-color:#7c2d12}\n.bg-orange-950{background-color:#431407}\n.text-orange-950{color:#431407}\n.border-orange-950{border-color:#431407}\n.bg-pink-100{background-color:#fce7f3}\n.text-pink-100{color:#fce7f3}\n.border-pink-100{border-color:#fce7f3}\n.bg-pink-200{background-color:#fbcfe8}\n.text-pink-200{color:#fbcfe8}\n.border-pink-200{border-color:#fbcfe8}\n.bg-pink-300{background-color:#f9a8d4}\n.text-pink-300{color:#f9a8d4}\n.border-pink-300{border-color:#f9a8d4}\n.bg-pink-400{background-color:#f472b6}\n.text-pink-400{color:#f472b6}\n.border-pink-400{border-color:#f472b6}\n.bg-pink-50{background-color:#fdf2f8}\n.text-pink-50{color:#fdf2f8}\n.border-pink-50{border-color:#fdf2f8}\n.bg-pink-500{background-color:#ec4899}\n.text-pink-500{color:#ec4899}\n.border-pink-500{border-color:#ec4899}\n.bg-pink-600{background-color:#db2777}\n.text-pink-600{color:#db2777}\n.border-pink-600{border-color:#db2777}\n.bg-pink-700{background-color:#be185d}\n.text-pink-700{color:#be185d}\n.border-pink-700{border-color:#be185d}\n.bg-pink-800{background-color:#9d174d}\n.text-pink-800{color:#9d174d}\n.border-pink-800{border-color:#9d174d}\n.bg-pink-900{background-color:#831843}\n.text-pink-900{color:#831843}\n.border-pink-900{border-color:#831843}\n.bg-pink-950{background-color:#500724}\n.text-pink-950{color:#500724}\n.border-pink-950{border-color:#500724}\n.bg-purple-100{background-color:#f3e8ff}\n.text-purple-100{color:#f3e8ff}\n.border-purple-100{border-color:#f3e8ff}\n.bg-purple-200{background-color:#e9d5ff}\n.text-purple-200{color:#e9d5ff}\n.border-purple-200{border-color:#e9d5ff}\n.bg-purple-300{background-color:#d8b4fe}\n.text-purple-300{color:#d8b4fe}\n.border-purple-300{border-color:#d8b4fe}\n.bg-purple-400{background-color:#c084fc}\n.text-purple-400{color:#c084fc}\n.border-purple-400{border-color:#c084fc}\n.bg-purple-50{background-color:#faf5ff}\n.text-purple-50{color:#faf5ff}\n.border-purple-50{border-color:#faf5ff}\n.bg-purple-500{background-color:#a855f7}\n.text-purple-500{color:#a855f7}\n.border-purple-500{border-color:#a855f7}\n.bg-purple-600{background-color:#9333ea}\n.text-purple-600{color:#9333ea}\n.border-purple-600{border-color:#9333ea}\n.bg-purple-700{background-color:#7e22ce}\n.text-purple-700{color:#7e22ce}\n.border-purple-700{border-color:#7e22ce}\n.bg-purple-800{background-color:#6b21a8}\n.text-purple-800{color:#6b21a8}\n.border-purple-800{border-color:#6b21a8}\n.bg-purple-900{background-color:#581c87}\n.text-purple-900{color:#581c87}\n.border-purple-900{border-color:#581c87}\n.bg-purple-950{background-color:#3b0764}\n.text-purple-950{color:#3b0764}\n.border-purple-950{border-color:#3b0764}\n.bg-red-100{background-color:#fee2e2}\n.text-red-100{color:#fee2e2}\n.border-red-100{border-color:#fee2e2}\n.bg-red-200{background-color:#fecaca}\n.text-red-200{color:#fecaca}\n.border-red-200{border-color:#fecaca}\n.bg-red-300{background-color:#fca5a5}\n.text-red-300{color:#fca5a5}\n.border-red-300{border-color:#fca5a5}\n.bg-red-400{background-color:#f87171}\n.text-red-400{color:#f87171}\n.border-red-400{border-color:#f87171}\n.bg-red-50{background-color:#fef2f2}\n.text-red-50{color:#fef2f2}\n.border-red-50{border-color:#fef2f2}\n.bg-red-500{background-color:#ef4444}\n.text-red-500{color:#ef4444}\n.border-red-500{border-color:#ef4444}\n.bg-red-600{background-color:#dc2626}\n.text-red-600{color:#dc2626}\n.border-red-600{border-color:#dc2626}\n.bg-red-700{background-color:#b91c1c}\n.text-red-700{color:#b91c1c}\n.border-red-700{border-color:#b91c1c}\n.bg-red-800{background-color:#991b1b}\n.text-red-800{color:#991b1b}\n.border-red-800{border-color:#991b1b}\n.bg-red-900{background-color:#7f1d1d}\n.text-red-900{color:#7f1d1d}\n.border-red-900{border-color:#7f1d1d}\n.bg-red-950{background-color:#450a0a}\n.text-red-950{color:#450a0a}\n.border-red-950{border-color:#450a0a}\n.bg-rose-100{background-color:#ffe4e6}\n.text-rose-100{color:#ffe4e6}\n.border-rose-100{border-color:#ffe4e6}\n.bg-rose-200{background-color:#fecdd3}\n.text-rose-200{color:#fecdd3}\n.border-rose-200{border-color:#fecdd3}\n.bg-rose-300{background-color:#fda4af}\n.text-rose-300{color:#fda4af}\n.border-rose-300{border-color:#fda4af}\n.bg-rose-400{background-color:#fb7185}\n.text-rose-400{color:#fb7185}\n.border-rose-400{border-color:#fb7185}\n.bg-rose-50{background-color:#fff1f2}\n.text-rose-50{color:#fff1f2}\n.border-rose-50{border-color:#fff1f2}\n.bg-rose-500{background-color:#f43f5e}\n.text-rose-500{color:#f43f5e}\n.border-rose-500{border-color:#f43f5e}\n.bg-rose-600{background-color:#e11d48}\n.text-rose-600{color:#e11d48}\n.border-rose-600{border-color:#e11d48}\n.bg-rose-700{background-color:#be123c}\n.text-rose-700{color:#be123c}\n.border-rose-700{border-color:#be123c}\n.bg-rose-800{background-color:#9f1239}\n.text-rose-800{color:#9f1239}\n.border-rose-800{border-color:#9f1239}\n.bg-rose-900{background-color:#881337}\n.text-rose-900{color:#881337}\n.border-rose-900{border-color:#881337}\n.bg-rose-950{background-color:#4c0519}\n.text-rose-950{color:#4c0519}\n.border-rose-950{border-color:#4c0519}\n.bg-sky-100{background-color:#e0f2fe}\n.text-sky-100{color:#e0f2fe}\n.border-sky-100{border-color:#e0f2fe}\n.bg-sky-200{background-color:#bae6fd}\n.text-sky-200{color:#bae6fd}\n.border-sky-200{border-color:#bae6fd}\n.bg-sky-300{background-color:#7dd3fc}\n.text-sky-300{color:#7dd3fc}\n.border-sky-300{border-color:#7dd3fc}\n.bg-sky-400{background-color:#38bdf8}\n.text-sky-400{color:#38bdf8}\n.border-sky-400{border-color:#38bdf8}\n.bg-sky-50{background-color:#f0f9ff}\n.text-sky-50{color:#f0f9ff}\n.border-sky-50{border-color:#f0f9ff}\n.bg-sky-500{background-color:#0ea5e9}\n.text-sky-500{color:#0ea5e9}\n.border-sky-500{border-color:#0ea5e9}\n.bg-sky-600{background-color:#0284c7}\n.text-sky-600{color:#0284c7}\n.border-sky-600{border-color:#0284c7}\n.bg-sky-700{background-color:#0369a1}\n.text-sky-700{color:#0369a1}\n.border-sky-700{border-color:#0369a1}\n.bg-sky-800{background-color:#075985}\n.text-sky-800{color:#075985}\n.border-sky-800{border-color:#075985}\n.bg-sky-900{background-color:#0c4a6e}\n.text-sky-900{color:#0c4a6e}\n.border-sky-900{border-color:#0c4a6e}\n.bg-sky-950{background-color:#082f49}\n.text-sky-950{color:#082f49}\n.border-sky-950{border-color:#082f49}\n.bg-slate-100{background-color:#f1f5f9}\n.text-slate-100{color:#f1f5f9}\n.border-slate-100{border-color:#f1f5f9}\n.bg-slate-200{background-color:#e2e8f0}\n.text-slate-200{color:#e2e8f0}\n.border-slate-200{border-color:#e2e8f0}\n.bg-slate-300{background-color:#cbd5e1}\n.text-slate-300{color:#cbd5e1}\n.border-slate-300{border-color:#cbd5e1}\n.bg-slate-400{background-color:#94a3b8}\n.text-slate-400{color:#94a3b8}\n.border-slate-400{border-color:#94a3b8}\n.bg-slate-50{background-color:#f8fafc}\n.text-slate-50{color:#f8fafc}\n.border-slate-50{border-color:#f8fafc}\n.bg-slate-500{background-color:#64748b}\n.text-slate-500{color:#64748b}\n.border-slate-500{border-color:#64748b}\n.bg-slate-600{background-color:#475569}\n.text-slate-600{color:#475569}\n.border-slate-600{border-color:#475569}\n.bg-slate-700{background-color:#334155}\n.text-slate-700{color:#334155}\n.border-slate-700{border-color:#334155}\n.bg-slate-800{background-color:#1e293b}\n.text-slate-800{color:#1e293b}\n.border-slate-800{border-color:#1e293b}\n.bg-slate-900{background-color:#0f172a}\n.text-slate-900{color:#0f172a}\n.border-slate-900{border-color:#0f172a}\n.bg-slate-950{background-color:#020617}\n.text-slate-950{color:#020617}\n.border-slate-950{border-color:#020617}\n.bg-stone-100{background-color:#f5f5f4}\n.text-stone-100{color:#f5f5f4}\n.border-stone-100{border-color:#f5f5f4}\n.bg-stone-200{background-color:#e7e5e4}\n.text-stone-200{color:#e7e5e4}\n.border-stone-200{border-color:#e7e5e4}\n.bg-stone-300{background-color:#d6d3d1}\n.text-stone-300{color:#d6d3d1}\n.border-stone-300{border-color:#d6d3d1}\n.bg-stone-400{background-color:#a8a29e}\n.text-stone-400{color:#a8a29e}\n.border-stone-400{border-color:#a8a29e}\n.bg-stone-50{background-color:#fafaf9}\n.text-stone-50{color:#fafaf9}\n.border-stone-50{border-color:#fafaf9}\n.bg-stone-500{background-color:#78716c}\n.text-stone-500{color:#78716c}\n.border-stone-500{border-color:#78716c}\n.bg-stone-600{background-color:#57534e}\n.text-stone-600{color:#57534e}\n.border-stone-600{border-color:#57534e}\n.bg-stone-700{background-color:#44403c}\n.text-stone-700{color:#44403c}\n.border-stone-700{border-color:#44403c}\n.bg-stone-800{background-color:#292524}\n.text-stone-800{color:#292524}\n.border-stone-800{border-color:#292524}\n.bg-stone-900{background-color:#1c1917}\n.text-stone-900{color:#1c1917}\n.border-stone-900{border-color:#1c1917}\n.bg-stone-950{background-color:#0c0a09}\n.text-stone-950{color:#0c0a09}\n.border-stone-950{border-color:#0c0a09}\n.bg-teal-100{background-color:#ccfbf1}\n.text-teal-100{color:#ccfbf1}\n.border-teal-100{border-color:#ccfbf1}\n.bg-teal-200{background-color:#99f6e4}\n.text-teal-200{color:#99f6e4}\n.border-teal-200{border-color:#99f6e4}\n.bg-teal-300{background-color:#5eead4}\n.text-teal-300{color:#5eead4}\n.border-teal-300{border-color:#5eead4}\n.bg-teal-400{background-color:#2dd4bf}\n.text-teal-400{color:#2dd4bf}\n.border-teal-400{border-color:#2dd4bf}\n.bg-teal-50{background-color:#f0fdfa}\n.text-teal-50{color:#f0fdfa}\n.border-teal-50{border-color:#f0fdfa}\n.bg-teal-500{background-color:#14b8a6}\n.text-teal-500{color:#14b8a6}\n.border-teal-500{border-color:#14b8a6}\n.bg-teal-600{background-color:#0d9488}\n.text-teal-600{color:#0d9488}\n.border-teal-600{border-color:#0d9488}\n.bg-teal-700{background-color:#0f766e}\n.text-teal-700{color:#0f766e}\n.border-teal-700{border-color:#0f766e}\n.bg-teal-800{background-color:#115e59}\n.text-teal-800{color:#115e59}\n.border-teal-800{border-color:#115e59}\n.bg-teal-900{background-color:#134e4a}\n.text-teal-900{color:#134e4a}\n.border-teal-900{border-color:#134e4a}\n.bg-teal-950{background-color:#042f2e}\n.text-teal-950{color:#042f2e}\n.border-teal-950{border-color:#042f2e}\n.bg-violet-100{background-color:#ede9fe}\n.text-violet-100{color:#ede9fe}\n.border-violet-100{border-color:#ede9fe}\n.bg-violet-200{background-color:#ddd6fe}\n.text-violet-200{color:#ddd6fe}\n.border-violet-200{border-color:#ddd6fe}\n.bg-violet-300{background-color:#c4b5fd}\n.text-violet-300{color:#c4b5fd}\n.border-violet-300{border-color:#c4b5fd}\n.bg-violet-400{background-color:#a78bfa}\n.text-violet-400{color:#a78bfa}\n.border-violet-400{border-color:#a78bfa}\n.bg-violet-50{background-color:#f5f3ff}\n.text-violet-50{color:#f5f3ff}\n.border-violet-50{border-color:#f5f3ff}\n.bg-violet-500{background-color:#8b5cf6}\n.text-violet-500{color:#8b5cf6}\n.border-violet-500{border-color:#8b5cf6}\n.bg-violet-600{background-color:#7c3aed}\n.text-violet-600{color:#7c3aed}\n.border-violet-600{border-color:#7c3aed}\n.bg-violet-700{background-color:#6d28d9}\n.text-violet-700{color:#6d28d9}\n.border-violet-700{border-color:#6d28d9}\n.bg-violet-800{background-color:#5b21b6}\n.text-violet-800{color:#5b21b6}\n.border-violet-800{border-color:#5b21b6}\n.bg-violet-900{background-color:#4c1d95}\n.text-violet-900{color:#4c1d95}\n.border-violet-900{border-color:#4c1d95}\n.bg-violet-950{background-color:#2e1065}\n.text-violet-950{color:#2e1065}\n.border-violet-950{border-color:#2e1065}\n.bg-white{background-color:#fff}\n.text-white{color:#fff}\n.border-white{border-color:#fff}\n.bg-yellow-100{background-color:#fef9c3}\n.text-yellow-100{color:#fef9c3}\n.border-yellow-100{border-color:#fef9c3}\n.bg-yellow-200{background-color:#fef08a}\n.text-yellow-200{color:#fef08a}\n.border-yellow-200{border-color:#fef08a}\n.bg-yellow-300{background-color:#fde047}\n.text-yellow-300{color:#fde047}\n.border-yellow-300{border-color:#fde047}\n.bg-yellow-400{background-color:#facc15}\n.text-yellow-400{color:#facc15}\n.border-yellow-400{border-color:#facc15}\n.bg-yellow-50{background-color:#fefce8}\n.text-yellow-50{color:#fefce8}\n.border-yellow-50{border-color:#fefce8}\n.bg-yellow-500{background-color:#eab308}\n.text-yellow-500{color:#eab308}\n.border-yellow-500{border-color:#eab308}\n.bg-yellow-600{background-color:#ca8a04}\n.text-yellow-600{color:#ca8a04}\n.border-yellow-600{border-color:#ca8a04}\n.bg-yellow-700{background-color:#a16207}\n.text-yellow-700{color:#a16207}\n.border-yellow-700{border-color:#a16207}\n.bg-yellow-800{background-color:#854d0e}\n.text-yellow-800{color:#854d0e}\n.border-yellow-800{border-color:#854d0e}\n.bg-yellow-900{background-color:#713f12}\n.text-yellow-900{color:#713f12}\n.border-yellow-900{border-color:#713f12}\n.bg-yellow-950{background-color:#422006}\n.text-yellow-950{color:#422006}\n.border-yellow-950{border-color:#422006}\n.bg-zinc-100{background-color:#f4f4f5}\n.text-zinc-100{color:#f4f4f5}\n.border-zinc-100{border-color:#f4f4f5}\n.bg-zinc-200{background-color:#e4e4e7}\n.text-zinc-200{color:#e4e4e7}\n.border-zinc-200{border-color:#e4e4e7}\n.bg-zinc-300{background-color:#d4d4d8}\n.text-zinc-300{color:#d4d4d8}\n.border-zinc-300{border-color:#d4d4d8}\n.bg-zinc-400{background-color:#a1a1aa}\n.text-zinc-400{color:#a1a1aa}\n.border-zinc-400{border-color:#a1a1aa}\n.bg-zinc-50{background-color:#fafafa}\n.text-zinc-50{color:#fafafa}\n.border-zinc-50{border-color:#fafafa}\n.bg-zinc-500{background-color:#71717a}\n.text-zinc-500{color:#71717a}\n.border-zinc-500{border-color:#71717a}\n.bg-zinc-600{background-color:#52525b}\n.text-zinc-600{color:#52525b}\n.border-zinc-600{border-color:#52525b}\n.bg-zinc-700{background-color:#3f3f46}\n.text-zinc-700{color:#3f3f46}\n.border-zinc-700{border-color:#3f3f46}\n.bg-zinc-800{background-color:#27272a}\n.text-zinc-800{color:#27272a}\n.border-zinc-800{border-color:#27272a}\n.bg-zinc-900{background-color:#18181b}\n.text-zinc-900{color:#18181b}\n.border-zinc-900{border-color:#18181b}\n.bg-zinc-950{background-color:#09090b}\n.text-zinc-950{color:#09090b}\n.border-zinc-950{border-color:#09090b}\n.bg-transparent{background-color:transparent}\n.p-0{padding:0rem}\n.px-0{padding-left:0rem;padding-right:0rem}\n.py-0{padding-top:0rem;padding-bottom:0rem}\n.pt-0{padding-top:0rem}\n.pr-0{padding-right:0rem}\n.pb-0{padding-bottom:0rem}\n.pl-0{padding-left:0rem}\n.p-0\\.5{padding:0.125rem}\n.px-0\\.5{padding-left:0.125rem;padding-right:0.125rem}\n.py-0\\.5{padding-top:0.125rem;padding-bottom:0.125rem}\n.pt-0\\.5{padding-top:0.125rem}\n.pr-0\\.5{padding-right:0.125rem}\n.pb-0\\.5{padding-bottom:0.125rem}\n.pl-0\\.5{padding-left:0.125rem}\n.p-1{padding:0.25rem}\n.px-1{padding-left:0.25rem;padding-right:0.25rem}\n.py-1{padding-top:0.25rem;padding-bottom:0.25rem}\n.pt-1{padding-top:0.25rem}\n.pr-1{padding-right:0.25rem}\n.pb-1{padding-bottom:0.25rem}\n.pl-1{padding-left:0.25rem}\n.p-1\\.5{padding:0.375rem}\n.px-1\\.5{padding-left:0.375rem;padding-right:0.375rem}\n.py-1\\.5{padding-top:0.375rem;padding-bottom:0.375rem}\n.pt-1\\.5{padding-top:0.375rem}\n.pr-1\\.5{padding-right:0.375rem}\n.pb-1\\.5{padding-bottom:0.375rem}\n.pl-1\\.5{padding-left:0.375rem}\n.p-2{padding:0.5rem}\n.px-2{padding-left:0.5rem;padding-right:0.5rem}\n.py-2{padding-top:0.5rem;padding-bottom:0.5rem}\n.pt-2{padding-top:0.5rem}\n.pr-2{padding-right:0.5rem}\n.pb-2{padding-bottom:0.5rem}\n.pl-2{padding-left:0.5rem}\n.p-2\\.5{padding:0.625rem}\n.px-2\\.5{padding-left:0.625rem;padding-right:0.625rem}\n.py-2\\.5{padding-top:0.625rem;padding-bottom:0.625rem}\n.pt-2\\.5{padding-top:0.625rem}\n.pr-2\\.5{padding-right:0.625rem}\n.pb-2\\.5{padding-bottom:0.625rem}\n.pl-2\\.5{padding-left:0.625rem}\n.p-3{padding:0.75rem}\n.px-3{padding-left:0.75rem;padding-right:0.75rem}\n.py-3{padding-top:0.75rem;padding-bottom:0.75rem}\n.pt-3{padding-top:0.75rem}\n.pr-3{padding-right:0.75rem}\n.pb-3{padding-bottom:0.75rem}\n.pl-3{padding-left:0.75rem}\n.p-3\\.5{padding:0.875rem}\n.px-3\\.5{padding-left:0.875rem;padding-right:0.875rem}\n.py-3\\.5{padding-top:0.875rem;padding-bottom:0.875rem}\n.pt-3\\.5{padding-top:0.875rem}\n.pr-3\\.5{padding-right:0.875rem}\n.pb-3\\.5{padding-bottom:0.875rem}\n.pl-3\\.5{padding-left:0.875rem}\n.p-4{padding:1rem}\n.px-4{padding-left:1rem;padding-right:1rem}\n.py-4{padding-top:1rem;padding-bottom:1rem}\n.pt-4{padding-top:1rem}\n.pr-4{padding-right:1rem}\n.pb-4{padding-bottom:1rem}\n.pl-4{padding-left:1rem}\n.p-5{padding:1.25rem}\n.px-5{padding-left:1.25rem;padding-right:1.25rem}\n.py-5{padding-top:1.25rem;padding-bottom:1.25rem}\n.pt-5{padding-top:1.25rem}\n.pr-5{padding-right:1.25rem}\n.pb-5{padding-bottom:1.25rem}\n.pl-5{padding-left:1.25rem}\n.p-6{padding:1.5rem}\n.px-6{padding-left:1.5rem;padding-right:1.5rem}\n.py-6{padding-top:1.5rem;padding-bottom:1.5rem}\n.pt-6{padding-top:1.5rem}\n.pr-6{padding-right:1.5rem}\n.pb-6{padding-bottom:1.5rem}\n.pl-6{padding-left:1.5rem}\n.p-7{padding:1.75rem}\n.px-7{padding-left:1.75rem;padding-right:1.75rem}\n.py-7{padding-top:1.75rem;padding-bottom:1.75rem}\n.pt-7{padding-top:1.75rem}\n.pr-7{padding-right:1.75rem}\n.pb-7{padding-bottom:1.75rem}\n.pl-7{padding-left:1.75rem}\n.p-8{padding:2rem}\n.px-8{padding-left:2rem;padding-right:2rem}\n.py-8{padding-top:2rem;padding-bottom:2rem}\n.pt-8{padding-top:2rem}\n.pr-8{padding-right:2rem}\n.pb-8{padding-bottom:2rem}\n.pl-8{padding-left:2rem}\n.p-9{padding:2.25rem}\n.px-9{padding-left:2.25rem;padding-right:2.25rem}\n.py-9{padding-top:2.25rem;padding-bottom:2.25rem}\n.pt-9{padding-top:2.25rem}\n.pr-9{padding-right:2.25rem}\n.pb-9{padding-bottom:2.25rem}\n.pl-9{padding-left:2.25rem}\n.p-10{padding:2.5rem}\n.px-10{padding-left:2.5rem;padding-right:2.5rem}\n.py-10{padding-top:2.5rem;padding-bottom:2.5rem}\n.pt-10{padding-top:2.5rem}\n.pr-10{padding-right:2.5rem}\n.pb-10{padding-bottom:2.5rem}\n.pl-10{padding-left:2.5rem}\n.p-11{padding:2.75rem}\n.px-11{padding-left:2.75rem;padding-right:2.75rem}\n.py-11{padding-top:2.75rem;padding-bottom:2.75rem}\n.pt-11{padding-top:2.75rem}\n.pr-11{padding-right:2.75rem}\n.pb-11{padding-bottom:2.75rem}\n.pl-11{padding-left:2.75rem}\n.p-12{padding:3rem}\n.px-12{padding-left:3rem;padding-right:3rem}\n.py-12{padding-top:3rem;padding-bottom:3rem}\n.pt-12{padding-top:3rem}\n.pr-12{padding-right:3rem}\n.pb-12{padding-bottom:3rem}\n.pl-12{padding-left:3rem}\n.p-14{padding:3.5rem}\n.px-14{padding-left:3.5rem;padding-right:3.5rem}\n.py-14{padding-top:3.5rem;padding-bottom:3.5rem}\n.pt-14{padding-top:3.5rem}\n.pr-14{padding-right:3.5rem}\n.pb-14{padding-bottom:3.5rem}\n.pl-14{padding-left:3.5rem}\n.p-16{padding:4rem}\n.px-16{padding-left:4rem;padding-right:4rem}\n.py-16{padding-top:4rem;padding-bottom:4rem}\n.pt-16{padding-top:4rem}\n.pr-16{padding-right:4rem}\n.pb-16{padding-bottom:4rem}\n.pl-16{padding-left:4rem}\n.p-20{padding:5rem}\n.px-20{padding-left:5rem;padding-right:5rem}\n.py-20{padding-top:5rem;padding-bottom:5rem}\n.pt-20{padding-top:5rem}\n.pr-20{padding-right:5rem}\n.pb-20{padding-bottom:5rem}\n.pl-20{padding-left:5rem}\n.p-24{padding:6rem}\n.px-24{padding-left:6rem;padding-right:6rem}\n.py-24{padding-top:6rem;padding-bottom:6rem}\n.pt-24{padding-top:6rem}\n.pr-24{padding-right:6rem}\n.pb-24{padding-bottom:6rem}\n.pl-24{padding-left:6rem}\n.text-xs{font-size:0.75rem;line-height:1rem}\n.text-sm{font-size:0.875rem;line-height:1.25rem}\n.text-base{font-size:1rem;line-height:1.5rem}\n.text-lg{font-size:1.125rem;line-height:1.75rem}\n.text-xl{font-size:1.25rem;line-height:1.75rem}\n.text-2xl{font-size:1.5rem;line-height:2rem}\n.text-3xl{font-size:1.875rem;line-height:2.25rem}\n.text-4xl{font-size:2.25rem;line-height:2.5rem}\n.text-5xl{font-size:3rem;line-height:1}\n.text-6xl{font-size:3.75rem;line-height:1}\n.font-thin{font-weight:100}\n.font-extralight{font-weight:200}\n.font-light{font-weight:300}\n.font-normal{font-weight:400}\n.font-medium{font-weight:500}\n.font-semibold{font-weight:600}\n.font-bold{font-weight:700}\n.font-extrabold{font-weight:800}\n.font-black{font-weight:900}\n.italic{font-style:italic}\n.not-italic{font-style:normal}\n.rounded-none{border-radius:0px}\n.rounded-sm{border-radius:2px}\n.rounded{border-radius:4px}\n.rounded-md{border-radius:6px}\n.rounded-lg{border-radius:8px}\n.rounded-xl{border-radius:12px}\n.rounded-2xl{border-radius:16px}\n.rounded-3xl{border-radius:24px}\n.rounded-full{border-radius:9999px}\n.border{border-width:1px;border-style:solid}\n.border-0{border-width:0px;border-style:solid}\n.border-2{border-width:2px;border-style:solid}\n.border-4{border-width:4px;border-style:solid}\n.border-8{border-width:8px;border-style:solid}\n.tracking-tighter{letter-spacing:-0.05em}\n.tracking-tight{letter-spacing:-0.025em}\n.tracking-normal{letter-spacing:0em}\n.tracking-wide{letter-spacing:0.025em}\n.tracking-wider{letter-spacing:0.05em}\n.tracking-widest{letter-spacing:0.1em}"
diff --git a/python/xy/styling/cascade.py b/python/xy/styling/cascade.py
index b7cb8737b..f8a77f6c7 100644
--- a/python/xy/styling/cascade.py
+++ b/python/xy/styling/cascade.py
@@ -187,6 +187,12 @@ def _expand_shorthands(declarations: dict[str, Any]) -> dict[str, Any]:
     """
     out: dict[str, Any] = {}
     for prop, value in declarations.items():
+        if prop == "background-color":
+            # Schema v1 speaks `background` (the browser capture makes the
+            # same mapping); when both spellings cascade, the shorthand
+            # already reset the longhand upstream, so last-in wins here too.
+            out["background"] = value
+            continue
         if prop == "padding" and isinstance(value, str):
             parts = value.split()
             if 1 <= len(parts) <= 4:
@@ -211,6 +217,7 @@ def resolve_for_figure(
     *,
     custom_css: str = "",
     stylesheets: tuple[str, ...] = (),
+    tailwind_profile: Optional[str] = None,
     color_scheme: str = "light",
     root_font_size: float = 16.0,
     width: Optional[float] = None,
@@ -242,7 +249,19 @@ def resolve_for_figure(
                 "parent": index[parent] if parent is not None else None,
             }
         )
-    css = "\n".join((*stylesheets, custom_css)) if (stylesheets or custom_css) else ""
+    sheets = list(stylesheets)
+    if tailwind_profile is not None:
+        if tailwind_profile != "core-v1":
+            raise ValueError(
+                f"unknown tailwind_profile {tailwind_profile!r}; this build ships "
+                '"core-v1" (a project\'s full Tailwind build rides stylesheets=)'
+            )
+        from ._tailwind_core import TAILWIND_CORE_CSS
+
+        # The manifest is the widest sheet: project stylesheets and
+        # custom_css cascade over it in that order.
+        sheets.insert(0, TAILWIND_CORE_CSS)
+    css = "\n".join((*sheets, custom_css)) if (sheets or custom_css) else ""
     reply = _call(
         css,
         {
diff --git a/scripts/gen_tailwind_core.py b/scripts/gen_tailwind_core.py
new file mode 100644
index 000000000..9fa47445f
--- /dev/null
+++ b/scripts/gen_tailwind_core.py
@@ -0,0 +1,203 @@
+#!/usr/bin/env python3
+"""Generate the Tailwind-core manifest the native cascade resolves.
+
+One generated stylesheet (`python/xy/styling/_tailwind_core.py`) covering the
+exactly-specified core utilities: the full default color palette for
+`bg-` / `text-` / `border-` (sourced from the real package —
+`scripts/tailwind_palette_v3.json` carries the provenance header — never
+hand-typed hexes: a wrong brand color is the worst silent failure this
+program exists to end), the numeric spacing scale as padding utilities, the
+type scale, font weights and styles, border radii and widths, and letter
+tracking. Every value is the published Tailwind default, expressed in
+rem/em/px exactly as Tailwind documents it — the cascade resolves rem/em
+against its font-size cascade, so the manifest stays faithful rather than
+pre-baked.
+
+Utilities OUTSIDE this manifest are simply absent from the stylesheet: the
+cascade then reports the unmatched class through its `unsupported` path via
+the preflight, which is the §28-honest boundary (a project's full Tailwind
+build rides the `stylesheets=` input instead).
+
+    uv run python scripts/gen_tailwind_core.py --write
+    uv run python scripts/gen_tailwind_core.py --check
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+PALETTE = ROOT / "scripts" / "tailwind_palette_v3.json"
+TARGET = ROOT / "python" / "xy" / "styling" / "_tailwind_core.py"
+
+VERSION = "core-v1"
+
+#: Tailwind's documented numeric spacing scale (rem = key / 4).
+SPACING = [
+    "0",
+    "0.5",
+    "1",
+    "1.5",
+    "2",
+    "2.5",
+    "3",
+    "3.5",
+    "4",
+    "5",
+    "6",
+    "7",
+    "8",
+    "9",
+    "10",
+    "11",
+    "12",
+    "14",
+    "16",
+    "20",
+    "24",
+]
+
+FONT_SIZES = {
+    "xs": ("0.75rem", "1rem"),
+    "sm": ("0.875rem", "1.25rem"),
+    "base": ("1rem", "1.5rem"),
+    "lg": ("1.125rem", "1.75rem"),
+    "xl": ("1.25rem", "1.75rem"),
+    "2xl": ("1.5rem", "2rem"),
+    "3xl": ("1.875rem", "2.25rem"),
+    "4xl": ("2.25rem", "2.5rem"),
+    "5xl": ("3rem", "1"),
+    "6xl": ("3.75rem", "1"),
+}
+
+FONT_WEIGHTS = {
+    "thin": 100,
+    "extralight": 200,
+    "light": 300,
+    "normal": 400,
+    "medium": 500,
+    "semibold": 600,
+    "bold": 700,
+    "extrabold": 800,
+    "black": 900,
+}
+
+RADII = {
+    "none": "0px",
+    "sm": "2px",
+    "": "4px",
+    "md": "6px",
+    "lg": "8px",
+    "xl": "12px",
+    "2xl": "16px",
+    "3xl": "24px",
+    "full": "9999px",
+}
+
+BORDER_WIDTHS = {"": "1px", "0": "0px", "2": "2px", "4": "4px", "8": "8px"}
+
+TRACKING = {
+    "tighter": "-0.05em",
+    "tight": "-0.025em",
+    "normal": "0em",
+    "wide": "0.025em",
+    "wider": "0.05em",
+    "widest": "0.1em",
+}
+
+
+def _class(name: str) -> str:
+    return name.replace(".", "\\.")
+
+
+def render_css(palette: dict) -> str:
+    rules: list[str] = []
+    colors: dict[str, str] = {"white": "#fff", "black": "#000"}
+    for hue, shades in palette["colors"].items():
+        if isinstance(shades, str):
+            colors[hue] = shades
+            continue
+        for shade, value in shades.items():
+            colors[f"{hue}-{shade}"] = value
+    for name, value in sorted(colors.items()):
+        rules.append(f".bg-{_class(name)}{{background-color:{value}}}")
+        rules.append(f".text-{_class(name)}{{color:{value}}}")
+        rules.append(f".border-{_class(name)}{{border-color:{value}}}")
+    rules.append(".bg-transparent{background-color:transparent}")
+
+    for key in SPACING:
+        rem = f"{float(key) / 4:g}rem"
+        cls = _class(key)
+        rules.append(f".p-{cls}{{padding:{rem}}}")
+        rules.append(f".px-{cls}{{padding-left:{rem};padding-right:{rem}}}")
+        rules.append(f".py-{cls}{{padding-top:{rem};padding-bottom:{rem}}}")
+        for side, prop in (("t", "top"), ("r", "right"), ("b", "bottom"), ("l", "left")):
+            rules.append(f".p{side}-{cls}{{padding-{prop}:{rem}}}")
+
+    for name, (size, line) in FONT_SIZES.items():
+        rules.append(f".text-{name}{{font-size:{size};line-height:{line}}}")
+    for name, weight in FONT_WEIGHTS.items():
+        rules.append(f".font-{name}{{font-weight:{weight}}}")
+    rules.append(".italic{font-style:italic}")
+    rules.append(".not-italic{font-style:normal}")
+    for name, value in RADII.items():
+        cls = f".rounded-{name}" if name else ".rounded"
+        rules.append(f"{cls}{{border-radius:{value}}}")
+    for name, value in BORDER_WIDTHS.items():
+        cls = f".border-{name}" if name else ".border"
+        rules.append(f"{cls}{{border-width:{value};border-style:solid}}")
+    for name, value in TRACKING.items():
+        rules.append(f".tracking-{name}{{letter-spacing:{value}}}")
+    return "\n".join(rules)
+
+
+def render_module(palette: dict) -> str:
+    css = render_css(palette)
+    return (
+        '"""The Tailwind-core manifest, as one generated stylesheet.\n\n'
+        "@generated by scripts/gen_tailwind_core.py — do not edit by hand.\n"
+        f"Palette provenance: {palette['source']}.\n"
+        "The native cascade prepends this sheet when an export names\n"
+        f'`tailwind_profile="{VERSION}"`; unmatched utilities are reported by\n'
+        "the cascade, never guessed (§28).\n"
+        '"""\n\n'
+        "from __future__ import annotations\n\n"
+        f'TAILWIND_CORE_VERSION = "{VERSION}"\n\n'
+        # Emitted as an explicit double-quoted literal (not repr): ruff
+        # format normalizes quotes, and a generated file the formatter
+        # rewrites is permanently "stale" to --check.
+        f'TAILWIND_CORE_CSS = "{_py_string(css)}"\n'
+    )
+
+
+def _py_string(text: str) -> str:
+    return text.replace("\\", "\\\\").replace('"', '\\"').replace("\n", "\\n")
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--write", action="store_true")
+    parser.add_argument("--check", action="store_true")
+    args = parser.parse_args(argv)
+    palette = json.loads(PALETTE.read_text(encoding="utf-8"))
+    document = render_module(palette)
+    if args.write:
+        TARGET.write_text(document, encoding="utf-8")
+        print(f"wrote {TARGET.relative_to(ROOT)}")
+        return 0
+    if args.check:
+        current = TARGET.read_text(encoding="utf-8") if TARGET.exists() else ""
+        if current != document:
+            print(f"{TARGET.relative_to(ROOT)} is stale; regenerate with --write", file=sys.stderr)
+            return 1
+        print("tailwind core manifest is current")
+        return 0
+    print(document[:2000])
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/scripts/tailwind_palette_v3.json b/scripts/tailwind_palette_v3.json
new file mode 100644
index 000000000..158196c59
--- /dev/null
+++ b/scripts/tailwind_palette_v3.json
@@ -0,0 +1 @@
+{"source":"tailwindcss@3.4.17 require(\"tailwindcss/colors\")","colors":{"black":"#000","white":"#fff","slate":{"50":"#f8fafc","100":"#f1f5f9","200":"#e2e8f0","300":"#cbd5e1","400":"#94a3b8","500":"#64748b","600":"#475569","700":"#334155","800":"#1e293b","900":"#0f172a","950":"#020617"},"gray":{"50":"#f9fafb","100":"#f3f4f6","200":"#e5e7eb","300":"#d1d5db","400":"#9ca3af","500":"#6b7280","600":"#4b5563","700":"#374151","800":"#1f2937","900":"#111827","950":"#030712"},"zinc":{"50":"#fafafa","100":"#f4f4f5","200":"#e4e4e7","300":"#d4d4d8","400":"#a1a1aa","500":"#71717a","600":"#52525b","700":"#3f3f46","800":"#27272a","900":"#18181b","950":"#09090b"},"neutral":{"50":"#fafafa","100":"#f5f5f5","200":"#e5e5e5","300":"#d4d4d4","400":"#a3a3a3","500":"#737373","600":"#525252","700":"#404040","800":"#262626","900":"#171717","950":"#0a0a0a"},"stone":{"50":"#fafaf9","100":"#f5f5f4","200":"#e7e5e4","300":"#d6d3d1","400":"#a8a29e","500":"#78716c","600":"#57534e","700":"#44403c","800":"#292524","900":"#1c1917","950":"#0c0a09"},"red":{"50":"#fef2f2","100":"#fee2e2","200":"#fecaca","300":"#fca5a5","400":"#f87171","500":"#ef4444","600":"#dc2626","700":"#b91c1c","800":"#991b1b","900":"#7f1d1d","950":"#450a0a"},"orange":{"50":"#fff7ed","100":"#ffedd5","200":"#fed7aa","300":"#fdba74","400":"#fb923c","500":"#f97316","600":"#ea580c","700":"#c2410c","800":"#9a3412","900":"#7c2d12","950":"#431407"},"amber":{"50":"#fffbeb","100":"#fef3c7","200":"#fde68a","300":"#fcd34d","400":"#fbbf24","500":"#f59e0b","600":"#d97706","700":"#b45309","800":"#92400e","900":"#78350f","950":"#451a03"},"yellow":{"50":"#fefce8","100":"#fef9c3","200":"#fef08a","300":"#fde047","400":"#facc15","500":"#eab308","600":"#ca8a04","700":"#a16207","800":"#854d0e","900":"#713f12","950":"#422006"},"lime":{"50":"#f7fee7","100":"#ecfccb","200":"#d9f99d","300":"#bef264","400":"#a3e635","500":"#84cc16","600":"#65a30d","700":"#4d7c0f","800":"#3f6212","900":"#365314","950":"#1a2e05"},"green":{"50":"#f0fdf4","100":"#dcfce7","200":"#bbf7d0","300":"#86efac","400":"#4ade80","500":"#22c55e","600":"#16a34a","700":"#15803d","800":"#166534","900":"#14532d","950":"#052e16"},"emerald":{"50":"#ecfdf5","100":"#d1fae5","200":"#a7f3d0","300":"#6ee7b7","400":"#34d399","500":"#10b981","600":"#059669","700":"#047857","800":"#065f46","900":"#064e3b","950":"#022c22"},"teal":{"50":"#f0fdfa","100":"#ccfbf1","200":"#99f6e4","300":"#5eead4","400":"#2dd4bf","500":"#14b8a6","600":"#0d9488","700":"#0f766e","800":"#115e59","900":"#134e4a","950":"#042f2e"},"cyan":{"50":"#ecfeff","100":"#cffafe","200":"#a5f3fc","300":"#67e8f9","400":"#22d3ee","500":"#06b6d4","600":"#0891b2","700":"#0e7490","800":"#155e75","900":"#164e63","950":"#083344"},"sky":{"50":"#f0f9ff","100":"#e0f2fe","200":"#bae6fd","300":"#7dd3fc","400":"#38bdf8","500":"#0ea5e9","600":"#0284c7","700":"#0369a1","800":"#075985","900":"#0c4a6e","950":"#082f49"},"blue":{"50":"#eff6ff","100":"#dbeafe","200":"#bfdbfe","300":"#93c5fd","400":"#60a5fa","500":"#3b82f6","600":"#2563eb","700":"#1d4ed8","800":"#1e40af","900":"#1e3a8a","950":"#172554"},"indigo":{"50":"#eef2ff","100":"#e0e7ff","200":"#c7d2fe","300":"#a5b4fc","400":"#818cf8","500":"#6366f1","600":"#4f46e5","700":"#4338ca","800":"#3730a3","900":"#312e81","950":"#1e1b4b"},"violet":{"50":"#f5f3ff","100":"#ede9fe","200":"#ddd6fe","300":"#c4b5fd","400":"#a78bfa","500":"#8b5cf6","600":"#7c3aed","700":"#6d28d9","800":"#5b21b6","900":"#4c1d95","950":"#2e1065"},"purple":{"50":"#faf5ff","100":"#f3e8ff","200":"#e9d5ff","300":"#d8b4fe","400":"#c084fc","500":"#a855f7","600":"#9333ea","700":"#7e22ce","800":"#6b21a8","900":"#581c87","950":"#3b0764"},"fuchsia":{"50":"#fdf4ff","100":"#fae8ff","200":"#f5d0fe","300":"#f0abfc","400":"#e879f9","500":"#d946ef","600":"#c026d3","700":"#a21caf","800":"#86198f","900":"#701a75","950":"#4a044e"},"pink":{"50":"#fdf2f8","100":"#fce7f3","200":"#fbcfe8","300":"#f9a8d4","400":"#f472b6","500":"#ec4899","600":"#db2777","700":"#be185d","800":"#9d174d","900":"#831843","950":"#500724"},"rose":{"50":"#fff1f2","100":"#ffe4e6","200":"#fecdd3","300":"#fda4af","400":"#fb7185","500":"#f43f5e","600":"#e11d48","700":"#be123c","800":"#9f1239","900":"#881337","950":"#4c0519"}}}
\ No newline at end of file
diff --git a/tests/test_components.py b/tests/test_components.py
index 0abcb7b3a..0b559f847 100644
--- a/tests/test_components.py
+++ b/tests/test_components.py
@@ -1985,6 +1985,8 @@ def fake_to_png(
         compatibility="legacy",
         style_snapshot=None,
         style_source="declared",
+        stylesheets=(),
+        tailwind_profile=None,
     ):
         seen.update(
             {
@@ -2001,6 +2003,8 @@ def fake_to_png(
                 "compatibility": compatibility,
                 "style_snapshot": style_snapshot,
                 "style_source": style_source,
+                "stylesheets": stylesheets,
+                "tailwind_profile": tailwind_profile,
             }
         )
         return b"PNG"
@@ -2035,6 +2039,8 @@ def fake_to_png(
         "compatibility": "warn",
         "style_snapshot": None,
         "style_source": "declared",
+        "stylesheets": (),
+        "tailwind_profile": None,
     }
 
 
diff --git a/tests/test_tailwind_manifest.py b/tests/test_tailwind_manifest.py
new file mode 100644
index 000000000..b06f679af
--- /dev/null
+++ b/tests/test_tailwind_manifest.py
@@ -0,0 +1,119 @@
+"""The Tailwind-core manifest: real palette, exact scales, honest boundary.
+
+The manifest is generated from the vendored package palette
+(`scripts/tailwind_palette_v3.json`, provenance in its header) — these
+tests pin that the generated sheet resolves utilities to the exact
+published values through the native cascade, that regeneration is a no-op
+on a clean tree, and that anything outside the manifest is reported, not
+guessed.
+"""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+import xy
+
+cascade = pytest.importorskip("xy.styling.cascade")
+
+try:
+    cascade._find_library()
+except FileNotFoundError:
+    pytest.skip(
+        "xy-cascade extension not built (cargo build --release -p xy-cascade)",
+        allow_module_level=True,
+    )
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def _resolve(class_names, **kw):
+    chart = xy.scatter_chart(xy.scatter([1.0, 2.0], [2.0, 1.0]), class_names=class_names)
+    return cascade.resolve_for_figure(chart.figure(), tailwind_profile="core-v1", **kw)
+
+
+def _decls(snapshot, slot):
+    for inst in snapshot.instances:
+        if inst.slot == slot:
+            return dict(snapshot.declarations[inst.declaration])
+    return {}
+
+
+def test_palette_utilities_resolve_to_the_vendored_hexes() -> None:
+    palette = json.loads((ROOT / "scripts" / "tailwind_palette_v3.json").read_text())
+    snapshot, unsupported = _resolve(
+        {"tick_label": "text-sky-800", "legend": "bg-slate-900 border-rose-500"}
+    )
+    assert unsupported == ()
+    assert _decls(snapshot, "tick_label")["color"] == palette["colors"]["sky"]["800"]
+    legend = _decls(snapshot, "legend")
+    assert legend["background"] == palette["colors"]["slate"]["900"]
+    assert legend["border-color"] == palette["colors"]["rose"]["500"]
+
+
+def test_scales_resolve_through_the_font_cascade() -> None:
+    snapshot, unsupported = _resolve(
+        {"legend": "p-4 rounded-lg border-2", "tick_label": "text-sm font-semibold tracking-wide"}
+    )
+    assert unsupported == ()
+    legend = _decls(snapshot, "legend")
+    assert legend["padding-top"] == "16px"  # 1rem at the 16px root
+    assert legend["border-radius"] == "8px"
+    assert legend["border-width"] == "2px"
+    tick = _decls(snapshot, "tick_label")
+    assert tick["font-size"] == "14px"  # 0.875rem
+    assert tick["font-weight"] == "600"
+    assert tick["letter-spacing"] == "0.35px"  # 0.025em of the OWN 14px
+
+
+def test_unknown_utilities_are_reported_not_guessed() -> None:
+    # `backdrop-blur` is outside the manifest: the class simply matches no
+    # rule, and the preflight/report boundary carries the class name.
+    snapshot, _ = _resolve({"tick_label": "text-sky-800 backdrop-blur-md"})
+    assert _decls(snapshot, "tick_label")["color"] == "#075985"
+    # Unmatched classes are visible in the report surface: the class list
+    # still declares them, and the capability report names class_names as
+    # browser-carried; nothing pretends backdrop-blur resolved.
+    assert "backdrop-filter" not in _decls(snapshot, "tick_label")
+
+
+def test_utilities_export_natively_end_to_end() -> None:
+    chart = xy.scatter_chart(
+        xy.scatter([1.0, 2.0], [2.0, 1.0]), class_names={"tick_label": "text-sky-800"}
+    )
+    svg = chart.to_image("svg", style_source="native_cascade", tailwind_profile="core-v1")
+    assert b"#075985" in svg
+
+
+def test_profile_inputs_require_the_cascade_source() -> None:
+    chart = xy.scatter_chart(xy.scatter([1.0, 2.0], [2.0, 1.0]))
+    with pytest.raises(ValueError, match="native-cascade inputs"):
+        chart.to_image("png", tailwind_profile="core-v1")
+    with pytest.raises(ValueError, match="unknown tailwind_profile"):
+        chart.to_image(
+            "png", style_source="native_cascade", tailwind_profile="core-v2-does-not-exist"
+        )
+
+
+def test_custom_css_cascades_over_the_manifest() -> None:
+    snapshot, _ = _resolve(
+        {"tick_label": "text-sky-800"},
+        custom_css="[data-xy-slot='tick_label'] { color: #123456; }",
+    )
+    # One attribute selector (0,1,0) vs one class (0,1,0): equal
+    # specificity, custom_css comes later in cascade order and wins.
+    assert _decls(snapshot, "tick_label")["color"] == "#123456"
+
+
+def test_the_committed_manifest_is_regenerated_not_hand_edited() -> None:
+    result = subprocess.run(
+        [sys.executable, str(ROOT / "scripts" / "gen_tailwind_core.py"), "--check"],
+        capture_output=True,
+        text=True,
+    )
+    assert result.returncode == 0, result.stdout + result.stderr

From a326726e233562380e6fceb4f8c12055ccb4c171 Mon Sep 17 00:00:00 2001
From: Alek Petuskey <alek@reflex.dev>
Date: Tue, 4 Aug 2026 16:14:24 -0700
Subject: [PATCH 15/27] Static-chrome parity P3.0: the raster box emitter reads
 w/h as extents, and the legacy bbox stroke pair becomes model data

The shared primitives get two corrections the annotation fold depends on:
_emit_slot_box passed w/h straight through as the far corner that
_rect_pts/_round_rect_pts expect, so every raster chrome box was drawn
against absolute coordinates its SVG twin never used; and ChromeBox learns
the pre-parity pyplot text-bbox serialization (an inert stroke pair on
borderless rects, byte-pinned by the corpus) as an explicit field instead
of forcing the adapter to bypass the shared emitter.
---
 python/xy/_chromebox.py |  9 ++++++
 python/xy/_raster.py    |  4 +--
 python/xy/_svg.py       | 11 ++++++-
 tests/test_chromebox.py | 63 +++++++++++++++++++++++++++++++++++++++++
 4 files changed, 84 insertions(+), 3 deletions(-)

diff --git a/python/xy/_chromebox.py b/python/xy/_chromebox.py
index 94af40b95..6171edc38 100644
--- a/python/xy/_chromebox.py
+++ b/python/xy/_chromebox.py
@@ -53,6 +53,15 @@ class ChromeBox:
     radius: float = 0.0
     shadow: Optional[tuple[float, float, str]] = None  # (dx, dy, color)
     opacity: float = 1.0
+    #: Pyplot text-bbox compatibility: the pre-parity SVG emitter serialized
+    #: `stroke=... stroke-width=...` on every bbox rect, including the inert
+    #: `stroke="none" stroke-width="0"` of a borderless box, and existing
+    #: pyplot output is byte-pinned (§0.5). An adapter folding that emitter
+    #: onto this model sets `(paint, width)` here so the SVG writer keeps
+    #: those exact attributes when no active border exists; the raster twin
+    #: ignores it, because the raster writer never painted a zero-width
+    #: border. New chrome boxes leave it None.
+    explicit_stroke: Optional[tuple[str, float]] = None
     unrepresentable: tuple[str, ...] = field(default_factory=tuple)
 
     @property
diff --git a/python/xy/_raster.py b/python/xy/_raster.py
index cc2646643..a89c8ff17 100644
--- a/python/xy/_raster.py
+++ b/python/xy/_raster.py
@@ -783,8 +783,8 @@ def _emit_slot_box(cmd: "_Cmd", box: Any) -> None:
 
     def pts(x: float, y: float) -> list[tuple[float, float]]:
         if box.radius > 0:
-            return _round_rect_pts(x, y, box.w, box.h, box.radius)
-        return _rect_pts(x, y, box.w, box.h)
+            return _round_rect_pts(x, y, x + box.w, y + box.h, box.radius)
+        return _rect_pts(x, y, x + box.w, y + box.h)
 
     if box.shadow is not None:
         dx, dy, color = box.shadow
diff --git a/python/xy/_svg.py b/python/xy/_svg.py
index 8f523c09e..9dea44478 100644
--- a/python/xy/_svg.py
+++ b/python/xy/_svg.py
@@ -1826,8 +1826,14 @@ def _slot_box_svg(box: Any) -> str:
     would inherit the text paint otherwise), radius as symmetric `rx` only
     (PDF rejects `ry`). Emits nothing for a box that paints nothing, so the
     unstyled document stays byte-identical.
+
+    `explicit_stroke` is the one legacy accommodation: the pyplot text-bbox
+    emitter always wrote a stroke pair, even the inert `stroke="none"
+    stroke-width="0"` of a borderless box, and that output is byte-pinned —
+    a box carrying it is serialized (never skipped) with exactly that pair
+    when no active border exists.
     """
-    if not box.paints_anything and box.shadow is None:
+    if not box.paints_anything and box.shadow is None and box.explicit_stroke is None:
         return ""
     parts: list[str] = []
     common_opacity = f' opacity="{_num(box.opacity)}"' if box.opacity < 1.0 else ""
@@ -1848,6 +1854,9 @@ def _slot_box_svg(box: Any) -> str:
         if box.border_dash:
             dashes = " ".join(_num(v) for v in box.border_dash)
             stroke += f' stroke-dasharray="{dashes}"'
+    elif box.explicit_stroke is not None:
+        paint, width = box.explicit_stroke
+        stroke = f' stroke="{_escape_attr(paint)}" stroke-width="{_num(width)}"'
     fill_opacity = f' fill-opacity="{_num(box.fill_opacity)}"' if box.fill_opacity < 1.0 else ""
     parts.append(
         f'<rect x="{_num(box.x)}" y="{_num(box.y)}" '
diff --git a/tests/test_chromebox.py b/tests/test_chromebox.py
index a2c967891..30bf5edd5 100644
--- a/tests/test_chromebox.py
+++ b/tests/test_chromebox.py
@@ -166,3 +166,66 @@ def test_direct_chromebox_construction_defaults_paint_nothing() -> None:
     box = ChromeBox(slot="title", x=0, y=0, w=10, h=10)
     assert not box.paints_anything
     assert _svg._slot_box_svg(box) == ""
+
+
+def _fill_points(cmd: _raster._Cmd) -> list[tuple[float, float]]:
+    import struct
+
+    buf = bytes(cmd.buf)
+    assert buf[0] == _raster._FILL
+    (count,) = struct.unpack_from("<I", buf, 1)
+    coords = struct.unpack_from(f"<{count * 2}f", buf, 5)
+    return list(zip(coords[0::2], coords[1::2], strict=True))
+
+
+def test_raster_emitter_treats_w_h_as_extents_like_the_svg_twin() -> None:
+    # `w`/`h` are extents (the SVG twin emits width=/height=), not the far
+    # corner. The raster emitter briefly read them as absolute corner
+    # coordinates, so a box at (50, 40) sized 60x20 filled the rectangle
+    # (50, 40)-(60, 20) instead of (50, 40)-(110, 60).
+    cmd = _raster._Cmd(1.0)
+    _raster._emit_slot_box(cmd, lower_box("legend", {"background": "#f00"}, x=50, y=40, w=60, h=20))
+    assert _fill_points(cmd) == [(50.0, 40.0), (110.0, 40.0), (110.0, 60.0), (50.0, 60.0)]
+
+
+def test_explicit_stroke_keeps_the_pinned_pyplot_bbox_serialization() -> None:
+    # The pre-parity text-bbox emitter always wrote a stroke pair; a
+    # borderless bbox rect carried the inert `stroke="none" stroke-width="0"`
+    # and that output is byte-pinned, so the adapter's boxes reproduce it.
+    box = ChromeBox(slot="annotation_label", x=1, y=2, w=30, h=10, fill="#ffee88")
+    modern = _svg._slot_box_svg(box)
+    assert "stroke" not in modern
+    legacy = _svg._slot_box_svg(
+        ChromeBox(
+            slot="annotation_label",
+            x=1,
+            y=2,
+            w=30,
+            h=10,
+            fill="#ffee88",
+            explicit_stroke=("none", 0.0),
+        )
+    )
+    assert legacy == modern.replace("/>", ' stroke="none" stroke-width="0"/>')
+    # An active border wins over the legacy pair — never two stroke attrs.
+    bordered = _svg._slot_box_svg(
+        ChromeBox(
+            slot="annotation_label",
+            x=1,
+            y=2,
+            w=30,
+            h=10,
+            border_color="#123",
+            border_width=2.0,
+            explicit_stroke=("none", 0.0),
+        )
+    )
+    assert bordered.count("stroke=") == 1 and 'stroke="#123"' in bordered
+    # A zero-width-border-only rect still serializes (the legacy emitter drew
+    # it as invisible bytes), while the raster twin paints nothing — exactly
+    # the old pair's behavior.
+    invisible = ChromeBox(slot="annotation_label", x=0, y=0, w=8, h=8, explicit_stroke=("red", 0.0))
+    assert 'stroke="red" stroke-width="0"' in _svg._slot_box_svg(invisible)
+    cmd = _raster._Cmd(1.0)
+    _raster._emit_slot_box(cmd, invisible)
+    assert bytes(cmd.buf) == b""

From c7c47ff31e20c413691908c68d6adfbf3b064aa3 Mon Sep 17 00:00:00 2001
From: Alek Petuskey <alek@reflex.dev>
Date: Tue, 4 Aug 2026 16:20:03 -0700
Subject: [PATCH 16/27] Ship the cascade crate in the sdist
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The sdist manifest is an exact allow/require pair so a distribution cannot
quietly gain a build artifact or lose a source file. The cascade extension
is a workspace member, so its crate belongs in the same category as src/:
allowed at top level, and REQUIRED — an sdist that dropped it would build
a wheel whose style_source="native_cascade" raises at a user's first
class-styled export instead of failing here.
---
 scripts/verify_sdist.py | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/scripts/verify_sdist.py b/scripts/verify_sdist.py
index 168893ef4..a22d0f842 100644
--- a/scripts/verify_sdist.py
+++ b/scripts/verify_sdist.py
@@ -91,6 +91,12 @@
     "python/xy/static/index.js",
     "python/xy/static/standalone.js",
     "python/xy/widget.py",
+    # The cascade extension's own crate: required, so an sdist that silently
+    # dropped it (and with it `style_source="native_cascade"`) fails here
+    # rather than at a user's first class-styled export.
+    "cascade/Cargo.toml",
+    "cascade/src/lib.rs",
+    "cascade/src/resolve.rs",
     "src/css.rs",
     "src/font.rs",
     "src/kernels.rs",
@@ -132,6 +138,10 @@
     "README.md",
     "SECURITY.md",
     "hatch_build.py",
+    # The optional style-cascade extension is a workspace member: its source
+    # ships for the same reason `src/` does — a source build must be able to
+    # produce every cdylib the wheel offers, not just the core.
+    "cascade",
     "js",
     "package-lock.json",
     "package.json",

From 6c07c882ba03e5048285f7b383019b925faee1c4 Mon Sep 17 00:00:00 2001
From: Alek Petuskey <alek@reflex.dev>
Date: Tue, 4 Aug 2026 16:27:01 -0700
Subject: [PATCH 17/27] Static-chrome parity P3.1: annotation_label reaches
 both writers through the folded chrome box
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

styles={'annotation_label': ...} used to leave zero trace in a file. The
slot channel now threads into _annotation_svg and _emit_annotations, and
one merge point (annotation_style_with_slot) defines the two-vocabulary
translation exactly once: the slot's kebab CSS folds UNDER the
annotation's own pyplot-derived style= per property group, matching the
browser's _applySlot-then-inline order. The duplicated box drawers
(_svg_text_box / _emit_text_box) become adapters over one shared lowering
(annotation_text_box -> ChromeBox -> the two P0.3 emitters), which fixes
the 4-value CSS padding misread, lowers dashed/dotted border styles to
dash patterns, and adds offset box-shadow, whole-label opacity and
em-in-the-label's-own-unit-domain resolution — while reproducing the
pre-fold output byte-for-byte for every current input (pyplot corpus
plus an 11-case SVG/raster/PDF capture diff). Registry, preflight
(SLOT_BOX_PROPS routing), capability matrix and the export/styling specs
move in the same commit; badge/badge_item stay view-gated with no writer
emission, pinned by test.
---
 .../limitations-and-alpha-status.md           |  16 +-
 docs/styling/capabilities.md                  |   3 +-
 python/xy/_raster.py                          |  78 ++---
 python/xy/_svg.py                             | 327 +++++++++++++++---
 python/xy/styling/capabilities.py             |  14 +
 python/xy/styling/preflight.py                |   6 +
 spec/api/capability-matrix.md                 |   5 +-
 spec/api/export.md                            |  11 +-
 spec/api/styling.md                           |  18 +-
 tests/test_chrome_parity_p3.py                | 323 +++++++++++++++++
 tests/test_export_style_survival.py           |   5 +-
 11 files changed, 698 insertions(+), 108 deletions(-)
 create mode 100644 tests/test_chrome_parity_p3.py

diff --git a/docs/api-reference/limitations-and-alpha-status.md b/docs/api-reference/limitations-and-alpha-status.md
index 77043be3f..455c91f81 100644
--- a/docs/api-reference/limitations-and-alpha-status.md
+++ b/docs/api-reference/limitations-and-alpha-status.md
@@ -85,15 +85,19 @@ implementation. The bullets below are the boundaries that page's rows imply.
 - **Styling does not survive every export path equally, and the boundary is
   published rather than left to be discovered.** Mark, axis, and chart-level
   `style=` reach all three renderers. Per-slot `styles={slot: {...}}` reaches
-  them for the nine slots that name chrome a static file contains — `title`,
-  `axis_title`, `tick_label`, the three legend slots, and the three colorbar
-  slots — carrying `font-size`, `font-weight`, `font-style`, `font-family`,
-  `letter-spacing`, `opacity`, and the text paint. The remaining slots are live
+  them for the ten slots that name chrome a static file contains — `title`,
+  `axis_title`, `tick_label`, the three legend slots, the three colorbar
+  slots, and `annotation_label` — carrying `font-size`, `font-weight`,
+  `font-style`, `font-family`, `letter-spacing`, `opacity`, and the text
+  paint; `annotation_label` additionally carries the chrome-box subset
+  (background, border, radius, padding, offset shadow) under the annotation's
+  own `style=`. The remaining slots are live
   chrome (`tooltip*`, `modebar*`, `crosshair_*`, `selection`, `badge*`) with
   nothing in a file to paint, and `class_names={slot: "..."}` cannot apply in a
   file at all: a class selects a rule out of a stylesheet an exported file does
-  not have. The native raster's baked atlas is one face, so PNG/JPEG/WebP honor
-  a slot's size and paint but not its typeface. `xy.colorbar(style=...)` still
+  not have. The native raster's atlas carries regular, bold and italic faces,
+  so PNG/JPEG/WebP honor a slot's size, paint, weight and style but not its
+  family or letter-spacing. `xy.colorbar(style=...)` still
   has no native channel — use the `colorbar_*` slots. The full matrix is
   [Static export §9](https://github.com/reflex-dev/xy/blob/main/spec/api/export.md),
   pinned by `tests/test_export_style_survival.py`.
diff --git a/docs/styling/capabilities.md b/docs/styling/capabilities.md
index bb428aaf7..f1446bd9f 100644
--- a/docs/styling/capabilities.md
+++ b/docs/styling/capabilities.md
@@ -110,7 +110,7 @@ would not survive, before any bytes exist.
 | `tick_mark` | clean static | full | none | none |
 | `tick_label` | clean static | full | partial | partial |
 | `axis_title` | clean static | full | partial | partial |
-| `annotation_label` | clean static | full | none | none |
+| `annotation_label` | clean static | full | partial | partial |
 
 ### Notes
 
@@ -124,6 +124,7 @@ would not survive, before any bytes exist.
 - **`colorbar_title`** (via `styles={'colorbar_title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
 - **`tick_label`** (via `styles={'tick_label': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
 - **`axis_title`** (via `styles={'axis_title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
+- **`annotation_label`** (via `styles={'annotation_label': ...}`) — The per-slot text subset plus the shared chrome-box model (`xy._svg.SLOT_BOX_PROPS`): background, border — with solid/dashed/dotted lowered to a dash pattern and other border styles drawn solid and recorded (§28) — border-radius, CSS 1-4 value padding, offset box-shadow (blur/spread recorded unrepresentable), and whole-label opacity. The annotation's own `style=` is the narrower selector and wins per property group, matching the browser's slot-then-inline order. em font sizes resolve against the label's own 11px default. Vertical (rotation 90/270) labels keep only size and paint in SVG — a pre-existing limit of the rotated text path.
 
 ## Extension points
 
diff --git a/python/xy/_raster.py b/python/xy/_raster.py
index a89c8ff17..7028c79f0 100644
--- a/python/xy/_raster.py
+++ b/python/xy/_raster.py
@@ -41,7 +41,6 @@
     _axis_tick_label_sides,
     _axis_tick_label_strategy,
     _axis_tick_sides,
-    _box_corner_radius,
     _colorbar_right_axis_room,
     _colormap_stops,
     _column,
@@ -49,7 +48,6 @@
     _css,
     _decode_title_geometry,
     _density_column,
-    _estimated_text_width,
     _heatmap_rgba_grid,
     _legend_layout,
     _lut,
@@ -65,6 +63,8 @@
     _title_metrics,
     affine_fast_path,
     annotation_label_placement,
+    annotation_style_with_slot,
+    annotation_text_box,
     apply_export_background,
     axis_ticks,
     hexbin_ring,
@@ -1093,6 +1093,10 @@ def render_raster(
     if polar is not None:
         cmd.polar_clip(polar)
 
+    # Hoisted above the annotation passes: both phases read the annotation
+    # slots, and the chrome text below reads the rest of the same mapping.
+    slots = slot_styles(spec)
+
     spec_palette: Sequence[str] = spec.get("palette") or DEFAULT_PALETTE
     for palette_i, t in enumerate(spec["traces"]):
         style = t.get("style") or {}
@@ -1136,7 +1140,17 @@ def render_raster(
         elif all(k in t for k in ("x0", "x1", "y0", "y1")):
             _emit_rects(cmd, t, blob, cols, trace_sx, trace_sy, style, color, plot, polar)
 
-    _emit_annotations(cmd, spec.get("annotations") or [], sx, sy, plot, width, height, polar=polar)
+    _emit_annotations(
+        cmd,
+        spec.get("annotations") or [],
+        sx,
+        sy,
+        plot,
+        width,
+        height,
+        polar=polar,
+        slots=slots,
+    )
 
     # Chrome (unclipped): baselines, labels, title, legend.
     cmd.clip(0, 0, width, height)
@@ -1152,6 +1166,7 @@ def render_raster(
         height,
         phase="text",
         polar=polar,
+        slots=slots,
     )
     # "none" silences the whole axis chrome (sparklines); "off" hides only the
     # label text and keeps baselines and the axis title (mpl shared axes).
@@ -1346,8 +1361,6 @@ def tick_span(style: dict[str, Any]) -> tuple[float, float]:
                     _parse_color(_css(axis_style.get("tick_color"), default_axis)),
                 )
 
-    slots = slot_styles(spec)
-
     def slot_paint(slot: str, fallback: str) -> tuple:
         """A slot's text paint, or the writer's own default."""
         resolved = slot_text_color(slots.get(slot) or {}, "")
@@ -1718,9 +1731,11 @@ def _emit_annotations(
     *,
     phase: str = "marks",
     polar: "Optional[_PolarProjection]" = None,
+    slots: Optional[dict[str, dict[str, Any]]] = None,
 ) -> None:
     px0, py0 = plot["x"], plot["y"]
     text_phase = phase == "text"
+    slots = slots or {}
 
     def point(x: float, y: float) -> tuple[float, float]:
         """Jointly project point-anchored geometry under polar coordinates."""
@@ -1733,7 +1748,7 @@ def point(x: float, y: float) -> tuple[float, float]:
         # Geometry (rules/bands/arrows/markers) draws in the clipped marks
         # pass; every label draws in the unclipped chrome pass, matching
         # matplotlib's Text and the client's DOM labels.
-        style = ann.get("style") or {}
+        style = annotation_style_with_slot(ann, slots)
         restore_plot_clip = False
         color = _rgba(style.get("color"), "#667085", float(style.get("opacity", 1.0)))
         start = max(0.0, min(1.0, float(style.get("span_start", 0.0))))
@@ -1924,42 +1939,25 @@ def _emit_text_box(
     font_size: float,
     anchor: int,
 ) -> None:
-    """Draw the bounded CSS approximation used by pyplot ``text(bbox=)``."""
-    background = style.get("background")
-    border = str(style.get("border", ""))
-    if background is None and not border:
-        return
-    pad_parts = str(style.get("padding", "0")).split()
+    """Adapter: the pyplot ``text(bbox=)`` approximation over the shared box.
 
-    def px(value: str) -> float:
-        try:
-            return max(0.0, float(value.removesuffix("px")))
-        except ValueError:
-            return 0.0
-
-    pad_y = px(pad_parts[0]) if pad_parts else 0.0
-    pad_x = px(pad_parts[1]) if len(pad_parts) > 1 else pad_y
-    text_width = _estimated_text_width(lines, font_size)
-    left = x - (text_width / 2 if anchor == 1 else text_width if anchor == 2 else 0.0) - pad_x
-    top = first_y - font_size * 0.8 - pad_y
-    right = left + text_width + pad_x * 2
-    bottom = top + font_size + (len(lines) - 1) * line_height + pad_y * 2
-    # `boxstyle="round"`/`round4` set border_radius, which the browser applies
-    # as CSS border-radius; round the same corners here or the exported box is
-    # square where the live one is not.
-    points = _round_rect_pts(
-        left, top, right, bottom, _box_corner_radius(style, right - left, bottom - top)
+    Geometry and declaration parsing live in `annotation_text_box` (one
+    lowering for both writers); the display list comes from `_emit_slot_box`.
+    A closed border stroke rasterizes pixel-identically to the old
+    repeat-the-first-point polyline (round cap == round join for the capsule
+    distance field).
+    """
+    box = annotation_text_box(
+        style,
+        lines,
+        x,
+        first_y,
+        line_height,
+        font_size,
+        {0: "start", 1: "middle", 2: "end"}.get(anchor, "start"),
     )
-    if background is not None:
-        cmd.fill(points, _parse_color(str(background)))
-    if border:
-        parts = border.split()
-        try:
-            width = max(0.0, float(parts[0].removesuffix("px")))
-        except (IndexError, ValueError):
-            width = 1.0
-        if width:
-            cmd.stroke(points + [points[0]], width, _parse_color(parts[-1]))
+    if box is not None:
+        _emit_slot_box(cmd, box)
 
 
 def _emit_area(
diff --git a/python/xy/_svg.py b/python/xy/_svg.py
index 9dea44478..45ca2c273 100644
--- a/python/xy/_svg.py
+++ b/python/xy/_svg.py
@@ -18,6 +18,7 @@
 from __future__ import annotations
 
 import base64
+import dataclasses
 import hashlib
 import math
 import re
@@ -31,6 +32,7 @@
 
 from . import _fontmetrics, _native, _paint, _png, _textblock
 from ._arrowgeom import arrow_shapes as _arrow_shapes
+from ._chromebox import ChromeBox, lower_box
 from .config import DEFAULT_PALETTE, polar_bar_segments
 
 
@@ -1374,6 +1376,7 @@ def _px_size(value: Any, default: float) -> float:
     "colorbar",
     "colorbar_title",
     "colorbar_tick",
+    "annotation_label",
 )
 
 
@@ -1428,6 +1431,30 @@ def slot_styles(spec: dict[str, Any]) -> dict[str, dict[str, Any]]:
     }
 )
 
+#: The box-model vocabulary the shared chrome-box primitive honors on a slot
+#: declaration (`xy._chromebox.lower_box` + the two emitters). One constant so
+#: the writers, the capability registry and the preflight cannot drift on
+#: which properties have a channel into a static file (plan §2 item 0.4; the
+#: `LEGEND_BOX_PROPS` pattern). Kebab spellings only — the declared resolver
+#: normalizes to kebab before any writer reads a declaration. `border` is the
+#: CSS shorthand; the longhands are what `lower_box` reads after the writer's
+#: own shorthand split.
+SLOT_BOX_PROPS: frozenset[str] = frozenset(
+    {
+        "background",
+        "background-color",
+        "border",
+        "border-width",
+        "border-color",
+        "border-style",
+        "border-radius",
+        "padding",
+        "box-shadow",
+        "opacity",
+        "fill-opacity",
+    }
+)
+
 
 def legend_options_with_slot(spec: dict[str, Any], options: dict[str, Any]) -> dict[str, Any]:
     """Fold the chart-level legend styling into a legend's own options, so every
@@ -4404,7 +4431,7 @@ def append_axis_title(axis: dict[str, Any], *, is_x: bool) -> None:
         )
 
     annotation_marks, unclipped_annotation_marks, annotation_labels = _annotation_svg(
-        spec.get("annotations") or [], sx, sy, plot, width, height, polar
+        spec.get("annotations") or [], sx, sy, plot, width, height, polar, slots
     )
     marks.extend(annotation_marks)
     labels.extend(annotation_labels)
@@ -4797,10 +4824,12 @@ def _annotation_svg(
     width: float,
     height: float,
     polar: "Optional[_PolarProjection]" = None,
+    slots: Optional[dict[str, dict[str, Any]]] = None,
 ) -> tuple[list[str], list[str], list[str]]:
     marks: list[str] = []
     unclipped_marks: list[str] = []
     labels: list[str] = []
+    slots = slots or {}
     px0, py0 = plot["x"], plot["y"]
 
     def point(x: float, y: float) -> tuple[float, float]:
@@ -4821,7 +4850,7 @@ def point(x: float, y: float) -> tuple[float, float]:
         return float(sx(x)), float(sy(y))
 
     for ann in annotations:
-        style = ann.get("style") or {}
+        style = annotation_style_with_slot(ann, slots)
         color = escape(_css(style.get("color"), "#667085"))
         opacity = float(style.get("opacity", 1.0))
         start = max(0.0, min(1.0, float(style.get("span_start", 0.0))))
@@ -5008,14 +5037,26 @@ def point(x: float, y: float) -> tuple[float, float]:
 
 
 def _svg_font_attrs(style: dict[str, Any]) -> str:
+    """Annotation-label font attributes, each emitted exactly once.
+
+    `letter_spacing` joined the tuple with the annotation_label slot channel
+    (it is in `SLOT_TEXT_PROPS`, and the merge translates the slot's kebab
+    spelling onto this vocabulary); a bare number is normalized to px the way
+    `slot_text_attrs` does for the other text slots.
+    """
     attrs = []
     for key, attribute in (
         ("font_family", "font-family"),
         ("font_weight", "font-weight"),
         ("font_style", "font-style"),
+        ("letter_spacing", "letter-spacing"),
     ):
-        if style.get(key) is not None:
-            attrs.append(f' {attribute}="{escape(str(style[key]))}"')
+        value = style.get(key)
+        if value is None:
+            continue
+        if key == "letter_spacing" and not isinstance(value, str):
+            value = _num(_px_size(value, 0.0))
+        attrs.append(f' {attribute}="{_escape_attr(value)}"')
     return "".join(attrs)
 
 
@@ -5053,7 +5094,157 @@ def _svg_mathtext_spans(line: str, style: dict[str, Any], offset: int) -> str:
     return "".join(out)
 
 
-def _svg_text_box(
+#: Annotation vocabulary ↔ slot CSS vocabulary, defined exactly once (the
+#: two-vocabulary collision is this family's named risk). Left: the kebab
+#: property a `styles={'annotation_label': ...}` declaration carries after
+#: resolver normalization; right: the pyplot-derived key the annotation's own
+#: `style=` mapping (and both writers) have always used. Paint and opacity
+#: are handled separately — their targets depend on the annotation kind.
+_ANNOTATION_SLOT_TEXT_KEYS: tuple[tuple[str, str], ...] = (
+    ("font-size", "font_size"),
+    ("font-weight", "font_weight"),
+    ("font-style", "font_style"),
+    ("font-family", "font_family"),
+    ("letter-spacing", "letter_spacing"),
+)
+
+#: What a labels-container declaration cascades into an annotation label.
+#: Exactly the text properties the live stylesheet leaves un-ruled on the
+#: label div: `20_theme.ts` pins font-size (11px), font-weight (400) and the
+#: color chain per label, so only these three inherit from the container.
+_LABELS_CONTAINER_ANNOTATION_PROPS: tuple[str, ...] = (
+    "font-style",
+    "font-family",
+    "letter-spacing",
+)
+
+#: The annotation label's own stylesheet font size (`20_theme.ts`), the base
+#: an em-valued slot font-size resolves against — the legend precedent:
+#: relative units resolve in the slot's own unit domain, never silently drop.
+_ANNOTATION_FONT_SIZE = 11.0
+
+
+def _annotation_em(value: Any, base: float) -> Any:
+    """Resolve an em spelling against `base`; pass everything else through."""
+    if isinstance(value, str) and value.strip().endswith("em"):
+        try:
+            return float(value.strip().removesuffix("em")) * base
+        except ValueError:
+            return value
+    return value
+
+
+def annotation_style_with_slot(ann: dict[str, Any], slots: dict[str, Any]) -> dict[str, Any]:
+    """One annotation's effective label styling: slot folded UNDER `style=`.
+
+    Mirrors the browser exactly: `_applySlot(d, "annotation_label")` runs
+    before the per-annotation inline styles (`51_annotations.ts`), so the
+    chart-wide declaration is the wider selector and the annotation's own
+    `style=` wins. The fold is per property GROUP, not per key, because the
+    two vocabularies overlap without matching one-to-one:
+
+    - text paint: slot `fill`/`color` becomes `label_color`, yielding to the
+      annotation's own `label_color` OR `color` (the browser pins inline
+      color when either is present);
+    - `opacity`: the slot's is a label dimmer (the div's CSS opacity), so it
+      becomes `label_opacity` + the box opacity, yielding to the annotation's
+      own `label_opacity` — and, for `kind="text"`, to its own `opacity`,
+      which already acts as the label alpha; a shape-bearing annotation's
+      `opacity` is shape alpha and never collides;
+    - box groups (`background`, the border, `border_radius`, `padding`):
+      whichever vocabulary the annotation used wins the whole group;
+    - `box-shadow` and `fill-opacity` exist only in the slot vocabulary and
+      pass through.
+
+    The labels-container slot sits under everything, restricted to the
+    properties that genuinely inherit in the live DOM
+    (`_LABELS_CONTAINER_ANNOTATION_PROPS`).
+    """
+    style = ann.get("style") or {}
+    slot = slots.get("annotation_label") or {}
+    container = slots.get("labels") or {}
+    if not slot and not container:
+        return style
+    merged: dict[str, Any] = {}
+    for prop, key in _ANNOTATION_SLOT_TEXT_KEYS:
+        if prop in _LABELS_CONTAINER_ANNOTATION_PROPS and prop in container:
+            merged[key] = container[prop]
+        if prop in slot:
+            merged[key] = slot[prop]
+    if "font_size" in merged:
+        merged["font_size"] = _annotation_em(merged["font_size"], _ANNOTATION_FONT_SIZE)
+    paint = slot_text_color(slot, "")
+    if paint and "label_color" not in style and "color" not in style:
+        merged["label_color"] = paint
+    if (
+        "opacity" in slot
+        and "label_opacity" not in style
+        and not (ann.get("kind") == "text" and "opacity" in style)
+    ):
+        merged["label_opacity"] = slot["opacity"]
+        merged["box-opacity"] = slot["opacity"]
+    if "background" not in style:
+        background = slot.get("background", slot.get("background-color"))
+        if background is not None:
+            merged["background"] = background
+    if "border" not in style:
+        for prop in ("border", "border-width", "border-color", "border-style"):
+            if prop in slot:
+                merged[prop] = slot[prop]
+    if "border_radius" not in style and "border-radius" in slot:
+        merged["border_radius"] = slot["border-radius"]
+    if "padding" not in style and "padding" in slot:
+        merged["padding"] = slot["padding"]
+    if "box-shadow" in slot:
+        merged["box-shadow"] = slot["box-shadow"]
+    if "fill-opacity" in slot:
+        merged["fill-opacity"] = slot["fill-opacity"]
+    return {**merged, **style}
+
+
+def _css_box_padding(value: Any, font_size: float) -> tuple[float, float, float, float]:
+    """CSS `padding` as (top, right, bottom, left) px.
+
+    The historical parsers read tokens [0]/[1] only, silently misreading
+    4-value CSS (`declared top/RIGHT/bottom/left` became `vertical/
+    horizontal`); this is the one correct read both writers now share. Em
+    tokens resolve against the label font size, like the browser; anything
+    unparseable stays 0, the failure mode the old parsers had.
+    """
+    tokens = str(value).split()
+
+    def length(token: str) -> float:
+        resolved = _annotation_em(token, font_size)
+        if isinstance(resolved, (int, float)):
+            return max(0.0, float(resolved))
+        try:
+            return max(0.0, float(str(resolved).removesuffix("px")))
+        except ValueError:
+            return 0.0
+
+    if not tokens:
+        return 0.0, 0.0, 0.0, 0.0
+    sides = [length(token) for token in tokens[:4]]
+    if len(sides) == 1:
+        top = right = bottom = left = sides[0]
+    elif len(sides) == 2:
+        top = bottom = sides[0]
+        right = left = sides[1]
+    elif len(sides) == 3:
+        top, right, bottom = sides
+        left = right
+    else:
+        top, right, bottom, left = sides
+    return top, right, bottom, left
+
+
+#: `border` shorthand middle tokens the writers lower to a dash pattern.
+#: Any other style keyword passes through to `lower_box`, which keeps the
+#: solid border the old emitters drew and records the approximation (§28).
+_BORDER_STYLE_TOKENS = frozenset({"solid", "dashed", "dotted"})
+
+
+def annotation_text_box(
     style: dict[str, Any],
     lines: list[str],
     x: float,
@@ -5061,63 +5252,107 @@ def _svg_text_box(
     line_height: float,
     font_size: float,
     anchor: str,
-) -> list[str]:
-    """SVG counterpart of the pyplot text-bbox CSS approximation."""
+) -> Optional[ChromeBox]:
+    """One annotation label's box, lowered onto the shared chrome-box model.
+
+    The single geometry + declaration lowering both writers consume — the
+    fold of the formerly duplicated `_svg_text_box` / `_emit_text_box` pair.
+    Reads the merged vocabulary `annotation_style_with_slot` produces: the
+    pyplot text-bbox keys (`background`, `border` shorthand, `padding`,
+    `border_radius`) plus the slot longhands the merge passes through.
+    Returns None when nothing was declared, so the unstyled document stays
+    byte-identical.
+    """
     background = style.get("background")
-    border = str(style.get("border", ""))
-    if background is None and not border:
-        return []
-    pad_parts = str(style.get("padding", "0")).split()
-
-    def px(value: str) -> float:
-        try:
-            return max(0.0, float(value.removesuffix("px")))
-        except ValueError:
-            return 0.0
+    border = str(style.get("border", "") or "")
+    has_slot_box = any(
+        prop in style for prop in ("border-width", "border-color", "border-style", "box-shadow")
+    )
+    if background is None and not border and not has_slot_box:
+        return None
 
-    pad_y = px(pad_parts[0]) if pad_parts else 0.0
-    pad_x = px(pad_parts[1]) if len(pad_parts) > 1 else pad_y
+    pad_top, pad_right, pad_bottom, pad_left = _css_box_padding(
+        style.get("padding", "0"), font_size
+    )
     text_width = _estimated_text_width(lines, font_size)
     left = (
         x
         - (text_width / 2 if anchor == "middle" else text_width if anchor == "end" else 0.0)
-        - pad_x
+        - pad_left
     )
-    top = first_y - font_size * 0.8 - pad_y
-    height = font_size + (len(lines) - 1) * line_height + pad_y * 2
-    fill = "none" if background is None else escape(str(background))
-    stroke = "none"
-    stroke_width = 0.0
+    top = first_y - font_size * 0.8 - pad_top
+    width = text_width + (pad_left + pad_right)
+    height = font_size + (len(lines) - 1) * line_height + (pad_top + pad_bottom)
+
+    decl: dict[str, Any] = {}
+    if background is not None:
+        decl["background"] = background
+    explicit_stroke: Optional[tuple[str, float]] = None
     if border:
         parts = border.split()
-        stroke = escape(parts[-1])
+        stroke_paint = parts[-1]
         try:
             stroke_width = max(0.0, float(parts[0].removesuffix("px")))
         except (IndexError, ValueError):
             stroke_width = 1.0
-    # `boxstyle="round"`/`round4` set border_radius; the browser gets it as CSS
-    # border-radius, so the exporters have to round the same corners or an
+        if stroke_width > 0:
+            decl["border-width"] = stroke_width
+            decl["border-color"] = stroke_paint
+            if len(parts) >= 3 and parts[1] in _BORDER_STYLE_TOKENS:
+                decl["border-style"] = parts[1]
+            elif len(parts) >= 3:
+                decl["border-style"] = parts[1] if parts[1] not in ("none", "hidden") else "solid"
+        else:
+            # A declared zero-width border has always serialized as an
+            # invisible stroke pair in SVG and as nothing in raster.
+            explicit_stroke = (stroke_paint, stroke_width)
+    else:
+        for prop in ("border-width", "border-color", "border-style"):
+            if prop in style:
+                decl[prop] = style[prop]
+    # `boxstyle="round"`/`round4` set border_radius; the browser gets it as
+    # CSS border-radius, so the exporters round the same corners or an
     # exported box is square where the live one is not.
-    radius = _box_corner_radius(style, text_width + pad_x * 2, height)
-    radius_attr = f' rx="{_num(radius)}"' if radius > 0 else ""
-    return [
-        f'<rect x="{_num(left)}" y="{_num(top)}" '
-        f'width="{_num(text_width + pad_x * 2)}" height="{_num(height)}"{radius_attr} '
-        f'fill="{fill}" stroke="{stroke}" stroke-width="{_num(stroke_width)}"/>'
-    ]
-
+    radius = style.get("border_radius", style.get("border-radius"))
+    if radius is not None:
+        decl["border-radius"] = _annotation_em(radius, font_size)
+    if "box-shadow" in style:
+        decl["box-shadow"] = style["box-shadow"]
+    if "box-opacity" in style:
+        decl["opacity"] = style["box-opacity"]
+    if "fill-opacity" in style:
+        decl["fill-opacity"] = style["fill-opacity"]
+
+    box = lower_box("annotation_label", decl, x=left, y=top, w=width, h=height)
+    if (
+        background is not None
+        and box.fill is None
+        and not any(unrep.startswith("background") for unrep in box.unrepresentable)
+    ):
+        # `lower_box` elides transparent paints; the legacy emitters wrote
+        # them verbatim (`fill="transparent"`), and those bytes are pinned.
+        box = dataclasses.replace(box, fill=str(background))
+    if box.border_color is None and explicit_stroke is None:
+        # The legacy pair: every drawn bbox rect carries a stroke, inert
+        # (`stroke="none" stroke-width="0"`) when no border was declared.
+        explicit_stroke = ("none", 0.0)
+    if explicit_stroke is not None and box.border_color is None:
+        box = dataclasses.replace(box, explicit_stroke=explicit_stroke)
+    return box
 
-def _box_corner_radius(style: dict[str, Any], width: float, height: float) -> float:
-    """`border_radius` in px, clamped to the box like CSS does.
 
-    Shared by the SVG and native raster text-box emitters so an exported
-    ``boxstyle="round"`` bbox is rounded exactly once, the same way.
-    """
-    try:
-        radius = float(str(style.get("border_radius", 0) or 0).removesuffix("px"))
-    except (TypeError, ValueError):
-        return 0.0
-    return max(0.0, min(radius, width / 2.0, height / 2.0))
+def _svg_text_box(
+    style: dict[str, Any],
+    lines: list[str],
+    x: float,
+    first_y: float,
+    line_height: float,
+    font_size: float,
+    anchor: str,
+) -> list[str]:
+    """Adapter: the pyplot text-bbox CSS approximation over the shared box."""
+    box = annotation_text_box(style, lines, x, first_y, line_height, font_size, anchor)
+    return [_slot_box_svg(box)] if box is not None else []
 
 
 def _fontmetrics_text_width(
diff --git a/python/xy/styling/capabilities.py b/python/xy/styling/capabilities.py
index 05461efe8..6300ee5b9 100644
--- a/python/xy/styling/capabilities.py
+++ b/python/xy/styling/capabilities.py
@@ -296,6 +296,20 @@ class ExtensionPoint:
     "(`spec['dom']['style']`). Prefer it for anything that must survive "
     "export.",
 )
+_SLOT_EXCEPTIONS["annotation_label"] = (
+    "partial",
+    "styles={'annotation_label': ...}",
+    "The per-slot text subset plus the shared chrome-box model "
+    "(`xy._svg.SLOT_BOX_PROPS`): background, border — with solid/dashed/"
+    "dotted lowered to a dash pattern and other border styles drawn solid "
+    "and recorded (§28) — border-radius, CSS 1-4 value padding, offset "
+    "box-shadow (blur/spread recorded unrepresentable), and whole-label "
+    "opacity. The annotation's own `style=` is the narrower selector and "
+    "wins per property group, matching the browser's slot-then-inline "
+    "order. em font sizes resolve against the label's own 11px default. "
+    "Vertical (rotation 90/270) labels keep only size and paint in SVG — "
+    "a pre-existing limit of the rotated text path.",
+)
 
 
 #: The state that gates each live-only slot. Listed explicitly, one entry per
diff --git a/python/xy/styling/preflight.py b/python/xy/styling/preflight.py
index b7df4991c..21a7123b9 100644
--- a/python/xy/styling/preflight.py
+++ b/python/xy/styling/preflight.py
@@ -200,6 +200,12 @@ def _honored_props(slot: str, family: str) -> tuple[frozenset[str], str]:
             "box properties route through the merged legend declaration; see the "
             "capability matrix legend note"
         )
+    if slot == "annotation_label":
+        return text | _svg.SLOT_BOX_PROPS, (
+            "box properties route through the shared chrome-box lowering; the "
+            "annotation's own style= is the narrower selector and wins per "
+            "property group"
+        )
     return text, ""
 
 
diff --git a/spec/api/capability-matrix.md b/spec/api/capability-matrix.md
index 863a51e98..cd0c89d63 100644
--- a/spec/api/capability-matrix.md
+++ b/spec/api/capability-matrix.md
@@ -14,7 +14,7 @@ which is sometimes deliberate, and the notes say which.
 ## In one line
 
 - **11** mark style properties across **21** mark kinds, drawn by all three renderers.
-- **48** stable chrome slots, CSS- and Tailwind-addressable in the browser. **24** of them name chrome a clean static export contains; **10** reach the native writers — **9** through `styles={slot: ...}` itself, and `root` through the chart-level `style=` token bag. The other **24** are interaction/view chrome (tooltip, modebar, crosshair, selection, reduction badges) that a clean static file does not contain, so they are gated by an export state rather than missing.
+- **48** stable chrome slots, CSS- and Tailwind-addressable in the browser. **24** of them name chrome a clean static export contains; **11** reach the native writers — **10** through `styles={slot: ...}` itself, and `root` through the chart-level `style=` token bag. The other **24** are interaction/view chrome (tooltip, modebar, crosshair, selection, reduction badges) that a clean static file does not contain, so they are gated by an export state rather than missing.
 - **1** shipped extension point.
 - **1** known default divergence between renderers, listed below rather than left to be discovered.
 
@@ -118,7 +118,7 @@ declared and names anything that would not survive.
 | `tick_mark` | clean static | full | none | none |
 | `tick_label` | clean static | full | partial | partial |
 | `axis_title` | clean static | full | partial | partial |
-| `annotation_label` | clean static | full | none | none |
+| `annotation_label` | clean static | full | partial | partial |
 
 ### Notes
 
@@ -132,6 +132,7 @@ declared and names anything that would not survive.
 - **`colorbar_title`** (via `styles={'colorbar_title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
 - **`tick_label`** (via `styles={'tick_label': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
 - **`axis_title`** (via `styles={'axis_title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
+- **`annotation_label`** (via `styles={'annotation_label': ...}`) — The per-slot text subset plus the shared chrome-box model (`xy._svg.SLOT_BOX_PROPS`): background, border — with solid/dashed/dotted lowered to a dash pattern and other border styles drawn solid and recorded (§28) — border-radius, CSS 1-4 value padding, offset box-shadow (blur/spread recorded unrepresentable), and whole-label opacity. The annotation's own `style=` is the narrower selector and wins per property group, matching the browser's slot-then-inline order. em font sizes resolve against the label's own 11px default. Vertical (rotation 90/270) labels keep only size and paint in SVG — a pre-existing limit of the rotated text path.
 
 ## Extension points
 
diff --git a/spec/api/export.md b/spec/api/export.md
index e6bf5c1ff..c9252bcbb 100644
--- a/spec/api/export.md
+++ b/spec/api/export.md
@@ -248,7 +248,7 @@ vector** (`_svg.to_svg`, and `_pdf.svg_to_pdf` on top of it).
 | `style={...}` on a mark | yes | yes | yes | validated CSS subset, `styles.compile_mark_style` |
 | `style={...}` on an axis | yes | yes | yes | validated vocabulary, `styles.compile_axis_style` |
 | `style={...}` on the chart (token bag) | yes | yes | yes | `spec["dom"]["style"]`, read at `_svg.py:767,1481` and `_raster.py:662` |
-| `styles={slot: {...}}` (per-slot inline) | yes, all 48 slots | text subset, 9 slots | text subset, 9 slots | `_svg.STATIC_STYLED_SLOTS`; the rest is live-only chrome |
+| `styles={slot: {...}}` (per-slot inline) | yes, all 48 slots | text subset, 10 slots (+ the chrome-box subset on `annotation_label`) | text subset, 10 slots (+ the chrome-box subset on `annotation_label`) | `_svg.STATIC_STYLED_SLOTS`; the rest is live-only chrome |
 | `class_names={slot: "..."}` | yes, all 48 slots | **dropped** (or resolved via `style_source="native_cascade"` / a captured `style_snapshot=`) | same | silent by default during migration; both opt-in routes are lossless for the published profile |
 | `custom_css="..."` | yes (HTML + Chromium capture) | **raises** | **raises** | `_resolve_image_engine`, `export.py:812` |
 | `xy.legend(style=...)` | yes | 6 keys | 6 keys | merged with the slot and the theme token before the writers see it |
@@ -325,9 +325,12 @@ and an exported file has no stylesheet to select from.
 A slot reaches the native writers when it names chrome a static file actually
 contains. `_svg.STATIC_STYLED_SLOTS` is that list: `title`, `axis_title`,
 `tick_label`, `legend`, `legend_title`, `legend_label`, `colorbar`,
-`colorbar_title`, and `colorbar_tick`. The remaining slots are live-only chrome
-— `tooltip*`, `modebar*`, `crosshair_*`, `selection`, `badge*` — or containers
-with no painted text of their own; there is nothing in a PNG for them to style.
+`colorbar_title`, `colorbar_tick`, and `annotation_label` (which additionally
+carries the chrome-box subset — `_svg.SLOT_BOX_PROPS` — under the
+annotation's own `style=`, the narrower selector). The remaining slots are
+live-only chrome — `tooltip*`, `modebar*`, `crosshair_*`, `selection`,
+`badge*` — or containers with no painted text of their own; there is nothing
+in a PNG for them to style.
 
 Within a supported slot the writers read a property subset, not a cascade:
 `font-size`, `font-weight`, `font-style`, `font-family`, `letter-spacing`,
diff --git a/spec/api/styling.md b/spec/api/styling.md
index 6bcdc270d..e55d79f83 100644
--- a/spec/api/styling.md
+++ b/spec/api/styling.md
@@ -1324,15 +1324,17 @@ carry a defined subset of their declarations into SVG, PNG and PDF:
 
 | | |
 | --- | --- |
-| Slots | `title`, `axis_title`, `tick_label`, `legend`, `legend_title`, `legend_label`, `colorbar`, `colorbar_title`, `colorbar_tick` (`_svg.STATIC_STYLED_SLOTS`) |
+| Slots | `title`, `axis_title`, `tick_label`, `legend`, `legend_title`, `legend_label`, `colorbar`, `colorbar_title`, `colorbar_tick`, `annotation_label` (`_svg.STATIC_STYLED_SLOTS`) |
 | Vector — SVG, PDF | `font-size`, `font-weight`, `font-style`, `font-family`, `letter-spacing`, `opacity`, and the text paint — `fill`, or `color` (`_svg.SLOT_TEXT_PROPS`) |
-| Raster — PNG, JPEG, WebP | `font-size` and the text paint only (`_svg.SLOT_RASTER_PROPS`) |
-
-The raster writer's glyph primitive takes a size and one RGBA paint and nothing
-else, so `font-weight`, `font-style`, `font-family`, `letter-spacing` and
-`opacity` are **vector-only**. They are not approximated: the atlas is a single
-baked face, and a silently substituted weight would be exactly the kind of
-invisible decision §28 forbids.
+| Raster — PNG, JPEG, WebP | `font-size`, `font-weight`, `font-style`, and the text paint (`_svg.SLOT_RASTER_PROPS`) |
+| `annotation_label` box | additionally `background`, `border` (+ longhands), `border-radius`, `padding`, offset `box-shadow`, `opacity`, `fill-opacity` (`_svg.SLOT_BOX_PROPS`), folded UNDER the annotation's own `style=` per property group |
+
+The raster atlas carries a regular, a bold and an italic face, so a slot's
+weight and style survive PNG/JPEG/WebP (weight ≥ 600 rounds up to the bold
+face). It has no family axis, no per-glyph advance control and no alpha on
+the blit, so `font-family`, `letter-spacing` and `opacity` are
+**vector-only**. They are not approximated: a silently substituted face would
+be exactly the kind of invisible decision §28 forbids.
 
 ```python
 xy.chart(
diff --git a/tests/test_chrome_parity_p3.py b/tests/test_chrome_parity_p3.py
new file mode 100644
index 000000000..6fdda336c
--- /dev/null
+++ b/tests/test_chrome_parity_p3.py
@@ -0,0 +1,323 @@
+"""Static-chrome parity, phase 3: annotation chrome.
+
+The two standing gates every assertion here serves (plan §0.5/§9):
+
+1. UNSTYLED output stays byte-identical — every new emission is strictly
+   conditional on a declaration being present.
+2. Everything emitted must round-trip to PDF; everything undrawable is
+   recorded (§28), never silent.
+
+The family's named risks are pinned executable: the two-vocabulary collision
+between the pyplot text-box style keys and the slot CSS vocabulary (the
+merge is group-wise, narrower wins), and the labels-container stacking
+conflict (flag D).
+"""
+
+from __future__ import annotations
+
+import re
+import struct
+
+import numpy as np
+import pytest
+
+import xy
+from xy import _raster
+from xy._pdf import svg_to_pdf
+
+
+def _line() -> object:
+    return xy.line([0.0, 1.0, 2.0], [0.0, 2.0, 1.0], name="series")
+
+
+def _svg_of(chart: xy.Chart) -> str:
+    return chart.figure().to_svg()
+
+
+def _raster_of(chart: xy.Chart) -> np.ndarray:
+    return _raster.render_raster(*chart.figure().build_payload(), scale=1)
+
+
+def _rects(svg: str) -> list[str]:
+    return re.findall(r"<rect[^>]*/>", svg)
+
+
+def _strokes(buf: bytes) -> list[dict[str, object]]:
+    """Every STROKE command in a raw display list, decoded."""
+    out: list[dict[str, object]] = []
+    offset = 0
+    while offset < len(buf):
+        op = buf[offset]
+        if op == _raster._STROKE:
+            (count,) = struct.unpack_from("<I", buf, offset + 1)
+            base = offset + 5 + count * 8
+            (width,) = struct.unpack_from("<f", buf, base)
+            rgba = tuple(buf[base + 4 : base + 8])
+            closed = buf[base + 8]
+            (dash_len,) = struct.unpack_from("<I", buf, base + 9)
+            dashes = struct.unpack_from(f"<{dash_len}f", buf, base + 13)
+            out.append({"width": width, "rgba": rgba, "closed": closed, "dash": list(dashes)})
+            offset = base + 13 + dash_len * 4 + 1
+        elif op == _raster._FILL:
+            (count,) = struct.unpack_from("<I", buf, offset + 1)
+            offset += 5 + count * 8 + 4
+        elif op == _raster._CLIP:
+            offset += 17
+        else:
+            # Anything else ends the region these tests decode.
+            break
+    return out
+
+
+# -- annotation_label ---------------------------------------------------------
+
+
+def test_annotation_label_slot_leaves_a_trace_in_both_writers() -> None:
+    # The verified zero-trace bug: styles={'annotation_label': ...} used to
+    # reach neither writer.
+    plain = xy.line_chart(_line(), xy.text(0.5, 0.5, "note"))
+    styled = xy.line_chart(
+        _line(),
+        xy.text(0.5, 0.5, "note"),
+        styles={"annotation_label": {"fill": "#123456"}},
+    )
+    svg = _svg_of(styled)
+    label = next(t for t in re.findall(r"<text[^>]*>.*?</text>", svg) if ">note<" in t)
+    assert 'fill="#123456"' in label
+    assert not (_raster_of(plain) == _raster_of(styled)).all()
+
+
+def test_unstyled_annotation_output_is_byte_identical() -> None:
+    # The standing gate at this family's door: an empty slot declaration and
+    # no declaration at all produce the same bytes in both writers.
+    def chart(**kwargs):
+        return xy.line_chart(
+            _line(),
+            xy.text(0.5, 0.5, "note"),
+            xy.hline(1.5, text="target"),
+            **kwargs,
+        )
+
+    assert _svg_of(chart()) == _svg_of(chart(styles={"annotation_label": {}}))
+    assert (_raster_of(chart()) == _raster_of(chart(styles={"annotation_label": {}}))).all()
+
+
+def test_the_annotation_own_style_wins_over_the_slot_per_group() -> None:
+    # Browser order: _applySlot runs before the per-annotation inline styles,
+    # so the annotation's own declaration is the narrower selector — in BOTH
+    # directions of the paint group (`color` as well as `label_color`).
+    slot = {"annotation_label": {"fill": "#0000ff", "background": "#0000ee"}}
+    own_color = xy.line_chart(_line(), xy.text(0.5, 0.5, "note", color="#ff0000"), styles=slot)
+    svg = _svg_of(own_color)
+    label = next(t for t in re.findall(r"<text[^>]*>.*?</text>", svg) if ">note<" in t)
+    assert 'fill="#ff0000"' in label and "#0000ff" not in label
+
+    own_box = xy.line_chart(
+        _line(),
+        xy.text(0.5, 0.5, "note", style={"background": "#00ff00"}),
+        styles=slot,
+    )
+    boxes = [r for r in _rects(_svg_of(own_box)) if "#00ff00" in r]
+    assert boxes and not any("#0000ee" in r for r in _rects(_svg_of(own_box)))
+
+
+def test_four_value_css_padding_reads_top_right_bottom_left() -> None:
+    # Both historical parsers read tokens [0]/[1] only, silently misreading
+    # 4-value CSS. The shared lowering reads the real sides.
+    def box(padding: str) -> dict[str, float]:
+        chart = xy.line_chart(
+            _line(),
+            xy.text(0.5, 0.5, "pad", style={"background": "#ffee88", "padding": padding}),
+        )
+        rect = next(r for r in _rects(_svg_of(chart)) if "#ffee88" in r)
+        return {
+            key: float(re.search(rf'{key}="([-\d.]+)"', rect).group(1))
+            for key in ("x", "y", "width", "height")
+        }
+
+    base = box("0")
+    padded = box("1px 2px 3px 4px")
+    assert padded["x"] == base["x"] - 4  # left
+    assert padded["y"] == base["y"] - 1  # top
+    assert padded["width"] == base["width"] + 4 + 2  # left + right
+    assert padded["height"] == base["height"] + 1 + 3  # top + bottom
+    # The 2-value spelling keeps its historical (vertical, horizontal) read.
+    two = box("6px 10px")
+    assert two["x"] == base["x"] - 10 and two["height"] == base["height"] + 12
+
+
+def test_dashed_border_style_renders_dasharray_in_svg_and_dash_in_raster() -> None:
+    chart = xy.line_chart(
+        xy.line([0.0, 1.0], [0.0, 1.0], name="s"),
+        xy.text(
+            0.5,
+            0.5,
+            "note",
+            style={"background": "#fff", "border": "2px dashed #123456"},
+        ),
+    )
+    rect = next(r for r in _rects(_svg_of(chart)) if "#123456" in r)
+    assert 'stroke-dasharray="7.4 3.2"' in rect
+
+    style = {"background": "#fff", "border": "2px dashed #123456"}
+    cmd = _raster._Cmd(1.0)
+    _raster._emit_text_box(cmd, style, ["note"], 100.0, 100.0, 13.2, 11.0, 0)
+    (stroke,) = _strokes(bytes(cmd.buf))
+    assert stroke["dash"] == [pytest.approx(7.4), pytest.approx(3.2)]
+    assert stroke["closed"] == 1
+
+
+def test_slot_box_shadow_draws_the_offset_rect_under_the_frame() -> None:
+    chart = xy.line_chart(
+        _line(),
+        xy.text(0.5, 0.5, "note"),
+        styles={
+            "annotation_label": {
+                "background": "#ffee88",
+                "box_shadow": "2px 3px rgba(0,0,0,0.3)",
+            }
+        },
+    )
+    rects = _rects(_svg_of(chart))
+    shadow = next(r for r in rects if "rgba(0,0,0,0.3)" in r)
+    frame = next(r for r in rects if "#ffee88" in r)
+    assert rects.index(shadow) == rects.index(frame) - 1  # under the frame
+    dx = float(re.search(r'x="([-\d.]+)"', shadow).group(1)) - float(
+        re.search(r'x="([-\d.]+)"', frame).group(1)
+    )
+    assert dx == 2.0
+    # Blur is not representable; it must be dropped LOUDLY, not approximated.
+    from xy._svg import annotation_text_box
+
+    box = annotation_text_box(
+        {"background": "#fff", "box-shadow": "0 4px 12px #000"},
+        ["x"],
+        0.0,
+        0.0,
+        13.2,
+        11.0,
+        "start",
+    )
+    assert box.shadow is None
+    assert any("blur" in reason for reason in box.unrepresentable)
+
+
+def test_em_slot_values_are_honored_via_the_merged_view() -> None:
+    # Schema v1 refuses relative units, so em declarations ride the writer
+    # view; the merge resolves them in the label's own unit domain (11px
+    # base) instead of silently dropping them — invariant §9.10.
+    chart = xy.line_chart(
+        _line(),
+        xy.text(0.5, 0.5, "note"),
+        styles={"annotation_label": {"font_size": "1.2em", "padding": "1em"}},
+    )
+    svg = _svg_of(chart)
+    label = next(t for t in re.findall(r"<text[^>]*>.*?</text>", svg) if ">note<" in t)
+    assert 'font-size="13.2"' in label  # 1.2 x 11px
+
+
+def test_slot_typography_reaches_both_writers() -> None:
+    plain = xy.line_chart(_line(), xy.text(0.5, 0.5, "note"))
+    bold = xy.line_chart(
+        _line(),
+        xy.text(0.5, 0.5, "note"),
+        styles={"annotation_label": {"font_weight": 700}},
+    )
+    italic = xy.line_chart(
+        _line(),
+        xy.text(0.5, 0.5, "note"),
+        styles={"annotation_label": {"font_style": "italic"}},
+    )
+    assert 'font-weight="700"' in _svg_of(bold)
+    assert 'font-style="italic"' in _svg_of(italic)
+    base = _raster_of(plain)
+    assert not (base == _raster_of(bold)).all(), "the bold atlas face must be selected"
+    assert not (base == _raster_of(italic)).all(), "the italic atlas face must be selected"
+
+
+def test_styled_annotation_labels_round_trip_to_pdf() -> None:
+    # Everything the slot can emit, through the closed subset in one pass:
+    # paint, emphasis, letter-spacing (P0.1), box with dashed border, radius
+    # and offset shadow.
+    chart = xy.line_chart(
+        _line(),
+        xy.text(0.5, 0.5, "note"),
+        styles={
+            "annotation_label": {
+                "fill": "#123456",
+                "font_style": "italic",
+                "letter_spacing": "2px",
+                "background": "#ffee88",
+                "border_color": "#334155",
+                "border_style": "dashed",
+                "border_radius": "6px",
+                "padding": "4px",
+                "box_shadow": "2px 3px rgba(0,0,0,0.3)",
+            }
+        },
+    )
+    pdf = svg_to_pdf(_svg_of(chart))
+    assert pdf[:4] == b"%PDF"
+    assert b"Helvetica-Oblique" in pdf
+
+
+def test_mathtext_annotation_pdf_raises_the_documented_fence() -> None:
+    # P0.1 fenced nested tspans rather than supporting them: a mathtext
+    # annotation must raise the closed-subset error, never emit silently
+    # broken text.
+    chart = xy.line_chart(
+        _line(),
+        xy.text(0.5, 0.5, "x_i", style={"math_italic_ranges": "0:3"}),
+    )
+    svg = _svg_of(chart)
+    assert '<tspan font-style="italic">' in svg
+    with pytest.raises(ValueError, match="unsupported SVG feature"):
+        svg_to_pdf(svg)
+
+
+def test_annotation_label_preflight_routes_text_and_box_props() -> None:
+    figure = xy.line_chart(
+        _line(),
+        xy.text(0.5, 0.5, "note"),
+        styles={
+            "annotation_label": {
+                "background": "#fff",
+                "border_radius": "4px",
+                "fill": "#123456",
+                "outline_color": "#badbad",
+            }
+        },
+    ).figure()
+    report = figure.style_compatibility_report(target="png")
+    (finding,) = [f for f in report.findings if f.slot == "annotation_label"]
+    assert set(finding.kept) >= {"background", "border-radius", "fill"}
+    assert finding.lost == ("outline-color",)
+
+
+# -- badge / badge_item: view-gated, excluded from static parity --------------
+
+
+def test_badge_slots_stay_view_gated_with_no_writer_emission() -> None:
+    # The applicability partition (capabilities.py): reduction badges exist
+    # only under the view state that triggers them, so a clean static export
+    # contains nothing for the slot to style — preflight records, writers
+    # stay silent, and the capability partition is unchanged.
+    from xy.styling import capabilities as caps
+
+    by_id = {slot.id: slot for slot in caps.CHART_SLOTS}
+    assert by_id["badge"].applicability == "view"
+    assert by_id["badge_item"].applicability == "view"
+    for surface in ("native_raster", "native_vector"):
+        assert by_id["badge"].support[surface] == "none"
+        assert by_id["badge_item"].support[surface] == "none"
+
+    def chart(**kwargs):
+        return xy.line_chart(_line(), xy.text(0.5, 0.5, "note"), **kwargs)
+
+    styled = chart(styles={"badge_item": {"background": "#123456"}})
+    assert _svg_of(chart()) == _svg_of(styled).replace("", "")
+    assert (_raster_of(chart()) == _raster_of(styled)).all()
+    report = styled.figure().style_compatibility_report(target="png")
+    (finding,) = [f for f in report.findings if f.slot == "badge_item"]
+    assert finding.route == "state-gated"
+    assert report.lossless
diff --git a/tests/test_export_style_survival.py b/tests/test_export_style_survival.py
index 46ea1470d..d3eaeba63 100644
--- a/tests/test_export_style_survival.py
+++ b/tests/test_export_style_survival.py
@@ -66,12 +66,15 @@ def test_native_writers_read_a_property_subset_not_the_whole_cascade() -> None:
 @pytest.mark.parametrize("slot", STATIC_STYLED_SLOTS)
 def test_every_static_slot_carries_its_paint_into_svg(slot: str) -> None:
     # The headline of the per-slot contract: a slot that names chrome a static
-    # file contains must carry that chrome's paint into the file.
+    # file contains must carry that chrome's paint into the file. The chart
+    # carries one of everything a slot can address, including an annotation
+    # label for the annotation chrome family.
     chart = xy.scatter_chart(
         xy.scatter(x=[0.0, 1.0], y=[1.0, 2.0], name="series", color=[0.0, 1.0], colormap="viridis"),
         xy.legend(title="Legend title"),
         xy.colorbar(title="Colorbar title"),
         xy.x_axis(label="x label"),
+        xy.text(0.5, 1.5, "annotation"),
         title="chart title",
         styles={slot: {_SLOT_PAINT_PROPERTY[slot]: "#123456"}},
     )

From 6deeebcf4d197f13a2ee2388c138a5e8ce8a00da Mon Sep 17 00:00:00 2001
From: Alek Petuskey <alek@reflex.dev>
Date: Tue, 4 Aug 2026 16:31:43 -0700
Subject: [PATCH 18/27] Static-chrome parity P3.2: annotation_layer group
 opacity and plot-clipped background
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The overlay slot reaches the writers: opacity wraps the annotation shape
tail (clipped and unclipped alike, never the labels) in a real <g> in
SVG/PDF, and folds into every shape RGBA in the raster display list,
which has no group compositing — the overlapping-shapes double-blend is
recorded in KNOWN_RENDERER_DIVERGENCES and pinned executable. The
background is a plot-rect chrome box under the shapes, inside the marks
clip: the live overlay canvas is full-bleed, but no writer seam is both
above the traces and below the shapes at full bleed, so the plot-clipped
geometry is the pinned decision, recorded as the second divergence
rather than left to be discovered. Registry, preflight routing, matrix
and the export/styling specs move in the same commit; unstyled bytes
hold in both writers.
---
 .../limitations-and-alpha-status.md           |  14 +--
 docs/styling/capabilities.md                  |   5 +-
 python/xy/_raster.py                          |  35 +++++-
 python/xy/_svg.py                             |  59 ++++++++++-
 python/xy/styling/capabilities.py             |  31 ++++++
 python/xy/styling/preflight.py                |   6 ++
 spec/api/capability-matrix.md                 |   9 +-
 spec/api/export.md                            |  14 +--
 spec/api/styling.md                           |   3 +-
 tests/test_chrome_parity_p3.py                | 100 ++++++++++++++++++
 tests/test_export_style_survival.py           |  11 +-
 11 files changed, 262 insertions(+), 25 deletions(-)

diff --git a/docs/api-reference/limitations-and-alpha-status.md b/docs/api-reference/limitations-and-alpha-status.md
index 455c91f81..26bb6e1fc 100644
--- a/docs/api-reference/limitations-and-alpha-status.md
+++ b/docs/api-reference/limitations-and-alpha-status.md
@@ -85,13 +85,15 @@ implementation. The bullets below are the boundaries that page's rows imply.
 - **Styling does not survive every export path equally, and the boundary is
   published rather than left to be discovered.** Mark, axis, and chart-level
   `style=` reach all three renderers. Per-slot `styles={slot: {...}}` reaches
-  them for the ten slots that name chrome a static file contains — `title`,
+  them for the eleven slots that name chrome a static file contains — `title`,
   `axis_title`, `tick_label`, the three legend slots, the three colorbar
-  slots, and `annotation_label` — carrying `font-size`, `font-weight`,
-  `font-style`, `font-family`, `letter-spacing`, `opacity`, and the text
-  paint; `annotation_label` additionally carries the chrome-box subset
-  (background, border, radius, padding, offset shadow) under the annotation's
-  own `style=`. The remaining slots are live
+  slots, `annotation_label`, and `annotation_layer` — carrying `font-size`,
+  `font-weight`, `font-style`, `font-family`, `letter-spacing`, `opacity`,
+  and the text paint; `annotation_label` additionally carries the chrome-box
+  subset (background, border, radius, padding, offset shadow) under the
+  annotation's own `style=`, and `annotation_layer` takes a group opacity
+  over the annotation shapes plus a plot-clipped background. The remaining
+  slots are live
   chrome (`tooltip*`, `modebar*`, `crosshair_*`, `selection`, `badge*`) with
   nothing in a file to paint, and `class_names={slot: "..."}` cannot apply in a
   file at all: a class selects a rule out of a stylesheet an exported file does
diff --git a/docs/styling/capabilities.md b/docs/styling/capabilities.md
index f1446bd9f..391d472f8 100644
--- a/docs/styling/capabilities.md
+++ b/docs/styling/capabilities.md
@@ -67,7 +67,7 @@ would not survive, before any bytes exist.
 | `title` | clean static | full | partial | partial |
 | `chrome` | clean static | full | none | none |
 | `canvas` | clean static | full | none | none |
-| `annotation_layer` | clean static | full | none | none |
+| `annotation_layer` | clean static | full | partial | partial |
 | `labels` | clean static | full | none | none |
 | `legend` | clean static | full | partial | partial |
 | `legend_title` | clean static | full | partial | partial |
@@ -116,6 +116,7 @@ would not survive, before any bytes exist.
 
 - **`root`** (via `chart style=`) — `styles={'root': ...}` is browser-only, but the chart-level `style=` token bag targets the same element and every renderer reads it (`spec['dom']['style']`). Prefer it for anything that must survive export.
 - **`title`** (via `styles={'title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
+- **`annotation_layer`** (via `styles={'annotation_layer': ...}`) — The annotation-shape overlay. `opacity` dims every annotation shape as a group (never the labels, which live in the labels container): SVG/PDF as real group opacity on a `<g>`, raster folded into each shape's RGBA because the display list has no group compositing — overlapping translucent shapes double-blend there, a recorded approximation (§28). `background` paints under the shapes, plot-clipped; the live overlay is full-bleed, a divergence recorded in KNOWN_RENDERER_DIVERGENCES. Everything else stays browser-only.
 - **`legend`** (via `styles={'legend': ...} / xy.legend(style=...) / --chart-legend-bg`) — The frame box. Both spellings and the theme token now converge on one merged declaration block before the writers see it, so what agrees in the browser agrees in a PNG. `background`, `boxShadow`, `borderRadius`, `--xy-legend-frame-alpha`, and `padding`/`rowGap` in `em` are honored; an explicit background paints opaque, as it does in the browser.
 - **`legend_title`** (via `styles={'legend_title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
 - **`legend_label`** (via `styles={'legend_label': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
@@ -144,6 +145,8 @@ an undocumented difference reads as a bug; a documented one is a contract.
 | what | browser | svg | native png | visible when |
 |---|---|---|---|---|
 | Interior vertices of a wide polyline | the notch two overlapping segment quads leave | round (the writer names it explicitly) | round (the capsule distance field fills the vertex) | stroke-width above ~4px at a sharp angle |
+| The annotation_layer slot's background extent | full-bleed (the overlay canvas is inset:0 over the whole chart) | plot rect, inside the marks clip (the only seam above traces and below shapes) | plot rect, under the active marks clip (same seam as SVG) | styles={'annotation_layer': {'background': ...}} is declared |
+| How the annotation_layer slot's opacity composites overlapping shapes | group opacity: the overlay canvas is dimmed once as a whole | group opacity on the wrapping <g>, PDF-legal, same as live | folded into each shape's RGBA (no group compositing opcode): overlapping translucent shapes double-blend | the slot declares opacity below 1 over overlapping annotation shapes |
 
 For what is still alpha, see
 [Limitations and Alpha Status](/docs/xy/api-reference/limitations-and-alpha-status/).
diff --git a/python/xy/_raster.py b/python/xy/_raster.py
index 7028c79f0..444bbdcc4 100644
--- a/python/xy/_raster.py
+++ b/python/xy/_raster.py
@@ -22,6 +22,7 @@
 
 from . import _paint, _png, _scene, _textblock
 from ._arrowgeom import arrow_shapes as _arrow_shapes
+from ._chromebox import lower_box
 from ._svg import (
     _AXIS,
     _AXIS_GRID_DASHES,
@@ -49,6 +50,7 @@
     _decode_title_geometry,
     _density_column,
     _heatmap_rgba_grid,
+    _layer_opacity,
     _legend_layout,
     _lut,
     _physical_density_alpha,
@@ -1736,6 +1738,29 @@ def _emit_annotations(
     px0, py0 = plot["x"], plot["y"]
     text_phase = phase == "text"
     slots = slots or {}
+    # annotation_layer: the display list has no group compositing, so the
+    # declared layer opacity folds into every shape RGBA (overlapping
+    # translucent shapes double-blend — recorded divergence, §28) and never
+    # into the labels, which live in the labels container in the browser.
+    # The layer background is a plot-rect box under the shapes, inside the
+    # active marks clip — the geometry pinned against the browser's
+    # full-bleed overlay in KNOWN_RENDERER_DIVERGENCES.
+    layer = slots.get("annotation_layer") or {}
+    layer_alpha = 1.0 if text_phase else _layer_opacity(layer)
+    if not text_phase and layer:
+        layer_background = layer.get("background", layer.get("background-color"))
+        if layer_background is not None:
+            _emit_slot_box(
+                cmd,
+                lower_box(
+                    "annotation_layer",
+                    {"background": layer_background, "opacity": layer_alpha},
+                    x=plot["x"],
+                    y=plot["y"],
+                    w=plot["w"],
+                    h=plot["h"],
+                ),
+            )
 
     def point(x: float, y: float) -> tuple[float, float]:
         """Jointly project point-anchored geometry under polar coordinates."""
@@ -1750,7 +1775,7 @@ def point(x: float, y: float) -> tuple[float, float]:
         # matplotlib's Text and the client's DOM labels.
         style = annotation_style_with_slot(ann, slots)
         restore_plot_clip = False
-        color = _rgba(style.get("color"), "#667085", float(style.get("opacity", 1.0)))
+        color = _rgba(style.get("color"), "#667085", float(style.get("opacity", 1.0)) * layer_alpha)
         start = max(0.0, min(1.0, float(style.get("span_start", 0.0))))
         end = max(start, min(1.0, float(style.get("span_end", 1.0))))
         if text_phase:
@@ -1782,7 +1807,11 @@ def point(x: float, y: float) -> tuple[float, float]:
                 x0, x1 = px0 + start * plot["w"], px0 + end * plot["w"]
             cmd.fill(
                 _rect_pts(x0, y0, x1, y1),
-                _rgba(style.get("color"), "#64748b", float(style.get("opacity", 0.14))),
+                _rgba(
+                    style.get("color"),
+                    "#64748b",
+                    float(style.get("opacity", 0.14)) * layer_alpha,
+                ),
             )
         elif ann.get("kind") in ("arrow", "callout"):
             if _annotation_connector_unclipped(ann, sx, sy, plot, polar):
@@ -1820,7 +1849,7 @@ def point(x: float, y: float) -> tuple[float, float]:
         elif ann.get("kind") == "marker":
             mx, my = point(float(ann["x"]), float(ann["y"]))
             if np.isfinite(mx) and np.isfinite(my):
-                alpha = float(style.get("opacity", 1.0))
+                alpha = float(style.get("opacity", 1.0)) * layer_alpha
                 stroke_w = float(style.get("stroke_width", 0.0))
                 cmd.point(
                     mx,
diff --git a/python/xy/_svg.py b/python/xy/_svg.py
index 45ca2c273..8161118c8 100644
--- a/python/xy/_svg.py
+++ b/python/xy/_svg.py
@@ -1377,6 +1377,7 @@ def _px_size(value: Any, default: float) -> float:
     "colorbar_title",
     "colorbar_tick",
     "annotation_label",
+    "annotation_layer",
 )
 
 
@@ -5033,7 +5034,63 @@ def point(x: float, y: float) -> tuple[float, float]:
                 + (f'fill-opacity="{_num(text_opacity)}" ' if text_opacity < 1 else "")
                 + f'fill="{label_color}">{tspans}</text>'
             )
-    return marks, unclipped_marks, labels
+    return _annotation_layer_wrap(marks, unclipped_marks, slots, plot) + (labels,)
+
+
+def _layer_opacity(layer: dict[str, Any]) -> float:
+    """The annotation_layer slot's declared group opacity, clamped, 1 unset."""
+    if "opacity" not in layer:
+        return 1.0
+    try:
+        return min(1.0, max(0.0, float(layer["opacity"])))
+    except (TypeError, ValueError):
+        return 1.0
+
+
+def _annotation_layer_wrap(
+    marks: list[str],
+    unclipped_marks: list[str],
+    slots: dict[str, Any],
+    plot: dict[str, float],
+) -> tuple[list[str], list[str]]:
+    """Apply the annotation_layer slot to the annotation shape lists.
+
+    Group opacity rides a `<g>` (PDF-legal), wrapping the clipped tail and
+    the unclipped connectors alike — never the labels, which live in the
+    labels container in the browser too. The layer background is a
+    plot-rect chrome box painted UNDER the shapes, inside the marks clip:
+    the live overlay canvas is full-bleed (`inset:0`), but a full-bleed rect
+    cannot sit above the traces and below the shapes in either writer, so
+    the writers pin the plot-clipped geometry and the divergence is recorded
+    in `KNOWN_RENDERER_DIVERGENCES` rather than left to be discovered.
+    """
+    layer = slots.get("annotation_layer") or {}
+    if not layer:
+        return marks, unclipped_marks
+    prefix: list[str] = []
+    background = layer.get("background", layer.get("background-color"))
+    if background is not None:
+        box = lower_box(
+            "annotation_layer",
+            {"background": background, "opacity": _layer_opacity(layer)},
+            x=plot["x"],
+            y=plot["y"],
+            w=plot["w"],
+            h=plot["h"],
+        )
+        # The rect carries the folded opacity itself (it sits outside the
+        # group so the group cannot double-dim it).
+        rect = _slot_box_svg(box)
+        if rect:
+            prefix.append(rect)
+    opacity = _layer_opacity(layer)
+    if opacity < 1.0:
+        wrap = f'<g opacity="{_num(opacity)}">'
+        if marks:
+            marks = [wrap, *marks, "</g>"]
+        if unclipped_marks:
+            unclipped_marks = [wrap, *unclipped_marks, "</g>"]
+    return prefix + marks, unclipped_marks
 
 
 def _svg_font_attrs(style: dict[str, Any]) -> str:
diff --git a/python/xy/styling/capabilities.py b/python/xy/styling/capabilities.py
index 6300ee5b9..28a2fff9d 100644
--- a/python/xy/styling/capabilities.py
+++ b/python/xy/styling/capabilities.py
@@ -256,6 +256,25 @@ class ExtensionPoint:
         visible_when="stroke-width above ~4px at a sharp angle",
         tracked_by="no style property selects a join; the default is the whole contract",
     ),
+    RendererDivergence(
+        id="annotation_layer_background_geometry",
+        what="The annotation_layer slot's background extent",
+        webgl="full-bleed (the overlay canvas is inset:0 over the whole chart)",
+        svg="plot rect, inside the marks clip (the only seam above traces and below shapes)",
+        native="plot rect, under the active marks clip (same seam as SVG)",
+        visible_when="styles={'annotation_layer': {'background': ...}} is declared",
+        tracked_by="tests/test_chrome_parity_p3.py pins the plot-rect geometry",
+    ),
+    RendererDivergence(
+        id="annotation_layer_opacity_compositing",
+        what="How the annotation_layer slot's opacity composites overlapping shapes",
+        webgl="group opacity: the overlay canvas is dimmed once as a whole",
+        svg="group opacity on the wrapping <g>, PDF-legal, same as live",
+        native="folded into each shape's RGBA (no group compositing opcode): "
+        "overlapping translucent shapes double-blend",
+        visible_when="the slot declares opacity below 1 over overlapping annotation shapes",
+        tracked_by="tests/test_chrome_parity_p3.py documents the double-blend delta",
+    ),
 )
 
 
@@ -296,6 +315,18 @@ class ExtensionPoint:
     "(`spec['dom']['style']`). Prefer it for anything that must survive "
     "export.",
 )
+_SLOT_EXCEPTIONS["annotation_layer"] = (
+    "partial",
+    "styles={'annotation_layer': ...}",
+    "The annotation-shape overlay. `opacity` dims every annotation shape as "
+    "a group (never the labels, which live in the labels container): SVG/PDF "
+    "as real group opacity on a `<g>`, raster folded into each shape's RGBA "
+    "because the display list has no group compositing — overlapping "
+    "translucent shapes double-blend there, a recorded approximation (§28). "
+    "`background` paints under the shapes, plot-clipped; the live overlay is "
+    "full-bleed, a divergence recorded in KNOWN_RENDERER_DIVERGENCES. "
+    "Everything else stays browser-only.",
+)
 _SLOT_EXCEPTIONS["annotation_label"] = (
     "partial",
     "styles={'annotation_label': ...}",
diff --git a/python/xy/styling/preflight.py b/python/xy/styling/preflight.py
index 21a7123b9..07428d710 100644
--- a/python/xy/styling/preflight.py
+++ b/python/xy/styling/preflight.py
@@ -206,6 +206,12 @@ def _honored_props(slot: str, family: str) -> tuple[frozenset[str], str]:
             "annotation's own style= is the narrower selector and wins per "
             "property group"
         )
+    if slot == "annotation_layer":
+        return frozenset({"background", "background-color", "opacity"}), (
+            "group opacity over the annotation shapes (raster folds it "
+            "per-primitive) and a plot-clipped background; the rest of the "
+            "overlay's box model stays browser-only"
+        )
     return text, ""
 
 
diff --git a/spec/api/capability-matrix.md b/spec/api/capability-matrix.md
index cd0c89d63..d0e6c9049 100644
--- a/spec/api/capability-matrix.md
+++ b/spec/api/capability-matrix.md
@@ -14,9 +14,9 @@ which is sometimes deliberate, and the notes say which.
 ## In one line
 
 - **11** mark style properties across **21** mark kinds, drawn by all three renderers.
-- **48** stable chrome slots, CSS- and Tailwind-addressable in the browser. **24** of them name chrome a clean static export contains; **11** reach the native writers — **10** through `styles={slot: ...}` itself, and `root` through the chart-level `style=` token bag. The other **24** are interaction/view chrome (tooltip, modebar, crosshair, selection, reduction badges) that a clean static file does not contain, so they are gated by an export state rather than missing.
+- **48** stable chrome slots, CSS- and Tailwind-addressable in the browser. **24** of them name chrome a clean static export contains; **12** reach the native writers — **11** through `styles={slot: ...}` itself, and `root` through the chart-level `style=` token bag. The other **24** are interaction/view chrome (tooltip, modebar, crosshair, selection, reduction badges) that a clean static file does not contain, so they are gated by an export state rather than missing.
 - **1** shipped extension point.
-- **1** known default divergence between renderers, listed below rather than left to be discovered.
+- **3** known default divergence between renderers, listed below rather than left to be discovered.
 
 ## Mark style properties
 
@@ -75,7 +75,7 @@ declared and names anything that would not survive.
 | `title` | clean static | full | partial | partial |
 | `chrome` | clean static | full | none | none |
 | `canvas` | clean static | full | none | none |
-| `annotation_layer` | clean static | full | none | none |
+| `annotation_layer` | clean static | full | partial | partial |
 | `labels` | clean static | full | none | none |
 | `legend` | clean static | full | partial | partial |
 | `legend_title` | clean static | full | partial | partial |
@@ -124,6 +124,7 @@ declared and names anything that would not survive.
 
 - **`root`** (via `chart style=`) — `styles={'root': ...}` is browser-only, but the chart-level `style=` token bag targets the same element and every renderer reads it (`spec['dom']['style']`). Prefer it for anything that must survive export.
 - **`title`** (via `styles={'title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
+- **`annotation_layer`** (via `styles={'annotation_layer': ...}`) — The annotation-shape overlay. `opacity` dims every annotation shape as a group (never the labels, which live in the labels container): SVG/PDF as real group opacity on a `<g>`, raster folded into each shape's RGBA because the display list has no group compositing — overlapping translucent shapes double-blend there, a recorded approximation (§28). `background` paints under the shapes, plot-clipped; the live overlay is full-bleed, a divergence recorded in KNOWN_RENDERER_DIVERGENCES. Everything else stays browser-only.
 - **`legend`** (via `styles={'legend': ...} / xy.legend(style=...) / --chart-legend-bg`) — The frame box. Both spellings and the theme token now converge on one merged declaration block before the writers see it, so what agrees in the browser agrees in a PNG. `background`, `boxShadow`, `borderRadius`, `--xy-legend-frame-alpha`, and `padding`/`rowGap` in `em` are honored; an explicit background paints opaque, as it does in the browser.
 - **`legend_title`** (via `styles={'legend_title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
 - **`legend_label`** (via `styles={'legend_label': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
@@ -158,6 +159,8 @@ until someone diffs two exports. Listed here for that reason.
 | what | webgl | svg | native | visible when | tracked by |
 |---|---|---|---|---|---|
 | Interior vertices of a wide polyline | the notch two overlapping segment quads leave | round (the writer names it explicitly) | round (the capsule distance field fills the vertex) | stroke-width above ~4px at a sharp angle | no style property selects a join; the default is the whole contract |
+| The annotation_layer slot's background extent | full-bleed (the overlay canvas is inset:0 over the whole chart) | plot rect, inside the marks clip (the only seam above traces and below shapes) | plot rect, under the active marks clip (same seam as SVG) | styles={'annotation_layer': {'background': ...}} is declared | tests/test_chrome_parity_p3.py pins the plot-rect geometry |
+| How the annotation_layer slot's opacity composites overlapping shapes | group opacity: the overlay canvas is dimmed once as a whole | group opacity on the wrapping <g>, PDF-legal, same as live | folded into each shape's RGBA (no group compositing opcode): overlapping translucent shapes double-blend | the slot declares opacity below 1 over overlapping annotation shapes | tests/test_chrome_parity_p3.py documents the double-blend delta |
 
 ## Regenerating
 
diff --git a/spec/api/export.md b/spec/api/export.md
index c9252bcbb..eabf75661 100644
--- a/spec/api/export.md
+++ b/spec/api/export.md
@@ -248,7 +248,7 @@ vector** (`_svg.to_svg`, and `_pdf.svg_to_pdf` on top of it).
 | `style={...}` on a mark | yes | yes | yes | validated CSS subset, `styles.compile_mark_style` |
 | `style={...}` on an axis | yes | yes | yes | validated vocabulary, `styles.compile_axis_style` |
 | `style={...}` on the chart (token bag) | yes | yes | yes | `spec["dom"]["style"]`, read at `_svg.py:767,1481` and `_raster.py:662` |
-| `styles={slot: {...}}` (per-slot inline) | yes, all 48 slots | text subset, 10 slots (+ the chrome-box subset on `annotation_label`) | text subset, 10 slots (+ the chrome-box subset on `annotation_label`) | `_svg.STATIC_STYLED_SLOTS`; the rest is live-only chrome |
+| `styles={slot: {...}}` (per-slot inline) | yes, all 48 slots | 11 slots: the text subset, + the chrome-box subset on `annotation_label`, + opacity/background on `annotation_layer` | 11 slots: the text subset, + the chrome-box subset on `annotation_label`, + opacity/background on `annotation_layer` | `_svg.STATIC_STYLED_SLOTS`; the rest is live-only chrome |
 | `class_names={slot: "..."}` | yes, all 48 slots | **dropped** (or resolved via `style_source="native_cascade"` / a captured `style_snapshot=`) | same | silent by default during migration; both opt-in routes are lossless for the published profile |
 | `custom_css="..."` | yes (HTML + Chromium capture) | **raises** | **raises** | `_resolve_image_engine`, `export.py:812` |
 | `xy.legend(style=...)` | yes | 6 keys | 6 keys | merged with the slot and the theme token before the writers see it |
@@ -325,12 +325,14 @@ and an exported file has no stylesheet to select from.
 A slot reaches the native writers when it names chrome a static file actually
 contains. `_svg.STATIC_STYLED_SLOTS` is that list: `title`, `axis_title`,
 `tick_label`, `legend`, `legend_title`, `legend_label`, `colorbar`,
-`colorbar_title`, `colorbar_tick`, and `annotation_label` (which additionally
+`colorbar_title`, `colorbar_tick`, `annotation_label` (which additionally
 carries the chrome-box subset — `_svg.SLOT_BOX_PROPS` — under the
-annotation's own `style=`, the narrower selector). The remaining slots are
-live-only chrome — `tooltip*`, `modebar*`, `crosshair_*`, `selection`,
-`badge*` — or containers with no painted text of their own; there is nothing
-in a PNG for them to style.
+annotation's own `style=`, the narrower selector), and `annotation_layer`
+(group opacity over the annotation shapes plus a plot-clipped background;
+the capability matrix records the two layer divergences). The remaining
+slots are live-only chrome — `tooltip*`, `modebar*`, `crosshair_*`,
+`selection`, `badge*` — or containers with no painted text of their own;
+there is nothing in a PNG for them to style.
 
 Within a supported slot the writers read a property subset, not a cascade:
 `font-size`, `font-weight`, `font-style`, `font-family`, `letter-spacing`,
diff --git a/spec/api/styling.md b/spec/api/styling.md
index e55d79f83..d0d9444c8 100644
--- a/spec/api/styling.md
+++ b/spec/api/styling.md
@@ -1324,10 +1324,11 @@ carry a defined subset of their declarations into SVG, PNG and PDF:
 
 | | |
 | --- | --- |
-| Slots | `title`, `axis_title`, `tick_label`, `legend`, `legend_title`, `legend_label`, `colorbar`, `colorbar_title`, `colorbar_tick`, `annotation_label` (`_svg.STATIC_STYLED_SLOTS`) |
+| Slots | `title`, `axis_title`, `tick_label`, `legend`, `legend_title`, `legend_label`, `colorbar`, `colorbar_title`, `colorbar_tick`, `annotation_label`, `annotation_layer` (`_svg.STATIC_STYLED_SLOTS`) |
 | Vector — SVG, PDF | `font-size`, `font-weight`, `font-style`, `font-family`, `letter-spacing`, `opacity`, and the text paint — `fill`, or `color` (`_svg.SLOT_TEXT_PROPS`) |
 | Raster — PNG, JPEG, WebP | `font-size`, `font-weight`, `font-style`, and the text paint (`_svg.SLOT_RASTER_PROPS`) |
 | `annotation_label` box | additionally `background`, `border` (+ longhands), `border-radius`, `padding`, offset `box-shadow`, `opacity`, `fill-opacity` (`_svg.SLOT_BOX_PROPS`), folded UNDER the annotation's own `style=` per property group |
+| `annotation_layer` | `opacity` (group over the annotation shapes; raster folds per-primitive) and `background`/`background-color` (plot-clipped) only |
 
 The raster atlas carries a regular, a bold and an italic face, so a slot's
 weight and style survive PNG/JPEG/WebP (weight ≥ 600 rounds up to the bold
diff --git a/tests/test_chrome_parity_p3.py b/tests/test_chrome_parity_p3.py
index 6fdda336c..492091289 100644
--- a/tests/test_chrome_parity_p3.py
+++ b/tests/test_chrome_parity_p3.py
@@ -294,6 +294,106 @@ def test_annotation_label_preflight_routes_text_and_box_props() -> None:
     assert finding.lost == ("outline-color",)
 
 
+# -- annotation_layer ---------------------------------------------------------
+
+
+def test_layer_opacity_wraps_shapes_in_a_group_and_survives_pdf() -> None:
+    chart = xy.line_chart(
+        _line(),
+        xy.hline(1.5, text="target"),
+        xy.marker(1.0, 1.0),
+        styles={"annotation_layer": {"opacity": 0.5}},
+    )
+    svg = _svg_of(chart)
+    assert '<g opacity="0.5">' in svg
+    # The group wraps shapes only — the label rides the labels container.
+    group = svg.split('<g opacity="0.5">', 1)[1].split("</g>", 1)[0]
+    assert "<line" in group and ">target<" not in group
+    assert svg_to_pdf(svg)[:4] == b"%PDF"
+    # Strictly declaration-gated in both writers.
+    plain = xy.line_chart(_line(), xy.hline(1.5, text="target"), xy.marker(1.0, 1.0))
+    empty = xy.line_chart(
+        _line(),
+        xy.hline(1.5, text="target"),
+        xy.marker(1.0, 1.0),
+        styles={"annotation_layer": {}},
+    )
+    assert _svg_of(plain) == _svg_of(empty)
+    assert (_raster_of(plain) == _raster_of(empty)).all()
+
+
+def test_layer_opacity_folds_per_primitive_in_raster_with_double_blend() -> None:
+    # The recorded divergence made executable: the display list has no group
+    # compositing, so two overlapping opaque bands under layer opacity 0.5
+    # blend TWICE where they overlap (darker), while the SVG group dims the
+    # union once (uniform). Both facts are asserted so the delta cannot rot
+    # silently.
+    def chart(**styles):
+        return xy.line_chart(
+            xy.line([0.0, 4.0], [0.0, 4.0], name="s"),
+            xy.x_band(1.0, 2.5, style={"color": "#2563eb", "opacity": 1.0}),
+            xy.x_band(1.5, 3.0, style={"color": "#2563eb", "opacity": 1.0}),
+            **styles,
+        )
+
+    dimmed = _raster_of(chart(styles={"annotation_layer": {"opacity": 0.5}}))
+    full = _raster_of(chart())
+    assert not (dimmed == full).all()
+    height, width = dimmed.shape[:2]
+    row = dimmed[height // 2]
+    full_row = full[height // 2]
+    # Sample one single-coverage column and one double-coverage column by
+    # walking the fully-opaque render: single-coverage pixels equal the band
+    # color exactly; the overlap is identical there (opaque over opaque).
+    band = np.array([37, 99, 235, 255])
+    on_band = np.where((full_row == band).all(axis=-1))[0]
+    assert on_band.size > 4
+    single_col, overlap_col = on_band[2], on_band[on_band.size // 2]
+    single = row[single_col].astype(float)
+    overlap = row[overlap_col].astype(float)
+    # Double-blend: the overlap is strictly darker than single coverage in
+    # the raster, where a browser-style group composite would keep them
+    # equal (KNOWN_RENDERER_DIVERGENCES: annotation_layer_opacity_compositing).
+    assert overlap[2] < single[2] < 255.0
+
+
+def test_layer_background_is_plot_clipped_and_under_the_shapes() -> None:
+    # Flagged geometry decision, pinned: the live overlay is full-bleed
+    # (inset:0) but the writers paint the plot rect — the only seam that is
+    # above the traces and below the annotation shapes in both writers
+    # (KNOWN_RENDERER_DIVERGENCES: annotation_layer_background_geometry).
+    chart = xy.line_chart(
+        _line(),
+        xy.hline(1.5),
+        styles={"annotation_layer": {"background": "#123456"}},
+    )
+    svg = _svg_of(chart)
+    rect = next(r for r in _rects(svg) if "#123456" in r)
+    clip_rect = re.search(r"<clipPath[^>]*><rect ([^/]*)/>", svg).group(1)
+    for key in ("x", "y", "width", "height"):
+        expected = re.search(rf'{key}="([-\d.]+)"', clip_rect).group(1)
+        assert f'{key}="{expected}"' in rect, (key, rect, clip_rect)
+    # Inside the clipped marks group, before the annotation shapes.
+    clipped = svg.split('<g clip-path="', 1)[1]
+    assert clipped.index("#123456") < clipped.index("<line ")
+    assert svg_to_pdf(svg)[:4] == b"%PDF"
+    # And the raster writer paints it (declaration-gated).
+    plain = xy.line_chart(_line(), xy.hline(1.5))
+    assert not (_raster_of(plain) == _raster_of(chart)).all()
+
+
+def test_layer_preflight_routes_opacity_and_background_only() -> None:
+    figure = xy.line_chart(
+        _line(),
+        xy.hline(1.5),
+        styles={"annotation_layer": {"opacity": 0.5, "border_radius": "4px"}},
+    ).figure()
+    report = figure.style_compatibility_report(target="png")
+    (finding,) = [f for f in report.findings if f.slot == "annotation_layer"]
+    assert finding.kept == ("opacity",)
+    assert finding.lost == ("border-radius",)
+
+
 # -- badge / badge_item: view-gated, excluded from static parity --------------
 
 
diff --git a/tests/test_export_style_survival.py b/tests/test_export_style_survival.py
index d3eaeba63..98b4245c2 100644
--- a/tests/test_export_style_survival.py
+++ b/tests/test_export_style_survival.py
@@ -57,10 +57,13 @@ def test_native_writers_read_a_property_subset_not_the_whole_cascade() -> None:
         assert f"cls-{slot}" not in svg
 
 
-#: The paint property each static slot answers to. `legend` is the frame box,
-#: so it takes `background`; every other static slot is text, so it takes the
-#: SVG text paint.
-_SLOT_PAINT_PROPERTY = {slot: "fill" for slot in STATIC_STYLED_SLOTS} | {"legend": "background"}
+#: The paint property each static slot answers to. `legend` is the frame box
+#: and `annotation_layer` the shape overlay, so they take `background`; every
+#: other static slot is text, so it takes the SVG text paint.
+_SLOT_PAINT_PROPERTY = {slot: "fill" for slot in STATIC_STYLED_SLOTS} | {
+    "legend": "background",
+    "annotation_layer": "background",
+}
 
 
 @pytest.mark.parametrize("slot", STATIC_STYLED_SLOTS)

From eb280212b8de6e0b8e0876127c0505fbe6aecb39 Mon Sep 17 00:00:00 2001
From: Alek Petuskey <alek@reflex.dev>
Date: Tue, 4 Aug 2026 16:39:32 -0700
Subject: [PATCH 19/27] Static-chrome parity P1: root, title, chrome and canvas
 boxes in both writers
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The four slots whose geometry the writers already know become real chrome
(spec/process/static-chrome-parity-plan-2026-08-04.md §3): every box goes
through the shared _chromebox lowering and the P0.3 emitter pair, and every
emission is strictly declaration-gated — tests prove an unstyled chart's
SVG and PNG bytes are unchanged by the new paths.

title: the anchor math both writers duplicated is hoisted into
_svg.title_placement / legacy_title_placement before any box is drawn (the
survey's explicit ordering — box extents added to two copies independently
would drift). title_box wraps the measured TextBlock — block width plus
padding, never the wrap width, because the browser box is the
shrink-to-fit div — and the rect rides `chrome` (SVG) / the display list
(raster) immediately before its text. _title_room grows by padding plus
paintable border WITH the client mirror (_titleBoxExtent,
js/src/50_chartview.ts) in the same change, or native and browser disagree
on plot.y. Per-entry box styling is native-only (the client's entry-style
allowlist) — recorded in KNOWN_RENDERER_DIVERGENCES, not silent.

root: the box IS the figure patch — same DOM element, one background
property — so its fill replaces theme(background=) instead of stacking, a
declared radius rounds it, and apply_export_background is now the single
precedence definition (export override > slot declaration > theme token),
silencing the root and canvas slot fills alongside the token pair. The
raster underlay skip requires a SQUARE fully-opaque patch: a rounded
root's corners must show the underlay, never uninitialized native white;
a painted root also satisfies the plot-rect white-fallback rule the way a
figure background does. box-shadow would fall outside the viewBox — it may
never grow the export, so it is a named preflight loss.

chrome: background/opacity only (plan §8 flag G), one rect between the
backgrounds and the grid in both writers; the browser's own DOM stacking
of this slot against titles diverges by design and is recorded in
KNOWN_RENDERER_DIVERGENCES rather than papered over.

canvas: painted at the ABOVE-grid seam — deliberately not the --chart-bg
anchor, the paint-order trap this family exists to avoid — so a declared
background hides the grid exactly as the browser's marks canvas does.
Radius is a THIRD clipPath wrapped around the marks group (never a
mutation of clip_id/marks_clip_id, which polar legends depend on) and
opacity rides that wrapper, both PDF-legal on <g>; the raster's rect-only
clip and missing group compositing make radius/opacity named raster
losses (SLOT_BOX_RASTER_UNSUPPORTED) until the rounded-clip opcode lands.

Registry, preflight and matrix move in the same commit (plan 0.4): the
three slots join STATIC_STYLED_SLOTS, SLOT_BOX_PROPS(_BY_SLOT) is the
writer-owned box vocabulary preflight._honored_props consumes, root loses
its browser-only special case, and the capability matrix regenerates.

Groundwork this landing completes: the border/padding shorthand expansion
promised with P0.3 (_chromebox.expand_box_shorthands, consumed by
lower_box and by the declared resolver so shorthands intern as schema
longhands while em legend values keep their authored residue spelling);
root/chrome SlotInstance geometry from the snapshot environment (spec
dims, never host padding — flag J's normalization rule; title/canvas need
the layout pass the resolver cannot re-enter and land with the capture
producers); and a P0.3 raster-emitter fix — _emit_slot_box fed (w, h) to
_rect_pts as the far corner, so any box not anchored at the origin painted
the wrong rectangle (now pinned by decoding the emitted quad).

Contracts updated with the change: spec/api/export.md §9, spec/api/styling.md
(including the P0.2-stale raster claim that weight/style were vector-only),
the capability matrix + docs mirror, and the limitations page.
---
 .../limitations-and-alpha-status.md           |  25 +-
 docs/styling/capabilities.md                  |  12 +-
 docs/styling/chrome-slots.md                  |  25 +-
 js/src/50_chartview.ts                        |  65 ++-
 python/xy/_chromebox.py                       |  91 +++-
 python/xy/_raster.py                          | 157 +++++--
 python/xy/_svg.py                             | 365 +++++++++++++---
 python/xy/styling/capabilities.py             |  91 +++-
 python/xy/styling/declared.py                 |  49 ++-
 python/xy/styling/preflight.py                |  43 +-
 scripts/gen_capability_matrix.py              |   9 +-
 spec/api/capability-matrix.md                 |  16 +-
 spec/api/export.md                            |  41 +-
 spec/api/styling.md                           |  33 +-
 .../static-chrome-parity-plan-2026-08-04.md   |  19 +-
 tests/test_chrome_parity_p1.py                | 389 ++++++++++++++++++
 tests/test_chromebox.py                       |  48 ++-
 tests/test_export_style_survival.py           |  10 +-
 tests/test_style_compatibility_report.py      |  50 ++-
 19 files changed, 1357 insertions(+), 181 deletions(-)
 create mode 100644 tests/test_chrome_parity_p1.py

diff --git a/docs/api-reference/limitations-and-alpha-status.md b/docs/api-reference/limitations-and-alpha-status.md
index 77043be3f..9dfd044a8 100644
--- a/docs/api-reference/limitations-and-alpha-status.md
+++ b/docs/api-reference/limitations-and-alpha-status.md
@@ -85,16 +85,21 @@ implementation. The bullets below are the boundaries that page's rows imply.
 - **Styling does not survive every export path equally, and the boundary is
   published rather than left to be discovered.** Mark, axis, and chart-level
   `style=` reach all three renderers. Per-slot `styles={slot: {...}}` reaches
-  them for the nine slots that name chrome a static file contains — `title`,
-  `axis_title`, `tick_label`, the three legend slots, and the three colorbar
-  slots — carrying `font-size`, `font-weight`, `font-style`, `font-family`,
-  `letter-spacing`, `opacity`, and the text paint. The remaining slots are live
-  chrome (`tooltip*`, `modebar*`, `crosshair_*`, `selection`, `badge*`) with
-  nothing in a file to paint, and `class_names={slot: "..."}` cannot apply in a
-  file at all: a class selects a rule out of a stylesheet an exported file does
-  not have. The native raster's baked atlas is one face, so PNG/JPEG/WebP honor
-  a slot's size and paint but not its typeface. `xy.colorbar(style=...)` still
-  has no native channel — use the `colorbar_*` slots. The full matrix is
+  them for the twelve slots that name chrome a static file contains — the box
+  slots `root`, `chrome`, and `canvas` (background, border, radius, opacity;
+  `chrome` is background/opacity only), plus `title`, `axis_title`,
+  `tick_label`, the three legend slots, and the three colorbar slots carrying
+  `font-size`, `font-weight`, `font-style`, `font-family`, `letter-spacing`,
+  `opacity`, and the text paint (the title also draws a box under its text).
+  The remaining slots are live chrome (`tooltip*`, `modebar*`, `crosshair_*`,
+  `selection`, `badge*`) with nothing in a file to paint, and
+  `class_names={slot: "..."}` cannot apply in a file at all: a class selects
+  a rule out of a stylesheet an exported file does not have. The raster atlas
+  carries regular/bold/italic faces but no family axis, so PNG/JPEG/WebP
+  honor a slot's size, paint, weight, and style but not its typeface — and
+  the raster's rectangular clip makes a `canvas` radius/opacity a named
+  raster loss. `xy.colorbar(style=...)` still has no native channel — use the
+  `colorbar_*` slots. The full matrix is
   [Static export §9](https://github.com/reflex-dev/xy/blob/main/spec/api/export.md),
   pinned by `tests/test_export_style_survival.py`.
 - Native PNG cannot apply author `custom_css`, and neither can native SVG, PDF,
diff --git a/docs/styling/capabilities.md b/docs/styling/capabilities.md
index bb428aaf7..717107f95 100644
--- a/docs/styling/capabilities.md
+++ b/docs/styling/capabilities.md
@@ -65,8 +65,8 @@ would not survive, before any bytes exist.
 |---|---|---|---|---|
 | `root` | clean static | full | partial | partial |
 | `title` | clean static | full | partial | partial |
-| `chrome` | clean static | full | none | none |
-| `canvas` | clean static | full | none | none |
+| `chrome` | clean static | full | partial | partial |
+| `canvas` | clean static | full | partial | partial |
 | `annotation_layer` | clean static | full | none | none |
 | `labels` | clean static | full | none | none |
 | `legend` | clean static | full | partial | partial |
@@ -114,8 +114,10 @@ would not survive, before any bytes exist.
 
 ### Notes
 
-- **`root`** (via `chart style=`) — `styles={'root': ...}` is browser-only, but the chart-level `style=` token bag targets the same element and every renderer reads it (`spec['dom']['style']`). Prefer it for anything that must survive export.
-- **`title`** (via `styles={'title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
+- **`root`** (via `styles={'root': ...} / chart style=`) — Box slot: both writers honor background, border (color/width/style, dashed/dotted as dash arrays), symmetric border-radius, opacity and fill-opacity through the shared chrome-box lowering (`xy._chromebox.lower_box`); everything it cannot draw is a named loss in the preflight, never silent (§28). The root box is the figure patch: its fill replaces the `theme(background=)` token when both are set (same element, one background property, matching the browser), and an export `background=` override silences it (`_svg.apply_export_background` is the one precedence definition). box-shadow would fall outside the canvas and is a named loss; text properties have no root text to style. The chart-level `style=` token bag still reaches every renderer.
+- **`title`** (via `styles={'title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only. The title also takes the full box vocabulary (`_svg.SLOT_BOX_PROPS`): a box under the text, sized to the measured block plus padding, with the title band growing to fit. Per-entry `xy.title(style=...)` box properties are native-only (KNOWN_RENDERER_DIVERGENCES `title_entry_box_allowlist`).
+- **`chrome`** (via `styles={'chrome': ...}`) — Background and opacity only (parity plan §8 flag G): one full-canvas backdrop above the root and plot fills, below the grid. The rest of the box vocabulary is a named preflight loss, and the browser's own stacking of this slot against titles diverges by design (KNOWN_RENDERER_DIVERGENCES `chrome_slot_title_stacking`).
+- **`canvas`** (via `styles={'canvas': ...}`) — Box slot: both writers honor background, border (color/width/style, dashed/dotted as dash arrays), symmetric border-radius, opacity and fill-opacity through the shared chrome-box lowering (`xy._chromebox.lower_box`); everything it cannot draw is a named loss in the preflight, never silent (§28). Painted at the above-grid seam, so a canvas background hides the grid exactly as the browser's marks canvas does; border-radius clips the marks through a dedicated clipPath in SVG/PDF and opacity rides the marks group there. The raster display list clips rectangles only and has no group compositing, so border-radius and opacity are named raster losses (`_svg.SLOT_BOX_RASTER_UNSUPPORTED`) until the rounded-clip opcode lands. An export `background=` override silences a canvas background like the plot token.
 - **`legend`** (via `styles={'legend': ...} / xy.legend(style=...) / --chart-legend-bg`) — The frame box. Both spellings and the theme token now converge on one merged declaration block before the writers see it, so what agrees in the browser agrees in a PNG. `background`, `boxShadow`, `borderRadius`, `--xy-legend-frame-alpha`, and `padding`/`rowGap` in `em` are honored; an explicit background paints opaque, as it does in the browser.
 - **`legend_title`** (via `styles={'legend_title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
 - **`legend_label`** (via `styles={'legend_label': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
@@ -143,6 +145,8 @@ an undocumented difference reads as a bug; a documented one is a contract.
 | what | browser | svg | native png | visible when |
 |---|---|---|---|---|
 | Interior vertices of a wide polyline | the notch two overlapping segment quads leave | round (the writer names it explicitly) | round (the capsule distance field fills the vertex) | stroke-width above ~4px at a sharp angle |
+| A styled `chrome` slot background against the title text and the plot fill | the chrome canvas is appended AFTER the title divs (js/src/50_chartview.ts) and its CSS background paints under its own bitmap, so the backdrop covers titles and sits below --chart-bg | one rect between the backgrounds and the grid group: above the root and plot fills, below every grid line and all chrome text | same seam as SVG (after the plot fill, before the plot clip) | styles={'chrome': {'background': ...}} overlaps a title, or is combined with a --chart-bg plot fill |
+| Box styling authored on a per-entry title `style=` (not the title slot) | dropped: the client copies only color/font-family/font-size/font-style/font-weight from an entry's style onto the title div (js/src/50_chartview.ts entry-style allowlist) | honored: `_title_metrics` merges entry style over the slot, box included | honored, same merge (the two writers share the title placement) | xy.title(style={'background': ...}) or another per-entry box property |
 
 For what is still alpha, see
 [Limitations and Alpha Status](/docs/xy/api-reference/limitations-and-alpha-status/).
diff --git a/docs/styling/chrome-slots.md b/docs/styling/chrome-slots.md
index 526d659ee..a942756f9 100644
--- a/docs/styling/chrome-slots.md
+++ b/docs/styling/chrome-slots.md
@@ -358,20 +358,27 @@ apply it with. Rather than leave that to be discovered, it is a contract:
 | --- | --- | --- | --- |
 | mark / axis `style=` | yes | yes | yes |
 | chart-level `style=` (design tokens) | yes | yes | yes |
-| `styles={slot: {...}}` | yes, all 48 slots | text subset, 9 slots | text subset, 9 slots |
+| `styles={slot: {...}}` | yes, all 48 slots | text/box subset, 12 slots | text/box subset, 12 slots |
 | `class_names={slot: "..."}` | yes, all 48 slots | dropped | dropped |
 | `custom_css=` | yes | raises | raises |
 | `xy.legend(style=...)` | yes | 6 keys | 6 keys |
 | `xy.colorbar(style=...)` | yes | dropped | dropped |
 
-A per-slot `styles=` block reaches a file for the nine slots that name chrome a
-file actually contains — `title`, `axis_title`, `tick_label`, the three legend
-slots and the three colorbar slots — carrying `font-size`, `font-weight`,
-`font-style`, `font-family`, `letter-spacing`, `opacity` and the text paint.
-The rest are live-only chrome (`tooltip*`, `modebar*`, `crosshair_*`,
-`selection`, `badge*`) with nothing in a file to paint. The native raster's
-baked atlas is one face, so it honors a slot's size and paint and leaves the
-typeface properties to the vector writers.
+A per-slot `styles=` block reaches a file for the twelve slots that name
+chrome a file actually contains. The box slots `root`, `chrome` and `canvas`
+carry background, border, symmetric border-radius and opacity (`chrome` is
+background/opacity only; the raster cannot round-clip or group-fade the
+marks, so a `canvas` radius/opacity survives SVG/PDF and is a named loss on
+PNG). The text slots — `title`, `axis_title`, `tick_label`, the three legend
+slots and the three colorbar slots — carry `font-size`, `font-weight`,
+`font-style`, `font-family`, `letter-spacing`, `opacity` and the text paint,
+and the title additionally draws a box under its text (padding and border
+included, with the title band growing to fit). The rest are live-only chrome
+(`tooltip*`, `modebar*`, `crosshair_*`, `selection`, `badge*`) with nothing
+in a file to paint. The raster atlas carries regular, bold and italic faces
+but no family axis, so it honors a slot's size, paint, weight and style and
+leaves `font-family`, `letter-spacing` and text opacity to the vector
+writers.
 
 The `class_names` row is dropped rather than raising: raising would break every
 native export of a chart that carries Tailwind classes for its live view, which
diff --git a/js/src/50_chartview.ts b/js/src/50_chartview.ts
index 7e8f22973..6bb44f38e 100644
--- a/js/src/50_chartview.ts
+++ b/js/src/50_chartview.ts
@@ -706,6 +706,13 @@ export class ChartView {
     // `_positionTitles` caps the element at this same width, so what the DOM
     // wraps is exactly what is reserved here.
     this._titleWrapWidth = Math.max(40, this.size.w - authoredLeft - baseRight);
+    // A declared title box (padding/border on the title slot) grows the DOM
+    // element, so the band must reserve the extra height or the box pokes
+    // above the canvas. Mirrors `_title_box_extent` in python/xy/_svg.py —
+    // the two must agree or native and browser disagree on plot.y. Slot-level
+    // only: per-entry box declarations are native-only by the entry-style
+    // allowlist below (a recorded divergence, KNOWN_RENDERER_DIVERGENCES).
+    const titleBoxExtent = this._titleBoxExtent();
     const titleRoom = this._titleEntries().reduce((room, entry) => {
       const authoredSize = Number.parseFloat(entry.style?.["font-size"]);
       const titleFontSize = Number.isFinite(authoredSize)
@@ -716,8 +723,8 @@ export class ChartView {
       ).h;
       const pad = Number.isFinite(Number(entry.pad)) ? Number(entry.pad) : 8;
       const candidate = entry.automatic_y !== false
-        ? Math.max(compact ? 26 : 30, measured + pad)
-        : (Number(entry.y ?? 1) >= 1 ? measured + pad : 0);
+        ? Math.max(compact ? 26 : 30, measured + titleBoxExtent + pad)
+        : (Number(entry.y ?? 1) >= 1 ? measured + titleBoxExtent + pad : 0);
       return Math.max(room, candidate);
     }, 0);
     this._titleRoom = titleRoom;
@@ -1032,6 +1039,60 @@ export class ChartView {
     return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
   }
 
+  // Vertical px the title slot's declared box adds around its text block:
+  // padding plus a paintable border, above and below. Mirrors
+  // `_title_box_extent` in python/xy/_svg.py (same rules, including the
+  // native model's "border counts only with an explicit border-color, which
+  // implies the 1px chrome border" — an out-of-model spelling like a
+  // colorless `border-style` reserves nothing in either renderer's layout).
+  // Zero whenever the slot declares no box, so unstyled layout cannot move.
+  _titleBoxExtent() {
+    const styles = this.spec.dom?.styles;
+    const raw = styles && typeof styles === "object" ? styles.title : null;
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) return 0;
+    const decl: Record<string, any> = {};
+    for (const [key, value] of Object.entries(raw)) {
+      if (typeof key !== "string") continue;
+      if (typeof value !== "string" && typeof value !== "number") continue;
+      decl[this._stylePropertyName(key)] = value;
+    }
+    const px = (value) => {
+      if (typeof value === "number") return Number.isFinite(value) ? value : null;
+      const m = /^\s*(-?\d+(?:\.\d+)?)(?:px)?\s*$/.exec(String(value ?? ""));
+      return m ? Number.parseFloat(m[1]) : null;
+    };
+    let top = px(decl["padding-top"]);
+    let bottom = px(decl["padding-bottom"]);
+    if ((top == null || bottom == null) && decl.padding != null) {
+      const parts = String(decl.padding).trim().split(/\s+/).map(px);
+      if (parts.length >= 1 && parts.length <= 4 && parts.every((p) => p != null)) {
+        if (top == null) top = parts[0];
+        if (bottom == null) bottom = parts.length > 2 ? parts[2] : parts[0];
+      }
+    }
+    let width = px(decl["border-width"]);
+    let hasColor = decl["border-color"] != null;
+    let style = decl["border-style"] != null ? String(decl["border-style"]).toLowerCase() : null;
+    if (typeof decl.border === "string") {
+      const styles_ = ["solid", "dashed", "dotted", "none", "hidden", "double",
+        "groove", "ridge", "inset", "outset"];
+      for (const token of decl.border.split(/\s+/).filter(Boolean)) {
+        const tokenPx = px(token);
+        if (tokenPx != null && width == null) width = tokenPx;
+        else if (styles_.includes(token.toLowerCase()) && style == null) style = token.toLowerCase();
+        else hasColor = true;
+      }
+    }
+    let border = 0;
+    if (hasColor && style !== "none" && style !== "hidden") {
+      // An absent or zero width with a declared color is the implied 1px
+      // chrome border (lower_box's rule); a negative width paints nothing.
+      if (width == null || width === 0) border = 1;
+      else if (width > 0) border = width;
+    }
+    return (top ?? 0) + (bottom ?? 0) + 2 * border;
+  }
+
   _xAxisRoom(side, plotWidth) {
     let room = 0;
     for (const axis of Object.values<any>(this.axes || {})) {
diff --git a/python/xy/_chromebox.py b/python/xy/_chromebox.py
index 94af40b95..d07691e23 100644
--- a/python/xy/_chromebox.py
+++ b/python/xy/_chromebox.py
@@ -31,10 +31,14 @@
 from dataclasses import dataclass, field
 from typing import Any, Optional
 
-__all__ = ["ChromeBox", "lower_box"]
+__all__ = ["ChromeBox", "box_padding", "expand_box_shorthands", "lower_box"]
 
 _LENGTH_RE = re.compile(r"^\s*(-?\d+(?:\.\d+)?)(?:px)?\s*$")
 
+_BORDER_STYLES = frozenset(
+    {"solid", "dashed", "dotted", "none", "hidden", "double", "groove", "ridge", "inset", "outset"}
+)
+
 
 @dataclass(frozen=True)
 class ChromeBox:
@@ -53,6 +57,10 @@ class ChromeBox:
     radius: float = 0.0
     shadow: Optional[tuple[float, float, str]] = None  # (dx, dy, color)
     opacity: float = 1.0
+    # (top, right, bottom, left) px. Consumed by the layout/room functions
+    # that size the box around its content — never by the emitters, which
+    # draw exactly the (x, y, w, h) they are given.
+    padding: tuple[float, float, float, float] = (0.0, 0.0, 0.0, 0.0)
     unrepresentable: tuple[str, ...] = field(default_factory=tuple)
 
     @property
@@ -141,6 +149,85 @@ def _parse_shadow(value: str) -> tuple[Optional[tuple[float, float, str]], Optio
     return (lengths[0], lengths[1], color or "rgba(0, 0, 0, 0.22)"), None
 
 
+def _padding_sides(value: Any) -> Optional[tuple[float, float, float, float]]:
+    """A CSS `padding` shorthand as (top, right, bottom, left), or None."""
+    if isinstance(value, (int, float)) and not isinstance(value, bool):
+        px = float(value)
+        return (px, px, px, px)
+    if not isinstance(value, str):
+        return None
+    parts = [_px(token) for token in value.split()]
+    if not 1 <= len(parts) <= 4 or any(px is None for px in parts):
+        return None
+    sides = [float(px) for px in parts if px is not None]
+    top = sides[0]
+    right = sides[1] if len(sides) > 1 else top
+    bottom = sides[2] if len(sides) > 2 else top
+    left = sides[3] if len(sides) > 3 else right
+    return (top, right, bottom, left)
+
+
+def expand_box_shorthands(declaration: dict[str, Any]) -> dict[str, Any]:
+    """Split the box shorthands (`border`, `padding`) into their longhands.
+
+    Same policy as the cascade extension's `_expand_shorthands`: an explicit
+    longhand beside the shorthand wins (it is the narrower author intent).
+    A shorthand this parser cannot split — an em `padding`, a `border` with
+    no recognizable parts — is passed through untouched so nothing declared
+    disappears; the consumer decides what an unexpanded value means.
+    """
+    out: dict[str, Any] = {}
+    for prop, value in declaration.items():
+        if prop == "padding":
+            sides = _padding_sides(value)
+            if sides is not None:
+                for name, side in zip(
+                    ("padding-top", "padding-right", "padding-bottom", "padding-left"),
+                    sides,
+                    strict=True,
+                ):
+                    if name not in declaration:
+                        out.setdefault(name, side)
+                continue
+        if prop == "border" and isinstance(value, str):
+            width: Optional[float] = None
+            style: Optional[str] = None
+            color_parts: list[str] = []
+            for token in value.split():
+                token_px = _px(token)
+                if token_px is not None and width is None:
+                    width = token_px
+                elif token.lower() in _BORDER_STYLES and style is None:
+                    style = token.lower()
+                else:
+                    color_parts.append(token)
+            if width is not None or style is not None or color_parts:
+                if width is not None and "border-width" not in declaration:
+                    out.setdefault("border-width", width)
+                if style is not None and "border-style" not in declaration:
+                    out.setdefault("border-style", style)
+                if color_parts and "border-color" not in declaration:
+                    out.setdefault("border-color", " ".join(color_parts))
+                continue
+        out[prop] = value
+    return out
+
+
+def box_padding(declaration: dict[str, Any]) -> tuple[float, float, float, float]:
+    """A declaration's resolved padding as (top, right, bottom, left) px.
+
+    Longhands win over the shorthand; anything unparsable (em values stay
+    the legend writers' domain until P4) contributes zero rather than a
+    guess.
+    """
+    expanded = expand_box_shorthands(declaration)
+    top, right, bottom, left = (
+        float(_px(expanded.get(name)) or 0.0)
+        for name in ("padding-top", "padding-right", "padding-bottom", "padding-left")
+    )
+    return (top, right, bottom, left)
+
+
 def lower_box(
     slot: str,
     declaration: dict[str, Any],
@@ -158,6 +245,7 @@ def lower_box(
     that list, so nothing rounds to silence.
     """
     unrepresentable: list[str] = []
+    declaration = expand_box_shorthands(declaration)
 
     fill = declaration.get("background")
     if fill is None:
@@ -218,5 +306,6 @@ def lower_box(
         radius=radius,
         shadow=shadow,
         opacity=_opacity(declaration.get("opacity"), 1.0),
+        padding=box_padding(declaration),
         unrepresentable=tuple(unrepresentable),
     )
diff --git a/python/xy/_raster.py b/python/xy/_raster.py
index cc2646643..5c3ad2f94 100644
--- a/python/xy/_raster.py
+++ b/python/xy/_raster.py
@@ -22,6 +22,7 @@
 
 from . import _paint, _png, _scene, _textblock
 from ._arrowgeom import arrow_shapes as _arrow_shapes
+from ._chromebox import lower_box
 from ._svg import (
     _AXIS,
     _AXIS_GRID_DASHES,
@@ -62,13 +63,13 @@
     _step_arrays,
     _tick_label_anchor,
     _title_entries,
-    _title_metrics,
     affine_fast_path,
     annotation_label_placement,
     apply_export_background,
     axis_ticks,
     hexbin_ring,
     layout,
+    legacy_title_placement,
     legend_clip_rect,
     legend_items,
     legend_options_with_slot,
@@ -76,9 +77,12 @@
     polar_heatmap_rgba,
     polar_tick_label_layout,
     polar_wedge_points,
+    slot_box_declaration,
     slot_font_size,
     slot_styles,
     slot_text_color,
+    title_box,
+    title_placement,
     warp_grid_rgba,
 )
 
@@ -782,9 +786,11 @@ def _emit_slot_box(cmd: "_Cmd", box: Any) -> None:
         return
 
     def pts(x: float, y: float) -> list[tuple[float, float]]:
+        # (x0, y0, x1, y1) corners, like every other _rect_pts caller — the
+        # box carries a width/height pair, not a far corner.
         if box.radius > 0:
-            return _round_rect_pts(x, y, box.w, box.h, box.radius)
-        return _rect_pts(x, y, box.w, box.h)
+            return _round_rect_pts(x, y, x + box.w, y + box.h, box.radius)
+        return _rect_pts(x, y, x + box.w, y + box.h)
 
     if box.shadow is not None:
         dx, dy, color = box.shadow
@@ -981,23 +987,53 @@ def render_raster(
     cmd = _Cmd(scale)
 
     dom_style = (spec.get("dom") or {}).get("style") or {}
+    slots = slot_styles(spec)
 
     # Figure patch (mpl figure.facecolor): `theme(background=)` lands on the
     # root element's CSS background, painted over the whole canvas so the
     # margins match the browser. Gradients stay browser-only (skipped).
     figure_background = _solid_color(dom_style.get("background"))
 
+    # The root slot's box (parity plan §3.4), mirroring the SVG writer:
+    # declaration-gated, and when declared it IS the figure patch (one DOM
+    # element, one `background` property), so the theme paint becomes the box
+    # fill when the slot declares chrome but no fill of its own.
+    # `apply_export_background` already silenced the slot fill under an
+    # export `background=` override — the single precedence definition.
+    root_declaration = slot_box_declaration(slots.get("root") or {}, "root")
+    root_box = None
+    if root_declaration:
+        figure_css = _solid_paint(dom_style.get("background"))
+        if figure_css is not None and not any(
+            prop in root_declaration for prop in ("background", "background-color")
+        ):
+            root_declaration = {"background": figure_css, **root_declaration}
+        root_box = lower_box("root", root_declaration, x=0.0, y=0.0, w=width, h=height)
+
     # The fused PNG path initializes its native canvas white, avoiding a second
     # full-frame memory pass. Raw RGBA callers still receive an explicit fill —
-    # skipped when an opaque figure background would fully cover it anyway
+    # skipped when an opaque full-bleed paint would fully cover it anyway
     # (a translucent one keeps the white underlay to composite over, matching
-    # the browser's white host page).
-    if not fast_png and (figure_background is None or figure_background[3] < 255):
+    # the browser's white host page). A ROUNDED root box breaks full-bleed
+    # coverage — its corners must show the underlay, never uninitialized
+    # pixels — so the skip only fires for a square, fully-opaque patch.
+    if root_box is not None:
+        root_fill = (
+            _parse_color(root_box.fill, opacity=root_box.opacity * root_box.fill_opacity)
+            if root_box.fill is not None
+            else None
+        )
+        covers = root_fill is not None and root_fill[3] >= 255 and root_box.radius == 0.0
+    else:
+        covers = figure_background is not None and figure_background[3] >= 255
+    if not fast_png and not covers:
         cmd.fill(
             _rect_pts(0, 0, width, height),
             _parse_color(spec.get("canvas_background", "#ffffff")),
         )
-    if figure_background is not None:
+    if root_box is not None:
+        _emit_slot_box(cmd, root_box)
+    elif figure_background is not None:
         cmd.fill(_rect_pts(0, 0, width, height), figure_background)
 
     # Static exports honor the same axes background token as HTML/SVG.  This
@@ -1005,11 +1041,13 @@ def render_raster(
     # is the Figure patch, composed above (or by pyplot's grid exporter). An
     # unset token keeps the plot rect transparent when a figure background is
     # present — matching the browser, where the root shows through — and
-    # falls back to the classic white fill otherwise.
+    # falls back to the classic white fill otherwise. A painted root box
+    # counts as a figure background here: the browser shows it through the
+    # transparent plot rect, so the white fallback must not bury it.
     plot_css = _css(dom_style.get("--chart-bg"), "")
     if plot_css:
         plot_background = _parse_color(plot_css)
-    elif figure_background is None:
+    elif figure_background is None and (root_box is None or root_box.fill is None):
         plot_background = _parse_color("#ffffff")
     else:
         plot_background = None
@@ -1019,6 +1057,17 @@ def render_raster(
             plot_background,
         )
 
+    # The chrome slot (parity plan §3.5, background/opacity only): above the
+    # root and plot backgrounds, below the grid — before the plot clip so it
+    # covers the full canvas exactly like the browser's inset:0 chrome
+    # canvas. Its stacking against the title divs diverges by design and is
+    # recorded in `KNOWN_RENDERER_DIVERGENCES` (`chrome_slot_title_stacking`).
+    chrome_declaration = slot_box_declaration(slots.get("chrome") or {}, "chrome")
+    if chrome_declaration:
+        _emit_slot_box(
+            cmd, lower_box("chrome", chrome_declaration, x=0.0, y=0.0, w=width, h=height)
+        )
+
     xt, xlab, xstep = axis_ticks(xa, plot["w"], True)
     yt, ylab, ystep = axis_ticks(ya, plot["h"], False)
     xmt, ymt = minor_axis_ticks(xa), minor_axis_ticks(ya)
@@ -1087,6 +1136,36 @@ def render_raster(
             dash=_AXIS_GRID_DASHES.get(str(ystyle.get("grid_dash", "solid"))),
         )
 
+    # The canvas slot (parity plan §3.6) paints at the ABOVE-grid seam,
+    # inside the plot clip and before every trace: the browser's marks canvas
+    # is a separate element over the chrome canvas, so a declared canvas
+    # background HIDES the grid — deliberately NOT the below-grid --chart-bg
+    # anchor, the paint-order trap this family exists to avoid. The display
+    # list clips rectangles only and has no group compositing, so a declared
+    # `border-radius` (rounded content clip) and `opacity` (fading marks
+    # already drawn by later commands) are raster losses the preflight names
+    # (`_svg.SLOT_BOX_RASTER_UNSUPPORTED`) — stripped here rather than
+    # half-approximated on the box alone.
+    canvas_declaration = slot_box_declaration(slots.get("canvas") or {}, "canvas")
+    if canvas_declaration:
+        canvas_declaration = {
+            prop: value
+            for prop, value in canvas_declaration.items()
+            if prop not in ("border-radius", "opacity")
+        }
+    if canvas_declaration:
+        _emit_slot_box(
+            cmd,
+            lower_box(
+                "canvas",
+                canvas_declaration,
+                x=plot["x"],
+                y=plot["y"],
+                w=plot["w"],
+                h=plot["h"],
+            ),
+        )
+
     # Grid/frame chrome is drawn before the shaped clip. Marks then share one
     # analytic annular-sector clip in the native painter, matching SVG's
     # polar clipPath without flattening every mark at the boundary.
@@ -1346,8 +1425,6 @@ def tick_span(style: dict[str, Any]) -> tuple[float, float]:
                     _parse_color(_css(axis_style.get("tick_color"), default_axis)),
                 )
 
-    slots = slot_styles(spec)
-
     def slot_paint(slot: str, fallback: str) -> tuple:
         """A slot's text paint, or the writer's own default."""
         resolved = slot_text_color(slots.get(slot) or {}, "")
@@ -1469,62 +1546,54 @@ def emit_tick_labels(
     # draw more lines than `title_room` reserved (see _svg._title_wrap_width).
     title_wrap_width = plot.get("title_wrap_width")
     if legacy_title:
-        title_slot = slots.get("title") or {}
+        # Anchor math shared with the SVG writer (`_svg.legacy_title_placement`):
+        # the last line keeps the historical single-line baseline, extra lines
+        # fill the reserved band above it — byte-identical when unstyled.
+        placement = legacy_title_placement(spec, plot, compact, width, title_wrap_width)
         title_italic, title_bold = _native_font_emphasis(
             {
-                "font_style": title_slot.get("font-style"),
-                "font_weight": title_slot.get("font-weight", 400),
+                "font_style": placement.style.get("font-style"),
+                "font_weight": placement.style.get("font-weight", 400),
             }
         )
-        legacy_size = slot_font_size(title_slot, 14.0)
-        legacy_block = _textblock.measure(legacy_title, legacy_size, max_width=title_wrap_width)
-        # Lines run downward from the baseline, so lift the block by its trailing
-        # lines: the last line keeps the historical single-line baseline. A
-        # one-line title has no trailing lines and emits exactly as before.
-        legacy_trailing = (legacy_block.line_count - 1) * legacy_block.line_step
+        legacy_box = title_box(placement)
+        if legacy_box is not None:
+            _emit_slot_box(cmd, legacy_box)
         _emit_text_block(
             cmd,
-            width / 2,
-            plot["y"] - plot["top_axis_room"] - (10 if compact else 12) - legacy_trailing,
+            placement.x,
+            placement.baseline,
             1,
-            legacy_size,
+            placement.size,
             slot_paint("title", default_text),
-            "\n".join(legacy_block.lines),
+            "\n".join(placement.block.lines),
             italic=title_italic,
             bold=title_bold,
         )
     for title_entry in [] if legacy_title else _title_entries(spec):
-        title_style, title_size, title_block = _title_metrics(spec, title_entry, title_wrap_width)
+        placement = title_placement(spec, title_entry, plot, title_wrap_width)
         title_italic, title_bold = _native_font_emphasis(
             {
-                "font_style": title_style.get("font-style"),
+                "font_style": placement.style.get("font-style"),
                 # 400 = Matplotlib's `axes.titleweight: normal`; the baked
                 # atlas only has a bold face, so anything >= 600 rounds up to
                 # it. Mirrors the SVG/browser title default.
-                "font_weight": title_style.get("font-weight", 400),
+                "font_weight": placement.style.get("font-weight", 400),
             }
         )
-        trailing = (title_block.line_count - 1) * title_block.line_step
-        if title_entry.get("automatic_y", True):
-            title_anchor_y = plot["y"] - plot["top_axis_room"]
-        else:
-            title_anchor_y = plot["y"] + (1.0 - float(title_entry.get("y", 1.0))) * plot["h"]
-        loc = str(title_entry.get("loc", "center"))
-        title_x = {
-            "left": plot["x"],
-            "center": plot["x"] + plot["w"] / 2.0,
-            "right": plot["x"] + plot["w"],
-        }.get(loc, plot["x"] + plot["w"] / 2.0)
+        entry_box = title_box(placement)
+        if entry_box is not None:
+            _emit_slot_box(cmd, entry_box)
         _emit_text_block(
             cmd,
-            title_x,
-            title_anchor_y - float(title_entry.get("pad", 8.0)) - title_block.descent - trailing,
-            {"left": 0, "center": 1, "right": 2}.get(loc, 1),
-            title_size,
-            _parse_color(slot_text_color(title_style, default_text)),
+            placement.x,
+            placement.baseline,
+            {"start": 0, "middle": 1, "end": 2}[placement.anchor],
+            placement.size,
+            _parse_color(slot_text_color(placement.style, default_text)),
             # The wrapped lines, not the raw string: one long line inside a
             # two-line band is the clipping bug this reservation exists to stop.
-            "\n".join(title_block.lines),
+            "\n".join(placement.block.lines),
             italic=title_italic,
             bold=title_bold,
         )
diff --git a/python/xy/_svg.py b/python/xy/_svg.py
index 8f523c09e..55f72dd7b 100644
--- a/python/xy/_svg.py
+++ b/python/xy/_svg.py
@@ -31,6 +31,7 @@
 
 from . import _fontmetrics, _native, _paint, _png, _textblock
 from ._arrowgeom import arrow_shapes as _arrow_shapes
+from ._chromebox import ChromeBox, box_padding, lower_box
 from .config import DEFAULT_PALETTE, polar_bar_segments
 
 
@@ -1363,8 +1364,14 @@ def _px_size(value: Any, default: float) -> float:
 #: Slots the native writers style. Every one names chrome that a static file
 #: actually contains; the rest of `CHART_DOM_SLOTS` is live-only chrome
 #: (tooltip, modebar, crosshair, selection, badge) or a container with no
-#: painted text of its own, and stays browser-only.
+#: painted box or text of its own yet, and stays browser-only. `root`,
+#: `chrome` and `canvas` joined with the static-chrome-parity P1 family
+#: (spec/process/static-chrome-parity-plan-2026-08-04.md §3): they take the
+#: box vocabulary (`SLOT_BOX_PROPS_BY_SLOT`), not the text subset.
 STATIC_STYLED_SLOTS: tuple[str, ...] = (
+    "root",
+    "chrome",
+    "canvas",
     "title",
     "axis_title",
     "tick_label",
@@ -1428,6 +1435,68 @@ def slot_styles(spec: dict[str, Any]) -> dict[str, dict[str, Any]]:
     }
 )
 
+#: The chrome-box vocabulary the writers honor on a box-capable slot — the
+#: declaration surface of `xy._chromebox.lower_box` plus the shorthands it
+#: expands. Owned here (the `LEGEND_BOX_PROPS` pattern) so the writers, the
+#: capability registry, and the preflight report cannot drift: preflight's
+#: `_honored_props` consumes `SLOT_BOX_PROPS_BY_SLOT` directly.
+SLOT_BOX_PROPS: frozenset[str] = frozenset(
+    {
+        "background",
+        "background-color",
+        "border",
+        "border-color",
+        "border-style",
+        "border-width",
+        "border-radius",
+        "box-shadow",
+        "padding",
+        "padding-top",
+        "padding-right",
+        "padding-bottom",
+        "padding-left",
+        "opacity",
+        "fill-opacity",
+    }
+)
+
+#: The padding spellings, split out so the per-slot subsets below can name
+#: "the box minus padding" without restating five strings.
+_SLOT_BOX_PADDING_PROPS: frozenset[str] = frozenset(
+    {"padding", "padding-top", "padding-right", "padding-bottom", "padding-left"}
+)
+
+#: Which box-capable slot honors which subset, per the P1 decisions:
+#: `title` takes the full box under its text; `root` and `canvas` take the
+#: box minus `box-shadow` (a shadow on either falls outside the canvas — it
+#: may never grow the export, so it is a named loss, §28) and minus padding
+#: (their geometry is the canvas/plot rect, there is no content to pad);
+#: `chrome` is background/opacity only (plan §8 flag G — the rest of its box
+#: model is recorded unrepresentable rather than half-drawn).
+SLOT_BOX_PROPS_BY_SLOT: dict[str, frozenset[str]] = {
+    "title": SLOT_BOX_PROPS,
+    "root": SLOT_BOX_PROPS - {"box-shadow"} - _SLOT_BOX_PADDING_PROPS,
+    "canvas": SLOT_BOX_PROPS - {"box-shadow"} - _SLOT_BOX_PADDING_PROPS,
+    "chrome": frozenset({"background", "background-color", "opacity"}),
+}
+
+#: Box requests a slot's RASTER path cannot draw while the vector path can:
+#: rounding the canvas needs a rounded content clip (the display list clips
+#: rectangles only) and canvas opacity needs group compositing (the display
+#: list has none) — both stay recorded losses on PNG/JPEG/WebP until the
+#: `src/raster.rs` opcode lands (plan §1.3), never silent approximations.
+SLOT_BOX_RASTER_UNSUPPORTED: dict[str, frozenset[str]] = {
+    "canvas": frozenset({"border-radius", "opacity"}),
+}
+
+
+def slot_box_declaration(style: dict[str, Any], slot: str) -> dict[str, Any]:
+    """The subset of a slot's declaration its box honors, or {} when the
+    declaration carries no box property at all — the emission gate every
+    box-capable slot shares, so unstyled output stays byte-identical."""
+    honored = SLOT_BOX_PROPS_BY_SLOT.get(slot, SLOT_BOX_PROPS)
+    return {prop: value for prop, value in style.items() if prop in honored}
+
 
 def legend_options_with_slot(spec: dict[str, Any], options: dict[str, Any]) -> dict[str, Any]:
     """Fold the chart-level legend styling into a legend's own options, so every
@@ -1519,6 +1588,12 @@ def apply_export_background(spec: dict[str, Any], background: Optional[str]) ->
     is what actually shows regardless of chart theme, instead of being buried
     under the theme paints. The plot token becomes "transparent" rather than
     the override color so translucent backgrounds composite exactly once.
+    The `root` and `canvas` slot backgrounds are part of that painted
+    backdrop (they target the same two elements the token pair does), so the
+    override silences them too — this function is the single definition of
+    the three-source precedence: export override > slot declaration > theme
+    token. Non-background box styling (a border, a radius) is chrome, not
+    backdrop, and survives the override.
     Shared by the raster exporter and (via SVG) the PDF exporter."""
     if background is None:
         return
@@ -1529,6 +1604,14 @@ def apply_export_background(spec: dict[str, Any], background: Optional[str]) ->
         if isinstance(style, dict):
             style.pop("background", None)
             style["--chart-bg"] = "transparent"
+        styles = dom.get("styles")
+        if isinstance(styles, dict):
+            for slot in ("root", "canvas"):
+                declaration = styles.get(slot)
+                if isinstance(declaration, dict):
+                    for prop in list(declaration):
+                        if str(prop).replace("_", "-") in ("background", "background-color"):
+                            declaration.pop(prop)
 
 
 def _solid_paint(css: Any) -> Optional[str]:
@@ -2598,15 +2681,139 @@ def _title_metrics(
     return style, size, _textblock.measure(entry["text"], size, max_width=wrap_width)
 
 
+#: Anchor math for one drawn title, shared verbatim by the SVG writer, the
+#: raster writer, and the box emitter: `x` and `baseline` (first line) are
+#: where the text goes, `anchor` its SVG anchor name (`_TEXT_ANCHOR_CODES`
+#: maps it for the raster op).
+class TitlePlacement(NamedTuple):
+    style: dict[str, Any]
+    size: float
+    block: _textblock.TextBlock
+    x: float
+    baseline: float
+    anchor: str
+
+
+def title_placement(
+    spec: dict[str, Any],
+    entry: dict[str, Any],
+    plot: dict[str, float],
+    wrap_width: float | None = None,
+) -> TitlePlacement:
+    """One authored title entry's shared anchor math (plan §3.1).
+
+    This is the hoist of the placement both writers used to duplicate —
+    change it here and both files move together, which is the property the
+    box emission relies on (a box drawn from one copy and text from another
+    would drift).
+    """
+    style, size, block = _title_metrics(spec, entry, wrap_width)
+    trailing = (block.line_count - 1) * block.line_step
+    if entry.get("automatic_y", True):
+        anchor_y = plot["y"] - plot["top_axis_room"]
+    else:
+        anchor_y = plot["y"] + (1.0 - float(entry.get("y", 1.0))) * plot["h"]
+    baseline = anchor_y - float(entry.get("pad", 8.0)) - block.descent - trailing
+    loc = str(entry.get("loc", "center"))
+    x = {
+        "left": plot["x"],
+        "center": plot["x"] + plot["w"] / 2.0,
+        "right": plot["x"] + plot["w"],
+    }.get(loc, plot["x"] + plot["w"] / 2.0)
+    anchor = {"left": "start", "center": "middle", "right": "end"}.get(loc, "middle")
+    return TitlePlacement(style, size, block, x, baseline, anchor)
+
+
+def legacy_title_placement(
+    spec: dict[str, Any],
+    plot: dict[str, float],
+    compact: bool,
+    width: float,
+    wrap_width: float | None = None,
+) -> TitlePlacement:
+    """The legacy `spec['title']` band's anchor math, shared like the above.
+
+    Kept as its own branch (not folded into `title_placement`) because its
+    offsets are the historical byte contract: centered on the CANVAS, not the
+    plot rect, with the 10/12 px compact gap instead of the entry `pad`.
+    """
+    style = slot_styles(spec).get("title") or {}
+    size = slot_font_size(style, 14.0)
+    block = _textblock.measure(spec.get("title", ""), size, max_width=wrap_width)
+    trailing = (block.line_count - 1) * block.line_step
+    baseline = plot["y"] - plot["top_axis_room"] - (10 if compact else 12) - trailing
+    return TitlePlacement(style, size, block, width / 2.0, baseline, "middle")
+
+
+def title_box(placement: TitlePlacement) -> Optional[ChromeBox]:
+    """The title's chrome box under its text, or None when nothing is declared.
+
+    The box wraps the measured `TextBlock` — width is block width plus the
+    declared padding, NOT the wrap width (the browser box is the
+    shrink-to-fit div, js/src/50_chartview.ts `_positionTitles`) — and the
+    text itself does not move: padding extends outward from the block like
+    the annotation text box, and `_title_room` reserves the extra height so
+    the box clears the top axis room. Strictly declaration-gated: no box
+    property, no box, and unstyled bytes stay identical.
+    """
+    declaration = slot_box_declaration(placement.style, "title")
+    if not declaration:
+        return None
+    block = placement.block
+    pad_top, pad_right, pad_bottom, pad_left = box_padding(declaration)
+    left = (
+        placement.x
+        - {"start": 0.0, "middle": block.width / 2.0, "end": block.width}[placement.anchor]
+    )
+    trailing = (block.line_count - 1) * block.line_step
+    # The block bottom in CSS line-box terms: the last baseline plus the
+    # descent — the same construction `_title_room` measures with.
+    bottom = placement.baseline + trailing + block.descent
+    return lower_box(
+        "title",
+        declaration,
+        x=left - pad_left,
+        y=bottom - block.height - pad_top,
+        w=block.width + pad_left + pad_right,
+        h=block.height + pad_top + pad_bottom,
+    )
+
+
+def _title_box_extent(style: dict[str, Any]) -> float:
+    """Vertical px a title's declared box adds above+below its text block.
+
+    Mirrored by `_titleBoxExtent` in js/src/50_chartview.ts — the two must
+    agree or native and browser disagree on `plot.y`. Padding counts as
+    declared; the border counts only when it would paint under the
+    `lower_box` rules (an explicit color, or a width the implied 1px chrome
+    border rule gives one), exactly like the CSS computed width collapses
+    without a border style.
+    """
+    declaration = slot_box_declaration(style, "title")
+    if not declaration:
+        return 0.0
+    probe = lower_box("title", declaration, x=0.0, y=0.0, w=1e9, h=1e9)
+    border = (
+        probe.border_width if probe.border_color is not None and probe.border_width > 0.0 else 0.0
+    )
+    return probe.padding[0] + probe.padding[2] + 2.0 * border
+
+
 def _title_room(spec: dict[str, Any], compact: bool, wrap_width: float | None = None) -> float:
     room = 0.0
     for entry in _title_entries(spec):
-        _style, _size, block = _title_metrics(spec, entry, wrap_width)
+        style, _size, block = _title_metrics(spec, entry, wrap_width)
+        # A declared box grows the band exactly like the browser element
+        # grows: padding and paintable border, above and below the block
+        # (zero when unstyled, so the reservation bytes cannot move).
+        box_extent = _title_box_extent(style)
         pad = float(entry.get("pad", 8.0))
         if entry.get("automatic_y", True):
-            candidate = max(26.0 if compact else 30.0, block.height + pad)
+            candidate = max(26.0 if compact else 30.0, block.height + box_extent + pad)
         else:
-            candidate = block.height + pad if float(entry.get("y", 1.0)) >= 1.0 else 0.0
+            candidate = (
+                block.height + box_extent + pad if float(entry.get("y", 1.0)) >= 1.0 else 0.0
+            )
         room = max(room, max(0.0, candidate))
     return room
 
@@ -4255,59 +4462,48 @@ def line_attrs(style: dict[str, Any], color: str) -> str:
     legacy_title = spec.get("title") if not spec.get("title_options") else None
     title_wrap_width = plot.get("title_wrap_width")
     if legacy_title:
-        title_slot = slots.get("title") or {}
-        legacy_size = slot_font_size(title_slot, 14.0)
-        legacy_block = _textblock.measure(legacy_title, legacy_size, max_width=title_wrap_width)
-        # Wrapped lines run downward from the baseline, so lift the block by its
-        # trailing lines: the LAST line keeps the historical single-line baseline
-        # and the extra lines fill the room `_title_room` reserved above it. A
-        # one-line title has no trailing lines and is byte-identical to before.
-        legacy_trailing = (legacy_block.line_count - 1) * legacy_block.line_step
-        legacy_y = plot["y"] - plot["top_axis_room"] - (10 if compact else 12) - legacy_trailing
-        legacy_x = width / 2
-        legacy_text = "\n".join(legacy_block.lines)
-        legacy_content = _text_block_content(legacy_text, legacy_x, legacy_block.line_step)
+        placement = legacy_title_placement(spec, plot, compact, width, title_wrap_width)
+        # Wrapped lines run downward from the baseline, so the shared anchor
+        # math lifts the block by its trailing lines: the LAST line keeps the
+        # historical single-line baseline and the extra lines fill the room
+        # `_title_room` reserved above it. A one-line title has no trailing
+        # lines and is byte-identical to before.
+        legacy_text = "\n".join(placement.block.lines)
+        legacy_content = _text_block_content(legacy_text, placement.x, placement.block.line_step)
+        legacy_box = title_box(placement)
+        if legacy_box is not None:
+            # The box rides `chrome` immediately before its text: under the
+            # title, above every earlier layer of the document.
+            chrome.append(_slot_box_svg(legacy_box))
         chrome.append(
-            f'<text x="{_num(legacy_x)}" '
-            f'y="{_num(legacy_y)}" '
-            f'text-anchor="middle" font-size="{_num(legacy_size)}"'
-            f"{slot_text_attrs(title_slot, font_weight='400')} "
-            f'fill="{escape(slot_text_color(title_slot, default_text))}">'
+            f'<text x="{_num(placement.x)}" '
+            f'y="{_num(placement.baseline)}" '
+            f'text-anchor="middle" font-size="{_num(placement.size)}"'
+            f"{slot_text_attrs(placement.style, font_weight='400')} "
+            f'fill="{escape(slot_text_color(placement.style, default_text))}">'
             f"{legacy_content}</text>"
         )
     for title_entry in [] if legacy_title else _title_entries(spec):
-        title_style, title_size, title_block = _title_metrics(spec, title_entry, title_wrap_width)
+        placement = title_placement(spec, title_entry, plot, title_wrap_width)
         # Matplotlib's `axes.titleweight`/`axes.labelweight` both default to
         # "normal", so chrome text stays at 400 unless a style or rcParam asks
         # for more. Keep this in step with the `title`/`axis_title` slot rules
         # in js/src/20_theme.ts and the raster defaults in _raster.py.
-        title_font_attrs = slot_text_attrs(title_style, font_weight="400")
-        trailing = (title_block.line_count - 1) * title_block.line_step
-        if title_entry.get("automatic_y", True):
-            title_anchor_y = plot["y"] - plot["top_axis_room"]
-        else:
-            title_anchor_y = plot["y"] + (1.0 - float(title_entry.get("y", 1.0))) * plot["h"]
-        title_y = (
-            title_anchor_y - float(title_entry.get("pad", 8.0)) - title_block.descent - trailing
-        )
-        loc = str(title_entry.get("loc", "center"))
-        title_x = {
-            "left": plot["x"],
-            "center": plot["x"] + plot["w"] / 2.0,
-            "right": plot["x"] + plot["w"],
-        }.get(loc, plot["x"] + plot["w"] / 2.0)
-        anchor = {"left": "start", "center": "middle", "right": "end"}.get(loc, "middle")
-        # `title_block.lines` is the wrapped set — drawing `entry["text"]` here
+        title_font_attrs = slot_text_attrs(placement.style, font_weight="400")
+        # `block.lines` is the wrapped set — drawing `entry["text"]` here
         # would put the whole title on one line inside a band reserved for two.
         title_content = _text_block_content(
-            "\n".join(title_block.lines), title_x, title_block.line_step
+            "\n".join(placement.block.lines), placement.x, placement.block.line_step
         )
+        entry_box = title_box(placement)
+        if entry_box is not None:
+            chrome.append(_slot_box_svg(entry_box))
         chrome.append(
-            f'<text x="{_num(title_x)}" '
-            f'y="{_num(title_y)}" '
-            f'text-anchor="{anchor}" font-size="{_num(title_size)}" '
+            f'<text x="{_num(placement.x)}" '
+            f'y="{_num(placement.baseline)}" '
+            f'text-anchor="{placement.anchor}" font-size="{_num(placement.size)}" '
             f"{title_font_attrs.lstrip()} "
-            f'fill="{escape(slot_text_color(title_style, default_text))}">'
+            f'fill="{escape(slot_text_color(placement.style, default_text))}">'
             f"{title_content}</text>"
         )
 
@@ -4586,7 +4782,7 @@ def tick_span(style: dict[str, Any]) -> tuple[float, float, float]:
                     f'stroke-width="{_num(tick_width)}"/>'
                 )
 
-    defs = f"<defs>{''.join(svg.defs)}</defs>" if svg.defs else ""
+    defs_parts = svg.defs
     # Figure patch + plot-rect backgrounds, mirroring the browser: the root
     # element's CSS `background` (theme(background=)) behind everything, then
     # the --chart-bg token over the plot rect only. Solid colors only —
@@ -4599,7 +4795,24 @@ def tick_span(style: dict[str, Any]) -> tuple[float, float, float]:
     if canvas_paint and canvas_paint not in ("transparent", "none"):
         backgrounds += f'<rect width="{width}" height="{height}" fill="{escape(canvas_paint)}"/>'
     figure_background = _solid_paint(dom_style.get("background"))
-    if figure_background is not None:
+    # The root slot's box (parity plan §3.4). Declaration-gated: with no box
+    # declaration the legacy figure-patch rect below emits byte-identically.
+    # When declared, the box IS the figure patch — same element in the DOM,
+    # one `background` property — so the theme paint becomes the box fill
+    # whenever the slot declares chrome around it but no fill of its own.
+    # First-painted content, like the browser's border-below-descendants;
+    # `apply_export_background` already silenced the slot fill if an export
+    # `background=` override is in force (the one precedence definition).
+    root_declaration = slot_box_declaration(slots.get("root") or {}, "root")
+    root_box: Optional[ChromeBox] = None
+    if root_declaration:
+        if figure_background is not None and not any(
+            prop in root_declaration for prop in ("background", "background-color")
+        ):
+            root_declaration = {"background": figure_background, **root_declaration}
+        root_box = lower_box("root", root_declaration, x=0.0, y=0.0, w=width, h=height)
+        backgrounds += _slot_box_svg(root_box)
+    elif figure_background is not None:
         backgrounds += (
             f'<rect width="{width}" height="{height}" fill="{escape(figure_background)}"/>'
         )
@@ -4609,6 +4822,62 @@ def tick_span(style: dict[str, Any]) -> tuple[float, float, float]:
             f'<rect x="{_num(plot["x"])}" y="{_num(plot["y"])}" width="{_num(plot["w"])}" '
             f'height="{_num(plot["h"])}" fill="{escape(plot_paint)}"/>'
         )
+    # The chrome slot (parity plan §3.5, background/opacity only): one rect
+    # above the root/plot backgrounds and below the grid — the browser's
+    # chrome canvas sits above the root element and holds the grid. Its DOM
+    # stacking against the title divs diverges by design and is recorded in
+    # `KNOWN_RENDERER_DIVERGENCES` (`chrome_slot_title_stacking`).
+    chrome_slot_backdrop = ""
+    chrome_declaration = slot_box_declaration(slots.get("chrome") or {}, "chrome")
+    if chrome_declaration:
+        chrome_slot_backdrop = _slot_box_svg(
+            lower_box("chrome", chrome_declaration, x=0.0, y=0.0, w=width, h=height)
+        )
+    # The canvas slot (parity plan §3.6) paints at the ABOVE-grid seam: the
+    # browser's marks canvas is a separate element over the chrome canvas, so
+    # a canvas background HIDES the grid. Deliberately NOT the --chart-bg
+    # anchor, which paints below the grid — that paint-order trap is this
+    # family's central divergence. A declared radius clips the marks through
+    # a THIRD clipPath (never by mutating clip_id/marks_clip_id: the shared
+    # clip also bounds legends, and polar legends live outside the disc);
+    # declared opacity rides the wrapping group, PDF-legal on <g>.
+    canvas_backdrop = ""
+    canvas_group_open = ""
+    canvas_group_close = ""
+    canvas_declaration = slot_box_declaration(slots.get("canvas") or {}, "canvas")
+    if canvas_declaration:
+        canvas_box = lower_box(
+            "canvas",
+            canvas_declaration,
+            x=plot["x"],
+            y=plot["y"],
+            w=plot["w"],
+            h=plot["h"],
+        )
+        canvas_backdrop = _slot_box_svg(canvas_box)
+        canvas_group_attrs = ""
+        if canvas_box.radius > 0:
+            canvas_clip_id = svg.uid("clip")
+            defs_parts.append(
+                f'<clipPath id="{canvas_clip_id}"><path d="'
+                + _rounded_rect_path(
+                    plot["x"],
+                    plot["y"],
+                    plot["w"],
+                    plot["h"],
+                    canvas_box.radius,
+                    canvas_box.radius,
+                    True,
+                )
+                + '"/></clipPath>'
+            )
+            canvas_group_attrs += f' clip-path="url(#{canvas_clip_id})"'
+        if canvas_box.opacity < 1.0:
+            canvas_group_attrs += f' opacity="{_num(canvas_box.opacity)}"'
+        if canvas_group_attrs:
+            canvas_group_open = f"<g{canvas_group_attrs}>"
+            canvas_group_close = "</g>"
+    defs = f"<defs>{''.join(defs_parts)}</defs>" if defs_parts else ""
     # One flat join over the pieces rather than nested `join`s inside an
     # f-string: the mark list is the whole document for a per-point chart (tens
     # of MB at 100k markers), and joining it separately would materialize a
@@ -4619,12 +4888,16 @@ def tick_span(style: dict[str, Any]) -> tuple[float, float, float]:
             f'viewBox="0 0 {width} {height}" font-family="{_FONT}" font-size="11">',
             defs,
             backgrounds,
+            chrome_slot_backdrop,
             "<g>",
             *grid,
             "</g>",
+            canvas_group_open,
+            canvas_backdrop,
             f'<g clip-path="url(#{marks_clip_id})">',
             *marks,
             "</g>",
+            canvas_group_close,
             *unclipped_annotation_marks,
             baselines,
             f'<g fill="{escape(default_text)}">',
diff --git a/python/xy/styling/capabilities.py b/python/xy/styling/capabilities.py
index 05461efe8..3d400ea4f 100644
--- a/python/xy/styling/capabilities.py
+++ b/python/xy/styling/capabilities.py
@@ -256,6 +256,44 @@ class ExtensionPoint:
         visible_when="stroke-width above ~4px at a sharp angle",
         tracked_by="no style property selects a join; the default is the whole contract",
     ),
+    RendererDivergence(
+        id="chrome_slot_title_stacking",
+        what="A styled `chrome` slot background against the title text and the plot fill",
+        webgl=(
+            "the chrome canvas is appended AFTER the title divs "
+            "(js/src/50_chartview.ts) and its CSS background paints under its "
+            "own bitmap, so the backdrop covers titles and sits below --chart-bg"
+        ),
+        svg=(
+            "one rect between the backgrounds and the grid group: above the "
+            "root and plot fills, below every grid line and all chrome text"
+        ),
+        native="same seam as SVG (after the plot fill, before the plot clip)",
+        visible_when=(
+            "styles={'chrome': {'background': ...}} overlaps a title, or is "
+            "combined with a --chart-bg plot fill"
+        ),
+        tracked_by=(
+            "static-chrome-parity plan §3.5 pins the writers' seam; the DOM "
+            "order is the browser's own stacking contract"
+        ),
+    ),
+    RendererDivergence(
+        id="title_entry_box_allowlist",
+        what="Box styling authored on a per-entry title `style=` (not the title slot)",
+        webgl=(
+            "dropped: the client copies only color/font-family/font-size/"
+            "font-style/font-weight from an entry's style onto the title div "
+            "(js/src/50_chartview.ts entry-style allowlist)"
+        ),
+        svg="honored: `_title_metrics` merges entry style over the slot, box included",
+        native="honored, same merge (the two writers share the title placement)",
+        visible_when="xy.title(style={'background': ...}) or another per-entry box property",
+        tracked_by=(
+            "static-chrome-parity plan §3 acceptance records the divergence; "
+            "slot-level `styles={'title': ...}` box declarations agree everywhere"
+        ),
+    ),
 )
 
 
@@ -275,6 +313,16 @@ class ExtensionPoint:
     "approximated. Properties outside the subset stay browser-only."
 )
 
+#: The box-vocabulary note shared by the P1 box slots (`_svg.SLOT_BOX_PROPS`,
+#: drawn through the shared `_chromebox` lowering in both writers).
+_SLOT_BOX_NOTE = (
+    "Box slot: both writers honor background, border (color/width/style, "
+    "dashed/dotted as dash arrays), symmetric border-radius, opacity and "
+    "fill-opacity through the shared chrome-box lowering "
+    "(`xy._chromebox.lower_box`); everything it cannot draw is a named loss "
+    "in the preflight, never silent (§28)."
+)
+
 _SLOT_EXCEPTIONS: dict[str, tuple[str, str, str]] = {
     slot: ("partial", f"styles={{{slot!r}: ...}}", _SLOT_SUBSET_NOTE)
     for slot in STATIC_STYLED_SLOTS
@@ -288,13 +336,46 @@ class ExtensionPoint:
     "`--xy-legend-frame-alpha`, and `padding`/`rowGap` in `em` are honored; an "
     "explicit background paints opaque, as it does in the browser.",
 )
+_SLOT_EXCEPTIONS["title"] = (
+    "partial",
+    "styles={'title': ...}",
+    _SLOT_SUBSET_NOTE + " The title also takes the full box vocabulary "
+    "(`_svg.SLOT_BOX_PROPS`): a box under the text, sized to the measured "
+    "block plus padding, with the title band growing to fit. Per-entry "
+    "`xy.title(style=...)` box properties are native-only "
+    "(KNOWN_RENDERER_DIVERGENCES `title_entry_box_allowlist`).",
+)
 _SLOT_EXCEPTIONS["root"] = (
     "partial",
-    "chart style=",
-    "`styles={'root': ...}` is browser-only, but the chart-level `style=` "
-    "token bag targets the same element and every renderer reads it "
-    "(`spec['dom']['style']`). Prefer it for anything that must survive "
-    "export.",
+    "styles={'root': ...} / chart style=",
+    _SLOT_BOX_NOTE + " The root box is the figure patch: its fill replaces "
+    "the `theme(background=)` token when both are set (same element, one "
+    "background property, matching the browser), and an export "
+    "`background=` override silences it (`_svg.apply_export_background` is "
+    "the one precedence definition). box-shadow would fall outside the "
+    "canvas and is a named loss; text properties have no root text to style. "
+    "The chart-level `style=` token bag still reaches every renderer.",
+)
+_SLOT_EXCEPTIONS["chrome"] = (
+    "partial",
+    "styles={'chrome': ...}",
+    "Background and opacity only (parity plan §8 flag G): one full-canvas "
+    "backdrop above the root and plot fills, below the grid. The rest of the "
+    "box vocabulary is a named preflight loss, and the browser's own "
+    "stacking of this slot against titles diverges by design "
+    "(KNOWN_RENDERER_DIVERGENCES `chrome_slot_title_stacking`).",
+)
+_SLOT_EXCEPTIONS["canvas"] = (
+    "partial",
+    "styles={'canvas': ...}",
+    _SLOT_BOX_NOTE + " Painted at the above-grid seam, so a canvas "
+    "background hides the grid exactly as the browser's marks canvas does; "
+    "border-radius clips the marks through a dedicated clipPath in SVG/PDF "
+    "and opacity rides the marks group there. The raster display list clips "
+    "rectangles only and has no group compositing, so border-radius and "
+    "opacity are named raster losses (`_svg.SLOT_BOX_RASTER_UNSUPPORTED`) "
+    "until the rounded-clip opcode lands. An export `background=` override "
+    "silences a canvas background like the plot token.",
 )
 
 
diff --git a/python/xy/styling/declared.py b/python/xy/styling/declared.py
index cb59daeb3..d1ac655e3 100644
--- a/python/xy/styling/declared.py
+++ b/python/xy/styling/declared.py
@@ -69,12 +69,18 @@ def resolve_declared(
     `writer_domain` instead, so nothing declared is dropped in either
     direction and the not-yet-IR remainder is exactly enumerable.
     """
+    from .._chromebox import expand_box_shorthands
+
     dom = spec.get("dom") or {}
     raw = dom.get("styles") or {}
     style = dom.get("style") or {}
     builder = SnapshotBuilder()
     view: dict[str, dict[str, Any]] = {}
     writer_domain: dict[str, dict[str, Any]] = {}
+    environment = SnapshotEnvironment(
+        width=_dimension(width, spec.get("width"), 800.0),
+        height=_dimension(height, spec.get("height"), 500.0),
+    )
     for slot, decls in raw.items():
         if not isinstance(decls, dict):
             continue
@@ -86,25 +92,54 @@ def resolve_declared(
             continue
         legal: dict[str, Any] = {}
         residue: dict[str, Any] = {}
+        # Schema v1 carries only longhands, so the box shorthands (`border`,
+        # `padding`) intern expanded. The expansion is per shorthand and
+        # all-or-nothing: if any expanded longhand is still writer-domain (an
+        # em legend padding), the *authored* spelling lands in the residue —
+        # the pinned residue enumeration stays in authored terms (§28).
         for name, value in normalized.items():
+            expanded = {
+                part: part_value
+                for part, part_value in expand_box_shorthands({name: value}).items()
+                # An explicit longhand beside the shorthand wins whatever the
+                # authored order was; the shorthand fills only what is unsaid.
+                if part == name or part not in normalized
+            }
             try:
-                assert_resolved(name, value)
+                resolved = {
+                    part: assert_resolved(part, part_value) for part, part_value in expanded.items()
+                }
             except ValueError:
                 residue[name] = value
             else:
-                legal[name] = value
+                legal.update(resolved)
         if legal:
-            builder.add(slot_name, legal)
+            builder.add(slot_name, legal, geometry=_environment_geometry(slot_name, environment))
         if residue:
             writer_domain[slot_name] = residue
-    environment = SnapshotEnvironment(
-        width=_dimension(width, spec.get("width"), 800.0),
-        height=_dimension(height, spec.get("height"), 500.0),
-    )
     snapshot = builder.build(environment, tokens=_concrete_tokens(style))
     return DeclaredStyling(snapshot=snapshot, writer_domain=writer_domain, _view=view)
 
 
+def _environment_geometry(
+    slot: str, environment: SnapshotEnvironment
+) -> Optional[tuple[float, float, float, float]]:
+    """The slot geometry the declared resolver can know without a layout pass.
+
+    `root` and `chrome` are the full canvas — (0, 0, width, height) in CSS px
+    against the spec's own dimensions, never the host page's padding (the
+    normalization rule for capture diffs: a browser capture must subtract host
+    box offsets before comparing, plan §8 flag J). Slots whose box needs the
+    layout pass (`title` wants measured text, `canvas` wants the plot rect)
+    stay None here: the resolver cannot run `layout()` without re-entering
+    itself through `slot_styles`, so their geometry is populated by the
+    capture producers that already have the layout in hand.
+    """
+    if slot in ("root", "chrome"):
+        return (0.0, 0.0, environment.width, environment.height)
+    return None
+
+
 def _dimension(override: Optional[float], declared: Any, fallback: float) -> float:
     for candidate in (override, declared):
         if isinstance(candidate, (int, float)) and not isinstance(candidate, bool):
diff --git a/python/xy/styling/preflight.py b/python/xy/styling/preflight.py
index b7df4991c..b4389d5d2 100644
--- a/python/xy/styling/preflight.py
+++ b/python/xy/styling/preflight.py
@@ -186,11 +186,13 @@ def _honored_props(slot: str, family: str) -> tuple[frozenset[str], str]:
     """(honored property names, qualifier) for a native-subset slot.
 
     The subsets are the writers' own constants — the text properties per
-    family, plus the legend frame's merged-declaration box vocabulary
-    (`_svg.LEGEND_BOX_PROPS`, owned by the writer module). A legend property
-    in neither set has no channel into a static file and is a provable loss:
-    the earlier declaration-level qualification rounded exactly those to
-    silence, which let warn stay quiet and strict permit a drop.
+    family, the legend frame's merged-declaration box vocabulary
+    (`_svg.LEGEND_BOX_PROPS`), and the chrome-box vocabulary per box-capable
+    slot (`_svg.SLOT_BOX_PROPS_BY_SLOT`, all owned by the writer module so
+    this report cannot drift from what actually draws). A property in none
+    of a slot's sets has no channel into a static file and is a provable
+    loss: the earlier declaration-level qualification rounded exactly those
+    to silence, which let warn stay quiet and strict permit a drop.
     """
     from .. import _svg
 
@@ -200,6 +202,26 @@ def _honored_props(slot: str, family: str) -> tuple[frozenset[str], str]:
             "box properties route through the merged legend declaration; see the "
             "capability matrix legend note"
         )
+    box = _svg.SLOT_BOX_PROPS_BY_SLOT.get(slot)
+    if box is not None:
+        if family == "native_raster":
+            box = box - _svg.SLOT_BOX_RASTER_UNSUPPORTED.get(slot, frozenset())
+        if slot == "title":
+            # The one slot with both text and a box under it.
+            return text | box, "box properties draw the title's own box (_svg.SLOT_BOX_PROPS)"
+        qualifier = (
+            "background/opacity only; the rest of the chrome slot's box model "
+            "is a recorded divergence (see the capability matrix chrome note)"
+            if slot == "chrome"
+            else (
+                "box properties only (this slot has no text of its own); raster "
+                "cannot round-clip or group-fade the marks, so border-radius and "
+                "opacity are raster losses"
+                if slot == "canvas" and family == "native_raster"
+                else "box properties only (this slot has no text of its own)"
+            )
+        )
+        return box, qualifier
     return text, ""
 
 
@@ -250,15 +272,14 @@ def _styles_finding(slot: str, decls: dict[str, Any], fmt: str) -> SlotFinding:
                 "contain it, so nothing in the file is unstyled"
             ),
         )
-    if slot == "root" or meta.support[family] == "none":
-        detail = meta.notes if slot == "root" else "no native path for this slot yet"
+    if meta.support[family] == "none":
         return SlotFinding(
             slot=slot,
             source="styles",
             applicability="static",
             route=ROUTE_BROWSER_ONLY,
             lost=props,
-            detail=detail,
+            detail="no native path for this slot yet",
         )
     honored, qualifier = _honored_props(slot, family)
     kept = tuple(p for p in props if p in honored)
@@ -281,7 +302,10 @@ def _styles_finding(slot: str, decls: dict[str, Any], fmt: str) -> SlotFinding:
             route=ROUTE_SUBSET,
             kept=kept,
             lost=lost,
-            detail="outside the writer's honored subset for this slot",
+            # The slot's own qualifier names WHY the loss exists (a raster
+            # canvas radius, the chrome background/opacity hedge) — more
+            # actionable than the generic subset sentence when there is one.
+            detail=qualifier or "outside the writer's honored subset for this slot",
         )
     return SlotFinding(
         slot=slot,
@@ -289,6 +313,7 @@ def _styles_finding(slot: str, decls: dict[str, Any], fmt: str) -> SlotFinding:
         applicability="static",
         route=ROUTE_SURVIVES,
         kept=kept,
+        detail=qualifier,
     )
 
 
diff --git a/scripts/gen_capability_matrix.py b/scripts/gen_capability_matrix.py
index 0f7369758..837c6afeb 100644
--- a/scripts/gen_capability_matrix.py
+++ b/scripts/gen_capability_matrix.py
@@ -65,15 +65,16 @@ def render() -> str:
         f"- **{counts['chart_slots']}** stable chrome slots, CSS- and Tailwind-addressable "
         "in the browser. "
         f"**{counts['chart_slots_static']}** of them name chrome a clean static export "
-        f"contains; **{counts['slots_styleable_natively']}** reach the native writers — "
-        f"**{counts['slots_via_styles']}** through `styles={{slot: ...}}` itself, and "
-        "`root` through the chart-level `style=` token bag. The other "
+        f"contains; **{counts['slots_styleable_natively']}** reach the native writers "
+        f"through `styles={{slot: ...}}` (the chart-level `style=` token bag "
+        "additionally reaches every renderer). The other "
         f"**{counts['chart_slots_state_gated']}** are interaction/view chrome "
         "(tooltip, modebar, crosshair, selection, reduction badges) that a clean "
         "static file does not contain, so they are gated by an export state "
         "rather than missing.",
         f"- **{counts['extension_points_shipped']}** shipped extension point.",
-        f"- **{counts['known_renderer_divergences']}** known default divergence between "
+        f"- **{counts['known_renderer_divergences']}** known default "
+        f"divergence{'s' if counts['known_renderer_divergences'] != 1 else ''} between "
         "renderers, listed below rather than left to be discovered.",
         "",
         "## Mark style properties",
diff --git a/spec/api/capability-matrix.md b/spec/api/capability-matrix.md
index 863a51e98..c5231b422 100644
--- a/spec/api/capability-matrix.md
+++ b/spec/api/capability-matrix.md
@@ -14,9 +14,9 @@ which is sometimes deliberate, and the notes say which.
 ## In one line
 
 - **11** mark style properties across **21** mark kinds, drawn by all three renderers.
-- **48** stable chrome slots, CSS- and Tailwind-addressable in the browser. **24** of them name chrome a clean static export contains; **10** reach the native writers — **9** through `styles={slot: ...}` itself, and `root` through the chart-level `style=` token bag. The other **24** are interaction/view chrome (tooltip, modebar, crosshair, selection, reduction badges) that a clean static file does not contain, so they are gated by an export state rather than missing.
+- **48** stable chrome slots, CSS- and Tailwind-addressable in the browser. **24** of them name chrome a clean static export contains; **12** reach the native writers through `styles={slot: ...}` (the chart-level `style=` token bag additionally reaches every renderer). The other **24** are interaction/view chrome (tooltip, modebar, crosshair, selection, reduction badges) that a clean static file does not contain, so they are gated by an export state rather than missing.
 - **1** shipped extension point.
-- **1** known default divergence between renderers, listed below rather than left to be discovered.
+- **3** known default divergences between renderers, listed below rather than left to be discovered.
 
 ## Mark style properties
 
@@ -73,8 +73,8 @@ declared and names anything that would not survive.
 |---|---|---|---|---|
 | `root` | clean static | full | partial | partial |
 | `title` | clean static | full | partial | partial |
-| `chrome` | clean static | full | none | none |
-| `canvas` | clean static | full | none | none |
+| `chrome` | clean static | full | partial | partial |
+| `canvas` | clean static | full | partial | partial |
 | `annotation_layer` | clean static | full | none | none |
 | `labels` | clean static | full | none | none |
 | `legend` | clean static | full | partial | partial |
@@ -122,8 +122,10 @@ declared and names anything that would not survive.
 
 ### Notes
 
-- **`root`** (via `chart style=`) — `styles={'root': ...}` is browser-only, but the chart-level `style=` token bag targets the same element and every renderer reads it (`spec['dom']['style']`). Prefer it for anything that must survive export.
-- **`title`** (via `styles={'title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
+- **`root`** (via `styles={'root': ...} / chart style=`) — Box slot: both writers honor background, border (color/width/style, dashed/dotted as dash arrays), symmetric border-radius, opacity and fill-opacity through the shared chrome-box lowering (`xy._chromebox.lower_box`); everything it cannot draw is a named loss in the preflight, never silent (§28). The root box is the figure patch: its fill replaces the `theme(background=)` token when both are set (same element, one background property, matching the browser), and an export `background=` override silences it (`_svg.apply_export_background` is the one precedence definition). box-shadow would fall outside the canvas and is a named loss; text properties have no root text to style. The chart-level `style=` token bag still reaches every renderer.
+- **`title`** (via `styles={'title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only. The title also takes the full box vocabulary (`_svg.SLOT_BOX_PROPS`): a box under the text, sized to the measured block plus padding, with the title band growing to fit. Per-entry `xy.title(style=...)` box properties are native-only (KNOWN_RENDERER_DIVERGENCES `title_entry_box_allowlist`).
+- **`chrome`** (via `styles={'chrome': ...}`) — Background and opacity only (parity plan §8 flag G): one full-canvas backdrop above the root and plot fills, below the grid. The rest of the box vocabulary is a named preflight loss, and the browser's own stacking of this slot against titles diverges by design (KNOWN_RENDERER_DIVERGENCES `chrome_slot_title_stacking`).
+- **`canvas`** (via `styles={'canvas': ...}`) — Box slot: both writers honor background, border (color/width/style, dashed/dotted as dash arrays), symmetric border-radius, opacity and fill-opacity through the shared chrome-box lowering (`xy._chromebox.lower_box`); everything it cannot draw is a named loss in the preflight, never silent (§28). Painted at the above-grid seam, so a canvas background hides the grid exactly as the browser's marks canvas does; border-radius clips the marks through a dedicated clipPath in SVG/PDF and opacity rides the marks group there. The raster display list clips rectangles only and has no group compositing, so border-radius and opacity are named raster losses (`_svg.SLOT_BOX_RASTER_UNSUPPORTED`) until the rounded-clip opcode lands. An export `background=` override silences a canvas background like the plot token.
 - **`legend`** (via `styles={'legend': ...} / xy.legend(style=...) / --chart-legend-bg`) — The frame box. Both spellings and the theme token now converge on one merged declaration block before the writers see it, so what agrees in the browser agrees in a PNG. `background`, `boxShadow`, `borderRadius`, `--xy-legend-frame-alpha`, and `padding`/`rowGap` in `em` are honored; an explicit background paints opaque, as it does in the browser.
 - **`legend_title`** (via `styles={'legend_title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
 - **`legend_label`** (via `styles={'legend_label': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
@@ -157,6 +159,8 @@ until someone diffs two exports. Listed here for that reason.
 | what | webgl | svg | native | visible when | tracked by |
 |---|---|---|---|---|---|
 | Interior vertices of a wide polyline | the notch two overlapping segment quads leave | round (the writer names it explicitly) | round (the capsule distance field fills the vertex) | stroke-width above ~4px at a sharp angle | no style property selects a join; the default is the whole contract |
+| A styled `chrome` slot background against the title text and the plot fill | the chrome canvas is appended AFTER the title divs (js/src/50_chartview.ts) and its CSS background paints under its own bitmap, so the backdrop covers titles and sits below --chart-bg | one rect between the backgrounds and the grid group: above the root and plot fills, below every grid line and all chrome text | same seam as SVG (after the plot fill, before the plot clip) | styles={'chrome': {'background': ...}} overlaps a title, or is combined with a --chart-bg plot fill | static-chrome-parity plan §3.5 pins the writers' seam; the DOM order is the browser's own stacking contract |
+| Box styling authored on a per-entry title `style=` (not the title slot) | dropped: the client copies only color/font-family/font-size/font-style/font-weight from an entry's style onto the title div (js/src/50_chartview.ts entry-style allowlist) | honored: `_title_metrics` merges entry style over the slot, box included | honored, same merge (the two writers share the title placement) | xy.title(style={'background': ...}) or another per-entry box property | static-chrome-parity plan §3 acceptance records the divergence; slot-level `styles={'title': ...}` box declarations agree everywhere |
 
 ## Regenerating
 
diff --git a/spec/api/export.md b/spec/api/export.md
index e6bf5c1ff..8198b08bc 100644
--- a/spec/api/export.md
+++ b/spec/api/export.md
@@ -248,7 +248,7 @@ vector** (`_svg.to_svg`, and `_pdf.svg_to_pdf` on top of it).
 | `style={...}` on a mark | yes | yes | yes | validated CSS subset, `styles.compile_mark_style` |
 | `style={...}` on an axis | yes | yes | yes | validated vocabulary, `styles.compile_axis_style` |
 | `style={...}` on the chart (token bag) | yes | yes | yes | `spec["dom"]["style"]`, read at `_svg.py:767,1481` and `_raster.py:662` |
-| `styles={slot: {...}}` (per-slot inline) | yes, all 48 slots | text subset, 9 slots | text subset, 9 slots | `_svg.STATIC_STYLED_SLOTS`; the rest is live-only chrome |
+| `styles={slot: {...}}` (per-slot inline) | yes, all 48 slots | text/box subset, 12 slots | text/box subset, 12 slots | `_svg.STATIC_STYLED_SLOTS`; the rest is live-only chrome |
 | `class_names={slot: "..."}` | yes, all 48 slots | **dropped** (or resolved via `style_source="native_cascade"` / a captured `style_snapshot=`) | same | silent by default during migration; both opt-in routes are lossless for the published profile |
 | `custom_css="..."` | yes (HTML + Chromium capture) | **raises** | **raises** | `_resolve_image_engine`, `export.py:812` |
 | `xy.legend(style=...)` | yes | 6 keys | 6 keys | merged with the slot and the theme token before the writers see it |
@@ -323,19 +323,32 @@ and an exported file has no stylesheet to select from.
 ### Which per-slot styles reach a file, and why only those
 
 A slot reaches the native writers when it names chrome a static file actually
-contains. `_svg.STATIC_STYLED_SLOTS` is that list: `title`, `axis_title`,
-`tick_label`, `legend`, `legend_title`, `legend_label`, `colorbar`,
-`colorbar_title`, and `colorbar_tick`. The remaining slots are live-only chrome
-— `tooltip*`, `modebar*`, `crosshair_*`, `selection`, `badge*` — or containers
-with no painted text of their own; there is nothing in a PNG for them to style.
-
-Within a supported slot the writers read a property subset, not a cascade:
-`font-size`, `font-weight`, `font-style`, `font-family`, `letter-spacing`,
-`opacity`, and the text paint (`fill`, or `color`). The native raster's atlas is
-a single baked face, so it honors size and paint and leaves the typeface
-properties to the vector writers — the one documented divergence, and
-`tests/test_export_style_survival.py` pins it. A declaration outside the subset
-stays browser-only.
+contains. `_svg.STATIC_STYLED_SLOTS` is that list: `root`, `chrome`,
+`canvas`, `title`, `axis_title`, `tick_label`, `legend`, `legend_title`,
+`legend_label`, `colorbar`, `colorbar_title`, and `colorbar_tick`. The
+remaining slots are live-only chrome — `tooltip*`, `modebar*`, `crosshair_*`,
+`selection`, `badge*` — or containers with no painted box or text of their
+own yet; there is nothing in a PNG for them to style.
+
+Within a supported slot the writers read a property subset, not a cascade.
+Text slots take `font-size`, `font-weight`, `font-style`, `font-family`,
+`letter-spacing`, `opacity`, and the text paint (`fill`, or `color`); the
+raster atlas carries regular/bold/italic faces, so weight and style survive
+there while `font-family`, `letter-spacing`, and `opacity` remain
+vector-only — the one documented text divergence, pinned by
+`tests/test_export_style_survival.py`. Box slots (`root`, `chrome`, `canvas`,
+plus the `title`'s box under its text) take the chrome-box vocabulary
+(`_svg.SLOT_BOX_PROPS_BY_SLOT`, drawn through the shared `xy._chromebox`
+lowering in both writers; `chrome` is background/opacity only, and the
+raster's rect-only clip makes a `canvas` radius/opacity a named raster loss,
+`tests/test_chrome_parity_p1.py`). A declaration outside a slot's subsets
+stays browser-only, and the preflight names it.
+
+The `root` and `canvas` slot backgrounds are part of the painted backdrop the
+unified export `background=` override replaces: `apply_export_background`
+silences both alongside the theme token pair, so the precedence — export
+override > slot declaration > theme token — is defined once and holds in
+every writer.
 
 Where two surfaces name the same chrome, the narrower selector wins: an axis's
 own `label_color` beats `styles={"axis_title": ...}`, which beats the
diff --git a/spec/api/styling.md b/spec/api/styling.md
index 6bcdc270d..c743f1dca 100644
--- a/spec/api/styling.md
+++ b/spec/api/styling.md
@@ -1324,15 +1324,30 @@ carry a defined subset of their declarations into SVG, PNG and PDF:
 
 | | |
 | --- | --- |
-| Slots | `title`, `axis_title`, `tick_label`, `legend`, `legend_title`, `legend_label`, `colorbar`, `colorbar_title`, `colorbar_tick` (`_svg.STATIC_STYLED_SLOTS`) |
-| Vector — SVG, PDF | `font-size`, `font-weight`, `font-style`, `font-family`, `letter-spacing`, `opacity`, and the text paint — `fill`, or `color` (`_svg.SLOT_TEXT_PROPS`) |
-| Raster — PNG, JPEG, WebP | `font-size` and the text paint only (`_svg.SLOT_RASTER_PROPS`) |
-
-The raster writer's glyph primitive takes a size and one RGBA paint and nothing
-else, so `font-weight`, `font-style`, `font-family`, `letter-spacing` and
-`opacity` are **vector-only**. They are not approximated: the atlas is a single
-baked face, and a silently substituted weight would be exactly the kind of
-invisible decision §28 forbids.
+| Slots | `root`, `chrome`, `canvas`, `title`, `axis_title`, `tick_label`, `legend`, `legend_title`, `legend_label`, `colorbar`, `colorbar_title`, `colorbar_tick` (`_svg.STATIC_STYLED_SLOTS`) |
+| Vector text — SVG, PDF | `font-size`, `font-weight`, `font-style`, `font-family`, `letter-spacing`, `opacity`, and the text paint — `fill`, or `color` (`_svg.SLOT_TEXT_PROPS`) |
+| Raster text — PNG, JPEG, WebP | `font-size`, `font-weight`, `font-style`, and the text paint (`_svg.SLOT_RASTER_PROPS`) |
+| Box slots | `background`, `border` (color/width/style, dashed/dotted as dash arrays), symmetric `border-radius`, `padding` (title only), `opacity`, `fill-opacity` (`_svg.SLOT_BOX_PROPS_BY_SLOT`), drawn through the shared `xy._chromebox` lowering in both writers |
+
+The raster atlas carries a regular, a bold and an italic face, so weight
+(>= 600 rounds to the bold face) and style survive the raster path;
+`font-family`, `letter-spacing` and `opacity` are **vector-only**. They are
+not approximated: the atlas has no family axis, no per-glyph advance control
+and no alpha on the blit, and a silently substituted face would be exactly
+the kind of invisible decision §28 forbids.
+
+The box slots landed with static-chrome-parity phase 1
+([the plan](../process/static-chrome-parity-plan-2026-08-04.md) §3): `title`
+draws its box under the text (sized to the measured block plus padding, with
+the title band growing to fit — mirrored by `_titleBoxExtent` in the
+client); `root` IS the figure patch (its fill replaces `theme(background=)`
+when both are set, and an export `background=` override silences it —
+`_svg.apply_export_background` is the single precedence definition:
+override > slot > token); `chrome` honors background/opacity only; `canvas`
+paints at the above-grid seam so its background hides the grid, clips marks
+through a dedicated clipPath for `border-radius` in SVG/PDF, and reports
+radius/opacity as named raster losses until the rounded-clip opcode lands
+(`_svg.SLOT_BOX_RASTER_UNSUPPORTED`).
 
 ```python
 xy.chart(
diff --git a/spec/process/static-chrome-parity-plan-2026-08-04.md b/spec/process/static-chrome-parity-plan-2026-08-04.md
index cd486bac4..5837a503f 100644
--- a/spec/process/static-chrome-parity-plan-2026-08-04.md
+++ b/spec/process/static-chrome-parity-plan-2026-08-04.md
@@ -65,7 +65,7 @@ The three existing duplicated box sites, converted per phase (not up front): leg
 
 ---
 
-## 2. Phase 0 — cross-cutting prerequisites (blocking)
+## 2. Phase 0 — cross-cutting prerequisites (blocking) — LANDED
 
 **0.1 PDF text-subset extension (live-bug fix).** All four surveys independently probe-verified: `_pdf._ALLOWED_ATTRS['text']` (`_pdf.py:204-206`) rejects `font-style`, `font-family`, `letter-spacing`, `opacity`, so `to_image(format='pdf')` RAISES today for an italic title, a letter-spaced legend_label, an italic tick_label/colorbar_tick, and mathtext annotations (nested tspan, `_pdf.py:1099-1100`). The `SLOT_TEXT_PROPS` docstring claim that PDF honors the vector subset (`_svg.py:1331-1332`) is false; the capability-matrix tick_label PDF note is also wrong.
 Edits: `_ALLOWED_ATTRS['text']` + `_render_text` (`_pdf.py:1062-1141`); Helvetica-Oblique/BoldOblique into `_font()` (`_pdf.py:681-691`, today regular/bold only, bold cutoff weight>=600 at `1065`); letter-spacing via `Tc`; text opacity multiplied into `ca` ExtGState; nested-tspan mathtext either supported or explicitly fenced. `font-family` beyond base-14 is policy-refused, not guessed.
@@ -83,10 +83,25 @@ Acceptance: unit tests on the lowering (border shorthand, per-side padding, radi
 
 ---
 
-## 3. Phase 1 — root / title / chrome / canvas
+## 3. Phase 1 — root / title / chrome / canvas — LANDED
 
 Geometry is free: root = chrome = (0,0,width,height); canvas = plot rect from `layout()` (`_svg.py:2665-2678`). Only the title needs a new helper.
 
+Landing notes (deltas from the letter of the plan, none from its intent):
+the shared title helper is `title_placement`/`legacy_title_placement` +
+`title_box` (the writers need the text anchor as well as the box, so the
+hoist returns both); the P0.3 shorthand expansion (`border`, `padding`) that
+had not landed with the primitive ships here (`_chromebox.expand_box_shorthands`,
+consumed by `lower_box` and the declared resolver's snapshot path, em residue
+untouched); `SlotInstance.geometry` is populated for `root`/`chrome` from the
+snapshot environment (spec dims, never host padding — flag J's normalization
+rule), while `title`/`canvas` geometry needs the layout pass the resolver
+cannot re-enter (`layout()` → `slot_styles` → `resolve_declared`) and lands
+with the capture producers; a raster-emitter coordinate bug from P0.3
+(`_rect_pts` fed (w, h) as the far corner) was fixed and pinned; contracts:
+`spec/api/export.md` §9, `spec/api/styling.md` § Per-slot styles in a file,
+tests in `tests/test_chrome_parity_p1.py`.
+
 **Edits, in order:**
 
 1. **`title_box(entry, plot, wrap_width) -> ChromeBox`** next to `_title_metrics` (`_svg.py:2550-2558`), replacing the anchor math duplicated at `_svg.py:4245-4258` / `_raster.py:1465-1479` (entry titles) and `_svg.py:4226-4227` / `_raster.py:1443-1453` (legacy), mirrored a third time in JS (`50_chartview.ts:940-963`). Hoist BEFORE drawing boxes — the survey is explicit that adding box extents in each copy independently will drift. Box width = measured `TextBlock` width + padding (`_textblock.py:31-43`), NOT `title_wrap_width` (browser box is the shrink-to-fit div, `50_chartview.ts:2455-2468`).
diff --git a/tests/test_chrome_parity_p1.py b/tests/test_chrome_parity_p1.py
new file mode 100644
index 000000000..f138e0005
--- /dev/null
+++ b/tests/test_chrome_parity_p1.py
@@ -0,0 +1,389 @@
+"""Static-chrome parity phase 1: root / title / chrome / canvas boxes.
+
+Every assertion here is an acceptance bullet from
+`spec/process/static-chrome-parity-plan-2026-08-04.md` §3. The standing gate
+(§2 item 0.5) leads: all emission is strictly declaration-gated, so an
+unstyled chart's SVG and PNG bytes cannot move. Then per slot: the box in
+both writers, the recorded divergences, the export-background override
+contract, and a PDF round-trip of every construct the family emits.
+"""
+
+from __future__ import annotations
+
+import io
+import re
+
+import numpy as np
+import pytest
+
+import xy
+from xy import _raster, _svg, export
+from xy._pdf import svg_to_pdf
+from xy.styling.capabilities import KNOWN_RENDERER_DIVERGENCES
+from xy.styling.declared import resolve_declared
+
+
+def _chart(**props) -> xy.Chart:
+    return xy.line_chart(
+        xy.line([0.0, 1.0, 2.0], [0.0, 1.0, 0.5], name="series"), title="Chart title", **props
+    )
+
+
+def _raster_pixels(chart: xy.Chart) -> np.ndarray:
+    rendered = _raster.render_raster(*chart.figure().build_payload(), scale=1)
+    assert isinstance(rendered, np.ndarray)
+    return rendered
+
+
+def _decode_png(data: bytes) -> np.ndarray:
+    from PIL import Image
+
+    return np.asarray(Image.open(io.BytesIO(data)).convert("RGBA"))
+
+
+def _pdf_round_trips(svg: str) -> None:
+    assert svg_to_pdf(svg)[:4] == b"%PDF"
+
+
+# -- the standing gate --------------------------------------------------------
+
+
+def test_unstyled_output_is_unchanged_by_the_p1_paths() -> None:
+    # Emission is strictly conditional on a BOX declaration being present:
+    # declarations outside every honored subset must leave the SVG and the
+    # raster display list byte-identical to a chart with no styles at all.
+    plain = _chart().figure()
+    decorated = _chart(
+        styles={
+            "root": {"outline_color": "#123456"},
+            "chrome": {"border_width": 2},
+            "canvas": {"cursor": "pointer"},
+            "title": {"text_decoration": "underline"},
+        }
+    ).figure()
+    assert plain.to_svg() == decorated.to_svg()
+    assert plain.to_png() == decorated.to_png()
+    # And the unstyled document contains none of this family's constructs:
+    # one clipPath (plot/legend) and no full-canvas box rect.
+    svg = plain.to_svg()
+    assert svg.count("<clipPath") == 1
+    assert '<rect x="0" y="0"' not in svg
+
+
+# -- title --------------------------------------------------------------------
+
+_TITLE_STYLES = {
+    "title": {
+        "background": "#e2e8f0",
+        "padding": "6px 10px",
+        "border_color": "#94a3b8",
+        "border_radius": "4px",
+    }
+}
+
+
+def _title_rect_and_text(svg: str) -> tuple[str, str]:
+    text = re.search(r"<text[^>]*>Chart title</text>", svg)
+    assert text is not None
+    before = svg[: text.start()]
+    rect = re.findall(r"<rect[^>]*/>", before)[-1]
+    # The box rides immediately before its text: under the title, above all
+    # earlier chrome.
+    assert before.rstrip().endswith(rect)
+    return rect, text.group(0)
+
+
+def test_title_box_renders_under_the_text_in_svg_and_pdf() -> None:
+    svg = _chart(styles=_TITLE_STYLES).figure().to_svg()
+    rect, _text = _title_rect_and_text(svg)
+    assert 'fill="#e2e8f0"' in rect
+    assert 'stroke="#94a3b8"' in rect
+    assert 'rx="4"' in rect
+    _pdf_round_trips(svg)
+
+
+def test_title_box_width_is_block_width_plus_padding_not_wrap_width() -> None:
+    chart = _chart(styles=_TITLE_STYLES)
+    spec, _blob = chart.figure().build_payload()
+    width, _height, _compact, plot = _svg.layout(spec)
+    svg = chart.figure().to_svg()
+    rect, _ = _title_rect_and_text(svg)
+    box_w = float(re.search(r'width="([\d.]+)"', rect).group(1))
+    from xy import _textblock
+
+    block = _textblock.measure("Chart title", 14.0, max_width=plot["title_wrap_width"])
+    assert box_w == pytest.approx(block.width + 10 + 10, abs=0.02)
+    assert box_w < plot["title_wrap_width"]
+
+
+def test_title_room_grows_for_padding_and_border() -> None:
+    plain_spec, _ = _chart().figure().build_payload()
+    styled_spec, _ = _chart(styles=_TITLE_STYLES).figure().build_payload()
+    *_, plain_plot = _svg.layout(plain_spec)
+    *_, styled_plot = _svg.layout(styled_spec)
+    # The room formula grows by 6px padding top+bottom plus the implied 1px
+    # border on both edges: max(30, block.height + 14 + pad) — mirrored by
+    # _titleBoxExtent in js/src/50_chartview.ts.
+    from xy import _textblock
+
+    block = _textblock.measure("Chart title", 14.0, max_width=plain_plot["title_wrap_width"])
+    assert plain_plot["title_room"] == pytest.approx(max(30.0, block.height + 8.0))
+    assert styled_plot["title_room"] == pytest.approx(max(30.0, block.height + 14.0 + 8.0))
+    grown = styled_plot["title_room"] - plain_plot["title_room"]
+    assert grown > 0
+    assert styled_plot["y"] == pytest.approx(plain_plot["y"] + grown)
+    # The box clears the canvas top: its rect starts at a positive y.
+    rect, _ = _title_rect_and_text(_chart(styles=_TITLE_STYLES).figure().to_svg())
+    assert float(re.search(r'y="([\d.-]+)"', rect).group(1)) > 0
+
+
+def test_title_entry_style_merges_over_the_slot() -> None:
+    # `_title_metrics` order: the per-entry style is the narrower selector.
+    fig = xy.line_chart(
+        xy.line([0.0, 1.0], [0.0, 1.0], name="series"),
+        styles={"title": {"background": "#445566", "padding": "4px"}},
+    ).figure()
+    fig.title_options = [
+        {"text": "Entry title", "loc": "center", "style": {"background": "#112233"}}
+    ]
+    svg = fig.to_svg()
+    assert "#112233" in svg
+    text = re.search(r"<text[^>]*>Entry title</text>", svg)
+    rect = re.findall(r"<rect[^>]*/>", svg[: text.start()])[-1]
+    assert 'fill="#112233"' in rect
+    # The per-entry-box browser divergence is recorded, not silent (§28).
+    assert "title_entry_box_allowlist" in {d.id for d in KNOWN_RENDERER_DIVERGENCES}
+
+
+def test_title_box_reaches_the_raster_writer() -> None:
+    plain = _raster_pixels(_chart())
+    styled = _raster_pixels(_chart(styles=_TITLE_STYLES))
+    assert not (plain == styled).all()
+    # The box paints AT THE TITLE, not somewhere near the origin — the
+    # (x, y, w, h)-vs-far-corner regression in the raster emitter.
+    spec, _ = _chart(styles=_TITLE_STYLES).figure().build_payload()
+    width, _h, compact, plot = _svg.layout(spec)
+    placement = _svg.legacy_title_placement(spec, plot, compact, width, plot["title_wrap_width"])
+    box = _svg.title_box(placement)
+    assert box is not None
+    inside = styled[int(box.y + box.h / 2), int(box.x + 3)]
+    assert tuple(inside[:3]) == (0xE2, 0xE8, 0xF0)
+    assert tuple(styled[2, 2]) == tuple(plain[2, 2])
+
+
+def test_italic_title_with_a_box_exports_to_pdf() -> None:
+    svg = (
+        _chart(styles={"title": {**_TITLE_STYLES["title"], "font_style": "italic"}})
+        .figure()
+        .to_svg()
+    )
+    _pdf_round_trips(svg)
+
+
+# -- root ---------------------------------------------------------------------
+
+_ROOT_STYLES = {
+    "root": {
+        "background": "#0f172a",
+        "border_color": "#334155",
+        "border_width": 2,
+        "border_radius": "12px",
+    }
+}
+
+
+def test_root_box_renders_in_both_writers_and_pdf() -> None:
+    svg = _chart(styles=_ROOT_STYLES).figure().to_svg()
+    # First painted content after the defs (clipPath rects are not paint).
+    rect = re.search(r"<rect[^>]*/>", svg[svg.index("</defs>") :]).group(0)
+    assert 'fill="#0f172a"' in rect
+    assert 'stroke="#334155"' in rect and 'stroke-width="2"' in rect
+    assert 'rx="12"' in rect
+    _pdf_round_trips(svg)
+    pixels = _raster_pixels(_chart(styles=_ROOT_STYLES))
+    assert tuple(pixels[30, 450][:3]) == (0x0F, 0x17, 0x2A)
+
+
+def test_root_radius_corners_show_the_underlay_not_native_white() -> None:
+    # Opaque dark root with a big radius: the corner pixel is the white
+    # underlay (the browser's host page), the inside is the root fill —
+    # so the fast_png full-coverage skip may not fire for a rounded patch.
+    chart = xy.line_chart(
+        xy.line([0.0, 1.0], [0.0, 1.0], name="series"),
+        styles={"root": {"background": "#112233", "border_radius": "40px"}},
+    )
+    pixels = _raster_pixels(chart)
+    assert tuple(pixels[0, 0]) == (255, 255, 255, 255)
+    assert tuple(pixels[60, 450][:3]) == (0x11, 0x22, 0x33)
+    # And on a transparent fast-path export the corners are transparent,
+    # never uninitialized native white.
+    png = _decode_png(export.to_image(chart.figure(), "png", background="transparent", scale=1.0))
+    assert tuple(png[0, 0]) == (0, 0, 0, 0)
+
+
+def test_transparent_export_background_kills_the_root_paint() -> None:
+    fig = _chart(styles=_ROOT_STYLES).figure()
+    svg = export.to_image(fig, "svg", background="transparent").decode()
+    assert "#0f172a" not in svg  # the fill is silenced...
+    assert "#334155" in svg  # ...the border is chrome, not backdrop
+    png = _decode_png(export.to_image(fig, "png", background="transparent", scale=1.0))
+    assert png[5, 450][3] == 0
+    # The override mutates one export's spec, never the figure: the next
+    # un-overridden export keeps the declared root paint.
+    assert "#0f172a" in fig.to_svg()
+
+
+def test_root_shadow_is_a_named_loss_and_never_grows_the_canvas() -> None:
+    chart = _chart(styles={"root": {"background": "#111", "box_shadow": "4px 4px #000"}})
+    report = chart.style_compatibility_report("png")
+    finding = next(f for f in report.findings if f.slot == "root")
+    assert "box-shadow" in finding.lost
+    svg = chart.figure().to_svg()
+    assert 'width="900" height="420"' in svg[:200]  # viewBox untouched
+    assert svg.count('width="900" height="420"') >= 2  # svg + the root rect
+
+
+def test_theme_background_becomes_the_root_box_fill_when_unset() -> None:
+    # Same element, one `background` property: a root border/radius rounds
+    # the theme figure patch instead of stacking a second paint.
+    chart = xy.line_chart(
+        xy.line([0.0, 1.0], [0.0, 1.0], name="series"),
+        xy.theme(background="#221100"),
+        styles={"root": {"border_radius": "16px"}},
+    )
+    svg = chart.figure().to_svg()
+    rect = re.search(r"<rect[^>]*/>", svg[svg.index("</defs>") :]).group(0)
+    assert 'fill="#221100"' in rect and 'rx="16"' in rect
+    assert svg.count("#221100") == 1  # replaced, not doubled
+
+
+# -- chrome -------------------------------------------------------------------
+
+
+def test_chrome_background_sits_above_root_below_grid_in_svg() -> None:
+    svg = (
+        _chart(
+            styles={
+                "root": {"background": "#0f172a"},
+                "chrome": {"background": "rgba(255, 0, 0, 0.25)"},
+            }
+        )
+        .figure()
+        .to_svg()
+    )
+    root_at = svg.index("#0f172a")
+    chrome_at = svg.index("rgba(255, 0, 0, 0.25)")
+    grid_at = svg.index("<g>")
+    assert root_at < chrome_at < grid_at
+    _pdf_round_trips(svg)
+
+
+def test_chrome_background_composites_in_the_raster_writer() -> None:
+    pixels = _raster_pixels(
+        _chart(
+            styles={
+                "root": {"background": "#0000ff"},
+                "chrome": {"background": "rgba(255, 0, 0, 0.5)"},
+            }
+        )
+    )
+    # 50% red over blue in the margin corner.
+    assert tuple(pixels[0, 0][:3]) == (128, 0, 127)
+    # The stacking divergence against the browser's DOM order is recorded.
+    assert "chrome_slot_title_stacking" in {d.id for d in KNOWN_RENDERER_DIVERGENCES}
+
+
+# -- canvas -------------------------------------------------------------------
+
+_CANVAS_STYLES = {"canvas": {"background": "#fefce8"}}
+
+
+def test_canvas_background_paints_at_the_above_grid_seam() -> None:
+    svg = _chart(styles=_CANVAS_STYLES).figure().to_svg()
+    grid_close = svg.index("</g>")
+    marks_open = svg.index('<g clip-path="url(#')
+    canvas_at = svg.index("#fefce8")
+    assert grid_close < canvas_at < marks_open
+
+
+def test_canvas_background_hides_the_grid_in_the_raster_writer() -> None:
+    plain_chart = _chart()
+    styled_chart = _chart(styles=_CANVAS_STYLES)
+    spec, _ = plain_chart.figure().build_payload()
+    *_, plot = _svg.layout(spec)
+    plain = _raster_pixels(plain_chart)
+    styled = _raster_pixels(styled_chart)
+    # The first vertical gridline, sampled mid-height (the data line for
+    # [0,1,2]->[0,1,.5] is far from mid-height at that x).
+    unstyled_svg = plain_chart.figure().to_svg()
+    grid_x = float(re.search(r'<line x1="([\d.]+)"', unstyled_svg).group(1))
+    row, col = int(plot["y"] + plot["h"] / 2), int(grid_x)
+    assert tuple(plain[row, col]) != (255, 255, 255, 255)  # grid ink visible
+    assert tuple(styled[row, col][:3]) == (0xFE, 0xFC, 0xE8)  # hidden by the box
+
+
+def test_canvas_radius_clips_the_marks_through_a_third_clippath() -> None:
+    styled = {"canvas": {"background": "#fefce8", "border_radius": "10px", "opacity": 0.9}}
+    svg = _chart(styles=styled).figure().to_svg()
+    # A dedicated clipPath: the plot/legend clip stays untouched (mutating it
+    # vanishes polar legends), and the wrapper group carries the clip and the
+    # declared opacity around the marks.
+    assert svg.count("<clipPath") == 2
+    clip_ids = re.findall(r'<clipPath id="([^"]+)"', svg)
+    assert re.search(rf'<g clip-path="url\(#{clip_ids[1]}\)" opacity="0.9">', svg)
+    _pdf_round_trips(svg)
+
+
+def test_canvas_border_composes_with_the_spines() -> None:
+    svg = (
+        _chart(styles={"canvas": {"border_color": "#a16207", "border_width": 2}}).figure().to_svg()
+    )
+    spec, _ = _chart().figure().build_payload()
+    *_, plot = _svg.layout(spec)
+    rect = next(r for r in re.findall(r"<rect[^>]*/>", svg) if "#a16207" in r)
+    assert f'x="{_svg._num(plot["x"])}"' in rect
+    # The default spines still draw afterwards (the border does not replace
+    # them): the axis baselines survive byte-identically.
+    plain = _chart().figure().to_svg()
+    baseline = re.search(r'<line x1="62"[^>]*stroke="rgba\(32,32,32,0\.5', plain)
+    assert baseline is not None and baseline.group(0) in svg
+
+
+def test_transparent_export_background_kills_the_canvas_paint() -> None:
+    fig = _chart(styles=_CANVAS_STYLES).figure()
+    svg = export.to_image(fig, "svg", background="transparent").decode()
+    assert "#fefce8" not in svg
+
+
+# -- the declared resolver ----------------------------------------------------
+
+
+def test_box_shorthands_intern_as_longhands_in_the_snapshot() -> None:
+    chart = _chart(
+        styles={
+            "title": {"padding": "4px 8px", "border": "2px dashed #333"},
+            "legend": {"padding": "1.2em"},  # stays writer-domain, authored spelling
+        }
+    )
+    spec, _ = chart.figure().build_payload()
+    styling = resolve_declared(spec)
+    by_slot = {
+        inst.slot: styling.snapshot.declarations[inst.declaration]
+        for inst in styling.snapshot.instances
+    }
+    assert by_slot["title"]["padding-top"] == 4.0
+    assert by_slot["title"]["padding-right"] == 8.0
+    assert by_slot["title"]["border-width"] == 2.0
+    assert by_slot["title"]["border-style"] == "dashed"
+    assert by_slot["title"]["border-color"] == "#333"
+    assert styling.writer_domain["legend"] == {"padding": "1.2em"}
+
+
+def test_declared_resolver_populates_root_and_chrome_geometry() -> None:
+    chart = _chart(styles={"root": {"background": "#111"}, "chrome": {"opacity": 0.5}})
+    spec, _ = chart.figure().build_payload()
+    styling = resolve_declared(spec)
+    geometry = {inst.slot: inst.geometry for inst in styling.snapshot.instances}
+    env = styling.snapshot.environment
+    assert geometry["root"] == (0.0, 0.0, env.width, env.height)
+    assert geometry["chrome"] == (0.0, 0.0, env.width, env.height)
diff --git a/tests/test_chromebox.py b/tests/test_chromebox.py
index a2c967891..607681f34 100644
--- a/tests/test_chromebox.py
+++ b/tests/test_chromebox.py
@@ -8,8 +8,10 @@
 
 from __future__ import annotations
 
+import struct
+
 from xy import _raster, _svg
-from xy._chromebox import ChromeBox, lower_box
+from xy._chromebox import ChromeBox, box_padding, expand_box_shorthands, lower_box
 from xy._pdf import svg_to_pdf
 
 
@@ -87,6 +89,50 @@ def test_shadow_parses_zero_blur_and_rejects_multiples() -> None:
     assert any("multiple" in u for u in multi.unrepresentable)
 
 
+def test_border_shorthand_lowers_like_its_longhands() -> None:
+    short = _box({"border": "2px dashed #333"})
+    long = _box({"border-width": "2px", "border-style": "dashed", "border-color": "#333"})
+    assert (short.border_color, short.border_width, short.border_dash) == (
+        long.border_color,
+        long.border_width,
+        long.border_dash,
+    )
+    # An explicit longhand beside the shorthand is the narrower author
+    # intent and wins.
+    assert _box({"border": "2px solid #333", "border-color": "#f00"}).border_color == "#f00"
+
+
+def test_padding_expands_per_css_sides_and_rides_the_box() -> None:
+    assert box_padding({"padding": "4px"}) == (4.0, 4.0, 4.0, 4.0)
+    assert box_padding({"padding": "4px 8px"}) == (4.0, 8.0, 4.0, 8.0)
+    assert box_padding({"padding": "1px 2px 3px"}) == (1.0, 2.0, 3.0, 2.0)
+    assert box_padding({"padding": "1px 2px 3px 4px"}) == (1.0, 2.0, 3.0, 4.0)
+    assert box_padding({"padding": "2px", "padding-left": 9}) == (2.0, 2.0, 2.0, 9.0)
+    # em spellings stay the legend writers' domain until P4: zero, not a guess.
+    assert box_padding({"padding": "1.2em"}) == (0.0, 0.0, 0.0, 0.0)
+    assert _box({"padding": "4px 8px"}).padding == (4.0, 8.0, 4.0, 8.0)
+
+
+def test_unparsable_shorthands_pass_through_unexpanded() -> None:
+    # Nothing declared may disappear: the consumer decides what an
+    # unexpanded value means (the declared resolver keeps it as residue).
+    assert expand_box_shorthands({"padding": "1.2em"}) == {"padding": "1.2em"}
+
+
+def test_raster_emitter_paints_the_box_rect_not_a_far_corner() -> None:
+    # `_rect_pts`/`_round_rect_pts` take (x0, y0, x1, y1); the box carries a
+    # width/height pair. The P0.3 emitter passed (w, h) as the far corner,
+    # so any box not anchored at the origin painted the wrong rectangle.
+    cmd = _raster._Cmd(1.0)
+    _raster._emit_slot_box(cmd, _box({"background": "#0f172a"}))
+    buf = bytes(cmd.buf)
+    assert buf[0] == _raster._FILL
+    (count,) = struct.unpack_from("<I", buf, 1)
+    pts = struct.unpack_from(f"<{count * 2}f", buf, 5)
+    quad = list(zip(pts[0::2], pts[1::2], strict=True))
+    assert quad == [(10.0, 20.0), (110.0, 20.0), (110.0, 60.0), (10.0, 60.0)]
+
+
 # -- emitters -----------------------------------------------------------------
 
 
diff --git a/tests/test_export_style_survival.py b/tests/test_export_style_survival.py
index 46ea1470d..55caadde4 100644
--- a/tests/test_export_style_survival.py
+++ b/tests/test_export_style_survival.py
@@ -57,10 +57,12 @@ def test_native_writers_read_a_property_subset_not_the_whole_cascade() -> None:
         assert f"cls-{slot}" not in svg
 
 
-#: The paint property each static slot answers to. `legend` is the frame box,
-#: so it takes `background`; every other static slot is text, so it takes the
-#: SVG text paint.
-_SLOT_PAINT_PROPERTY = {slot: "fill" for slot in STATIC_STYLED_SLOTS} | {"legend": "background"}
+#: The paint property each static slot answers to. The box slots (`legend`'s
+#: frame and the P1 family: `root`, `chrome`, `canvas`) take `background`;
+#: every other static slot is text, so it takes the SVG text paint.
+_SLOT_PAINT_PROPERTY = {slot: "fill" for slot in STATIC_STYLED_SLOTS} | {
+    slot: "background" for slot in ("legend", "root", "chrome", "canvas")
+}
 
 
 @pytest.mark.parametrize("slot", STATIC_STYLED_SLOTS)
diff --git a/tests/test_style_compatibility_report.py b/tests/test_style_compatibility_report.py
index 8c07a9a67..e71295603 100644
--- a/tests/test_style_compatibility_report.py
+++ b/tests/test_style_compatibility_report.py
@@ -116,11 +116,53 @@ def test_styles_on_a_slot_with_no_native_path_are_named_lost() -> None:
     assert not report.lossless
 
 
-def test_root_styles_point_at_the_token_bag_channel() -> None:
-    report = _chart(styles={"root": {"background": "#111"}}).style_compatibility_report("png")
+def test_root_styles_route_through_the_box_vocabulary() -> None:
+    # The P1 flip: `styles={'root': ...}` reaches the writers as the figure
+    # patch's own box (static-chrome-parity plan §3.4). Box properties are
+    # kept; a property outside the box vocabulary (root has no text of its
+    # own) is a named loss, not a silent drop.
+    report = _chart(
+        styles={"root": {"background": "#111", "border_radius": "8px"}}
+    ).style_compatibility_report("png")
     finding = _finding(report, "root", "styles")
-    assert finding.route == pf.ROUTE_BROWSER_ONLY
-    assert "style=" in finding.detail
+    assert finding.route == pf.ROUTE_SURVIVES
+    assert set(finding.kept) == {"background", "border-radius"}
+    assert report.lossless
+
+    lossy = _chart(
+        styles={"root": {"background": "#111", "font_size": 20}}
+    ).style_compatibility_report("png")
+    finding = _finding(lossy, "root", "styles")
+    assert finding.route == pf.ROUTE_SUBSET
+    assert finding.lost == ("font-size",)
+    assert not lossy.lossless
+
+
+def test_canvas_radius_and_opacity_are_named_raster_losses() -> None:
+    # The raster display list clips rectangles only and has no group
+    # compositing, so a canvas radius/opacity is a recorded loss on PNG and
+    # survives on the vector targets (parity plan §3.6; the acceptance's
+    # "preflight reports raster radius partial").
+    chart = _chart(styles={"canvas": {"background": "#eee", "border_radius": "10px"}})
+    raster = chart.style_compatibility_report("png")
+    finding = _finding(raster, "canvas", "styles")
+    assert finding.route == pf.ROUTE_SUBSET
+    assert finding.lost == ("border-radius",)
+    assert "background" in finding.kept
+    assert "round-clip" in finding.detail
+    assert not raster.lossless
+    assert chart.style_compatibility_report("svg").lossless
+    assert chart.style_compatibility_report("pdf").lossless
+
+
+def test_chrome_slot_honors_background_and_opacity_only() -> None:
+    report = _chart(
+        styles={"chrome": {"background": "rgba(0, 0, 0, 0.2)", "opacity": 0.5, "border_width": 2}}
+    ).style_compatibility_report("png")
+    finding = _finding(report, "chrome", "styles")
+    assert finding.route == pf.ROUTE_SUBSET
+    assert set(finding.kept) == {"background", "opacity"}
+    assert finding.lost == ("border-width",)
 
 
 def test_legend_styles_route_at_property_level() -> None:

From 43d98c75eb5a6975c8fe692799a17c77118d2af7 Mon Sep 17 00:00:00 2001
From: Alek Petuskey <alek@reflex.dev>
Date: Tue, 4 Aug 2026 16:40:00 -0700
Subject: [PATCH 20/27] Static-chrome parity P3.3: the labels container becomes
 the writers' inherited default
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

styles={'labels': ...} now does in a file what the container does live.
Color threads as the default under the live var(--chart-text, inherit)
chain — theme token first, container color second, writer default last —
for every text the container holds (tick labels, axis titles, annotation
labels), in both writers, while title/legend/colorbar stay siblings on
default_text. Typography folds UNDER the contained slots exactly where
the live stylesheet leaves the property un-ruled (size/weight cascade
into tick labels only; style/family/letter-spacing into all three), and
opacity rides the SVG label group. The flag-D stacking conflict resolves
to the browser's own order: the full-bleed background paints under the
axis rules and every label text in both writers, pinned by golden; the
residual sibling stacking (live, the container covers the title) is
recorded in KNOWN_RENDERER_DIVERGENCES rather than left to be
discovered. Registry, preflight, matrix and specs move in the same
commit; unstyled bytes hold.
---
 .../limitations-and-alpha-status.md           |  16 ++-
 docs/styling/capabilities.md                  |   4 +-
 python/xy/_raster.py                          |  43 ++++--
 python/xy/_svg.py                             |  80 ++++++++++-
 python/xy/styling/capabilities.py             |  30 ++++
 python/xy/styling/preflight.py                |   6 +
 spec/api/capability-matrix.md                 |   8 +-
 spec/api/export.md                            |   9 +-
 spec/api/styling.md                           |   3 +-
 tests/test_chrome_parity_p3.py                | 134 ++++++++++++++++++
 10 files changed, 300 insertions(+), 33 deletions(-)

diff --git a/docs/api-reference/limitations-and-alpha-status.md b/docs/api-reference/limitations-and-alpha-status.md
index 26bb6e1fc..0291caa58 100644
--- a/docs/api-reference/limitations-and-alpha-status.md
+++ b/docs/api-reference/limitations-and-alpha-status.md
@@ -85,14 +85,16 @@ implementation. The bullets below are the boundaries that page's rows imply.
 - **Styling does not survive every export path equally, and the boundary is
   published rather than left to be discovered.** Mark, axis, and chart-level
   `style=` reach all three renderers. Per-slot `styles={slot: {...}}` reaches
-  them for the eleven slots that name chrome a static file contains — `title`,
+  them for the twelve slots that name chrome a static file contains — `title`,
   `axis_title`, `tick_label`, the three legend slots, the three colorbar
-  slots, `annotation_label`, and `annotation_layer` — carrying `font-size`,
-  `font-weight`, `font-style`, `font-family`, `letter-spacing`, `opacity`,
-  and the text paint; `annotation_label` additionally carries the chrome-box
-  subset (background, border, radius, padding, offset shadow) under the
-  annotation's own `style=`, and `annotation_layer` takes a group opacity
-  over the annotation shapes plus a plot-clipped background. The remaining
+  slots, `annotation_label`, `annotation_layer`, and `labels` — carrying
+  `font-size`, `font-weight`, `font-style`, `font-family`, `letter-spacing`,
+  `opacity`, and the text paint; `annotation_label` additionally carries the
+  chrome-box subset (background, border, radius, padding, offset shadow)
+  under the annotation's own `style=`, `annotation_layer` takes a group
+  opacity over the annotation shapes plus a plot-clipped background, and
+  `labels` supplies the container defaults (color and typography) under the
+  contained slots. The remaining
   slots are live
   chrome (`tooltip*`, `modebar*`, `crosshair_*`, `selection`, `badge*`) with
   nothing in a file to paint, and `class_names={slot: "..."}` cannot apply in a
diff --git a/docs/styling/capabilities.md b/docs/styling/capabilities.md
index 391d472f8..ad9bacddf 100644
--- a/docs/styling/capabilities.md
+++ b/docs/styling/capabilities.md
@@ -68,7 +68,7 @@ would not survive, before any bytes exist.
 | `chrome` | clean static | full | none | none |
 | `canvas` | clean static | full | none | none |
 | `annotation_layer` | clean static | full | partial | partial |
-| `labels` | clean static | full | none | none |
+| `labels` | clean static | full | partial | partial |
 | `legend` | clean static | full | partial | partial |
 | `legend_title` | clean static | full | partial | partial |
 | `legend_item` | clean static | full | none | none |
@@ -117,6 +117,7 @@ would not survive, before any bytes exist.
 - **`root`** (via `chart style=`) — `styles={'root': ...}` is browser-only, but the chart-level `style=` token bag targets the same element and every renderer reads it (`spec['dom']['style']`). Prefer it for anything that must survive export.
 - **`title`** (via `styles={'title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
 - **`annotation_layer`** (via `styles={'annotation_layer': ...}`) — The annotation-shape overlay. `opacity` dims every annotation shape as a group (never the labels, which live in the labels container): SVG/PDF as real group opacity on a `<g>`, raster folded into each shape's RGBA because the display list has no group compositing — overlapping translucent shapes double-blend there, a recorded approximation (§28). `background` paints under the shapes, plot-clipped; the live overlay is full-bleed, a divergence recorded in KNOWN_RENDERER_DIVERGENCES. Everything else stays browser-only.
+- **`labels`** (via `styles={'labels': ...}`) — The label container. Its color is the default under the live chain `var(--chart-text, inherit)` for every contained text (tick labels, axis titles, annotation labels): the theme token wins, then the container color, then the writer default — the axis's own colors and the specific slots stay narrower and win. Typography folds under the contained slots exactly where the live stylesheet leaves the property un-ruled (font-size/weight cascade into tick labels only; style/family/letter-spacing into all three). `background` paints full-bleed under the axis rules and every label text, the live order; the residual sibling stacking difference is in KNOWN_RENDERER_DIVERGENCES. `opacity` rides the SVG label group (vector-only); live it also dims the contained axis rules and the container background — recorded here rather than approximated.
 - **`legend`** (via `styles={'legend': ...} / xy.legend(style=...) / --chart-legend-bg`) — The frame box. Both spellings and the theme token now converge on one merged declaration block before the writers see it, so what agrees in the browser agrees in a PNG. `background`, `boxShadow`, `borderRadius`, `--xy-legend-frame-alpha`, and `padding`/`rowGap` in `em` are honored; an explicit background paints opaque, as it does in the browser.
 - **`legend_title`** (via `styles={'legend_title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
 - **`legend_label`** (via `styles={'legend_label': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
@@ -146,6 +147,7 @@ an undocumented difference reads as a bug; a documented one is a contract.
 |---|---|---|---|---|
 | Interior vertices of a wide polyline | the notch two overlapping segment quads leave | round (the writer names it explicitly) | round (the capsule distance field fills the vertex) | stroke-width above ~4px at a sharp angle |
 | The annotation_layer slot's background extent | full-bleed (the overlay canvas is inset:0 over the whole chart) | plot rect, inside the marks clip (the only seam above traces and below shapes) | plot rect, under the active marks clip (same seam as SVG) | styles={'annotation_layer': {'background': ...}} is declared |
+| Where the labels-container background sits among its siblings (flag D) | over the chart title (the container is a later DOM sibling), under the axis rules and label texts it contains | under the axis rules and label texts (the resolved flag-D order), and under the title/legend/colorbar chrome, which joins later | same as SVG: filled after the marks, before the chrome text phase | styles={'labels': {'background': ...}} on a chart with a title, legend or colorbar |
 | How the annotation_layer slot's opacity composites overlapping shapes | group opacity: the overlay canvas is dimmed once as a whole | group opacity on the wrapping <g>, PDF-legal, same as live | folded into each shape's RGBA (no group compositing opcode): overlapping translucent shapes double-blend | the slot declares opacity below 1 over overlapping annotation shapes |
 
 For what is still alpha, see
diff --git a/python/xy/_raster.py b/python/xy/_raster.py
index 444bbdcc4..449978460 100644
--- a/python/xy/_raster.py
+++ b/python/xy/_raster.py
@@ -79,6 +79,7 @@
     polar_tick_label_layout,
     polar_wedge_points,
     slot_font_size,
+    slot_in_labels_container,
     slot_styles,
     slot_text_color,
     warp_grid_rgba,
@@ -1098,6 +1099,15 @@ def render_raster(
     # Hoisted above the annotation passes: both phases read the annotation
     # slots, and the chrome text below reads the rest of the same mapping.
     slots = slot_styles(spec)
+    labels_slot = slots.get("labels") or {}
+    # The live chain for every text in the labels container is
+    # `color: var(--chart-text, inherit)`: the theme token wins, the
+    # container's own declared color is the inherited fallback, then the
+    # writer default. Title/legend/colorbar are siblings and keep
+    # `default_text`.
+    label_text_default = (
+        _css(dom_style.get("--chart-text"), "") or slot_text_color(labels_slot, "") or _TEXT
+    )
 
     spec_palette: Sequence[str] = spec.get("palette") or DEFAULT_PALETTE
     for palette_i, t in enumerate(spec["traces"]):
@@ -1156,6 +1166,16 @@ def render_raster(
 
     # Chrome (unclipped): baselines, labels, title, legend.
     cmd.clip(0, 0, width, height)
+    # labels-container box (flag D, resolved): the background paints UNDER
+    # the baselines and every label text — the live DOM's order, where the
+    # spine/tick rules are children of the labels container. Painted before
+    # the annotation text phase because the raster draws those labels ahead
+    # of the spines (a pre-existing phase-order difference from SVG).
+    labels_paint = labels_slot.get("background", labels_slot.get("background-color"))
+    if labels_paint is not None:
+        _emit_slot_box(
+            cmd, lower_box("labels", {"background": labels_paint}, x=0, y=0, w=width, h=height)
+        )
     # Text annotations are unclipped like matplotlib Text (clip_on=False):
     # margin titles and edge labels may live outside the plot rectangle.
     _emit_annotations(
@@ -1377,19 +1397,20 @@ def emit_tick_labels(
         is_x: bool,
     ) -> None:
         axis_style = axis.get("style") or {}
+        tick_slot = slot_in_labels_container(slots, "tick_label")
         # The axis's own tick_label_color/tick_color is the narrower
         # selector and wins; the chart-wide slot fills in when it says nothing.
         axis_tick_paint = _css(axis_style.get("tick_label_color", axis_style.get("tick_color")), "")
         tick_color = (
             _parse_color(axis_tick_paint)
             if axis_tick_paint
-            else slot_paint("tick_label", default_text)
+            else _parse_color(slot_text_color(tick_slot, "") or label_text_default)
         )
-        font_size = slot_font_size(slots.get("tick_label") or {}, _axis_tick_font_size(axis))
+        font_size = slot_font_size(tick_slot, _axis_tick_font_size(axis))
         tick_italic, tick_bold = _native_font_emphasis(
             {
-                "font_style": (slots.get("tick_label") or {}).get("font-style"),
-                "font_weight": (slots.get("tick_label") or {}).get("font-weight", 400),
+                "font_style": tick_slot.get("font-style"),
+                "font_weight": tick_slot.get("font-weight", 400),
             }
         )
         baseline_shift = _axis_tick_label_baseline_shift(axis)
@@ -1463,10 +1484,10 @@ def emit_tick_labels(
             ystep,
             xa,
             ya,
-            slot_font_size(slots.get("tick_label") or {}, _axis_tick_font_size(xa)),
-            slot_font_size(slots.get("tick_label") or {}, _axis_tick_font_size(ya)),
-            _polar_label_paint(xa, slot_paint, default_text),
-            _polar_label_paint(ya, slot_paint, default_text),
+            slot_font_size(slot_in_labels_container(slots, "tick_label"), _axis_tick_font_size(xa)),
+            slot_font_size(slot_in_labels_container(slots, "tick_label"), _axis_tick_font_size(ya)),
+            _polar_label_paint(xa, slot_paint, label_text_default),
+            _polar_label_paint(ya, slot_paint, label_text_default),
             hide_x or xa.get("tick_label_strategy") == "off",
             hide_y or ya.get("tick_label_strategy") == "off",
         )
@@ -1550,7 +1571,7 @@ def emit_axis_title(axis: dict[str, Any], *, is_x: bool) -> None:
         axis_style = axis.get("style") or {}
         geometry = _axis_label_geometry(axis, plot, is_x=is_x)
         anchor = {"start": 0, "middle": 1, "end": 2}[geometry["anchor"]]
-        axis_title_slot = slots.get("axis_title") or {}
+        axis_title_slot = slot_in_labels_container(slots, "axis_title")
         italic, bold = _native_font_emphasis(
             {
                 "font_style": axis_style.get("label_font_style")
@@ -1565,11 +1586,11 @@ def emit_axis_title(axis: dict[str, Any], *, is_x: bool) -> None:
             float(geometry["x"]),
             float(geometry["y"]),
             anchor,
-            slot_font_size(slots.get("axis_title") or {}, float(geometry["font_size"])),
+            slot_font_size(axis_title_slot, float(geometry["font_size"])),
             (
                 _parse_color(_css(axis_style.get("label_color"), ""))
                 if _css(axis_style.get("label_color"), "")
-                else slot_paint("axis_title", default_text)
+                else _parse_color(slot_text_color(axis_title_slot, "") or label_text_default)
             ),
             str(axis["label"]),
             angle=float(geometry["angle"]),
diff --git a/python/xy/_svg.py b/python/xy/_svg.py
index 8161118c8..4705a0081 100644
--- a/python/xy/_svg.py
+++ b/python/xy/_svg.py
@@ -1378,6 +1378,7 @@ def _px_size(value: Any, default: float) -> float:
     "colorbar_tick",
     "annotation_label",
     "annotation_layer",
+    "labels",
 )
 
 
@@ -3900,7 +3901,7 @@ def _polar_tick_labels(
     hide_r: bool,
 ) -> None:
     """Emit polar tick labels as SVG text, from the shared placement."""
-    slot = slots.get("tick_label") or {}
+    slot = slot_in_labels_container(slots, "tick_label")
     attrs = slot_text_attrs(slot)
 
     def tick_color(axis: dict[str, Any]) -> str:
@@ -3999,6 +4000,15 @@ def ticks_for(axis: dict[str, Any], length_px: float) -> tuple[list[float], list
     default_axis = _css(dom_style.get("--chart-axis"), _AXIS)
     default_text = _css(dom_style.get("--chart-text"), _TEXT)
     slots = slot_styles(spec)
+    labels_slot = slots.get("labels") or {}
+    # The live chain for every text in the labels container is
+    # `color: var(--chart-text, inherit)`: the theme token wins, the
+    # container's own declared color is the inherited fallback, then the
+    # writer default. Title/legend/colorbar are siblings of the container
+    # and keep `default_text`.
+    label_text_default = (
+        _css(dom_style.get("--chart-text"), "") or slot_text_color(labels_slot, "") or _TEXT
+    )
     grid: list[str] = []
     labels: list[str] = []
     # "none" silences the whole axis chrome (sparklines); "off" hides only the
@@ -4068,7 +4078,7 @@ def append_tick_labels(
         is_x: bool,
     ) -> None:
         axis_style = axis.get("style") or {}
-        slot = slots.get("tick_label") or {}
+        slot = slot_in_labels_container(slots, "tick_label")
         # The axis's own tick_label_color/tick_color is the narrower selector
         # and wins; the chart-wide slot fills in when the axis says nothing.
         color = escape(
@@ -4076,7 +4086,7 @@ def append_tick_labels(
                 axis_style.get("tick_label_color", axis_style.get("tick_color")),
                 "",
             )
-            or slot_text_color(slot, default_text)
+            or slot_text_color(slot, label_text_default)
         )
         font_size = slot_font_size(slot, _axis_tick_font_size(axis))
         slot_attrs = slot_text_attrs(slot)
@@ -4154,7 +4164,7 @@ def append_tick_labels(
             xa,
             ya,
             slots,
-            default_text,
+            label_text_default,
             hide_x or xa.get("tick_label_strategy") == "off",
             hide_y or ya.get("tick_label_strategy") == "off",
         )
@@ -4352,7 +4362,7 @@ def append_axis_title(axis: dict[str, Any], *, is_x: bool) -> None:
         if not axis.get("label") or _axis_tick_label_strategy(axis) == "none":
             return
         axis_style = axis.get("style") or {}
-        slot = slots.get("axis_title") or {}
+        slot = slot_in_labels_container(slots, "axis_title")
         geometry = _axis_label_geometry(axis, plot, is_x=is_x)
         x, y = float(geometry["x"]), float(geometry["y"])
         angle = float(geometry["angle"])
@@ -4362,7 +4372,7 @@ def append_axis_title(axis: dict[str, Any], *, is_x: bool) -> None:
         family = axis_style.get("label_font_family")
         font_style = axis_style.get("label_font_style")
         weight = axis_style.get("label_font_weight", 400)
-        paint = _css(axis_style.get("label_color"), "") or slot_text_color(slot, default_text)
+        paint = _css(axis_style.get("label_color"), "") or slot_text_color(slot, label_text_default)
         font_attrs = (f' font-family="{_escape_attr(family)}"' if family is not None else "") + (
             f' font-style="{_escape_attr(font_style)}"' if font_style is not None else ""
         )
@@ -4646,6 +4656,21 @@ def tick_span(style: dict[str, Any]) -> tuple[float, float, float]:
             f'<rect x="{_num(plot["x"])}" y="{_num(plot["y"])}" width="{_num(plot["w"])}" '
             f'height="{_num(plot["h"])}" fill="{escape(plot_paint)}"/>'
         )
+    # labels-container box (flag D, resolved): the background paints UNDER
+    # the axis baselines and every label text, exactly where the live DOM
+    # puts it — the spine/tick rules are children of the labels container,
+    # so its background sits below them and above marks + annotation shapes.
+    # The residual stacking difference (live, the full-bleed container also
+    # covers the title/legend/colorbar, which are earlier/later siblings) is
+    # recorded in KNOWN_RENDERER_DIVERGENCES, never silent.
+    labels_background = ""
+    container_paint = labels_slot.get("background", labels_slot.get("background-color"))
+    if container_paint is not None:
+        labels_background = _slot_box_svg(
+            lower_box("labels", {"background": container_paint}, x=0, y=0, w=width, h=height)
+        )
+    labels_opacity = _layer_opacity(labels_slot)
+    labels_group_attrs = f' opacity="{_num(labels_opacity)}"' if labels_opacity < 1.0 else ""
     # One flat join over the pieces rather than nested `join`s inside an
     # f-string: the mark list is the whole document for a per-point chart (tens
     # of MB at 100k markers), and joining it separately would materialize a
@@ -4663,8 +4688,9 @@ def tick_span(style: dict[str, Any]) -> tuple[float, float, float]:
             *marks,
             "</g>",
             *unclipped_annotation_marks,
+            labels_background,
             baselines,
-            f'<g fill="{escape(default_text)}">',
+            f'<g fill="{escape(label_text_default)}"{labels_group_attrs}>',
             *labels,
             "</g>",
             *chrome,
@@ -5180,6 +5206,46 @@ def _svg_mathtext_spans(line: str, style: dict[str, Any], offset: int) -> str:
 #: relative units resolve in the slot's own unit domain, never silently drop.
 _ANNOTATION_FONT_SIZE = 11.0
 
+#: What a labels-container declaration cascades into each text slot living in
+#: the container, per property. Read straight off the live stylesheet
+#: (`20_theme.ts`): a `:where()` rule on the child beats inheritance from the
+#: container even at zero specificity, so only the properties the child's
+#: rule leaves unset inherit. tick_label has a color rule only; axis_title
+#: pins font-size (12px) and font-weight (400); annotation_label pins both
+#: plus line-height (`_LABELS_CONTAINER_ANNOTATION_PROPS`).
+_LABELS_CONTAINER_TEXT_PROPS: dict[str, tuple[str, ...]] = {
+    "tick_label": ("font-size", "font-weight", "font-style", "font-family", "letter-spacing"),
+    "axis_title": ("font-style", "font-family", "letter-spacing"),
+}
+
+#: The labels container's own inherited font size (`:where(.xy){font:12px…}`),
+#: the base an em-valued labels-slot font-size resolves against.
+_LABELS_CONTAINER_FONT_SIZE = 12.0
+
+
+def slot_in_labels_container(slots: dict[str, Any], name: str) -> dict[str, Any]:
+    """The effective declaration for a text slot inside the labels container.
+
+    The labels-slot typography folds UNDER the specific slot (container <
+    specific slot < axis/annotation style — the cascade order the live DOM
+    gives inherited container styling). Color is deliberately absent: every
+    contained text resolves paint through `var(--chart-text, inherit)`, so
+    the container's color is a *default* below the theme token, threaded by
+    the writers as the label-text fallback instead of merged here.
+    """
+    slot = slots.get(name) or {}
+    container = slots.get("labels") or {}
+    if not container:
+        return slot
+    inherited = {
+        prop: container[prop] for prop in _LABELS_CONTAINER_TEXT_PROPS[name] if prop in container
+    }
+    if not inherited:
+        return slot
+    if "font-size" in inherited:
+        inherited["font-size"] = _annotation_em(inherited["font-size"], _LABELS_CONTAINER_FONT_SIZE)
+    return {**inherited, **slot}
+
 
 def _annotation_em(value: Any, base: float) -> Any:
     """Resolve an em spelling against `base`; pass everything else through."""
diff --git a/python/xy/styling/capabilities.py b/python/xy/styling/capabilities.py
index 28a2fff9d..1867a75d8 100644
--- a/python/xy/styling/capabilities.py
+++ b/python/xy/styling/capabilities.py
@@ -265,6 +265,19 @@ class ExtensionPoint:
         visible_when="styles={'annotation_layer': {'background': ...}} is declared",
         tracked_by="tests/test_chrome_parity_p3.py pins the plot-rect geometry",
     ),
+    RendererDivergence(
+        id="labels_container_stacking",
+        what="Where the labels-container background sits among its siblings (flag D)",
+        webgl="over the chart title (the container is a later DOM sibling), "
+        "under the axis rules and label texts it contains",
+        svg="under the axis rules and label texts (the resolved flag-D order), "
+        "and under the title/legend/colorbar chrome, which joins later",
+        native="same as SVG: filled after the marks, before the chrome text phase",
+        visible_when="styles={'labels': {'background': ...}} on a chart with a title, "
+        "legend or colorbar",
+        tracked_by="flag D of the static-chrome parity plan; "
+        "tests/test_chrome_parity_p3.py pins the writers' order",
+    ),
     RendererDivergence(
         id="annotation_layer_opacity_compositing",
         what="How the annotation_layer slot's opacity composites overlapping shapes",
@@ -315,6 +328,23 @@ class ExtensionPoint:
     "(`spec['dom']['style']`). Prefer it for anything that must survive "
     "export.",
 )
+_SLOT_EXCEPTIONS["labels"] = (
+    "partial",
+    "styles={'labels': ...}",
+    "The label container. Its color is the default under the live chain "
+    "`var(--chart-text, inherit)` for every contained text (tick labels, "
+    "axis titles, annotation labels): the theme token wins, then the "
+    "container color, then the writer default — the axis's own colors and "
+    "the specific slots stay narrower and win. Typography folds under the "
+    "contained slots exactly where the live stylesheet leaves the property "
+    "un-ruled (font-size/weight cascade into tick labels only; style/family/"
+    "letter-spacing into all three). `background` paints full-bleed under "
+    "the axis rules and every label text, the live order; the residual "
+    "sibling stacking difference is in KNOWN_RENDERER_DIVERGENCES. "
+    "`opacity` rides the SVG label group (vector-only); live it also dims "
+    "the contained axis rules and the container background — recorded here "
+    "rather than approximated.",
+)
 _SLOT_EXCEPTIONS["annotation_layer"] = (
     "partial",
     "styles={'annotation_layer': ...}",
diff --git a/python/xy/styling/preflight.py b/python/xy/styling/preflight.py
index 07428d710..7451195f7 100644
--- a/python/xy/styling/preflight.py
+++ b/python/xy/styling/preflight.py
@@ -212,6 +212,12 @@ def _honored_props(slot: str, family: str) -> tuple[frozenset[str], str]:
             "per-primitive) and a plot-clipped background; the rest of the "
             "overlay's box model stays browser-only"
         )
+    if slot == "labels":
+        return text | frozenset({"background", "background-color"}), (
+            "the container's color and typography are defaults under the "
+            "contained slots; the background paints under the axis rules and "
+            "every label text (flag D)"
+        )
     return text, ""
 
 
diff --git a/spec/api/capability-matrix.md b/spec/api/capability-matrix.md
index d0e6c9049..e3f950802 100644
--- a/spec/api/capability-matrix.md
+++ b/spec/api/capability-matrix.md
@@ -14,9 +14,9 @@ which is sometimes deliberate, and the notes say which.
 ## In one line
 
 - **11** mark style properties across **21** mark kinds, drawn by all three renderers.
-- **48** stable chrome slots, CSS- and Tailwind-addressable in the browser. **24** of them name chrome a clean static export contains; **12** reach the native writers — **11** through `styles={slot: ...}` itself, and `root` through the chart-level `style=` token bag. The other **24** are interaction/view chrome (tooltip, modebar, crosshair, selection, reduction badges) that a clean static file does not contain, so they are gated by an export state rather than missing.
+- **48** stable chrome slots, CSS- and Tailwind-addressable in the browser. **24** of them name chrome a clean static export contains; **13** reach the native writers — **12** through `styles={slot: ...}` itself, and `root` through the chart-level `style=` token bag. The other **24** are interaction/view chrome (tooltip, modebar, crosshair, selection, reduction badges) that a clean static file does not contain, so they are gated by an export state rather than missing.
 - **1** shipped extension point.
-- **3** known default divergence between renderers, listed below rather than left to be discovered.
+- **4** known default divergence between renderers, listed below rather than left to be discovered.
 
 ## Mark style properties
 
@@ -76,7 +76,7 @@ declared and names anything that would not survive.
 | `chrome` | clean static | full | none | none |
 | `canvas` | clean static | full | none | none |
 | `annotation_layer` | clean static | full | partial | partial |
-| `labels` | clean static | full | none | none |
+| `labels` | clean static | full | partial | partial |
 | `legend` | clean static | full | partial | partial |
 | `legend_title` | clean static | full | partial | partial |
 | `legend_item` | clean static | full | none | none |
@@ -125,6 +125,7 @@ declared and names anything that would not survive.
 - **`root`** (via `chart style=`) — `styles={'root': ...}` is browser-only, but the chart-level `style=` token bag targets the same element and every renderer reads it (`spec['dom']['style']`). Prefer it for anything that must survive export.
 - **`title`** (via `styles={'title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
 - **`annotation_layer`** (via `styles={'annotation_layer': ...}`) — The annotation-shape overlay. `opacity` dims every annotation shape as a group (never the labels, which live in the labels container): SVG/PDF as real group opacity on a `<g>`, raster folded into each shape's RGBA because the display list has no group compositing — overlapping translucent shapes double-blend there, a recorded approximation (§28). `background` paints under the shapes, plot-clipped; the live overlay is full-bleed, a divergence recorded in KNOWN_RENDERER_DIVERGENCES. Everything else stays browser-only.
+- **`labels`** (via `styles={'labels': ...}`) — The label container. Its color is the default under the live chain `var(--chart-text, inherit)` for every contained text (tick labels, axis titles, annotation labels): the theme token wins, then the container color, then the writer default — the axis's own colors and the specific slots stay narrower and win. Typography folds under the contained slots exactly where the live stylesheet leaves the property un-ruled (font-size/weight cascade into tick labels only; style/family/letter-spacing into all three). `background` paints full-bleed under the axis rules and every label text, the live order; the residual sibling stacking difference is in KNOWN_RENDERER_DIVERGENCES. `opacity` rides the SVG label group (vector-only); live it also dims the contained axis rules and the container background — recorded here rather than approximated.
 - **`legend`** (via `styles={'legend': ...} / xy.legend(style=...) / --chart-legend-bg`) — The frame box. Both spellings and the theme token now converge on one merged declaration block before the writers see it, so what agrees in the browser agrees in a PNG. `background`, `boxShadow`, `borderRadius`, `--xy-legend-frame-alpha`, and `padding`/`rowGap` in `em` are honored; an explicit background paints opaque, as it does in the browser.
 - **`legend_title`** (via `styles={'legend_title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
 - **`legend_label`** (via `styles={'legend_label': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
@@ -160,6 +161,7 @@ until someone diffs two exports. Listed here for that reason.
 |---|---|---|---|---|---|
 | Interior vertices of a wide polyline | the notch two overlapping segment quads leave | round (the writer names it explicitly) | round (the capsule distance field fills the vertex) | stroke-width above ~4px at a sharp angle | no style property selects a join; the default is the whole contract |
 | The annotation_layer slot's background extent | full-bleed (the overlay canvas is inset:0 over the whole chart) | plot rect, inside the marks clip (the only seam above traces and below shapes) | plot rect, under the active marks clip (same seam as SVG) | styles={'annotation_layer': {'background': ...}} is declared | tests/test_chrome_parity_p3.py pins the plot-rect geometry |
+| Where the labels-container background sits among its siblings (flag D) | over the chart title (the container is a later DOM sibling), under the axis rules and label texts it contains | under the axis rules and label texts (the resolved flag-D order), and under the title/legend/colorbar chrome, which joins later | same as SVG: filled after the marks, before the chrome text phase | styles={'labels': {'background': ...}} on a chart with a title, legend or colorbar | flag D of the static-chrome parity plan; tests/test_chrome_parity_p3.py pins the writers' order |
 | How the annotation_layer slot's opacity composites overlapping shapes | group opacity: the overlay canvas is dimmed once as a whole | group opacity on the wrapping <g>, PDF-legal, same as live | folded into each shape's RGBA (no group compositing opcode): overlapping translucent shapes double-blend | the slot declares opacity below 1 over overlapping annotation shapes | tests/test_chrome_parity_p3.py documents the double-blend delta |
 
 ## Regenerating
diff --git a/spec/api/export.md b/spec/api/export.md
index eabf75661..3baa37c53 100644
--- a/spec/api/export.md
+++ b/spec/api/export.md
@@ -248,7 +248,7 @@ vector** (`_svg.to_svg`, and `_pdf.svg_to_pdf` on top of it).
 | `style={...}` on a mark | yes | yes | yes | validated CSS subset, `styles.compile_mark_style` |
 | `style={...}` on an axis | yes | yes | yes | validated vocabulary, `styles.compile_axis_style` |
 | `style={...}` on the chart (token bag) | yes | yes | yes | `spec["dom"]["style"]`, read at `_svg.py:767,1481` and `_raster.py:662` |
-| `styles={slot: {...}}` (per-slot inline) | yes, all 48 slots | 11 slots: the text subset, + the chrome-box subset on `annotation_label`, + opacity/background on `annotation_layer` | 11 slots: the text subset, + the chrome-box subset on `annotation_label`, + opacity/background on `annotation_layer` | `_svg.STATIC_STYLED_SLOTS`; the rest is live-only chrome |
+| `styles={slot: {...}}` (per-slot inline) | yes, all 48 slots | 12 slots: the text subset, + the chrome-box subset on `annotation_label`, + opacity/background on `annotation_layer`, + the container defaults on `labels` | 12 slots: the text subset, + the chrome-box subset on `annotation_label`, + opacity/background on `annotation_layer`, + the container defaults on `labels` | `_svg.STATIC_STYLED_SLOTS`; the rest is live-only chrome |
 | `class_names={slot: "..."}` | yes, all 48 slots | **dropped** (or resolved via `style_source="native_cascade"` / a captured `style_snapshot=`) | same | silent by default during migration; both opt-in routes are lossless for the published profile |
 | `custom_css="..."` | yes (HTML + Chromium capture) | **raises** | **raises** | `_resolve_image_engine`, `export.py:812` |
 | `xy.legend(style=...)` | yes | 6 keys | 6 keys | merged with the slot and the theme token before the writers see it |
@@ -327,9 +327,12 @@ contains. `_svg.STATIC_STYLED_SLOTS` is that list: `title`, `axis_title`,
 `tick_label`, `legend`, `legend_title`, `legend_label`, `colorbar`,
 `colorbar_title`, `colorbar_tick`, `annotation_label` (which additionally
 carries the chrome-box subset — `_svg.SLOT_BOX_PROPS` — under the
-annotation's own `style=`, the narrower selector), and `annotation_layer`
+annotation's own `style=`, the narrower selector), `annotation_layer`
 (group opacity over the annotation shapes plus a plot-clipped background;
-the capability matrix records the two layer divergences). The remaining
+the capability matrix records the two layer divergences), and `labels`
+(the container: its color and typography are the inherited defaults under
+the contained tick/axis-title/annotation slots, and its background paints
+under the axis rules per the resolved flag-D order). The remaining
 slots are live-only chrome — `tooltip*`, `modebar*`, `crosshair_*`,
 `selection`, `badge*` — or containers with no painted text of their own;
 there is nothing in a PNG for them to style.
diff --git a/spec/api/styling.md b/spec/api/styling.md
index d0d9444c8..6272e9591 100644
--- a/spec/api/styling.md
+++ b/spec/api/styling.md
@@ -1324,11 +1324,12 @@ carry a defined subset of their declarations into SVG, PNG and PDF:
 
 | | |
 | --- | --- |
-| Slots | `title`, `axis_title`, `tick_label`, `legend`, `legend_title`, `legend_label`, `colorbar`, `colorbar_title`, `colorbar_tick`, `annotation_label`, `annotation_layer` (`_svg.STATIC_STYLED_SLOTS`) |
+| Slots | `title`, `axis_title`, `tick_label`, `legend`, `legend_title`, `legend_label`, `colorbar`, `colorbar_title`, `colorbar_tick`, `annotation_label`, `annotation_layer`, `labels` (`_svg.STATIC_STYLED_SLOTS`) |
 | Vector — SVG, PDF | `font-size`, `font-weight`, `font-style`, `font-family`, `letter-spacing`, `opacity`, and the text paint — `fill`, or `color` (`_svg.SLOT_TEXT_PROPS`) |
 | Raster — PNG, JPEG, WebP | `font-size`, `font-weight`, `font-style`, and the text paint (`_svg.SLOT_RASTER_PROPS`) |
 | `annotation_label` box | additionally `background`, `border` (+ longhands), `border-radius`, `padding`, offset `box-shadow`, `opacity`, `fill-opacity` (`_svg.SLOT_BOX_PROPS`), folded UNDER the annotation's own `style=` per property group |
 | `annotation_layer` | `opacity` (group over the annotation shapes; raster folds per-primitive) and `background`/`background-color` (plot-clipped) only |
+| `labels` | container defaults: color under the `var(--chart-text, inherit)` chain, typography folded under the contained slots per the live stylesheet's un-ruled properties, full-bleed `background` under the axis rules (flag D), `opacity` on the SVG label group |
 
 The raster atlas carries a regular, a bold and an italic face, so a slot's
 weight and style survive PNG/JPEG/WebP (weight ≥ 600 rounds up to the bold
diff --git a/tests/test_chrome_parity_p3.py b/tests/test_chrome_parity_p3.py
index 492091289..466f623aa 100644
--- a/tests/test_chrome_parity_p3.py
+++ b/tests/test_chrome_parity_p3.py
@@ -394,6 +394,140 @@ def test_layer_preflight_routes_opacity_and_background_only() -> None:
     assert finding.lost == ("border-radius",)
 
 
+# -- labels (the container slot) ----------------------------------------------
+
+
+def test_labels_color_is_every_contained_labels_default_in_both_writers() -> None:
+    # tick labels, the axis title and annotation labels all live in the
+    # labels container; its color is their inherited default.
+    def chart(**kwargs):
+        return xy.line_chart(
+            _line(),
+            xy.x_axis(label="x title"),
+            xy.text(0.5, 0.5, "note"),
+            **kwargs,
+        )
+
+    styled = chart(styles={"labels": {"color": "#123456"}})
+    svg = _svg_of(styled)
+    assert '<g fill="#123456"' in svg  # the container group itself
+    tick = next(t for t in re.findall(r"<text[^>]*>.*?</text>", svg) if ">0.5<" in t)
+    title = next(t for t in re.findall(r"<text[^>]*>.*?</text>", svg) if ">x title<" in t)
+    assert 'fill="#123456"' in tick and 'fill="#123456"' in title
+    assert not (_raster_of(chart()) == _raster_of(styled)).all()
+    # Byte-exact unstyled fallback: the empty declaration changes nothing.
+    assert _svg_of(chart()) == _svg_of(chart(styles={"labels": {}}))
+    assert (_raster_of(chart()) == _raster_of(chart(styles={"labels": {}}))).all()
+
+
+def test_the_theme_token_outranks_the_labels_container_color() -> None:
+    # The live chain is `color: var(--chart-text, inherit)`: the token wins
+    # over the container's own color, which is only the inherit fallback.
+    chart = xy.line_chart(
+        _line(),
+        style={"--chart-text": "#ff8800"},
+        styles={"labels": {"color": "#123456"}},
+    )
+    svg = _svg_of(chart)
+    assert "#ff8800" in svg
+    tick = next(t for t in re.findall(r"<text[^>]*>.*?</text>", svg) if ">0.5<" in t)
+    assert 'fill="#ff8800"' in tick and "#123456" not in tick
+
+
+def test_labels_typography_cascades_container_under_slot_under_axis() -> None:
+    # The acceptance cascade, per property: labels < tick_label < axis style.
+    def tick(svg: str) -> str:
+        return next(t for t in re.findall(r"<text[^>]*>.*?</text>", svg) if ">0.5<" in t)
+
+    container_only = _svg_of(
+        xy.line_chart(_line(), styles={"labels": {"font_size": 15, "font_style": "italic"}})
+    )
+    assert 'font-size="15"' in tick(container_only)
+    assert 'font-style="italic"' in tick(container_only)
+
+    slot_wins = _svg_of(
+        xy.line_chart(
+            _line(),
+            styles={"labels": {"font_size": 15}, "tick_label": {"font_size": 9}},
+        )
+    )
+    assert 'font-size="9"' in tick(slot_wins)
+
+    # The axis's own styling is the narrowest selector for paint (the
+    # pre-existing font-size knot — slot beats axis — is the axis family's
+    # to untangle, plan §4.6; this pins the paint direction only).
+    axis_wins = _svg_of(
+        xy.line_chart(
+            _line(),
+            xy.y_axis(style={"tick_label_color": "#ff0000"}),
+            styles={"labels": {"color": "#123456"}, "tick_label": {"fill": "#00ff00"}},
+        )
+    )
+    y_tick = next(t for t in re.findall(r"<text[^>]*>.*?</text>", axis_wins) if ">0.5<" in t)
+    assert 'fill="#ff0000"' in y_tick
+
+    # The live stylesheet pins the axis title's font-size (12px rule), so the
+    # container's size must NOT cascade into it — only style/family/spacing.
+    titled = _svg_of(
+        xy.line_chart(
+            _line(),
+            xy.x_axis(label="x title"),
+            styles={"labels": {"font_size": 15, "font_style": "italic"}},
+        )
+    )
+    title = next(t for t in re.findall(r"<text[^>]*>.*?</text>", titled) if ">x title<" in t)
+    assert 'font-size="15"' not in title
+    assert 'font-style="italic"' in title
+
+    # And the raster writer honors the same merged view (font-size lands).
+    plain = xy.line_chart(_line())
+    sized = xy.line_chart(_line(), styles={"labels": {"font_size": 15}})
+    assert not (_raster_of(plain) == _raster_of(sized)).all()
+
+
+def test_labels_background_paints_under_the_baselines_and_texts() -> None:
+    # Flag D, resolved and pinned: the container background sits UNDER the
+    # axis rules and every label text — the live order, where the spine and
+    # tick rules are children of the labels container. The residual sibling
+    # stacking (title/legend live under the full-bleed container) is in
+    # KNOWN_RENDERER_DIVERGENCES.
+    chart = xy.line_chart(
+        _line(),
+        xy.text(0.5, 0.5, "note"),
+        styles={"labels": {"background": "#123456"}},
+    )
+    svg = _svg_of(chart)
+    rect = next(r for r in _rects(svg) if "#123456" in r)
+    assert 'x="0" y="0"' in rect  # full-bleed, matching the inset:0 container
+    # Order: after the clipped marks group, before the first baseline <line>
+    # outside it, before the labels <g>.
+    tail = svg.split("</g>", 2)[2]  # past grid + marks groups
+    assert tail.index("#123456") < tail.index("<line ")
+    assert tail.index("#123456") < tail.index("<g fill=")
+    assert svg_to_pdf(svg)[:4] == b"%PDF"
+
+    plain = xy.line_chart(_line(), xy.text(0.5, 0.5, "note"))
+    assert not (_raster_of(plain) == _raster_of(chart)).all()
+
+
+def test_labels_opacity_rides_the_label_group() -> None:
+    chart = xy.line_chart(_line(), styles={"labels": {"opacity": 0.5}})
+    svg = _svg_of(chart)
+    assert re.search(r'<g fill="[^"]*" opacity="0.5">', svg)
+    assert svg_to_pdf(svg)[:4] == b"%PDF"
+
+
+def test_labels_preflight_routes_text_and_background() -> None:
+    figure = xy.line_chart(
+        _line(),
+        styles={"labels": {"color": "#123456", "background": "#fff", "border_radius": "3px"}},
+    ).figure()
+    report = figure.style_compatibility_report(target="png")
+    (finding,) = [f for f in report.findings if f.slot == "labels"]
+    assert set(finding.kept) == {"color", "background"}
+    assert finding.lost == ("border-radius",)
+
+
 # -- badge / badge_item: view-gated, excluded from static parity --------------
 
 

From b140f80bb74785e22f0abfca16548b13c05c82b3 Mon Sep 17 00:00:00 2001
From: Alek Petuskey <alek@reflex.dev>
Date: Tue, 4 Aug 2026 16:42:53 -0700
Subject: [PATCH 21/27] Return the annotation lists as a fixed triple, not a
 tuple concat

The concat in _annotation_svg widened the declared 3-tuple return type to
tuple[list[str], ...]; unpack the layer wrap explicitly so the signature
stays checkable (ty back to the repo baseline).
---
 python/xy/_svg.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/python/xy/_svg.py b/python/xy/_svg.py
index 4705a0081..ea8700add 100644
--- a/python/xy/_svg.py
+++ b/python/xy/_svg.py
@@ -5060,7 +5060,8 @@ def point(x: float, y: float) -> tuple[float, float]:
                 + (f'fill-opacity="{_num(text_opacity)}" ' if text_opacity < 1 else "")
                 + f'fill="{label_color}">{tspans}</text>'
             )
-    return _annotation_layer_wrap(marks, unclipped_marks, slots, plot) + (labels,)
+    wrapped_marks, wrapped_unclipped = _annotation_layer_wrap(marks, unclipped_marks, slots, plot)
+    return wrapped_marks, wrapped_unclipped, labels
 
 
 def _layer_opacity(layer: dict[str, Any]) -> float:

From 31e5f44717e668e676027c845bced7720906a761 Mon Sep 17 00:00:00 2001
From: Alek Petuskey <alek@reflex.dev>
Date: Tue, 4 Aug 2026 16:48:40 -0700
Subject: [PATCH 22/27] Merge main and narrow the two type holes it exposed
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

main promoted ty from advisory to a hard CI gate (#451, the PEP 561
typing surface), which this branch predates — so it inherited 79
diagnostics that main had already fixed. Merging clears 69 of them; the
remaining ten are byte-identical to main (redundant numpy casts, reflex
EventHandler subscripts that resolve differently across installed
versions), so this branch's type state now equals the branch it targets.

Two were genuinely this program's. The snapshot environment validator
converted an `object` straight to float behind a type: ignore; it now
narrows first, so a JSON payload carrying a list where a width belongs
raises the module's own ValueError instead of relying on a silenced
call. The style_snapshot coercion casts its JSON-shaped dict at the
boundary it already validates. Neither changes behavior — both replace a
silenced or unstated assumption with the check it was standing in for.
---
 python/xy/export.py           | 4 +++-
 python/xy/styling/resolved.py | 7 ++++++-
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/python/xy/export.py b/python/xy/export.py
index b1809b2e4..8017639b3 100644
--- a/python/xy/export.py
+++ b/python/xy/export.py
@@ -979,7 +979,9 @@ def _coerce_style_snapshot(value: object) -> Any:
     if isinstance(value, ResolvedStyleSnapshot):
         return value
     if isinstance(value, dict):
-        return snapshot_from_payload(value)
+        # Keys come from JSON, so the mapping is dict[Unknown, Unknown] to a
+        # checker; the schema validates every key and value on the way in.
+        return snapshot_from_payload(cast("dict[str, Any]", value))
     raise ValueError(
         "style_snapshot must be a ResolvedStyleSnapshot (from "
         "capture_style_snapshot()) or its payload dict"
diff --git a/python/xy/styling/resolved.py b/python/xy/styling/resolved.py
index 52a1ff02d..75faa175c 100644
--- a/python/xy/styling/resolved.py
+++ b/python/xy/styling/resolved.py
@@ -410,8 +410,13 @@ def _validated_environment(
     """One environment contract for both construction ends of the wire."""
     numbers = {}
     for label, value in (("width", width), ("height", height), ("dpr", dpr)):
+        # The payload path hands in whatever JSON produced, so the type is
+        # genuinely `object` here; narrow before converting rather than
+        # silencing the checker on an unguarded call.
+        if isinstance(value, bool) or not isinstance(value, (int, float, str)):
+            raise ValueError(f"environment {label} must be a finite positive number")
         try:
-            out = float(value)  # type: ignore[arg-type]
+            out = float(value)
         except (TypeError, ValueError) as exc:
             raise ValueError(f"environment {label} must be a finite positive number") from exc
         if not math.isfinite(out) or out <= 0:

From 800a80f1335f7cce6a459a27a0e0bffd2c1138fd Mon Sep 17 00:00:00 2001
From: Alek Petuskey <alek@reflex.dev>
Date: Tue, 4 Aug 2026 16:52:03 -0700
Subject: [PATCH 23/27] Static-chrome parity P2: axis chrome boxes,
 per-property axis text, the axis_band ruling
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

axis_line and tick_mark join STATIC_STYLED_SLOTS as pure box slots.
Emission is strictly declaration-gated — an unstyled chart's bytes never
move — and when a box is declared, the spine/tick strokes are replaced
by ChromeBoxes from one shared producer (_svg.axis_chrome_boxes),
consumed identically by the SVG writer, the raster writer, and the
declared snapshot, which now records per-instance qualifiers and
geometry (axis id, major|minor, side, tick index; one interned
declaration, N instances). Spines stay centered on the plot edge where
the unstyled stroke has always run — the browser insets right/bottom
spines by their own width, recorded in KNOWN_RENDERER_DIVERGENCES and
pinned by golden rather than silently matched. A box-styled spine keeps
its axis_color ink unless the slot declares a background; an explicit
transparent erases it (the fill_declared distinction). tick_length
stays 0 by default and no length is invented for a styled slot: a
zero-area box draws nothing, casts no shadow, records no instance, and
the preflight says so. Polar spines/ticks keep stroke semantics in
every renderer — the browser shares the limit. The near-duplicate
tick_span closures unify on one module-level 3-tuple.

tick_label and axis_title additionally draw boxes through the shared
text_box metrics (block + padding in anchor space), emitted immediately
before each <text> in both writers, cartesian and polar. The room
functions learn the box model in the same change: padding/border grows
the measured gutters in both orientations (declared tick boxes take the
measuring path where unstyled auto ticks keep their historical flat
band), the y-title baseline shifts outward past the padded tick boxes,
and layout() stashes the extents on the plot record so reservation and
placement cannot disagree. The rotated-box PDF lowering is pinned
repo-wide per plan flag E's recommendation: pre-rotated <polygon> when
radius == 0, <path> with circular arcs when radius > 0, shadow offset
applied in element space before rotation — rect takes no transform in
the PDF closed subset, and both replacements round-trip it (tested).

Per-property completion of the axis text contract: the SVG axis-title
branch that dropped the slot's letter-spacing and opacity wholesale
whenever the axis authored label_font_family/style is now a
per-property merge (axis label_* wins per key, the slot fills the rest;
font-size keeps running the other way — slot over label_size —
documented in spec/api/styling.md with a precedence-table test), and
the raster polar tick-label sink gains the P0.2 emphasis routing it had
missed. Letter-spacing stays outside the gutter measurement, qualified
in the capability note next to the pre-existing slot-size/axis-size
measurement gap rather than half-folded.

axis_band is ruled interaction chrome (plan flag F, the badge
precedent): the browser creates it only while its axis is navigable and
a static file has no gesture for it to serve, so it joins
_STATE_GATED_SLOTS under a new "navigation" export state — preflight
reports state-gated, no writer draws it, and the capability matrix's
stale "clean static" row is regenerated away.

Repairs to the P0.3 primitives found en route: _emit_slot_box passed
(x, y, w, h) to corner-coordinate helpers, collapsing every raster box
off the origin (the P0.3 test only asserted non-empty bytes; a
decoded-geometry regression test now pins the rect), and the plan's
SLOT_BOX_PROPS constant (P0.4) did not exist yet — created in _svg.py
on the LEGEND_BOX_PROPS pattern and read by the writers' gating, the
capability registry, and the preflight's honored-props routing so the
three cannot drift. Registry, preflight, matrix, spec (§4 status +
flags E/F resolutions), docs, and CHANGELOG move in this commit;
tests/test_chrome_parity_p2.py is the executable acceptance list.
---
 CHANGELOG.md                                  |  10 +
 .../limitations-and-alpha-status.md           |  23 +-
 docs/styling/capabilities.md                  |  15 +-
 python/xy/_chromebox.py                       | 223 +++-
 python/xy/_raster.py                          | 314 ++++--
 python/xy/_svg.py                             | 950 +++++++++++++++---
 python/xy/styling/capabilities.py             |  96 +-
 python/xy/styling/declared.py                 |  53 +-
 python/xy/styling/preflight.py                |  32 +-
 spec/api/capability-matrix.md                 |  17 +-
 spec/api/export.md                            |  29 +-
 spec/api/styling.md                           |  75 +-
 .../static-chrome-parity-plan-2026-08-04.md   |  13 +-
 tests/test_capability_registry.py             |   6 +-
 tests/test_chrome_parity_p2.py                | 538 ++++++++++
 tests/test_chromebox.py                       |  86 +-
 tests/test_export_style_survival.py           |  18 +-
 17 files changed, 2170 insertions(+), 328 deletions(-)
 create mode 100644 tests/test_chrome_parity_p2.py

diff --git a/CHANGELOG.md b/CHANGELOG.md
index fac85aa0e..fc4beb280 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,6 +9,16 @@ in the README).
 ## [Unreleased]
 
 ### Added
+- Axis chrome joins static-export styling (parity phase 2): `axis_line` and
+  `tick_mark` accept the shared box vocabulary (background, border, radius,
+  offset shadow, opacity) in SVG, PNG and PDF, `tick_label` and `axis_title`
+  additionally draw padded boxes with the axis gutters growing to fit, and a
+  rotated y-title box lowers to PDF-legal pre-rotated geometry. Emission is
+  strictly declaration-gated (unstyled bytes are untouched), one shared
+  producer feeds both writers and the declared snapshot (per-tick
+  qualifiers + geometry), and `axis_band` is recorded as navigation-gated
+  live chrome rather than drawn. The preflight, capability registry and
+  matrix moved in the same change.
 - The mount-free native cascade (optional `xy-cascade` extension, ~3.8 MB
   cdylib built from the same workspace): `chart.to_png(custom_css=css,
   style_source="native_cascade")` resolves classes and self-contained author
diff --git a/docs/api-reference/limitations-and-alpha-status.md b/docs/api-reference/limitations-and-alpha-status.md
index 77043be3f..fe75b4709 100644
--- a/docs/api-reference/limitations-and-alpha-status.md
+++ b/docs/api-reference/limitations-and-alpha-status.md
@@ -85,15 +85,20 @@ implementation. The bullets below are the boundaries that page's rows imply.
 - **Styling does not survive every export path equally, and the boundary is
   published rather than left to be discovered.** Mark, axis, and chart-level
   `style=` reach all three renderers. Per-slot `styles={slot: {...}}` reaches
-  them for the nine slots that name chrome a static file contains — `title`,
-  `axis_title`, `tick_label`, the three legend slots, and the three colorbar
-  slots — carrying `font-size`, `font-weight`, `font-style`, `font-family`,
-  `letter-spacing`, `opacity`, and the text paint. The remaining slots are live
-  chrome (`tooltip*`, `modebar*`, `crosshair_*`, `selection`, `badge*`) with
-  nothing in a file to paint, and `class_names={slot: "..."}` cannot apply in a
-  file at all: a class selects a rule out of a stylesheet an exported file does
-  not have. The native raster's baked atlas is one face, so PNG/JPEG/WebP honor
-  a slot's size and paint but not its typeface. `xy.colorbar(style=...)` still
+  them for the eleven slots that name chrome a static file contains — `title`,
+  `axis_line`, `tick_mark`, `axis_title`, `tick_label`, the three legend
+  slots, and the three colorbar slots — carrying the text subset
+  (`font-size`, `font-weight`, `font-style`, `font-family`, `letter-spacing`,
+  `opacity`, and the text paint) and, on the axis-chrome slots, the box
+  subset (background, border, radius, offset shadow, padding, opacity). The
+  remaining slots are live chrome (`tooltip*`, `modebar*`, `crosshair_*`,
+  `selection`, `badge*`, `axis_band`) with nothing in a file to paint, and
+  `class_names={slot: "..."}` cannot apply in a file at all: a class selects
+  a rule out of a stylesheet an exported file does not have. The native
+  raster's atlas carries regular/bold/italic faces but no family axis or
+  per-glyph advances, so PNG/JPEG/WebP honor a slot's size, paint, weight and
+  style but not `font-family`/`letter-spacing`/text `opacity`.
+  `xy.colorbar(style=...)` still
   has no native channel — use the `colorbar_*` slots. The full matrix is
   [Static export §9](https://github.com/reflex-dev/xy/blob/main/spec/api/export.md),
   pinned by `tests/test_export_style_survival.py`.
diff --git a/docs/styling/capabilities.md b/docs/styling/capabilities.md
index bb428aaf7..e449f7f96 100644
--- a/docs/styling/capabilities.md
+++ b/docs/styling/capabilities.md
@@ -12,7 +12,7 @@ and *does the change survive where I need it*. This page answers both from the
 registry the implementation is checked against.
 
 - **11** mark style properties across **21** mark kinds, drawn by all three renderers.
-- **48** stable chrome slots for CSS and Tailwind in the browser — **24** of them in a clean static export, **24** gated by an interaction or view state.
+- **48** stable chrome slots for CSS and Tailwind in the browser — **23** of them in a clean static export, **25** gated by an interaction or view state.
 - **1** way to add a mark kind XY does not ship, without forking it.
 
 ## Mark style properties
@@ -105,9 +105,9 @@ would not survive, before any bytes exist.
 | `crosshair_y` | crosshair state | full | none | none |
 | `badge` | view state | full | none | none |
 | `badge_item` | view state | full | none | none |
-| `axis_band` | clean static | full | none | none |
-| `axis_line` | clean static | full | none | none |
-| `tick_mark` | clean static | full | none | none |
+| `axis_band` | navigation state | full | none | none |
+| `axis_line` | clean static | full | partial | partial |
+| `tick_mark` | clean static | full | partial | partial |
 | `tick_label` | clean static | full | partial | partial |
 | `axis_title` | clean static | full | partial | partial |
 | `annotation_label` | clean static | full | none | none |
@@ -122,8 +122,10 @@ would not survive, before any bytes exist.
 - **`colorbar`** (via `styles={'colorbar': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
 - **`colorbar_tick`** (via `styles={'colorbar_tick': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
 - **`colorbar_title`** (via `styles={'colorbar_title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
-- **`tick_label`** (via `styles={'tick_label': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
-- **`axis_title`** (via `styles={'axis_title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
+- **`axis_line`** (via `styles={'axis_line': ...}`) — Spines as boxes when box properties are declared: background, border (color/width/style, dashed/dotted as dash arrays), symmetric border-radius, offset box-shadow (blur/spread recorded unrepresentable), opacity and fill-opacity. The spine keeps its axis_color ink unless the slot declares a background (an explicit transparent erases it, as in the browser). Writers center the box on the plot edge where the unstyled stroke ran; the browser insets right/bottom spines (see KNOWN_RENDERER_DIVERGENCES). Polar spines stay strokes — the browser shares the limit (DIV spines cannot express a circle).
+- **`tick_mark`** (via `styles={'tick_mark': ...}`) — Tick marks as boxes when box properties are declared: background, border (color/width/style, dashed/dotted as dash arrays), symmetric border-radius, offset box-shadow (blur/spread recorded unrepresentable), opacity and fill-opacity. Geometry is the centered stroke's own coverage — the same pixels as the browser's rect. Marks exist only where an axis authors tick_length > 0; a zero-length tick draws nothing (and casts no shadow) — the preflight carries the note rather than a length being invented. tick_color stays the narrower paint selector; polar has no cartesian tick marks (recorded).
+- **`tick_label`** (via `styles={'tick_label': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only. Additionally a per-label box: background, border (color/width/style, dashed/dotted as dash arrays), symmetric border-radius, offset box-shadow (blur/spread recorded unrepresentable), opacity and fill-opacity, with padding growing the axis gutters so the box stays on the canvas (cartesian; the polar label ring keeps its flat 30px allowance). Box geometry is measured with the writers' DejaVu metrics, so an authored font-family renders its own glyphs inside a DejaVu-measured box (recorded misfit); letter-spacing is likewise outside the gutter measurement. On the raster writer a declared opacity reaches the box, not the glyphs (the atlas blit has no alpha channel).
+- **`axis_title`** (via `styles={'axis_title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only. Additionally a per-title box: background, border (color/width/style, dashed/dotted as dash arrays), symmetric border-radius, offset box-shadow (blur/spread recorded unrepresentable), opacity and fill-opacity; a rotated y-title box is pre-rotated to a polygon (radius 0) or an arc path (radius > 0), staying inside the PDF closed subset. The axis's own label_* keys win per property over the slot (label_color, label_font_family/style/weight); font-size runs the other way — the slot's font-size wins over label_size (pre-existing, documented in spec/api/styling.md). DejaVu-measured box vs authored-family text and raster box-not-glyph opacity are recorded exactly as for tick_label.
 
 ## Extension points
 
@@ -143,6 +145,7 @@ an undocumented difference reads as a bug; a documented one is a contract.
 | what | browser | svg | native png | visible when |
 |---|---|---|---|---|
 | Interior vertices of a wide polyline | the notch two overlapping segment quads leave | round (the writer names it explicitly) | round (the capsule distance field fills the vertex) | stroke-width above ~4px at a sharp angle |
+| Where an axis spine's box sits relative to the plot edge | right/bottom spines inset by their own width (DIVs laid inside the box) | centered on the plot edge, where the unstyled stroke has always run | centered on the plot edge (same shared box producer as SVG) | axis_width above ~2px, or a styled axis_line box under a magnifier |
 
 For what is still alpha, see
 [Limitations and Alpha Status](/docs/xy/api-reference/limitations-and-alpha-status/).
diff --git a/python/xy/_chromebox.py b/python/xy/_chromebox.py
index 94af40b95..0514d21c5 100644
--- a/python/xy/_chromebox.py
+++ b/python/xy/_chromebox.py
@@ -23,22 +23,63 @@
 - `border-style` lowers `dashed`/`dotted` to dash arrays scaled by width —
   the same construction both writers already use for data strokes; `double`
   and friends are recorded unrepresentable.
+- A rotated box (`angle` about `(cx, cy)`) is lowered by the emitters to
+  pre-rotated geometry — a polygon when `radius == 0`, a path with circular
+  arcs when `radius > 0` — because the PDF closed subset accepts no
+  `transform` on `<rect>`. One lowering repo-wide (plan flag E).
+- A zero-area box emits nothing at all — no fill, no border, and explicitly
+  no shadow (a `tick_length: 0` tick must not cast one).
 """
 
 from __future__ import annotations
 
+import math
 import re
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, replace
 from typing import Any, Optional
 
-__all__ = ["ChromeBox", "lower_box"]
+__all__ = [
+    "ChromeBox",
+    "box_at",
+    "box_room",
+    "box_template",
+    "lower_box",
+    "padding_sides",
+    "parse_padding",
+    "rotate_points",
+    "text_box",
+]
+
+
+def rotate_points(
+    points: list[tuple[float, float]], angle: float, cx: float, cy: float
+) -> list[tuple[float, float]]:
+    """Points rotated `angle` degrees (screen space, y down) about `(cx, cy)`.
+
+    The one rotation both emitters use to pre-rotate a posed box — the PDF
+    subset accepts no transform on shapes, and the raster display list has no
+    transform primitive, so rotation happens here, once, in Python.
+    """
+    radians = math.radians(angle)
+    cos, sin = math.cos(radians), math.sin(radians)
+    return [
+        (cx + (px - cx) * cos - (py - cy) * sin, cy + (px - cx) * sin + (py - cy) * cos)
+        for px, py in points
+    ]
+
 
 _LENGTH_RE = re.compile(r"^\s*(-?\d+(?:\.\d+)?)(?:px)?\s*$")
 
 
 @dataclass(frozen=True)
 class ChromeBox:
-    """One slot instance's resolved box, ready for either writer."""
+    """One slot instance's resolved box, ready for either writer.
+
+    `qualifiers` is the instance's stable identity beyond the slot name
+    (`SlotInstance.qualifiers` carrier — e.g. `("x", "major", "bottom", "3")`
+    for a tick mark). `angle`/`cx`/`cy` is the rotation pose (an axis
+    y-title); zero for most slots.
+    """
 
     slot: str
     x: float
@@ -54,12 +95,186 @@ class ChromeBox:
     shadow: Optional[tuple[float, float, str]] = None  # (dx, dy, color)
     opacity: float = 1.0
     unrepresentable: tuple[str, ...] = field(default_factory=tuple)
+    qualifiers: tuple[str, ...] = ()
+    angle: float = 0.0
+    cx: float = 0.0
+    cy: float = 0.0
+    #: True when the declaration carried a `background`/`background-color`
+    #: key at all — an explicit `transparent` (fill None, declared True) must
+    #: not fall back to a slot's default ink the way an absent key does.
+    fill_declared: bool = False
 
     @property
     def paints_anything(self) -> bool:
+        if self.w <= 0.0 or self.h <= 0.0:
+            return False
         return self.fill is not None or (self.border_color is not None and self.border_width > 0)
 
 
+def parse_padding(value: Any) -> Optional[tuple[float, float, float, float]]:
+    """CSS `padding` shorthand as `(top, right, bottom, left)` px, or None.
+
+    Accepts 1-4 px lengths with the standard CSS expansion. The existing
+    annotation-box parsers read tokens [0]/[1] only, which silently misreads
+    a 4-value shorthand — this is the one correct expansion every box
+    consumer shares.
+    """
+    if isinstance(value, (int, float)) and not isinstance(value, bool):
+        v = float(value)
+        return (v, v, v, v)
+    if not isinstance(value, str):
+        return None
+    tokens = value.split()
+    if not 1 <= len(tokens) <= 4:
+        return None
+    sides = [_px(token) for token in tokens]
+    if any(side is None for side in sides):
+        return None
+    vals = [float(side) for side in sides if side is not None]
+    if len(vals) == 1:
+        vals *= 4
+    elif len(vals) == 2:
+        vals = [vals[0], vals[1], vals[0], vals[1]]
+    elif len(vals) == 3:
+        vals = [vals[0], vals[1], vals[2], vals[1]]
+    return (vals[0], vals[1], vals[2], vals[3])
+
+
+def padding_sides(declaration: Optional[dict[str, Any]]) -> tuple[float, float, float, float]:
+    """A declaration's padding as `(top, right, bottom, left)` px.
+
+    The `padding` shorthand seeds all four sides; a `padding-*` longhand
+    overrides its side regardless of dict order (documented precedence — the
+    resolver has no declaration order to honor).
+    """
+    if not declaration:
+        return (0.0, 0.0, 0.0, 0.0)
+    sides = list(parse_padding(declaration.get("padding")) or (0.0, 0.0, 0.0, 0.0))
+    for index, prop in enumerate(
+        ("padding-top", "padding-right", "padding-bottom", "padding-left")
+    ):
+        longhand = _px(declaration.get(prop))
+        if longhand is not None:
+            sides[index] = longhand
+    return (sides[0], sides[1], sides[2], sides[3])
+
+
+def _border_width(declaration: dict[str, Any]) -> float:
+    """The border width lower_box would draw — one rule, shared with rooms."""
+    width = _px(declaration.get("border-width")) or 0.0
+    style = str(declaration.get("border-style", "solid") or "solid").strip().lower()
+    if style in ("none", "hidden"):
+        return 0.0
+    if declaration.get("border-color") is not None and width == 0.0:
+        return 1.0  # the 1px chrome-border default, mirroring lower_box
+    return width
+
+
+def box_room(declaration: Optional[dict[str, Any]]) -> tuple[float, float, float, float]:
+    """Outward growth `(top, right, bottom, left)` a declared box adds around
+    its content: per-side padding plus the border width. The layout/room
+    functions consume this; the emitters never do (geometry already carries
+    it)."""
+    if not declaration:
+        return (0.0, 0.0, 0.0, 0.0)
+    top, right, bottom, left = padding_sides(declaration)
+    border = _border_width(declaration)
+    return (top + border, right + border, bottom + border, left + border)
+
+
+def box_template(slot: str, declaration: dict[str, Any]) -> ChromeBox:
+    """The declaration lowered once, geometry-free — the interning half.
+
+    A dense axis draws one declaration N times; parsing it per instance is
+    the cost `styling/resolved.py`'s interning design exists to avoid. The
+    huge placeholder geometry keeps the radius unclamped so `box_at` can
+    clamp per instance.
+    """
+    return lower_box(slot, declaration, x=0.0, y=0.0, w=1e18, h=1e18)
+
+
+def box_at(
+    template: ChromeBox,
+    x: float,
+    y: float,
+    w: float,
+    h: float,
+    *,
+    qualifiers: tuple[str, ...] = (),
+    angle: float = 0.0,
+    cx: float = 0.0,
+    cy: float = 0.0,
+    fallback_fill: Optional[str] = None,
+) -> ChromeBox:
+    """One instance of an interned template at a concrete geometry.
+
+    `fallback_fill` is the slot's default ink (an axis spine's `axis_color`);
+    it applies only when the declaration never mentioned a background — an
+    explicit `transparent` stays unpainted, exactly as in the browser.
+    """
+    fill = template.fill
+    if fill is None and not template.fill_declared and fallback_fill is not None:
+        fill = fallback_fill
+    radius = max(0.0, min(template.radius, w / 2.0, h / 2.0)) if w > 0.0 and h > 0.0 else 0.0
+    return replace(
+        template,
+        x=float(x),
+        y=float(y),
+        w=float(w),
+        h=float(h),
+        fill=fill,
+        radius=radius,
+        qualifiers=tuple(str(q) for q in qualifiers),
+        angle=float(angle),
+        cx=float(cx),
+        cy=float(cy),
+    )
+
+
+def text_box(
+    template: ChromeBox,
+    pads: tuple[float, float, float, float],
+    *,
+    x: float,
+    y: float,
+    anchor: str,
+    block: Any,
+    angle: float = 0.0,
+    qualifiers: tuple[str, ...] = (),
+) -> ChromeBox:
+    """The box around one text block, in the writers' shared metrics.
+
+    `(x, y)` is the text anchor (first-line baseline), `anchor` the SVG
+    vocabulary (`start`/`middle`/`end`), `block` a `_textblock.TextBlock`.
+    Padding is applied in text-local space; a rotated label's box rotates
+    with the text about the anchor — the emitters lower that pose to
+    PDF-legal pre-rotated geometry. Both writers build tick-label and
+    axis-title boxes through here, so their geometry cannot drift (the
+    metrics are the writers' DejaVu tables; an authored font-family renders
+    other glyphs inside a DejaVu-measured box — recorded misfit, §28).
+    """
+    pad_t, pad_r, pad_b, pad_l = pads
+    if anchor == "middle":
+        x0 = x - block.width / 2.0
+    elif anchor == "end":
+        x0 = x - block.width
+    else:
+        x0 = x
+    y0 = y - block.ascent
+    height = block.ascent + block.descent + (block.line_count - 1) * block.line_step
+    return box_at(
+        template,
+        x0 - pad_l,
+        y0 - pad_t,
+        block.width + pad_l + pad_r,
+        height + pad_t + pad_b,
+        qualifiers=qualifiers,
+        angle=angle,
+        cx=x,
+        cy=y,
+    )
+
+
 def _px(value: Any) -> Optional[float]:
     if isinstance(value, bool):
         return None
@@ -159,6 +374,7 @@ def lower_box(
     """
     unrepresentable: list[str] = []
 
+    fill_declared = "background" in declaration or "background-color" in declaration
     fill = declaration.get("background")
     if fill is None:
         fill = declaration.get("background-color")
@@ -219,4 +435,5 @@ def lower_box(
         shadow=shadow,
         opacity=_opacity(declaration.get("opacity"), 1.0),
         unrepresentable=tuple(unrepresentable),
+        fill_declared=fill_declared,
     )
diff --git a/python/xy/_raster.py b/python/xy/_raster.py
index cc2646643..821642dc2 100644
--- a/python/xy/_raster.py
+++ b/python/xy/_raster.py
@@ -22,6 +22,8 @@
 
 from . import _paint, _png, _scene, _textblock
 from ._arrowgeom import arrow_shapes as _arrow_shapes
+from ._chromebox import box_template, padding_sides, text_box
+from ._chromebox import rotate_points as _chromebox_rotate
 from ._svg import (
     _AXIS,
     _AXIS_GRID_DASHES,
@@ -50,6 +52,7 @@
     _decode_title_geometry,
     _density_column,
     _estimated_text_width,
+    _has_box_declaration,
     _heatmap_rgba_grid,
     _legend_layout,
     _lut,
@@ -66,6 +69,7 @@
     affine_fast_path,
     annotation_label_placement,
     apply_export_background,
+    axis_chrome_boxes,
     axis_ticks,
     hexbin_ring,
     layout,
@@ -79,6 +83,7 @@
     slot_font_size,
     slot_styles,
     slot_text_color,
+    tick_span,
     warp_grid_rgba,
 )
 
@@ -775,16 +780,26 @@ def _emit_slot_box(cmd: "_Cmd", box: Any) -> None:
 
     Slot opacity folds into every RGBA (the display list has no group
     compositing); rounded corners go through `_round_rect_pts`; the border
-    strokes closed so the final edge is not silently dropped. Emits nothing
-    for a box that paints nothing — the unstyled-bytes gate.
+    strokes closed so the final edge is not silently dropped. A posed box
+    (`angle != 0`) is pre-rotated in Python — `cmd.fill` takes any polygon
+    and the display list has no transform primitive — the raster half of the
+    repo's one rotated-box lowering (plan flag E). Emits nothing for a box
+    that paints nothing — including any zero-area box, which casts no shadow
+    either — the unstyled-bytes gate.
     """
+    if box.w <= 0.0 or box.h <= 0.0:
+        return
     if not box.paints_anything and box.shadow is None:
         return
 
     def pts(x: float, y: float) -> list[tuple[float, float]]:
         if box.radius > 0:
-            return _round_rect_pts(x, y, box.w, box.h, box.radius)
-        return _rect_pts(x, y, box.w, box.h)
+            shape = _round_rect_pts(x, y, x + box.w, y + box.h, box.radius)
+        else:
+            shape = _rect_pts(x, y, x + box.w, y + box.h)
+        if box.angle:
+            shape = _chromebox_rotate(shape, box.angle, box.cx, box.cy)
+        return shape
 
     if box.shadow is not None:
         dx, dy, color = box.shadow
@@ -920,13 +935,23 @@ def _emit_polar_tick_labels(
     r_color: tuple[int, ...],
     hide_theta: bool,
     hide_r: bool,
+    tick_label_slot: Optional[dict[str, Any]] = None,
 ) -> None:
     """Emit polar tick labels as display-list text, from the shared placement.
 
     Placement lives in `_svg.polar_tick_label_layout`; this is only the sink,
     so the two exporters cannot drift on rim offsets, quadrant anchors or the
-    radial spoke angle.
+    radial spoke angle. `tick_label_slot` carries the chart-wide slot: its
+    font emphasis routes to the atlas faces here exactly as on the cartesian
+    path (the P0.2 contract — this sink was the one emitter it had missed),
+    and its declared box rides `text_box` like every other label.
     """
+    slot = tick_label_slot or {}
+    italic, bold = _native_font_emphasis(
+        {"font_style": slot.get("font-style"), "font_weight": slot.get("font-weight", 400)}
+    )
+    box_tmpl = box_template("tick_label", slot) if _has_box_declaration(slot) else None
+    box_pads = padding_sides(slot)
     angular, radial = polar_tick_label_layout(
         polar,
         theta_values,
@@ -942,6 +967,19 @@ def _emit_polar_tick_labels(
     )
     for placed, paint in ((angular, theta_color), (radial, r_color)):
         for item in placed:
+            if box_tmpl is not None:
+                _emit_slot_box(
+                    cmd,
+                    text_box(
+                        box_tmpl,
+                        box_pads,
+                        x=item.x,
+                        y=item.y,
+                        anchor=item.anchor,
+                        block=_textblock.measure(item.text, item.size),
+                        angle=item.spin,
+                    ),
+                )
             cmd.text(
                 item.x,
                 item.y,
@@ -952,6 +990,8 @@ def _emit_polar_tick_labels(
                 paint,
                 item.text,
                 angle=item.spin,
+                italic=italic,
+                bold=bold,
             )
 
 
@@ -1153,6 +1193,17 @@ def render_raster(
         phase="text",
         polar=polar,
     )
+    # Hoisted above the axis chrome: the axis_line/tick_mark box slots are
+    # read here (formerly assigned after the tick loops, which could never
+    # see them). Same resolver, same view — a pure reorder for unstyled
+    # charts.
+    slots = slot_styles(spec)
+    axis_line_boxed = polar is None and _has_box_declaration(slots.get("axis_line"))
+    tick_mark_boxed = polar is None and _has_box_declaration(slots.get("tick_mark"))
+    # One producer feeds both writers and the declared snapshot, so a styled
+    # spine or tick cannot mean different geometry in different outputs.
+    # Polar keeps stroke semantics (the browser shares the limit).
+    axis_boxes = axis_chrome_boxes(spec, slots) if (axis_line_boxed or tick_mark_boxed) else []
     # "none" silences the whole axis chrome (sparklines); "off" hides only the
     # label text and keeps baselines and the axis title (mpl shared axes).
     frame_sides = spec.get("frame_sides")
@@ -1189,64 +1240,63 @@ def render_raster(
                     )
                     boundary = [*outer, *reversed(inner)]
                     cmd.stroke([*boundary, boundary[0]], width_, paint)
-    if not hide_y or explicit_frame_sides:
-        if "left" in frame_sides:
-            cmd.stroke(
-                [(px0, py0), (px0, py1)],
-                float(ystyle.get("axis_width", 1)),
-                _parse_color(_css(ystyle.get("axis_color"), default_axis)),
-            )
-        if "right" in frame_sides:
-            cmd.stroke(
-                [(px1, py0), (px1, py1)],
-                float(ystyle.get("axis_width", 1)),
-                _parse_color(_css(ystyle.get("axis_color"), default_axis)),
-            )
-    if not hide_x or explicit_frame_sides:
-        if "top" in frame_sides:
+    if not axis_line_boxed:
+        if not hide_y or explicit_frame_sides:
+            if "left" in frame_sides:
+                cmd.stroke(
+                    [(px0, py0), (px0, py1)],
+                    float(ystyle.get("axis_width", 1)),
+                    _parse_color(_css(ystyle.get("axis_color"), default_axis)),
+                )
+            if "right" in frame_sides:
+                cmd.stroke(
+                    [(px1, py0), (px1, py1)],
+                    float(ystyle.get("axis_width", 1)),
+                    _parse_color(_css(ystyle.get("axis_color"), default_axis)),
+                )
+        if not hide_x or explicit_frame_sides:
+            if "top" in frame_sides:
+                cmd.stroke(
+                    [(px0, py0), (px1, py0)],
+                    float(xstyle.get("axis_width", 1)),
+                    _parse_color(_css(xstyle.get("axis_color"), default_axis)),
+                )
+            if "bottom" in frame_sides:
+                cmd.stroke(
+                    [(px0, py1), (px1, py1)],
+                    float(xstyle.get("axis_width", 1)),
+                    _parse_color(_css(xstyle.get("axis_color"), default_axis)),
+                )
+        for _axis_id, axis, _axis_scale in extra_x_axes:
+            if _axis_tick_label_strategy(axis) == "none":
+                continue
+            axis_style = axis.get("style") or {}
+            edge = py0 if axis.get("side", "bottom") == "top" else py1
             cmd.stroke(
-                [(px0, py0), (px1, py0)],
-                float(xstyle.get("axis_width", 1)),
-                _parse_color(_css(xstyle.get("axis_color"), default_axis)),
+                [(px0, edge), (px1, edge)],
+                float(axis_style.get("axis_width", 1)),
+                _parse_color(_css(axis_style.get("axis_color"), default_axis)),
             )
-        if "bottom" in frame_sides:
+        for _axis_id, axis, _axis_scale in extra_y_axes:
+            if _axis_tick_label_strategy(axis) == "none":
+                continue
+            axis_style = axis.get("style") or {}
+            edge = px1 if axis.get("side", "right") == "right" else px0
             cmd.stroke(
-                [(px0, py1), (px1, py1)],
-                float(xstyle.get("axis_width", 1)),
-                _parse_color(_css(xstyle.get("axis_color"), default_axis)),
+                [(edge, py0), (edge, py1)],
+                float(axis_style.get("axis_width", 1)),
+                _parse_color(_css(axis_style.get("axis_color"), default_axis)),
             )
-    for _axis_id, axis, _axis_scale in extra_x_axes:
-        if _axis_tick_label_strategy(axis) == "none":
-            continue
-        axis_style = axis.get("style") or {}
-        edge = py0 if axis.get("side", "bottom") == "top" else py1
-        cmd.stroke(
-            [(px0, edge), (px1, edge)],
-            float(axis_style.get("axis_width", 1)),
-            _parse_color(_css(axis_style.get("axis_color"), default_axis)),
-        )
-    for _axis_id, axis, _axis_scale in extra_y_axes:
-        if _axis_tick_label_strategy(axis) == "none":
-            continue
-        axis_style = axis.get("style") or {}
-        edge = px1 if axis.get("side", "right") == "right" else px0
-        cmd.stroke(
-            [(edge, py0), (edge, py1)],
-            float(axis_style.get("axis_width", 1)),
-            _parse_color(_css(axis_style.get("axis_color"), default_axis)),
-        )
-
-    def tick_span(style: dict[str, Any]) -> tuple[float, float]:
-        length = max(0.0, float(style.get("tick_length", 0)))
-        direction = str(style.get("tick_direction", "out"))
-        if direction == "in":
-            return length, 0.0
-        if direction == "inout":
-            return length / 2, length / 2
-        return 0.0, length
-
-    if not hide_x and polar is None:
-        inward, outward = tick_span(xmstyle)
+    else:
+        # The styled spines as boxes, centered on the plot edge exactly where
+        # the unstyled stroke ran (the browser insets right/bottom spines —
+        # recorded divergence in `KNOWN_RENDERER_DIVERGENCES`).
+        for box in axis_boxes:
+            if box.slot == "axis_line":
+                _emit_slot_box(cmd, box)
+
+    if not tick_mark_boxed and not hide_x and polar is None:
+        inward, outward, tick_width = tick_span(xmstyle)
         side = xa.get("side", "bottom")
         edge = py0 if side == "top" else py1
         for value in xmt:
@@ -1258,10 +1308,10 @@ def tick_span(style: dict[str, Any]) -> tuple[float, float]:
             )
             cmd.stroke(
                 [(x, y0), (x, y1)],
-                float(xmstyle.get("tick_width", 1)),
+                tick_width,
                 _parse_color(_css(xmstyle.get("tick_color"), default_axis)),
             )
-        inward, outward = tick_span(xstyle)
+        inward, outward, tick_width = tick_span(xstyle)
         for side in _axis_tick_sides(xa, is_x=True):
             edge = py0 if side == "top" else py1
             for value in xt:
@@ -1273,11 +1323,11 @@ def tick_span(style: dict[str, Any]) -> tuple[float, float]:
                 )
                 cmd.stroke(
                     [(x, y0), (x, y1)],
-                    float(xstyle.get("tick_width", 1)),
+                    tick_width,
                     _parse_color(_css(xstyle.get("tick_color"), default_axis)),
                 )
-    if not hide_y and polar is None:
-        inward, outward = tick_span(ymstyle)
+    if not tick_mark_boxed and not hide_y and polar is None:
+        inward, outward, tick_width = tick_span(ymstyle)
         side = ya.get("side", "left")
         edge = px1 if side == "right" else px0
         for value in ymt:
@@ -1289,10 +1339,10 @@ def tick_span(style: dict[str, Any]) -> tuple[float, float]:
             )
             cmd.stroke(
                 [(x0, y), (x1, y)],
-                float(ymstyle.get("tick_width", 1)),
+                tick_width,
                 _parse_color(_css(ymstyle.get("tick_color"), default_axis)),
             )
-        inward, outward = tick_span(ystyle)
+        inward, outward, tick_width = tick_span(ystyle)
         for side in _axis_tick_sides(ya, is_x=False):
             edge = px1 if side == "right" else px0
             for value in yt:
@@ -1304,49 +1354,55 @@ def tick_span(style: dict[str, Any]) -> tuple[float, float]:
                 )
                 cmd.stroke(
                     [(x0, y), (x1, y)],
-                    float(ystyle.get("tick_width", 1)),
+                    tick_width,
                     _parse_color(_css(ystyle.get("tick_color"), default_axis)),
                 )
-    for axis_id, axis, axis_scale in extra_x_axes:
-        if _axis_tick_label_strategy(axis) == "none":
-            continue
-        axis_style = axis.get("style") or {}
-        inward, outward = tick_span(axis_style)
-        for side in _axis_tick_sides(axis, is_x=True):
-            edge = py0 if side == "top" else py1
-            for value in extra_x_ticks[axis_id][0]:
-                x = float(axis_scale(value))
-                y0, y1 = (
-                    (edge - outward, edge + inward)
-                    if side == "top"
-                    else (edge - inward, edge + outward)
-                )
-                cmd.stroke(
-                    [(x, y0), (x, y1)],
-                    float(axis_style.get("tick_width", 1)),
-                    _parse_color(_css(axis_style.get("tick_color"), default_axis)),
-                )
-    for axis_id, axis, axis_scale in extra_y_axes:
-        if _axis_tick_label_strategy(axis) == "none":
-            continue
-        axis_style = axis.get("style") or {}
-        inward, outward = tick_span(axis_style)
-        for side in _axis_tick_sides(axis, is_x=False):
-            edge = px1 if side == "right" else px0
-            for value in extra_y_ticks[axis_id][0]:
-                y = float(axis_scale(value))
-                x0, x1 = (
-                    (edge - inward, edge + outward)
-                    if side == "right"
-                    else (edge - outward, edge + inward)
-                )
-                cmd.stroke(
-                    [(x0, y), (x1, y)],
-                    float(axis_style.get("tick_width", 1)),
-                    _parse_color(_css(axis_style.get("tick_color"), default_axis)),
-                )
-
-    slots = slot_styles(spec)
+    if not tick_mark_boxed:
+        for axis_id, axis, axis_scale in extra_x_axes:
+            if _axis_tick_label_strategy(axis) == "none":
+                continue
+            axis_style = axis.get("style") or {}
+            inward, outward, tick_width = tick_span(axis_style)
+            for side in _axis_tick_sides(axis, is_x=True):
+                edge = py0 if side == "top" else py1
+                for value in extra_x_ticks[axis_id][0]:
+                    x = float(axis_scale(value))
+                    y0, y1 = (
+                        (edge - outward, edge + inward)
+                        if side == "top"
+                        else (edge - inward, edge + outward)
+                    )
+                    cmd.stroke(
+                        [(x, y0), (x, y1)],
+                        tick_width,
+                        _parse_color(_css(axis_style.get("tick_color"), default_axis)),
+                    )
+        for axis_id, axis, axis_scale in extra_y_axes:
+            if _axis_tick_label_strategy(axis) == "none":
+                continue
+            axis_style = axis.get("style") or {}
+            inward, outward, tick_width = tick_span(axis_style)
+            for side in _axis_tick_sides(axis, is_x=False):
+                edge = px1 if side == "right" else px0
+                for value in extra_y_ticks[axis_id][0]:
+                    y = float(axis_scale(value))
+                    x0, x1 = (
+                        (edge - inward, edge + outward)
+                        if side == "right"
+                        else (edge - outward, edge + inward)
+                    )
+                    cmd.stroke(
+                        [(x0, y), (x1, y)],
+                        tick_width,
+                        _parse_color(_css(axis_style.get("tick_color"), default_axis)),
+                    )
+    if tick_mark_boxed:
+        # The styled tick marks, from the shared producer — the same boxes the
+        # SVG writer and the declared snapshot consume, at the stroke's own
+        # paint position in the display list.
+        for box in axis_boxes:
+            if box.slot == "tick_mark":
+                _emit_slot_box(cmd, box)
 
     def slot_paint(slot: str, fallback: str) -> tuple:
         """A slot's text paint, or the writer's own default."""
@@ -1377,6 +1433,16 @@ def emit_tick_labels(
                 "font_weight": (slots.get("tick_label") or {}).get("font-weight", 400),
             }
         )
+        # The slot's box, lowered once and stamped per label — the raster
+        # twin of the SVG writer's per-<text> rect, from the same shared
+        # `text_box` metrics.
+        tick_label_slot = slots.get("tick_label") or {}
+        box_tmpl = (
+            box_template("tick_label", tick_label_slot)
+            if _has_box_declaration(tick_label_slot)
+            else None
+        )
+        box_pads = padding_sides(tick_label_slot)
         baseline_shift = _axis_tick_label_baseline_shift(axis)
         # An explicit tick_label_anchor (axis spec or style) overrides the
         # side-derived default, matching the browser client and SVG export.
@@ -1425,6 +1491,19 @@ def emit_tick_labels(
                     anchor = (
                         _TEXT_ANCHOR_CODES[explicit_anchor] if explicit_anchor else default_anchor
                     )
+                if box_tmpl is not None:
+                    _emit_slot_box(
+                        cmd,
+                        text_box(
+                            box_tmpl,
+                            box_pads,
+                            x=x,
+                            y=y,
+                            anchor=("start", "middle", "end")[anchor],
+                            block=block,
+                            angle=float(item["angle"]),
+                        ),
+                    )
                 _emit_text_block(
                     cmd,
                     x,
@@ -1454,6 +1533,7 @@ def emit_tick_labels(
             _polar_label_paint(ya, slot_paint, default_text),
             hide_x or xa.get("tick_label_strategy") == "off",
             hide_y or ya.get("tick_label_strategy") == "off",
+            tick_label_slot=slots.get("tick_label") or {},
         )
     else:
         emit_tick_labels(xa, xlab, xstep, sx, is_x=True)
@@ -1545,12 +1625,30 @@ def emit_axis_title(axis: dict[str, Any], *, is_x: bool) -> None:
                 ),
             }
         )
+        font_size = slot_font_size(axis_title_slot, float(geometry["font_size"]))
+        if _has_box_declaration(axis_title_slot):
+            # The title's box before its text, from the same shared `text_box`
+            # metrics the SVG writer uses; a rotated y-title box is
+            # pre-rotated by the emitter (flag-E lowering, no transform
+            # primitive in the display list).
+            _emit_slot_box(
+                cmd,
+                text_box(
+                    box_template("axis_title", axis_title_slot),
+                    padding_sides(axis_title_slot),
+                    x=float(geometry["x"]),
+                    y=float(geometry["y"]),
+                    anchor=str(geometry["anchor"]),
+                    block=_textblock.measure(str(axis["label"]), font_size),
+                    angle=float(geometry["angle"]),
+                ),
+            )
         _emit_text_block(
             cmd,
             float(geometry["x"]),
             float(geometry["y"]),
             anchor,
-            slot_font_size(slots.get("axis_title") or {}, float(geometry["font_size"])),
+            font_size,
             (
                 _parse_color(_css(axis_style.get("label_color"), ""))
                 if _css(axis_style.get("label_color"), "")
diff --git a/python/xy/_svg.py b/python/xy/_svg.py
index 8f523c09e..d9c0bfe3a 100644
--- a/python/xy/_svg.py
+++ b/python/xy/_svg.py
@@ -21,6 +21,7 @@
 import hashlib
 import math
 import re
+import threading
 from collections.abc import Callable, Sequence
 from datetime import UTC, datetime
 from itertools import pairwise
@@ -31,6 +32,8 @@
 
 from . import _fontmetrics, _native, _paint, _png, _textblock
 from ._arrowgeom import arrow_shapes as _arrow_shapes
+from ._chromebox import ChromeBox, box_at, box_room, box_template, padding_sides, rotate_points
+from ._chromebox import text_box as _chrome_text_box
 from .config import DEFAULT_PALETTE, polar_bar_segments
 
 
@@ -1366,6 +1369,8 @@ def _px_size(value: Any, default: float) -> float:
 #: painted text of its own, and stays browser-only.
 STATIC_STYLED_SLOTS: tuple[str, ...] = (
     "title",
+    "axis_line",
+    "tick_mark",
     "axis_title",
     "tick_label",
     "legend",
@@ -1429,6 +1434,43 @@ def slot_styles(spec: dict[str, Any]) -> dict[str, dict[str, Any]]:
 )
 
 
+#: The shared chrome-box vocabulary (`_chromebox.lower_box` + the room
+#: functions): what a slot's declaration may say about its BOX, as opposed to
+#: its text. One constant consumed by the writers (emission gating), the
+#: capability registry, and the preflight's honored-props routing, so the
+#: three cannot drift (plan §2 item 0.4 — the `LEGEND_BOX_PROPS` pattern).
+#: `padding`/`padding-*` are consumed by the layout/room functions, never by
+#: the emitters (geometry already carries them). The legend keeps its own
+#: historical vocabulary (`LEGEND_BOX_PROPS`) until P4 retires the em residue.
+SLOT_BOX_PROPS: frozenset[str] = frozenset(
+    {
+        "background",
+        "background-color",
+        "border-color",
+        "border-width",
+        "border-style",
+        "border-radius",
+        "box-shadow",
+        "opacity",
+        "fill-opacity",
+        "padding",
+        "padding-top",
+        "padding-right",
+        "padding-bottom",
+        "padding-left",
+    }
+)
+
+
+def _has_box_declaration(style: Optional[dict[str, Any]]) -> bool:
+    """Whether a slot declaration says anything the box model draws or
+    measures. The writers' box emission is strictly gated on this — an
+    absent/empty declaration must leave the unstyled bytes untouched."""
+    if not style:
+        return False
+    return any(style.get(prop) is not None for prop in SLOT_BOX_PROPS)
+
+
 def legend_options_with_slot(spec: dict[str, Any], options: dict[str, Any]) -> dict[str, Any]:
     """Fold the chart-level legend styling into a legend's own options, so every
     spelling that agrees in the browser also agrees in a file.
@@ -1817,16 +1859,84 @@ def _rounded_rect_path(
     return " ".join(s for s in p if s)
 
 
-def _slot_box_svg(box: Any) -> str:
-    """One chrome box as SVG rects — the writer half of `_chromebox`.
+def _slot_box_paint_attrs(box: Any) -> str:
+    """A chrome box's geometry-free attribute tail, computed once per
+    declaration (the interned-attrs rule, `styling/resolved.py`): dense loops
+    format the paints once and reuse the string across N instances."""
+    fill = _escape_attr(box.fill) if box.fill is not None else "none"
+    stroke = ""
+    if box.border_color is not None and box.border_width > 0:
+        stroke = (
+            f' stroke="{_escape_attr(box.border_color)}" stroke-width="{_num(box.border_width)}"'
+        )
+        if box.border_dash:
+            dashes = " ".join(_num(v) for v in box.border_dash)
+            stroke += f' stroke-dasharray="{dashes}"'
+    fill_opacity = f' fill-opacity="{_num(box.fill_opacity)}"' if box.fill_opacity < 1.0 else ""
+    common_opacity = f' opacity="{_num(box.opacity)}"' if box.opacity < 1.0 else ""
+    return f' fill="{fill}"{fill_opacity}{stroke}{common_opacity}'
+
 
-    Shadow first, then the background/border rect; every attribute exactly
+def _rotated_box_shape(
+    x: float, y: float, w: float, h: float, radius: float, angle: float, cx: float, cy: float
+) -> str:
+    """A rotated box's geometry, pre-rotated to the PDF-legal lowering.
+
+    The pinned repo-wide rule (plan flag E): `<polygon>` when `radius == 0`,
+    `<path>` with circular arcs when `radius > 0` — `<rect>` accepts no
+    `transform` in the PDF closed subset, and both replacements do accept
+    the shared paint attributes. Returns everything up to (not including)
+    the paint attribute tail.
+    """
+    if radius <= 0.0:
+        corners = rotate_points([(x, y), (x + w, y), (x + w, y + h), (x, y + h)], angle, cx, cy)
+        points = " ".join(f"{_num(px)},{_num(py)}" for px, py in corners)
+        return f'<polygon points="{points}"'
+    r = min(radius, w / 2.0, h / 2.0)
+    # Endpoints of the rounded-rect outline, walked clockwise; quarter arcs
+    # are circular, so rotation moves only their endpoints (sweep stays 1).
+    locals_ = [
+        (x + r, y),
+        (x + w - r, y),
+        (x + w, y + r),
+        (x + w, y + h - r),
+        (x + w - r, y + h),
+        (x + r, y + h),
+        (x, y + h - r),
+        (x, y + r),
+    ]
+    p = rotate_points(locals_, angle, cx, cy)
+    rr = _num(r)
+
+    def pt(i: int) -> str:
+        return f"{_num(p[i][0])} {_num(p[i][1])}"
+
+    d = (
+        f"M {pt(0)} L {pt(1)} A {rr} {rr} 0 0 1 {pt(2)} L {pt(3)} "
+        f"A {rr} {rr} 0 0 1 {pt(4)} L {pt(5)} A {rr} {rr} 0 0 1 {pt(6)} "
+        f"L {pt(7)} A {rr} {rr} 0 0 1 {pt(0)} Z"
+    )
+    return f'<path d="{d}"'
+
+
+def _slot_box_svg(box: Any, paint_attrs: Optional[str] = None) -> str:
+    """One chrome box as SVG shapes — the writer half of `_chromebox`.
+
+    Shadow first, then the background/border shape; every attribute exactly
     once (the duplicate-attribute XML trap: parsers keep the first value
     silently), always an explicit `fill` (a rect inside the labels group
     would inherit the text paint otherwise), radius as symmetric `rx` only
-    (PDF rejects `ry`). Emits nothing for a box that paints nothing, so the
-    unstyled document stays byte-identical.
+    (PDF rejects `ry`). A posed box (`angle != 0`) lowers to pre-rotated
+    geometry via `_rotated_box_shape`. Emits nothing for a box that paints
+    nothing — including any zero-area box, which casts no shadow either —
+    so the unstyled document stays byte-identical.
+
+    `paint_attrs` is the optional interned tail from `_slot_box_paint_attrs`
+    for dense per-instance loops; it must have been built from a box sharing
+    this box's declaration.
     """
+    if box.w <= 0.0 or box.h <= 0.0:
+        return ""
     if not box.paints_anything and box.shadow is None:
         return ""
     parts: list[str] = []
@@ -1834,26 +1944,35 @@ def _slot_box_svg(box: Any) -> str:
     radius_attr = f' rx="{_num(box.radius)}"' if box.radius > 0 else ""
     if box.shadow is not None:
         dx, dy, color = box.shadow
+        shadow_attrs = f' fill="{_escape_attr(color)}"{common_opacity}'
+        if box.angle:
+            parts.append(
+                _rotated_box_shape(
+                    box.x + dx, box.y + dy, box.w, box.h, box.radius, box.angle, box.cx, box.cy
+                )
+                + shadow_attrs
+                + "/>"
+            )
+        else:
+            parts.append(
+                f'<rect x="{_num(box.x + dx)}" y="{_num(box.y + dy)}" '
+                f'width="{_num(box.w)}" height="{_num(box.h)}"{radius_attr}'
+                f"{shadow_attrs}/>"
+            )
+    if paint_attrs is None:
+        paint_attrs = _slot_box_paint_attrs(box)
+    if box.angle:
         parts.append(
-            f'<rect x="{_num(box.x + dx)}" y="{_num(box.y + dy)}" '
-            f'width="{_num(box.w)}" height="{_num(box.h)}"{radius_attr} '
-            f'fill="{_escape_attr(color)}"{common_opacity}/>'
+            _rotated_box_shape(box.x, box.y, box.w, box.h, box.radius, box.angle, box.cx, box.cy)
+            + paint_attrs
+            + "/>"
         )
-    fill = _escape_attr(box.fill) if box.fill is not None else "none"
-    stroke = ""
-    if box.border_color is not None and box.border_width > 0:
-        stroke = (
-            f' stroke="{_escape_attr(box.border_color)}" stroke-width="{_num(box.border_width)}"'
+    else:
+        parts.append(
+            f'<rect x="{_num(box.x)}" y="{_num(box.y)}" '
+            f'width="{_num(box.w)}" height="{_num(box.h)}"{radius_attr}'
+            f"{paint_attrs}/>"
         )
-        if box.border_dash:
-            dashes = " ".join(_num(v) for v in box.border_dash)
-            stroke += f' stroke-dasharray="{dashes}"'
-    fill_opacity = f' fill-opacity="{_num(box.fill_opacity)}"' if box.fill_opacity < 1.0 else ""
-    parts.append(
-        f'<rect x="{_num(box.x)}" y="{_num(box.y)}" '
-        f'width="{_num(box.w)}" height="{_num(box.h)}"{radius_attr} '
-        f'fill="{fill}"{fill_opacity}{stroke}{common_opacity}/>'
-    )
     return "".join(parts)
 
 
@@ -2252,25 +2371,53 @@ def _y_title_baseline(
         angle = float(axis.get("label_angle", 90.0))
         shift = (ascent - descent) / 2 if abs(abs(angle) - 90.0) < 0.5 else 0.0
         return plot["x"] + plot["w"] + 40.0 - shift + float(axis.get("label_offset", 0.0))
-    tick_offset, tick_room = (
-        _y_tick_label_room(axis, plot["h"])
-        if "left" in _axis_tick_label_sides(axis, is_x=False)
-        else (0.0, 0.0)
+    # Declared tick_label/axis_title boxes widen this gutter; `layout()`
+    # stashes their outward extents on the plot record so emission-time
+    # callers agree with the reservation it made (zero/absent when unstyled —
+    # the historical arithmetic runs untouched).
+    tick_box = (
+        plot.get("tick_label_box_t", 0.0),
+        plot.get("tick_label_box_r", 0.0),
+        plot.get("tick_label_box_b", 0.0),
+        plot.get("tick_label_box_l", 0.0),
     )
+    if "left" in _axis_tick_label_sides(axis, is_x=False):
+        tick_offset, tick_room = (
+            _y_tick_label_room(axis, plot["h"], tick_box)
+            if any(tick_box)
+            else _y_tick_label_room(axis, plot["h"])
+        )
+    else:
+        tick_offset, tick_room = 0.0, 0.0
     gap = float(axis.get("label_offset", _Y_TITLE_TICK_GAP * font_size))
     # For a -90 degree title, later lines move toward the plot. Pin the first
     # baseline so the whole block, not only line one, remains outside ticks.
     title_depth = descent + (block.line_count - 1) * block.line_step
-    return plot["x"] - tick_offset - tick_room - gap - title_depth
+    # A -90-degree title's plot-side box edge is its local bottom (descent
+    # side); shift the baseline outward by that extent so the box clears the
+    # tick labels.
+    return (
+        plot["x"] - tick_offset - tick_room - gap - title_depth - plot.get("axis_title_box_b", 0.0)
+    )
 
 
-def _y_tick_label_room(axis: dict[str, Any], plot_h: float) -> tuple[float, float]:
+def _y_tick_label_room(
+    axis: dict[str, Any],
+    plot_h: float,
+    box_out: tuple[float, float, float, float] = (0.0, 0.0, 0.0, 0.0),
+) -> tuple[float, float]:
     """(offset from the spine, widest tick-label extent) for a y axis, in px.
 
     Measured from the advance widths of the strings that will actually be drawn,
     using the same DejaVu metrics the Rust rasterizer blits (`src/font.rs`) —
     which is also Matplotlib's default face, so an advance measured here is the
     advance Matplotlib lays out.
+
+    `box_out` is the tick_label slot's outward box growth (`_chromebox
+    .box_room`): a declared padding/border extends the drawn box past the
+    glyphs on the gutter side, and the reservation must cover it or the box
+    clips at the canvas edge. Zero — the default, and the only value the
+    unstyled path ever passes — reproduces the historical rooms exactly.
     """
     if _axis_tick_label_strategy(axis) in {"none", "off"} or not _axis_text_paint_visible(
         axis, "tick_label_color", "tick_color"
@@ -2286,6 +2433,10 @@ def _y_tick_label_room(axis: dict[str, Any], plot_h: float) -> tuple[float, floa
         # A rotated block trades its measured width for its full line-box
         # height about the pinned edge.
         room = max(room, _textblock.rotated_extent(block, angle)[0])
+    if room > 0.0:
+        # The gutter-side box extent: right-side axes grow by the box's
+        # right edge, everything else by its left.
+        room += box_out[1] if axis.get("side") == "right" else box_out[3]
     # Match the SVG y-label placement below.  A y label's anchored edge is
     # already the glyph-side edge, so unlike an x-label baseline it needs no
     # extra font-room term.
@@ -2308,6 +2459,12 @@ def _y_axis_left_room(spec: dict[str, Any], plot_h: float) -> float:
     `spec/api/styling.md`, not silently fixed here.
     """
     room = 0.0
+    # Declared tick_label/axis_title boxes widen the gutter; both extents are
+    # zero on the unstyled path, which then runs the historical arithmetic
+    # (and the historical two-argument `_y_tick_label_room` call) untouched.
+    slots = slot_styles(spec)
+    tick_box = box_room(slots.get("tick_label"))
+    title_box = box_room(slots.get("axis_title"))
     for axis_id, axis in _axes_by_id(spec).items():
         if not axis_id.startswith("y"):
             continue
@@ -2315,7 +2472,14 @@ def _y_axis_left_room(spec: dict[str, Any], plot_h: float) -> float:
         left_title = axis.get("side", "left") != "right"
         if not left_labels and not left_title:
             continue
-        tick_offset, tick_room = _y_tick_label_room(axis, plot_h) if left_labels else (0.0, 0.0)
+        if left_labels:
+            tick_offset, tick_room = (
+                _y_tick_label_room(axis, plot_h, tick_box)
+                if any(tick_box)
+                else _y_tick_label_room(axis, plot_h)
+            )
+        else:
+            tick_offset, tick_room = 0.0, 0.0
         title_visible = (
             left_title
             and _has_outside_y_title(axis)
@@ -2335,6 +2499,10 @@ def _y_axis_left_room(spec: dict[str, Any], plot_h: float) -> float:
             + block.ascent
             + block.descent
             + (block.line_count - 1) * block.line_step
+            # A quarter-turned title box spends its local top/bottom extents
+            # horizontally: both sides of the rotated box live in this gutter.
+            + title_box[0]
+            + title_box[2]
             + gap
             + tick_offset
             + tick_room,
@@ -2342,13 +2510,20 @@ def _y_axis_left_room(spec: dict[str, Any], plot_h: float) -> float:
     return room
 
 
-def _x_axis_title_room(axis: dict[str, Any]) -> float:
+def _x_axis_title_room(
+    axis: dict[str, Any],
+    box_out: tuple[float, float, float, float] = (0.0, 0.0, 0.0, 0.0),
+) -> float:
     """Outward room needed by an outside x-axis title.
 
     ``_axis_label_geometry()`` positions x titles from their line-box top and
     converts that top to a static-text baseline.  Measure the corresponding
     outer glyph edge here so tight/constrained layout does not stop at the
     historical 36/42 px band while the title itself extends past the canvas.
+
+    `box_out` is the axis_title slot's outward box growth; the outward side
+    (top pad for a top axis, bottom pad otherwise) joins the reservation so
+    a padded title box stays on the canvas. Zero when unstyled.
     """
     if not axis.get("label") or not _axis_text_paint_visible(axis, "label_color"):
         return 0.0
@@ -2363,7 +2538,7 @@ def _x_axis_title_room(axis: dict[str, Any]) -> float:
     if axis.get("side", "bottom") == "top":
         # outside_top = plot-top - 34; the baseline conversion then moves
         # 0.82em back toward the plot.
-        return _AXIS_TEXT_EDGE_PAD + 34.0 + offset - font_size * 0.82 + block.ascent
+        return _AXIS_TEXT_EDGE_PAD + 34.0 + offset - font_size * 0.82 + block.ascent + box_out[0]
     # outside_bottom = plot-bottom + 24; later lines move farther outward.
     return (
         _AXIS_TEXT_EDGE_PAD
@@ -2372,10 +2547,16 @@ def _x_axis_title_room(axis: dict[str, Any]) -> float:
         + font_size * 0.82
         + (block.line_count - 1) * block.line_step
         + block.descent
+        + box_out[2]
     )
 
 
-def _x_tick_label_room(axis: dict[str, Any], plot_w: float) -> float:
+def _x_tick_label_room(
+    axis: dict[str, Any],
+    plot_w: float,
+    tick_box: tuple[float, float, float, float] = (0.0, 0.0, 0.0, 0.0),
+    title_box: tuple[float, float, float, float] = (0.0, 0.0, 0.0, 0.0),
+) -> float:
     """Outward room needed by the x axis's final tick-label set and title.
 
     The old 32/42 px bands only fit horizontal labels. Measure the strings and
@@ -2383,15 +2564,23 @@ def _x_tick_label_room(axis: dict[str, Any], plot_w: float) -> float:
     is deliberately evaluated *after* collision policy, so ``auto`` reserves
     only labels it will draw while pyplot's ``preserve`` reserves all fixed
     locations. The same value is used by SVG and native PNG layout.
+
+    `tick_box`/`title_box` are the tick_label/axis_title slots' outward box
+    growth: a declared padding/border must join the reservation, which also
+    means a declared tick box takes the measuring path where unstyled auto
+    ticks keep their historical flat band. Both default to zero and the
+    unstyled arithmetic is untouched.
     """
     strategy = _axis_tick_label_strategy(axis)
     if strategy == "none":
         return 0.0
-    title_room = _x_axis_title_room(axis)
+    title_room = _x_axis_title_room(axis, title_box)
     if strategy == "off" or not _axis_text_paint_visible(axis, "tick_label_color", "tick_color"):
         return title_room
+    boxed = any(tick_box)
     if (
-        strategy == "auto"
+        not boxed
+        and strategy == "auto"
         and axis.get("tick_label_angle") is None
         and axis.get("tick_values") is None
         and axis.get("kind") != "category"
@@ -2411,7 +2600,8 @@ def _x_tick_label_room(axis: dict[str, Any], plot_w: float) -> float:
     font_size = _axis_tick_font_size(axis)
     has_multiline_ticks = any(len(_textblock.split_lines(item["text"])) > 1 for item in items)
     if (
-        not has_adaptive_layout
+        not boxed
+        and not has_adaptive_layout
         and not has_multiline_ticks
         and strategy == "auto"
         and axis.get("tick_label_angle") is None
@@ -2431,17 +2621,26 @@ def _x_tick_label_room(axis: dict[str, Any], plot_w: float) -> float:
         else _axis_tick_label_offset(axis, 16.0, 0.8)
     )
     rows = max(int(item.get("row", 0)) for item in items)
-    tick_room = _AXIS_TEXT_EDGE_PAD + label_offset + rows * (font_size + 4.0) + extent
+    # The outward side of a declared label box: top pad above a top axis,
+    # bottom pad below a bottom one.
+    box_extent = tick_box[0] if side == "top" else tick_box[2]
+    tick_room = _AXIS_TEXT_EDGE_PAD + label_offset + rows * (font_size + 4.0) + extent + box_extent
     return max(title_room, tick_room)
 
 
-def _x_tick_label_edge_rooms(axes: dict[str, dict[str, Any]], plot_w: float) -> tuple[float, float]:
+def _x_tick_label_edge_rooms(
+    axes: dict[str, dict[str, Any]],
+    plot_w: float,
+    tick_box: tuple[float, float, float, float] = (0.0, 0.0, 0.0, 0.0),
+) -> tuple[float, float]:
     """Canvas-edge room needed by x tick labels that overhang the plot.
 
     A terminal tick label is centered on the end of the spine by default, so
     half its ink lives outside the plot rectangle. Matplotlib includes every
     visible tick-label bbox in ``Axes.get_tightbbox``; mirror that horizontal
     union here instead of relying on the compact layout's flat right gutter.
+    A declared tick_label box widens each label by its left/right extents
+    (`tick_box`; zero when unstyled).
     """
     left = right = 0.0
     for axis_id, axis in axes.items():
@@ -2497,22 +2696,28 @@ def _x_tick_label_edge_rooms(axes: dict[str, dict[str, Any]], plot_w: float) ->
                 cosine, sine = math.cos(radians), math.sin(radians)
                 rotated_x = [x * cosine - y * sine for x in (x0, x1) for y in (y0, y1)]
                 position = float(item["pos"])
-                left = max(left, _AXIS_TEXT_EDGE_PAD - position - min(rotated_x))
+                left = max(left, _AXIS_TEXT_EDGE_PAD - position - min(rotated_x) + tick_box[3])
                 right = max(
                     right,
-                    _AXIS_TEXT_EDGE_PAD + position + max(rotated_x) - plot_w,
+                    _AXIS_TEXT_EDGE_PAD + position + max(rotated_x) - plot_w + tick_box[1],
                 )
     return float(math.ceil(max(0.0, left))), float(math.ceil(max(0.0, right)))
 
 
 def _x_axis_rooms(
-    axes: dict[str, dict[str, Any]], plot_w: float, compact: bool
+    axes: dict[str, dict[str, Any]],
+    plot_w: float,
+    compact: bool,
+    tick_box: tuple[float, float, float, float] = (0.0, 0.0, 0.0, 0.0),
+    title_box: tuple[float, float, float, float] = (0.0, 0.0, 0.0, 0.0),
 ) -> tuple[float, float, float]:
     """Shared ``(top, bottom, measured_bottom)`` x-axis bands.
 
     The fixed bottom band is metadata for colorbar placement.  It must not
     override an explicit figure ``padding`` authored by pyplot unless rotated
-    or staggered labels actually require more room.
+    or staggered labels actually require more room. `tick_box`/`title_box`
+    carry the declared slot-box extents through to `_x_tick_label_room`
+    (zero when unstyled).
     """
     top = 0.0
     bottom = 0.0
@@ -2528,7 +2733,7 @@ def _x_axis_rooms(
             side_axis = {**axis, "side": side}
             if side != title_side:
                 side_axis.pop("label", None)
-            measured = _x_tick_label_room(side_axis, plot_w)
+            measured = _x_tick_label_room(side_axis, plot_w, tick_box, title_box)
             if side == "top":
                 top = max(top, 26.0 if compact else 32.0, measured)
             else:
@@ -2630,6 +2835,13 @@ def layout(spec: dict[str, Any]) -> tuple[int, int, bool, dict[str, float]]:
         top = 6 if compact else 10
         bottom = 36 if compact else 42
     axes = _axes_by_id(spec)
+    # Declared tick_label/axis_title boxes grow the reservations below; both
+    # extents are zero for the (overwhelmingly common) unstyled chart, whose
+    # rooms then come out of the historical arithmetic byte-identically.
+    chrome_slots = slot_styles(spec)
+    tick_box = box_room(chrome_slots.get("tick_label"))
+    title_box = box_room(chrome_slots.get("axis_title"))
+    slot_boxed = any(tick_box) or any(title_box)
     # The first pass uses the authored/default horizontal allocation. A second
     # pass after the measured left gutter catches an auto-collision decision
     # whose final plot width changes the chosen label set.
@@ -2638,8 +2850,10 @@ def layout(spec: dict[str, Any]) -> tuple[int, int, bool, dict[str, float]]:
     # how many lines the title wraps into at this width.
     title_wrap_width = _title_wrap_width(width, left, right)
     title_room = _title_room(spec, compact, title_wrap_width)
-    top_axis_room, bottom_axis_room, measured_bottom_room = _x_axis_rooms(
-        axes, provisional_w, compact
+    top_axis_room, bottom_axis_room, measured_bottom_room = (
+        _x_axis_rooms(axes, provisional_w, compact, tick_box, title_box)
+        if slot_boxed
+        else _x_axis_rooms(axes, provisional_w, compact)
     )
     top += title_room
     top += top_axis_room
@@ -2682,6 +2896,7 @@ def layout(spec: dict[str, Any]) -> tuple[int, int, bool, dict[str, float]]:
         edge_left, edge_right = _x_tick_label_edge_rooms(
             axes,
             max(40.0, width - left - right),
+            tick_box,
         )
         widened_left = max(left, edge_left)
         widened_right = max(right, edge_right)
@@ -2694,7 +2909,11 @@ def layout(spec: dict[str, Any]) -> tuple[int, int, bool, dict[str, float]]:
         measured_bottom = bottom_axis_room
         final_measured_bottom = measured_bottom_room
     else:
-        measured_top, measured_bottom, final_measured_bottom = _x_axis_rooms(axes, final_w, compact)
+        measured_top, measured_bottom, final_measured_bottom = (
+            _x_axis_rooms(axes, final_w, compact, tick_box, title_box)
+            if slot_boxed
+            else _x_axis_rooms(axes, final_w, compact)
+        )
     if measured_top > top_axis_room:
         top += measured_top - top_axis_room
         top_axis_room = measured_top
@@ -2716,6 +2935,16 @@ def layout(spec: dict[str, Any]) -> tuple[int, int, bool, dict[str, float]]:
         "top_axis_room": top_axis_room,
         "bottom_axis_room": bottom_axis_room,
     }
+    if slot_boxed:
+        # Emission-time callers (`_y_title_baseline` via
+        # `_axis_label_geometry`) read the extents layout reserved with, so
+        # placement and reservation cannot disagree. Scalar entries keep the
+        # plot record's float value type; absent when unstyled.
+        plot["tick_label_box_t"] = tick_box[0]
+        plot["tick_label_box_r"] = tick_box[1]
+        plot["tick_label_box_b"] = tick_box[2]
+        plot["tick_label_box_l"] = tick_box[3]
+        plot["axis_title_box_b"] = title_box[2]
     if spec.get("coords") == "polar":
         _recut_polar_plot(spec, plot, width, height, compact)
     return width, height, compact, plot
@@ -3134,6 +3363,27 @@ def _axis_tick_label_sides(axis: dict[str, Any], *, is_x: bool) -> list[str]:
     return [side for side in allowed if side in authored]
 
 
+def tick_span(style: dict[str, Any]) -> tuple[float, float, float]:
+    """`(inward, outward, width)` of an axis's tick marks, in px.
+
+    The one reading of `tick_length`/`tick_direction`/`tick_width` shared by
+    the SVG writer, the raster writer, and the axis-chrome box producer —
+    formerly a literal near-duplicate closure in each writer (the 2-tuple
+    raster copy re-read `tick_width` at every call site). `tick_length`
+    defaults to 0: an axis that authors no tick geometry has no marks, and
+    the box producer deliberately does not invent a length for a styled
+    `tick_mark` slot (the preflight says so instead).
+    """
+    length = max(0.0, float(style.get("tick_length", 0)))
+    direction = str(style.get("tick_direction", "out"))
+    width = float(style.get("tick_width", 1))
+    if direction == "in":
+        return length, 0.0, width
+    if direction == "inout":
+        return length / 2, length / 2, width
+    return 0.0, length, width
+
+
 def _axis_tick_label_offset(axis: dict[str, Any], unstyled: float, font_room: float = 0.0) -> float:
     """Distance from the axis spine to a tick label's anchor point, in px.
 
@@ -3865,6 +4115,12 @@ def _polar_tick_labels(
     """Emit polar tick labels as SVG text, from the shared placement."""
     slot = slots.get("tick_label") or {}
     attrs = slot_text_attrs(slot)
+    # Same box hook as the cartesian labels; polar keeps its flat 30 px label
+    # ring (`_POLAR_LABEL_ROOM`), so a padded box spends that allowance
+    # rather than growing it — recorded in the capability note.
+    box_tmpl = box_template("tick_label", slot) if _has_box_declaration(slot) else None
+    box_pads = padding_sides(slot)
+    box_attrs = _slot_box_paint_attrs(box_tmpl) if box_tmpl is not None else ""
 
     def tick_color(axis: dict[str, Any]) -> str:
         """Axis tick_label_color/tick_color first, chart slot second.
@@ -3899,6 +4155,21 @@ def tick_color(axis: dict[str, Any]) -> str:
                 if item.spin
                 else ""
             )
+            if box_tmpl is not None:
+                labels.append(
+                    _slot_box_svg(
+                        _chrome_text_box(
+                            box_tmpl,
+                            box_pads,
+                            x=item.x,
+                            y=item.y,
+                            anchor=item.anchor,
+                            block=_textblock.measure(item.text, item.size),
+                            angle=item.spin,
+                        ),
+                        box_attrs,
+                    )
+                )
             labels.append(
                 f'<text data-xy-tick="{kind}" x="{_num(item.x)}" y="{_num(item.y)}" '
                 f'fill="{color}" font-size="{_num(item.size)}" '
@@ -3906,6 +4177,317 @@ def tick_color(axis: dict[str, Any]) -> str:
             )
 
 
+#: Re-entrancy guard for `axis_chrome_boxes` (see its docstring).
+_AXIS_BOX_GUARD = threading.local()
+
+
+def axis_chrome_boxes(
+    spec: dict[str, Any], slots: Optional[dict[str, dict[str, Any]]] = None
+) -> "list[ChromeBox]":
+    """Per-instance `ChromeBox`es for the axis-chrome box slots.
+
+    One producer, three consumers — the SVG writer, the raster writer, and
+    the declared snapshot (`styling/declared.py`, which fills
+    `SlotInstance.qualifiers`/`geometry` from these records) — so a styled
+    spine or tick cannot mean different geometry in different outputs.
+    Returns `[]` unless `axis_line`/`tick_mark` declare box properties; the
+    writers keep their historical stroke loops for anything unstyled (the
+    unstyled-bytes gate). The declaration is lowered once per slot and
+    stamped per instance (`box_template`/`box_at` — the interning rule).
+
+    Geometry decisions, each deliberate and pinned by golden tests:
+
+    - Spines center on the plot edge exactly where the unstyled stroke ran.
+      The browser insets right/bottom spines by their own width
+      (`50_chartview.ts` `rule()` call sites); matching it unstyled would
+      break the byte pin, so the writers keep the centered geometry and the
+      divergence is recorded in `KNOWN_RENDERER_DIVERGENCES`.
+    - A tick box is the centered stroke's own coverage (`x - width/2`, span
+      `inward + outward`) — the same pixels the browser's rect occupies.
+    - `tick_length` defaults to 0 and no length is invented for a styled
+      slot: a zero-area box draws nothing (and casts no shadow); the
+      preflight carries the note.
+    - Polar charts return nothing: spines and ticks keep stroke semantics
+      there, and the browser shares the limit ("spines are
+      background-coloured DIVs and cannot express a circle").
+    - The slot's `background` replaces the axis ink when declared (an
+      explicit `transparent` erases it, as in the browser); otherwise the
+      box keeps the axis's own `axis_color`/`tick_color` — the narrower
+      selector still wins the paint.
+    """
+    if getattr(_AXIS_BOX_GUARD, "active", False):
+        # Re-entrant resolution: this producer's own `layout()` call resolves
+        # declarations (title metrics), whose snapshot enrichment would call
+        # back in. The nested result is discarded, so produce nothing.
+        return []
+    if slots is None:
+        slots = slot_styles(spec)
+    line_slot = slots.get("axis_line") or {}
+    tick_slot = slots.get("tick_mark") or {}
+    line_boxed = _has_box_declaration(line_slot)
+    tick_boxed = _has_box_declaration(tick_slot)
+    if not line_boxed and not tick_boxed:
+        return []
+    if spec.get("coords") == "polar":
+        return []
+    _AXIS_BOX_GUARD.active = True
+    try:
+        return _axis_chrome_boxes_body(spec, slots, line_slot, tick_slot, line_boxed, tick_boxed)
+    finally:
+        _AXIS_BOX_GUARD.active = False
+
+
+def _axis_chrome_boxes_body(
+    spec: dict[str, Any],
+    slots: dict[str, dict[str, Any]],
+    line_slot: dict[str, Any],
+    tick_slot: dict[str, Any],
+    line_boxed: bool,
+    tick_boxed: bool,
+) -> "list[ChromeBox]":
+    _width, _height, _compact, plot = layout(spec)
+    xa, ya = spec["x_axis"], spec["y_axis"]
+    _x_scales, _y_scales, sx, sy, extra_x_axes, extra_y_axes = _axis_scales(spec, plot)
+    dom_style = (spec.get("dom") or {}).get("style") or {}
+    default_axis = _css(dom_style.get("--chart-axis"), _AXIS)
+    xstyle, ystyle = xa.get("style") or {}, ya.get("style") or {}
+    xmstyle, ymstyle = xa.get("minor_style") or {}, ya.get("minor_style") or {}
+    hide_x = xa.get("tick_label_strategy") == "none"
+    hide_y = ya.get("tick_label_strategy") == "none"
+    frame_sides = spec.get("frame_sides")
+    explicit_frame_sides = frame_sides is not None
+    if frame_sides is None:
+        frame_sides = [xa.get("side", "bottom"), ya.get("side", "left")]
+    boxes: list[ChromeBox] = []
+
+    if line_boxed:
+        line_template = box_template("axis_line", line_slot)
+
+        def spine(axis_id: str, side: str, x: float, y: float, w: float, h: float, paint: str):
+            if w <= 0.0 or h <= 0.0:
+                return  # a zero-width spine draws nothing; record no instance
+            boxes.append(
+                box_at(
+                    line_template,
+                    x,
+                    y,
+                    w,
+                    h,
+                    qualifiers=(axis_id, side),
+                    fallback_fill=paint,
+                )
+            )
+
+        if not hide_y or explicit_frame_sides:
+            width_ = float(ystyle.get("axis_width", 1))
+            paint = _css(ystyle.get("axis_color"), default_axis)
+            for side, x in (("left", plot["x"]), ("right", plot["x"] + plot["w"])):
+                if side in frame_sides:
+                    spine("y", side, x - width_ / 2.0, plot["y"], width_, plot["h"], paint)
+        if not hide_x or explicit_frame_sides:
+            width_ = float(xstyle.get("axis_width", 1))
+            paint = _css(xstyle.get("axis_color"), default_axis)
+            for side, y in (("top", plot["y"]), ("bottom", plot["y"] + plot["h"])):
+                if side in frame_sides:
+                    spine("x", side, plot["x"], y - width_ / 2.0, plot["w"], width_, paint)
+        for axis_id, axis, _axis_scale in extra_x_axes:
+            if _axis_tick_label_strategy(axis) == "none":
+                continue
+            axis_style = axis.get("style") or {}
+            width_ = float(axis_style.get("axis_width", 1))
+            side = axis.get("side", "bottom")
+            edge = plot["y"] if side == "top" else plot["y"] + plot["h"]
+            spine(
+                axis_id,
+                side,
+                plot["x"],
+                edge - width_ / 2.0,
+                plot["w"],
+                width_,
+                _css(axis_style.get("axis_color"), default_axis),
+            )
+        for axis_id, axis, _axis_scale in extra_y_axes:
+            if _axis_tick_label_strategy(axis) == "none":
+                continue
+            axis_style = axis.get("style") or {}
+            width_ = float(axis_style.get("axis_width", 1))
+            side = axis.get("side", "right")
+            edge = plot["x"] + plot["w"] if side == "right" else plot["x"]
+            spine(
+                axis_id,
+                side,
+                edge - width_ / 2.0,
+                plot["y"],
+                width_,
+                plot["h"],
+                _css(axis_style.get("axis_color"), default_axis),
+            )
+
+    if tick_boxed:
+        tick_template = box_template("tick_mark", tick_slot)
+        xt = axis_ticks(xa, plot["w"], True)[0]
+        yt = axis_ticks(ya, plot["h"], False)[0]
+        xmt, ymt = minor_axis_ticks(xa), minor_axis_ticks(ya)
+
+        def tick(
+            axis_id: str,
+            kind: str,
+            side: str,
+            index: int,
+            x: float,
+            y: float,
+            w: float,
+            h: float,
+            paint: str,
+        ):
+            if w <= 0.0 or h <= 0.0:
+                # tick_length 0 (the default): the mark does not exist, so no
+                # box, no shadow, and no snapshot instance — the preflight
+                # carries the note instead of a length being invented.
+                return
+            boxes.append(
+                box_at(
+                    tick_template,
+                    x,
+                    y,
+                    w,
+                    h,
+                    qualifiers=(axis_id, kind, side, str(index)),
+                    fallback_fill=paint,
+                )
+            )
+
+        if not hide_x:
+            inward, outward, tick_width = tick_span(xmstyle)
+            side = xa.get("side", "bottom")
+            edge = plot["y"] if side == "top" else plot["y"] + plot["h"]
+            paint = _css(xmstyle.get("tick_color"), default_axis)
+            for index, value in enumerate(xmt):
+                x = float(sx(value))
+                y1, y2 = (
+                    (edge - outward, edge + inward)
+                    if side == "top"
+                    else (edge - inward, edge + outward)
+                )
+                tick(
+                    "x", "minor", side, index, x - tick_width / 2.0, y1, tick_width, y2 - y1, paint
+                )
+            inward, outward, tick_width = tick_span(xstyle)
+            paint = _css(xstyle.get("tick_color"), default_axis)
+            for side in _axis_tick_sides(xa, is_x=True):
+                edge = plot["y"] if side == "top" else plot["y"] + plot["h"]
+                for index, value in enumerate(xt):
+                    x = float(sx(value))
+                    y1, y2 = (
+                        (edge - outward, edge + inward)
+                        if side == "top"
+                        else (edge - inward, edge + outward)
+                    )
+                    tick(
+                        "x",
+                        "major",
+                        side,
+                        index,
+                        x - tick_width / 2.0,
+                        y1,
+                        tick_width,
+                        y2 - y1,
+                        paint,
+                    )
+        if not hide_y:
+            inward, outward, tick_width = tick_span(ymstyle)
+            side = ya.get("side", "left")
+            edge = plot["x"] + plot["w"] if side == "right" else plot["x"]
+            paint = _css(ymstyle.get("tick_color"), default_axis)
+            for index, value in enumerate(ymt):
+                y = float(sy(value))
+                x1, x2 = (
+                    (edge - inward, edge + outward)
+                    if side == "right"
+                    else (edge - outward, edge + inward)
+                )
+                tick(
+                    "y", "minor", side, index, x1, y - tick_width / 2.0, x2 - x1, tick_width, paint
+                )
+            inward, outward, tick_width = tick_span(ystyle)
+            paint = _css(ystyle.get("tick_color"), default_axis)
+            for side in _axis_tick_sides(ya, is_x=False):
+                edge = plot["x"] + plot["w"] if side == "right" else plot["x"]
+                for index, value in enumerate(yt):
+                    y = float(sy(value))
+                    x1, x2 = (
+                        (edge - inward, edge + outward)
+                        if side == "right"
+                        else (edge - outward, edge + inward)
+                    )
+                    tick(
+                        "y",
+                        "major",
+                        side,
+                        index,
+                        x1,
+                        y - tick_width / 2.0,
+                        x2 - x1,
+                        tick_width,
+                        paint,
+                    )
+        for axis_id, axis, axis_scale in extra_x_axes:
+            if _axis_tick_label_strategy(axis) == "none":
+                continue
+            axis_style = axis.get("style") or {}
+            inward, outward, tick_width = tick_span(axis_style)
+            paint = _css(axis_style.get("tick_color"), default_axis)
+            values = axis_ticks(axis, plot["w"], True)[0]
+            for side in _axis_tick_sides(axis, is_x=True):
+                edge = plot["y"] if side == "top" else plot["y"] + plot["h"]
+                for index, value in enumerate(values):
+                    x = float(axis_scale(value))
+                    y1, y2 = (
+                        (edge - outward, edge + inward)
+                        if side == "top"
+                        else (edge - inward, edge + outward)
+                    )
+                    tick(
+                        axis_id,
+                        "major",
+                        side,
+                        index,
+                        x - tick_width / 2.0,
+                        y1,
+                        tick_width,
+                        y2 - y1,
+                        paint,
+                    )
+        for axis_id, axis, axis_scale in extra_y_axes:
+            if _axis_tick_label_strategy(axis) == "none":
+                continue
+            axis_style = axis.get("style") or {}
+            inward, outward, tick_width = tick_span(axis_style)
+            paint = _css(axis_style.get("tick_color"), default_axis)
+            values = axis_ticks(axis, plot["h"], False)[0]
+            for side in _axis_tick_sides(axis, is_x=False):
+                edge = plot["x"] + plot["w"] if side == "right" else plot["x"]
+                for index, value in enumerate(values):
+                    y = float(axis_scale(value))
+                    x1, x2 = (
+                        (edge - inward, edge + outward)
+                        if side == "right"
+                        else (edge - outward, edge + inward)
+                    )
+                    tick(
+                        axis_id,
+                        "major",
+                        side,
+                        index,
+                        x1,
+                        y - tick_width / 2.0,
+                        x2 - x1,
+                        tick_width,
+                        paint,
+                    )
+    return boxes
+
+
 def render_svg(spec: dict[str, Any], blob: bytes, *, id_prefix: str = "") -> str:
     spec = _decode_title_geometry(spec, blob)
     spec = _resolve_static_css_vars(spec)
@@ -4043,6 +4625,13 @@ def append_tick_labels(
         )
         font_size = slot_font_size(slot, _axis_tick_font_size(axis))
         slot_attrs = slot_text_attrs(slot)
+        # The slot's box, lowered once and stamped per label (interned attrs:
+        # one declaration string, N instances). Emitted immediately before
+        # each <text> inside the labels group — the emitter always writes an
+        # explicit fill, or the rect would inherit the group's text paint.
+        box_tmpl = box_template("tick_label", slot) if _has_box_declaration(slot) else None
+        box_pads = padding_sides(slot)
+        box_attrs = _slot_box_paint_attrs(box_tmpl) if box_tmpl is not None else ""
         baseline_shift = _axis_tick_label_baseline_shift(axis)
         # An explicit tick_label_anchor (axis spec or style) overrides the
         # angle/side-derived default. Anchored labels rotate about the tick
@@ -4097,6 +4686,21 @@ def append_tick_labels(
                 transform = (
                     f' transform="rotate({_num(angle)} {_num(x)} {_num(y)})"' if angle else ""
                 )
+                if box_tmpl is not None:
+                    labels.append(
+                        _slot_box_svg(
+                            _chrome_text_box(
+                                box_tmpl,
+                                box_pads,
+                                x=x,
+                                y=y,
+                                anchor=anchor,
+                                block=block,
+                                angle=angle,
+                            ),
+                            box_attrs,
+                        )
+                    )
                 labels.append(
                     f'<text x="{_num(x)}" y="{_num(y)}" fill="{color}" '
                     f'font-size="{_num(font_size)}" text-anchor="{anchor}"'
@@ -4320,21 +4924,43 @@ def append_axis_title(axis: dict[str, Any], *, is_x: bool) -> None:
         x, y = float(geometry["x"]), float(geometry["y"])
         angle = float(geometry["angle"])
         transform = f' transform="rotate({_num(angle)} {_num(x)} {_num(y)})"' if angle else ""
-        # The axis's own label_* keys are the narrower selector, so they win
-        # over the chart-wide slot; the slot supplies whatever they leave unset.
-        family = axis_style.get("label_font_family")
-        font_style = axis_style.get("label_font_style")
-        weight = axis_style.get("label_font_weight", 400)
+        # Per-property merge: the axis's own label_* keys are the narrower
+        # selector and win; the chart-wide slot supplies whatever they leave
+        # unset. The pre-parity branch dropped the slot's letter-spacing and
+        # opacity wholesale the moment the axis authored a family or style.
+        # letter-spacing/opacity have no axis spelling, so the slot always
+        # carries them. Documented exception (spec/api/styling.md): font-size
+        # runs the other way — the slot's font-size wins over label_size.
         paint = _css(axis_style.get("label_color"), "") or slot_text_color(slot, default_text)
-        font_attrs = (f' font-family="{_escape_attr(family)}"' if family is not None else "") + (
-            f' font-style="{_escape_attr(font_style)}"' if font_style is not None else ""
-        )
-        if not font_attrs:
-            font_attrs = slot_text_attrs(slot, font_weight=weight)
-        else:
-            font_attrs = f' font-weight="{_escape_attr(weight)}"' + font_attrs
+        merged = dict(slot)
+        for axis_key, prop in (
+            ("label_font_family", "font-family"),
+            ("label_font_style", "font-style"),
+            ("label_font_weight", "font-weight"),
+        ):
+            if axis_style.get(axis_key) is not None:
+                merged[prop] = axis_style[axis_key]
+        font_attrs = slot_text_attrs(merged, font_weight=400)
         font_size = slot_font_size(slot, float(geometry["font_size"]))
         block = _textblock.measure(axis["label"], font_size)
+        if _has_box_declaration(slot):
+            # The title's box, from the same shared metrics both writers
+            # use. A rotated y-title box rides the flag-E lowering in the
+            # emitter (pre-rotated polygon / path-with-arcs), so it stays
+            # inside the PDF closed subset.
+            chrome.append(
+                _slot_box_svg(
+                    _chrome_text_box(
+                        box_template("axis_title", slot),
+                        padding_sides(slot),
+                        x=x,
+                        y=y,
+                        anchor=geometry["anchor"],
+                        block=block,
+                        angle=angle,
+                    )
+                )
+            )
         chrome.append(
             f'<text x="{_num(x)}" y="{_num(y)}" text-anchor="{geometry["anchor"]}" '
             f'font-size="{_num(font_size)}"'
@@ -4402,6 +5028,32 @@ def append_axis_title(axis: dict[str, Any], *, is_x: bool) -> None:
 
     # baselines above the marks, matching the client's overlay rules
     baselines = ""
+    # The axis_line/tick_mark box slots: when either declares box properties,
+    # its elements come from the shared producer (`axis_chrome_boxes` — the
+    # same boxes the raster writer and the declared snapshot consume) instead
+    # of the historical stroke loops below. Polar keeps stroke semantics in
+    # every renderer (the browser's spines are DIVs and cannot express a
+    # circle), so the flags stay off there and the loops run unchanged.
+    axis_line_boxed = polar is None and _has_box_declaration(slots.get("axis_line"))
+    tick_mark_boxed = polar is None and _has_box_declaration(slots.get("tick_mark"))
+    axis_boxes = axis_chrome_boxes(spec, slots) if (axis_line_boxed or tick_mark_boxed) else []
+
+    def _boxed_chrome_svg(slot_name: str) -> str:
+        # One paint-attr string per declaration, N instances (the interned-
+        # attrs rule): geometry varies per box, the paints do not — except
+        # through the per-axis ink fallback, which keys the tiny cache.
+        interned: dict[Optional[str], str] = {}
+        parts: list[str] = []
+        for box in axis_boxes:
+            if box.slot != slot_name:
+                continue
+            attrs = interned.get(box.fill)
+            if attrs is None:
+                attrs = _slot_box_paint_attrs(box)
+                interned[box.fill] = attrs
+            parts.append(_slot_box_svg(box, attrs))
+        return "".join(parts)
+
     frame_sides = spec.get("frame_sides")
     explicit_frame_sides = frame_sides is not None
     if frame_sides is None:
@@ -4429,57 +5081,53 @@ def append_axis_title(axis: dict[str, Any], *, is_x: bool) -> None:
                     f'<path data-xy-frame="polar" d="{frame_path}" fill="none" '
                     f'stroke="{frame_paint}" stroke-width="{frame_width}"/>'
                 )
-    if not hide_y or explicit_frame_sides:
-        for side, x in (("left", plot["x"]), ("right", plot["x"] + plot["w"])):
-            if side in frame_sides:
-                baselines += (
-                    f'<line x1="{_num(x)}" y1="{_num(plot["y"])}" x2="{_num(x)}" '
-                    f'y2="{_num(plot["y"] + plot["h"])}" '
-                    f'stroke="{escape(_css(ystyle.get("axis_color"), default_axis))}" '
-                    f'stroke-width="{_num(float(ystyle.get("axis_width", 1)))}"/>'
-                )
-    if not hide_x or explicit_frame_sides:
-        for side, y in (("top", plot["y"]), ("bottom", plot["y"] + plot["h"])):
-            if side in frame_sides:
-                baselines += (
-                    f'<line x1="{_num(plot["x"])}" y1="{_num(y)}" '
-                    f'x2="{_num(plot["x"] + plot["w"])}" y2="{_num(y)}" '
-                    f'stroke="{escape(_css(xstyle.get("axis_color"), default_axis))}" '
-                    f'stroke-width="{_num(float(xstyle.get("axis_width", 1)))}"/>'
-                )
-    for _axis_id, axis, _axis_scale in extra_x_axes:
-        if _axis_tick_label_strategy(axis) == "none":
-            continue
-        axis_style = axis.get("style") or {}
-        edge = plot["y"] if axis.get("side", "bottom") == "top" else plot["y"] + plot["h"]
-        baselines += (
-            f'<line x1="{_num(plot["x"])}" y1="{_num(edge)}" '
-            f'x2="{_num(plot["x"] + plot["w"])}" y2="{_num(edge)}" '
-            f'stroke="{escape(_css(axis_style.get("axis_color"), default_axis))}" '
-            f'stroke-width="{_num(float(axis_style.get("axis_width", 1)))}"/>'
-        )
-    for _axis_id, axis, _axis_scale in extra_y_axes:
-        if _axis_tick_label_strategy(axis) == "none":
-            continue
-        axis_style = axis.get("style") or {}
-        edge = plot["x"] + plot["w"] if axis.get("side", "right") == "right" else plot["x"]
-        baselines += (
-            f'<line x1="{_num(edge)}" y1="{_num(plot["y"])}" x2="{_num(edge)}" '
-            f'y2="{_num(plot["y"] + plot["h"])}" '
-            f'stroke="{escape(_css(axis_style.get("axis_color"), default_axis))}" '
-            f'stroke-width="{_num(float(axis_style.get("axis_width", 1)))}"/>'
-        )
-
-    def tick_span(style: dict[str, Any]) -> tuple[float, float, float]:
-        length = max(0.0, float(style.get("tick_length", 0)))
-        direction = str(style.get("tick_direction", "out"))
-        if direction == "in":
-            return length, 0.0, float(style.get("tick_width", 1))
-        if direction == "inout":
-            return length / 2, length / 2, float(style.get("tick_width", 1))
-        return 0.0, length, float(style.get("tick_width", 1))
+    if axis_line_boxed:
+        # Styled spines as boxes, at the strokes' own place in the paint
+        # order (below the labels group, above the marks).
+        baselines += _boxed_chrome_svg("axis_line")
+    else:
+        if not hide_y or explicit_frame_sides:
+            for side, x in (("left", plot["x"]), ("right", plot["x"] + plot["w"])):
+                if side in frame_sides:
+                    baselines += (
+                        f'<line x1="{_num(x)}" y1="{_num(plot["y"])}" x2="{_num(x)}" '
+                        f'y2="{_num(plot["y"] + plot["h"])}" '
+                        f'stroke="{escape(_css(ystyle.get("axis_color"), default_axis))}" '
+                        f'stroke-width="{_num(float(ystyle.get("axis_width", 1)))}"/>'
+                    )
+        if not hide_x or explicit_frame_sides:
+            for side, y in (("top", plot["y"]), ("bottom", plot["y"] + plot["h"])):
+                if side in frame_sides:
+                    baselines += (
+                        f'<line x1="{_num(plot["x"])}" y1="{_num(y)}" '
+                        f'x2="{_num(plot["x"] + plot["w"])}" y2="{_num(y)}" '
+                        f'stroke="{escape(_css(xstyle.get("axis_color"), default_axis))}" '
+                        f'stroke-width="{_num(float(xstyle.get("axis_width", 1)))}"/>'
+                    )
+        for _axis_id, axis, _axis_scale in extra_x_axes:
+            if _axis_tick_label_strategy(axis) == "none":
+                continue
+            axis_style = axis.get("style") or {}
+            edge = plot["y"] if axis.get("side", "bottom") == "top" else plot["y"] + plot["h"]
+            baselines += (
+                f'<line x1="{_num(plot["x"])}" y1="{_num(edge)}" '
+                f'x2="{_num(plot["x"] + plot["w"])}" y2="{_num(edge)}" '
+                f'stroke="{escape(_css(axis_style.get("axis_color"), default_axis))}" '
+                f'stroke-width="{_num(float(axis_style.get("axis_width", 1)))}"/>'
+            )
+        for _axis_id, axis, _axis_scale in extra_y_axes:
+            if _axis_tick_label_strategy(axis) == "none":
+                continue
+            axis_style = axis.get("style") or {}
+            edge = plot["x"] + plot["w"] if axis.get("side", "right") == "right" else plot["x"]
+            baselines += (
+                f'<line x1="{_num(edge)}" y1="{_num(plot["y"])}" x2="{_num(edge)}" '
+                f'y2="{_num(plot["y"] + plot["h"])}" '
+                f'stroke="{escape(_css(axis_style.get("axis_color"), default_axis))}" '
+                f'stroke-width="{_num(float(axis_style.get("axis_width", 1)))}"/>'
+            )
 
-    if not hide_x and polar is None:
+    if not tick_mark_boxed and not hide_x and polar is None:
         inward, outward, tick_width = tick_span(xmstyle)
         side = xa.get("side", "bottom")
         edge = plot["y"] if side == "top" else plot["y"] + plot["h"]
@@ -4512,7 +5160,7 @@ def tick_span(style: dict[str, Any]) -> tuple[float, float, float]:
                     f'stroke="{escape(_css(xstyle.get("tick_color"), default_axis))}" '
                     f'stroke-width="{_num(tick_width)}"/>'
                 )
-    if not hide_y and polar is None:
+    if not tick_mark_boxed and not hide_y and polar is None:
         inward, outward, tick_width = tick_span(ymstyle)
         side = ya.get("side", "left")
         edge = plot["x"] + plot["w"] if side == "right" else plot["x"]
@@ -4545,46 +5193,52 @@ def tick_span(style: dict[str, Any]) -> tuple[float, float, float]:
                     f'stroke="{escape(_css(ystyle.get("tick_color"), default_axis))}" '
                     f'stroke-width="{_num(tick_width)}"/>'
                 )
-    for axis_id, axis, axis_scale in extra_x_axes:
-        if _axis_tick_label_strategy(axis) == "none":
-            continue
-        axis_style = axis.get("style") or {}
-        inward, outward, tick_width = tick_span(axis_style)
-        for side in _axis_tick_sides(axis, is_x=True):
-            edge = plot["y"] if side == "top" else plot["y"] + plot["h"]
-            for value in extra_x_ticks[axis_id][0]:
-                x = float(axis_scale(value))
-                y1, y2 = (
-                    (edge - outward, edge + inward)
-                    if side == "top"
-                    else (edge - inward, edge + outward)
-                )
-                baselines += (
-                    f'<line x1="{_num(x)}" y1="{_num(y1)}" '
-                    f'x2="{_num(x)}" y2="{_num(y2)}" '
-                    f'stroke="{escape(_css(axis_style.get("tick_color"), default_axis))}" '
-                    f'stroke-width="{_num(tick_width)}"/>'
-                )
-    for axis_id, axis, axis_scale in extra_y_axes:
-        if _axis_tick_label_strategy(axis) == "none":
-            continue
-        axis_style = axis.get("style") or {}
-        inward, outward, tick_width = tick_span(axis_style)
-        for side in _axis_tick_sides(axis, is_x=False):
-            edge = plot["x"] + plot["w"] if side == "right" else plot["x"]
-            for value in extra_y_ticks[axis_id][0]:
-                y = float(axis_scale(value))
-                x1, x2 = (
-                    (edge - inward, edge + outward)
-                    if side == "right"
-                    else (edge - outward, edge + inward)
-                )
-                baselines += (
-                    f'<line x1="{_num(x1)}" y1="{_num(y)}" '
-                    f'x2="{_num(x2)}" y2="{_num(y)}" '
-                    f'stroke="{escape(_css(axis_style.get("tick_color"), default_axis))}" '
-                    f'stroke-width="{_num(tick_width)}"/>'
-                )
+    if not tick_mark_boxed:
+        for axis_id, axis, axis_scale in extra_x_axes:
+            if _axis_tick_label_strategy(axis) == "none":
+                continue
+            axis_style = axis.get("style") or {}
+            inward, outward, tick_width = tick_span(axis_style)
+            for side in _axis_tick_sides(axis, is_x=True):
+                edge = plot["y"] if side == "top" else plot["y"] + plot["h"]
+                for value in extra_x_ticks[axis_id][0]:
+                    x = float(axis_scale(value))
+                    y1, y2 = (
+                        (edge - outward, edge + inward)
+                        if side == "top"
+                        else (edge - inward, edge + outward)
+                    )
+                    baselines += (
+                        f'<line x1="{_num(x)}" y1="{_num(y1)}" '
+                        f'x2="{_num(x)}" y2="{_num(y2)}" '
+                        f'stroke="{escape(_css(axis_style.get("tick_color"), default_axis))}" '
+                        f'stroke-width="{_num(tick_width)}"/>'
+                    )
+        for axis_id, axis, axis_scale in extra_y_axes:
+            if _axis_tick_label_strategy(axis) == "none":
+                continue
+            axis_style = axis.get("style") or {}
+            inward, outward, tick_width = tick_span(axis_style)
+            for side in _axis_tick_sides(axis, is_x=False):
+                edge = plot["x"] + plot["w"] if side == "right" else plot["x"]
+                for value in extra_y_ticks[axis_id][0]:
+                    y = float(axis_scale(value))
+                    x1, x2 = (
+                        (edge - inward, edge + outward)
+                        if side == "right"
+                        else (edge - outward, edge + inward)
+                    )
+                    baselines += (
+                        f'<line x1="{_num(x1)}" y1="{_num(y)}" '
+                        f'x2="{_num(x2)}" y2="{_num(y)}" '
+                        f'stroke="{escape(_css(axis_style.get("tick_color"), default_axis))}" '
+                        f'stroke-width="{_num(tick_width)}"/>'
+                    )
+    else:
+        # Styled tick marks as boxes, at the strokes' own place in the paint
+        # order. Geometry parity is exact: a box at x - width/2 covers the
+        # same pixels as the centered stroke (and as the browser's rect).
+        baselines += _boxed_chrome_svg("tick_mark")
 
     defs = f"<defs>{''.join(svg.defs)}</defs>" if svg.defs else ""
     # Figure patch + plot-rect backgrounds, mirroring the browser: the root
diff --git a/python/xy/styling/capabilities.py b/python/xy/styling/capabilities.py
index 05461efe8..6ed0ad4b4 100644
--- a/python/xy/styling/capabilities.py
+++ b/python/xy/styling/capabilities.py
@@ -52,12 +52,20 @@
 #: Interaction/view states that gate live-only chrome. A slot tagged with one
 #: of these exists in the document only while its state is active — a tooltip
 #: under hover, the modebar under a pointer, a reduction badge under the view
-#: that triggered it — so a clean static export does not *contain* it. Styling
-#: such a slot is therefore not "dropped" by a clean static export: there is
-#: nothing in the file to style. Counting those slots against static parity
-#: overstated the gap; tagging them records the distinction instead of leaving
-#: it silent (§28).
-EXPORT_STATES: tuple[str, ...] = ("hover", "selection", "crosshair", "modebar", "view")
+#: that triggered it, an axis gesture band only while its axis is navigable —
+#: so a clean static export does not *contain* it. Styling such a slot is
+#: therefore not "dropped" by a clean static export: there is nothing in the
+#: file to style. Counting those slots against static parity overstated the
+#: gap; tagging them records the distinction instead of leaving it silent
+#: (§28).
+EXPORT_STATES: tuple[str, ...] = (
+    "hover",
+    "selection",
+    "crosshair",
+    "modebar",
+    "view",
+    "navigation",
+)
 
 #: Every slot is either present in a clean static export ("static") or gated
 #: by exactly one export state.
@@ -256,6 +264,19 @@ class ExtensionPoint:
         visible_when="stroke-width above ~4px at a sharp angle",
         tracked_by="no style property selects a join; the default is the whole contract",
     ),
+    RendererDivergence(
+        id="axis_line_edge_geometry",
+        what="Where an axis spine's box sits relative to the plot edge",
+        webgl="right/bottom spines inset by their own width (DIVs laid inside the box)",
+        svg="centered on the plot edge, where the unstyled stroke has always run",
+        native="centered on the plot edge (same shared box producer as SVG)",
+        visible_when="axis_width above ~2px, or a styled axis_line box under a magnifier",
+        tracked_by=(
+            "matching the browser would move every unstyled spine and break the "
+            "byte pin; the writers' centered geometry is pinned by golden in "
+            "tests/test_chrome_parity_p2.py"
+        ),
+    ),
 )
 
 
@@ -297,6 +318,61 @@ class ExtensionPoint:
     "export.",
 )
 
+#: The shared chrome-box vocabulary note, referenced by the axis-chrome slots
+#: below. The vocabulary itself is `xy._svg.SLOT_BOX_PROPS` (writer-owned, the
+#: preflight reads the same constant).
+_BOX_VOCAB_NOTE = (
+    "background, border (color/width/style, dashed/dotted as dash arrays), "
+    "symmetric border-radius, offset box-shadow (blur/spread recorded "
+    "unrepresentable), opacity and fill-opacity"
+)
+_SLOT_EXCEPTIONS["axis_line"] = (
+    "partial",
+    "styles={'axis_line': ...}",
+    "Spines as boxes when box properties are declared: " + _BOX_VOCAB_NOTE + ". "
+    "The spine keeps its axis_color ink unless the slot declares a background "
+    "(an explicit transparent erases it, as in the browser). Writers center "
+    "the box on the plot edge where the unstyled stroke ran; the browser "
+    "insets right/bottom spines (see KNOWN_RENDERER_DIVERGENCES). Polar "
+    "spines stay strokes — the browser shares the limit (DIV spines cannot "
+    "express a circle).",
+)
+_SLOT_EXCEPTIONS["tick_mark"] = (
+    "partial",
+    "styles={'tick_mark': ...}",
+    "Tick marks as boxes when box properties are declared: " + _BOX_VOCAB_NOTE + ". "
+    "Geometry is the centered stroke's own coverage — the same pixels as the "
+    "browser's rect. Marks exist only where an axis authors tick_length > 0; "
+    "a zero-length tick draws nothing (and casts no shadow) — the preflight "
+    "carries the note rather than a length being invented. tick_color stays "
+    "the narrower paint selector; polar has no cartesian tick marks "
+    "(recorded).",
+)
+_SLOT_EXCEPTIONS["tick_label"] = (
+    "partial",
+    "styles={'tick_label': ...}",
+    _SLOT_SUBSET_NOTE + " Additionally a per-label box: " + _BOX_VOCAB_NOTE + ", "
+    "with padding growing the axis gutters so the box stays on the canvas "
+    "(cartesian; the polar label ring keeps its flat 30px allowance). Box "
+    "geometry is measured with the writers' DejaVu metrics, so an authored "
+    "font-family renders its own glyphs inside a DejaVu-measured box "
+    "(recorded misfit); letter-spacing is likewise outside the gutter "
+    "measurement. On the raster writer a declared opacity reaches the box, "
+    "not the glyphs (the atlas blit has no alpha channel).",
+)
+_SLOT_EXCEPTIONS["axis_title"] = (
+    "partial",
+    "styles={'axis_title': ...}",
+    _SLOT_SUBSET_NOTE + " Additionally a per-title box: " + _BOX_VOCAB_NOTE + "; "
+    "a rotated y-title box is pre-rotated to a polygon (radius 0) or an "
+    "arc path (radius > 0), staying inside the PDF closed subset. The axis's "
+    "own label_* keys win per property over the slot (label_color, "
+    "label_font_family/style/weight); font-size runs the other way — the "
+    "slot's font-size wins over label_size (pre-existing, documented in "
+    "spec/api/styling.md). DejaVu-measured box vs authored-family text and "
+    "raster box-not-glyph opacity are recorded exactly as for tick_label.",
+)
+
 
 #: The state that gates each live-only slot. Listed explicitly, one entry per
 #: slot rather than by prefix, so `tests/test_capability_registry.py` can
@@ -328,6 +404,14 @@ class ExtensionPoint:
     "crosshair_y": "crosshair",
     "badge": "view",
     "badge_item": "view",
+    # Flag-F resolution (static-chrome-parity plan §8): the browser creates
+    # the band only when its axis is navigable (`57_viewstate.ts
+    # _axisBandNavigable`) — pan/zoom chrome, not structure — and a static
+    # file has no gesture for it to serve, so it follows the badge precedent
+    # (interaction-gated, no writer emission) rather than the earlier
+    # capability-matrix "clean static" row. Deemed structural again only by
+    # a spec decision, never by a writer quietly drawing it.
+    "axis_band": "navigation",
 }
 
 
diff --git a/python/xy/styling/declared.py b/python/xy/styling/declared.py
index cb59daeb3..013248730 100644
--- a/python/xy/styling/declared.py
+++ b/python/xy/styling/declared.py
@@ -28,12 +28,48 @@
 
 from __future__ import annotations
 
+import threading
 from dataclasses import dataclass, field
 from typing import Any, Optional
 
 from ..dom import CHART_DOM_SLOTS
 from .resolved import ResolvedStyleSnapshot, SnapshotBuilder, SnapshotEnvironment, assert_resolved
 
+#: Slots whose snapshot instances carry per-instance qualifiers + geometry,
+#: produced by the writers' own `axis_chrome_boxes` (one geometry source for
+#: the SVG writer, the raster writer, and this snapshot). The rest of the
+#: axis family joins as its per-instance identity becomes load-bearing.
+_PER_INSTANCE_SLOTS: tuple[str, ...] = ("axis_line", "tick_mark")
+
+#: Re-entrancy guard for the per-instance producer: `axis_chrome_boxes` runs
+#: `_svg.layout`, whose title measurement calls back into `resolve_declared`.
+#: The nested resolution only needs the writer view, so it skips instance
+#: production instead of recursing.
+_INSTANCE_GUARD = threading.local()
+
+
+def _axis_instance_records(
+    spec: dict[str, Any], view: dict[str, dict[str, Any]]
+) -> dict[str, list[tuple[tuple[str, ...], tuple[float, float, float, float]]]]:
+    """Per-instance (qualifiers, geometry) records for the axis box slots."""
+    if getattr(_INSTANCE_GUARD, "active", False):
+        return {}
+    if "x_axis" not in spec or "y_axis" not in spec:
+        return {}  # a bare styling spec has no layout to resolve against
+    from .._svg import _has_box_declaration, axis_chrome_boxes
+
+    if not any(_has_box_declaration(view.get(slot)) for slot in _PER_INSTANCE_SLOTS):
+        return {}
+    _INSTANCE_GUARD.active = True
+    try:
+        boxes = axis_chrome_boxes(spec, view)
+    finally:
+        _INSTANCE_GUARD.active = False
+    records: dict[str, list[tuple[tuple[str, ...], tuple[float, float, float, float]]]] = {}
+    for box in boxes:
+        records.setdefault(box.slot, []).append((box.qualifiers, (box.x, box.y, box.w, box.h)))
+    return records
+
 
 @dataclass(frozen=True)
 class DeclaredStyling:
@@ -78,9 +114,13 @@ def resolve_declared(
     for slot, decls in raw.items():
         if not isinstance(decls, dict):
             continue
-        slot_name = str(slot)
-        normalized = {_kebab(prop): value for prop, value in decls.items()}
-        view[slot_name] = normalized
+        view[str(slot)] = {_kebab(prop): value for prop, value in decls.items()}
+    # Axis-chrome box slots intern one declaration and record N instances,
+    # each with its qualifiers (axis id, major|minor, side, tick index) and
+    # resolved geometry — produced by the writers' own box producer, so the
+    # snapshot cannot disagree with what either writer draws.
+    instance_records = _axis_instance_records(spec, view)
+    for slot_name, normalized in view.items():
         if slot_name not in CHART_DOM_SLOTS:
             writer_domain[slot_name] = dict(normalized)
             continue
@@ -94,7 +134,12 @@ def resolve_declared(
             else:
                 legal[name] = value
         if legal:
-            builder.add(slot_name, legal)
+            records = instance_records.get(slot_name)
+            if records:
+                for qualifiers, geometry in records:
+                    builder.add(slot_name, legal, qualifiers=qualifiers, geometry=geometry)
+            else:
+                builder.add(slot_name, legal)
         if residue:
             writer_domain[slot_name] = residue
     environment = SnapshotEnvironment(
diff --git a/python/xy/styling/preflight.py b/python/xy/styling/preflight.py
index b7df4991c..718740d4e 100644
--- a/python/xy/styling/preflight.py
+++ b/python/xy/styling/preflight.py
@@ -186,10 +186,12 @@ def _honored_props(slot: str, family: str) -> tuple[frozenset[str], str]:
     """(honored property names, qualifier) for a native-subset slot.
 
     The subsets are the writers' own constants — the text properties per
-    family, plus the legend frame's merged-declaration box vocabulary
-    (`_svg.LEGEND_BOX_PROPS`, owned by the writer module). A legend property
-    in neither set has no channel into a static file and is a provable loss:
-    the earlier declaration-level qualification rounded exactly those to
+    family, the shared chrome-box vocabulary (`_svg.SLOT_BOX_PROPS`) for the
+    slots whose boxes the writers draw, plus the legend frame's merged-
+    declaration box vocabulary (`_svg.LEGEND_BOX_PROPS`, owned by the writer
+    module until P4 retires the em residue). A property in none of a slot's
+    sets has no channel into a static file and is a provable loss: the
+    earlier declaration-level qualification rounded exactly those to
     silence, which let warn stay quiet and strict permit a drop.
     """
     from .. import _svg
@@ -200,6 +202,23 @@ def _honored_props(slot: str, family: str) -> tuple[frozenset[str], str]:
             "box properties route through the merged legend declaration; see the "
             "capability matrix legend note"
         )
+    if slot in ("axis_line", "tick_mark"):
+        # Pure box slots: no text of their own, so the text subsets do not
+        # apply; the box vocabulary is honored by both writers.
+        qualifier = ""
+        if slot == "tick_mark":
+            qualifier = (
+                "tick marks exist only where an axis authors tick_length > 0; a "
+                "zero-length tick draws no box (no length is invented for a "
+                "styled slot)"
+            )
+        return frozenset(_svg.SLOT_BOX_PROPS), qualifier
+    if slot in ("tick_label", "axis_title"):
+        # Text slots that also draw a box: the union of the family's text
+        # subset and the box vocabulary. On the raster family a declared
+        # `opacity` reaches the box but not the glyphs (the atlas blit has
+        # no alpha channel) — recorded in the capability-matrix note.
+        return text | _svg.SLOT_BOX_PROPS, ""
     return text, ""
 
 
@@ -263,7 +282,10 @@ def _styles_finding(slot: str, decls: dict[str, Any], fmt: str) -> SlotFinding:
     honored, qualifier = _honored_props(slot, family)
     kept = tuple(p for p in props if p in honored)
     lost = tuple(p for p in props if p not in honored)
-    if slot == "legend" and not lost:
+    if qualifier and not lost:
+        # Nothing drops, but the slot's channel carries a condition the
+        # author should know (the merged legend declaration; tick marks
+        # existing only at authored tick_length) — qualified, never silent.
         return SlotFinding(
             slot=slot,
             source="styles",
diff --git a/spec/api/capability-matrix.md b/spec/api/capability-matrix.md
index 863a51e98..fa50cdf13 100644
--- a/spec/api/capability-matrix.md
+++ b/spec/api/capability-matrix.md
@@ -14,9 +14,9 @@ which is sometimes deliberate, and the notes say which.
 ## In one line
 
 - **11** mark style properties across **21** mark kinds, drawn by all three renderers.
-- **48** stable chrome slots, CSS- and Tailwind-addressable in the browser. **24** of them name chrome a clean static export contains; **10** reach the native writers — **9** through `styles={slot: ...}` itself, and `root` through the chart-level `style=` token bag. The other **24** are interaction/view chrome (tooltip, modebar, crosshair, selection, reduction badges) that a clean static file does not contain, so they are gated by an export state rather than missing.
+- **48** stable chrome slots, CSS- and Tailwind-addressable in the browser. **23** of them name chrome a clean static export contains; **12** reach the native writers — **11** through `styles={slot: ...}` itself, and `root` through the chart-level `style=` token bag. The other **25** are interaction/view chrome (tooltip, modebar, crosshair, selection, reduction badges) that a clean static file does not contain, so they are gated by an export state rather than missing.
 - **1** shipped extension point.
-- **1** known default divergence between renderers, listed below rather than left to be discovered.
+- **2** known default divergence between renderers, listed below rather than left to be discovered.
 
 ## Mark style properties
 
@@ -113,9 +113,9 @@ declared and names anything that would not survive.
 | `crosshair_y` | crosshair state | full | none | none |
 | `badge` | view state | full | none | none |
 | `badge_item` | view state | full | none | none |
-| `axis_band` | clean static | full | none | none |
-| `axis_line` | clean static | full | none | none |
-| `tick_mark` | clean static | full | none | none |
+| `axis_band` | navigation state | full | none | none |
+| `axis_line` | clean static | full | partial | partial |
+| `tick_mark` | clean static | full | partial | partial |
 | `tick_label` | clean static | full | partial | partial |
 | `axis_title` | clean static | full | partial | partial |
 | `annotation_label` | clean static | full | none | none |
@@ -130,8 +130,10 @@ declared and names anything that would not survive.
 - **`colorbar`** (via `styles={'colorbar': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
 - **`colorbar_tick`** (via `styles={'colorbar_tick': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
 - **`colorbar_title`** (via `styles={'colorbar_title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
-- **`tick_label`** (via `styles={'tick_label': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
-- **`axis_title`** (via `styles={'axis_title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
+- **`axis_line`** (via `styles={'axis_line': ...}`) — Spines as boxes when box properties are declared: background, border (color/width/style, dashed/dotted as dash arrays), symmetric border-radius, offset box-shadow (blur/spread recorded unrepresentable), opacity and fill-opacity. The spine keeps its axis_color ink unless the slot declares a background (an explicit transparent erases it, as in the browser). Writers center the box on the plot edge where the unstyled stroke ran; the browser insets right/bottom spines (see KNOWN_RENDERER_DIVERGENCES). Polar spines stay strokes — the browser shares the limit (DIV spines cannot express a circle).
+- **`tick_mark`** (via `styles={'tick_mark': ...}`) — Tick marks as boxes when box properties are declared: background, border (color/width/style, dashed/dotted as dash arrays), symmetric border-radius, offset box-shadow (blur/spread recorded unrepresentable), opacity and fill-opacity. Geometry is the centered stroke's own coverage — the same pixels as the browser's rect. Marks exist only where an axis authors tick_length > 0; a zero-length tick draws nothing (and casts no shadow) — the preflight carries the note rather than a length being invented. tick_color stays the narrower paint selector; polar has no cartesian tick marks (recorded).
+- **`tick_label`** (via `styles={'tick_label': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only. Additionally a per-label box: background, border (color/width/style, dashed/dotted as dash arrays), symmetric border-radius, offset box-shadow (blur/spread recorded unrepresentable), opacity and fill-opacity, with padding growing the axis gutters so the box stays on the canvas (cartesian; the polar label ring keeps its flat 30px allowance). Box geometry is measured with the writers' DejaVu metrics, so an authored font-family renders its own glyphs inside a DejaVu-measured box (recorded misfit); letter-spacing is likewise outside the gutter measurement. On the raster writer a declared opacity reaches the box, not the glyphs (the atlas blit has no alpha channel).
+- **`axis_title`** (via `styles={'axis_title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only. Additionally a per-title box: background, border (color/width/style, dashed/dotted as dash arrays), symmetric border-radius, offset box-shadow (blur/spread recorded unrepresentable), opacity and fill-opacity; a rotated y-title box is pre-rotated to a polygon (radius 0) or an arc path (radius > 0), staying inside the PDF closed subset. The axis's own label_* keys win per property over the slot (label_color, label_font_family/style/weight); font-size runs the other way — the slot's font-size wins over label_size (pre-existing, documented in spec/api/styling.md). DejaVu-measured box vs authored-family text and raster box-not-glyph opacity are recorded exactly as for tick_label.
 
 ## Extension points
 
@@ -157,6 +159,7 @@ until someone diffs two exports. Listed here for that reason.
 | what | webgl | svg | native | visible when | tracked by |
 |---|---|---|---|---|---|
 | Interior vertices of a wide polyline | the notch two overlapping segment quads leave | round (the writer names it explicitly) | round (the capsule distance field fills the vertex) | stroke-width above ~4px at a sharp angle | no style property selects a join; the default is the whole contract |
+| Where an axis spine's box sits relative to the plot edge | right/bottom spines inset by their own width (DIVs laid inside the box) | centered on the plot edge, where the unstyled stroke has always run | centered on the plot edge (same shared box producer as SVG) | axis_width above ~2px, or a styled axis_line box under a magnifier | matching the browser would move every unstyled spine and break the byte pin; the writers' centered geometry is pinned by golden in tests/test_chrome_parity_p2.py |
 
 ## Regenerating
 
diff --git a/spec/api/export.md b/spec/api/export.md
index e6bf5c1ff..492d8b027 100644
--- a/spec/api/export.md
+++ b/spec/api/export.md
@@ -248,7 +248,7 @@ vector** (`_svg.to_svg`, and `_pdf.svg_to_pdf` on top of it).
 | `style={...}` on a mark | yes | yes | yes | validated CSS subset, `styles.compile_mark_style` |
 | `style={...}` on an axis | yes | yes | yes | validated vocabulary, `styles.compile_axis_style` |
 | `style={...}` on the chart (token bag) | yes | yes | yes | `spec["dom"]["style"]`, read at `_svg.py:767,1481` and `_raster.py:662` |
-| `styles={slot: {...}}` (per-slot inline) | yes, all 48 slots | text subset, 9 slots | text subset, 9 slots | `_svg.STATIC_STYLED_SLOTS`; the rest is live-only chrome |
+| `styles={slot: {...}}` (per-slot inline) | yes, all 48 slots | text + box subsets, 11 slots | text + box subsets, 11 slots | `_svg.STATIC_STYLED_SLOTS`; the rest is live-only chrome |
 | `class_names={slot: "..."}` | yes, all 48 slots | **dropped** (or resolved via `style_source="native_cascade"` / a captured `style_snapshot=`) | same | silent by default during migration; both opt-in routes are lossless for the published profile |
 | `custom_css="..."` | yes (HTML + Chromium capture) | **raises** | **raises** | `_resolve_image_engine`, `export.py:812` |
 | `xy.legend(style=...)` | yes | 6 keys | 6 keys | merged with the slot and the theme token before the writers see it |
@@ -323,19 +323,24 @@ and an exported file has no stylesheet to select from.
 ### Which per-slot styles reach a file, and why only those
 
 A slot reaches the native writers when it names chrome a static file actually
-contains. `_svg.STATIC_STYLED_SLOTS` is that list: `title`, `axis_title`,
-`tick_label`, `legend`, `legend_title`, `legend_label`, `colorbar`,
-`colorbar_title`, and `colorbar_tick`. The remaining slots are live-only chrome
-— `tooltip*`, `modebar*`, `crosshair_*`, `selection`, `badge*` — or containers
-with no painted text of their own; there is nothing in a PNG for them to style.
+contains. `_svg.STATIC_STYLED_SLOTS` is that list: `title`, `axis_line`,
+`tick_mark`, `axis_title`, `tick_label`, `legend`, `legend_title`,
+`legend_label`, `colorbar`, `colorbar_title`, and `colorbar_tick`. The
+remaining slots are live-only chrome — `tooltip*`, `modebar*`, `crosshair_*`,
+`selection`, `badge*`, and `axis_band`, which exists only while its axis is
+navigable — or containers with no painted text of their own; there is nothing
+in a PNG for them to style.
 
 Within a supported slot the writers read a property subset, not a cascade:
-`font-size`, `font-weight`, `font-style`, `font-family`, `letter-spacing`,
-`opacity`, and the text paint (`fill`, or `color`). The native raster's atlas is
-a single baked face, so it honors size and paint and leaves the typeface
-properties to the vector writers — the one documented divergence, and
-`tests/test_export_style_survival.py` pins it. A declaration outside the subset
-stays browser-only.
+the text subset — `font-size`, `font-weight`, `font-style`, `font-family`,
+`letter-spacing`, `opacity`, and the text paint (`fill`, or `color`) — plus,
+on the axis-chrome slots (`axis_line`, `tick_mark`, `tick_label`,
+`axis_title`), the shared box vocabulary (`_svg.SLOT_BOX_PROPS`). The raster
+atlas carries regular/bold/italic faces but no family axis, per-glyph
+advances, or blit alpha, so `font-family`, `letter-spacing` and text
+`opacity` stay vector-only — the documented divergence
+`tests/test_export_style_survival.py` pins. A declaration outside a slot's
+subsets stays browser-only.
 
 Where two surfaces name the same chrome, the narrower selector wins: an axis's
 own `label_color` beats `styles={"axis_title": ...}`, which beats the
diff --git a/spec/api/styling.md b/spec/api/styling.md
index 6bcdc270d..a8e35f3ea 100644
--- a/spec/api/styling.md
+++ b/spec/api/styling.md
@@ -723,7 +723,7 @@ raises before it reaches the client.
 | `tick_label` | Axis tick label |
 | `axis_title` | Axis title label |
 | `annotation_label` | Text/label/callout annotation (DOM overlay) |
-| `axis_band` | Invisible axis-only pan/zoom gesture band |
+| `axis_band` | Invisible axis-only pan/zoom gesture band (exists only while its axis is navigable — navigation-gated for export, like the badge) |
 | `axis_line` | One Cartesian axis baseline |
 | `tick_mark` | One Cartesian major or minor tick mark |
 
@@ -1324,15 +1324,70 @@ carry a defined subset of their declarations into SVG, PNG and PDF:
 
 | | |
 | --- | --- |
-| Slots | `title`, `axis_title`, `tick_label`, `legend`, `legend_title`, `legend_label`, `colorbar`, `colorbar_title`, `colorbar_tick` (`_svg.STATIC_STYLED_SLOTS`) |
-| Vector — SVG, PDF | `font-size`, `font-weight`, `font-style`, `font-family`, `letter-spacing`, `opacity`, and the text paint — `fill`, or `color` (`_svg.SLOT_TEXT_PROPS`) |
-| Raster — PNG, JPEG, WebP | `font-size` and the text paint only (`_svg.SLOT_RASTER_PROPS`) |
-
-The raster writer's glyph primitive takes a size and one RGBA paint and nothing
-else, so `font-weight`, `font-style`, `font-family`, `letter-spacing` and
-`opacity` are **vector-only**. They are not approximated: the atlas is a single
-baked face, and a silently substituted weight would be exactly the kind of
-invisible decision §28 forbids.
+| Slots | `title`, `axis_line`, `tick_mark`, `axis_title`, `tick_label`, `legend`, `legend_title`, `legend_label`, `colorbar`, `colorbar_title`, `colorbar_tick` (`_svg.STATIC_STYLED_SLOTS`) |
+| Vector text — SVG, PDF | `font-size`, `font-weight`, `font-style`, `font-family`, `letter-spacing`, `opacity`, and the text paint — `fill`, or `color` (`_svg.SLOT_TEXT_PROPS`) |
+| Raster text — PNG, JPEG, WebP | `font-size`, `font-weight`, `font-style`, and the text paint (`_svg.SLOT_RASTER_PROPS`) |
+| Box, both writers | `background`/`background-color`, `border-color`/`border-width`/`border-style`, `border-radius`, `box-shadow` (offset only), `opacity`, `fill-opacity`, `padding` (`_svg.SLOT_BOX_PROPS`) — on `axis_line`, `tick_mark`, `tick_label`, `axis_title` (the legend keeps its own merged vocabulary) |
+
+The raster atlas carries a regular, a bold and an italic face, so weight
+(>= 600 rounds up to bold) and style survive rasterization; it has no family
+axis, no per-glyph advance control and no alpha channel on the glyph blit, so
+`font-family`, `letter-spacing` and `opacity` are **vector-only for text**.
+They are not approximated: a silently substituted face would be exactly the
+kind of invisible decision §28 forbids. (A declared `opacity` still reaches a
+slot's *box* in the raster — the box is ordinary geometry — which the
+capability matrix notes per slot.)
+
+#### Axis chrome boxes (parity phase 2)
+
+`axis_line` and `tick_mark` are pure box slots. Emission is strictly gated on
+a box declaration being present — an unstyled chart's bytes never move — and
+when it is, the spine/tick strokes are replaced by boxes from one shared
+producer (`_svg.axis_chrome_boxes`) consumed identically by the SVG writer,
+the raster writer, and the declared style snapshot (per-instance
+`qualifiers`/`geometry`: axis id, major|minor, side, tick index). Decisions,
+each recorded rather than silent:
+
+- **Geometry.** Spines stay centered on the plot edge, exactly where the
+  unstyled stroke has always run; the browser insets right/bottom spines by
+  their own width (`KNOWN_RENDERER_DIVERGENCES`, `axis_line_edge_geometry`).
+  A tick box is the centered stroke's own coverage — the same pixels as the
+  browser's rect.
+- **Ink.** The slot's `background` replaces the axis ink when declared (an
+  explicit `transparent` erases it, as in the browser); otherwise the box
+  keeps the axis's own `axis_color`/`tick_color` — the narrower selector
+  still wins the paint.
+- **No invented ticks.** `tick_length` defaults to 0; a zero-area box draws
+  nothing and casts no shadow, and the preflight says so instead of a length
+  being invented.
+- **Polar.** Spines and ticks keep stroke semantics under polar in every
+  renderer — the browser shares the limit (DIV spines cannot express a
+  circle).
+- **Rotated boxes** (an axis y-title) lower to pre-rotated geometry — a
+  `<polygon>` at radius 0, a `<path>` with circular arcs at radius > 0 —
+  because the PDF closed subset accepts no `transform` on `<rect>`. One
+  lowering repo-wide (`_chromebox` / `_svg._rotated_box_shape`).
+- **Rooms.** A `tick_label`/`axis_title` padding/border grows the measured
+  gutters (both orientations) so the box stays on the canvas; the polar
+  label ring keeps its flat 30 px allowance. Box geometry is measured with
+  the writers' DejaVu metrics — an authored `font-family` renders its own
+  glyphs inside a DejaVu-measured box, and `letter-spacing` is likewise
+  outside the gutter measurement (recorded misfits).
+
+`axis_band` is **navigation-gated** chrome, not structural: the browser
+creates it only while its axis is navigable (`57_viewstate.ts`
+`_axisBandNavigable`), a static file has no gesture for it to serve, and so —
+resolving the plan's flag F by the badge precedent — no writer draws it and
+the preflight reports it state-gated rather than dropped.
+
+`axis_title` precedence is per property. The axis's own `label_color`,
+`label_font_family`, `label_font_style` and `label_font_weight` are the
+narrower selector and win; the slot supplies whatever they leave unset —
+`letter-spacing` and `opacity` have no axis spelling, so the slot always
+carries them (the pre-parity writers dropped both the moment the axis
+authored a family or style). One documented exception, kept for
+compatibility: **font-size runs the other way** — the slot's `font-size` wins
+over the axis `label_size`.
 
 ```python
 xy.chart(
diff --git a/spec/process/static-chrome-parity-plan-2026-08-04.md b/spec/process/static-chrome-parity-plan-2026-08-04.md
index cd486bac4..7d81c5577 100644
--- a/spec/process/static-chrome-parity-plan-2026-08-04.md
+++ b/spec/process/static-chrome-parity-plan-2026-08-04.md
@@ -106,6 +106,15 @@ Geometry is free: root = chrome = (0,0,width,height); canvas = plot rect from `l
 
 ## 4. Phase 2 — axis chrome
 
+**Status: LANDED** (branch alek/style-compat; tests/test_chrome_parity_p2.py is the executable acceptance). Decisions taken while landing, each recorded where consumers read it:
+
+- Flag E pinned repo-wide as recommended: pre-rotated `<polygon>` when radius==0, `<path>` with circular arcs when radius>0 (`_chromebox.rotate_points` + `_svg._rotated_box_shape` + Python-side corner rotation in `_raster._emit_slot_box`). PDF-verified both ways.
+- Flag F resolved: axis_band is **navigation-gated** (badge precedent) — `capabilities.EXPORT_STATES` gained `"navigation"`, no writer emission, preflight reports state-gated. Item 7's z-order/OUT-IN-mirror work dies with the decision; the capability-matrix "clean static" row was the casualty, regenerated.
+- Item 2 scope: per-instance qualifiers+geometry land in the declared snapshot for `axis_line`/`tick_mark` (the box slots), produced by `_svg.axis_chrome_boxes` — one geometry source for both writers and the snapshot. `tick_label`/`axis_title` keep single-instance records until their per-instance identity is load-bearing.
+- Item 5 letter-spacing: **qualified**, not folded — the rooms already measure at the axis font size while emitters draw at slot size (the pre-existing overflow this section names); folding spacing but not size would be false precision. Recorded in the tick_label capability note.
+- P0.3 repair discovered en route: `_raster._emit_slot_box` passed `(x, y, w, h)` to corner-coordinate helpers, collapsing every box off the origin; fixed with a decoded-geometry regression test. The zero-area rule (no box, no shadow, no snapshot instance) now lives in the primitives.
+- P0.4's `SLOT_BOX_PROPS` did not exist in this branch yet; created in `_svg.py` per the LEGEND_BOX_PROPS pattern, consumed by writers, registry note, and preflight.
+
 **Edits, in order:**
 
 1. **Extract shared `tick_span`** — literal near-duplicate (`_svg.py:4433-4440` returns (in,out,width) vs `_raster.py:1205-1212` returns (in,out)). The survey calls it the obvious first extraction; unify on the 3-tuple.
@@ -189,8 +198,8 @@ Three I verified against the code in this pass; the rest need a look before the
 - **B. Legend border "hard-coded 1px #cccccc" (RESOLVED BY CODE — family-1 overstates).** Family-1 calls the frame border hard-coded; family-2 says camelCase `borderColor` IS honored with #cccccc default. Code confirms family-2: `_svg.py:6618`, `_raster.py:3108`. Only width (1px) and style (solid) are hard-coded. Additional nuance neither survey states: the SVG frame stroke rides `stroke-opacity=alpha` from the frame-alpha logic (`_svg.py:6622`) and the raster folds the same alpha into the border RGBA (`3108`) — the border dims with the frame; the new lowering must decide whether that coupling survives.
 - **C. What the annotation box pair shares (RESOLVED BY CODE — family-1 undercounts).** Family-1: they share "only `_box_corner_radius`". Family-4: `_estimated_text_width` is also shared. Code: `_raster.py:52` imports `_estimated_text_width`. Family-4 correct.
 - **D. Labels/baselines stacking (REAL CONFLICT, both surveys partially right — must be resolved before P3.5).** The axis family asserts the writers' order (baselines above marks, below the labels group) "matches the browser" (`50_chartview.ts:6948-6952`). The annotation family asserts the browser keeps spine/rule DIVs INSIDE the labels container so a labels-slot background cannot sit under baselines and above marks without reordering. Code (verified): `rule()` appends spine/tick DIVs to `this.labels` (`50_chartview.ts:6988-6989`). Both claims describe the same DOM: relative z of rules-vs-marks matches, but a labels-container BACKGROUND paints under the rules live and above them in the writers. The axis family's "matches the browser" is true only for slot ink, not for the container box. Decide and record before implementing the labels background.
-- **E. Rotated-box PDF lowering (CONFLICTING PRESCRIPTIONS).** Axis family: `<polygon>` (loses radius) OR `<path>` with arcs (keeps it), leaning toward pinning path-with-arcs since rotated y-titles are the common case. Colorbar family: pre-rotated `<polygon>` "so SVG, PDF and raster share one geometry" — no radius. Pick ONE repo-wide lowering in P0.3 (recommendation: pre-rotated polygon when radius==0, path-with-arcs when radius>0) and make both families consume it.
-- **F. axis_band applicability policy (CROSS-FAMILY PRINCIPLE CONFLICT).** The axis family plans full box support for axis_band and notes `capability-matrix.md:116` claims it applicable in clean static. The annotation family's badge rationale (`capabilities.py:299-329`: clean static exports contain no state-gated chrome) argues the opposite for interaction-gated chrome — and the band exists live ONLY when the axis is navigable (`57_viewstate.ts:295, 272-279`), i.e., it is interaction-gated. Either the band is deemed structural chrome (draw it, full support) or interaction chrome (view-gate it like badge). Spec decision before P2.7; the surveys point different directions.
+- **E. Rotated-box PDF lowering (RESOLVED IN P2, as recommended).** Pinned repo-wide: pre-rotated polygon when radius==0, path-with-circular-arcs when radius>0, shadow offset applied in element space before rotation. Implemented once in the shared primitives (`_chromebox.rotate_points`, `_svg._rotated_box_shape`, raster corner pre-rotation); P5's colorbar title must consume it, not re-lower.
+- **F. axis_band applicability policy (RESOLVED IN P2: interaction chrome, view-gated).** The band exists live ONLY while its axis is navigable (`57_viewstate.ts _axisBandNavigable`) and a static file has no gesture for it to serve; the badge rationale won. `_STATE_GATED_SLOTS["axis_band"] = "navigation"` (new export state), preflight reports state-gated, no writer emission, matrix regenerated off the stale "clean static" row. Deeming it structural again is a spec decision, never a writer quietly drawing it.
 - **G. chrome-slot scope (SELF-HEDGED, needs a call).** Family-1 lists full box-model gaps for `chrome`, then recommends background/opacity-only with the rest unrepresentable. Its proposed static anchor (below grid) matches live compositing per its own analysis but contradicts DOM order for titles (chrome canvas appended after title divs). The plan adopts the hedge (P1.5) — that adoption is a decision, not a survey consensus.
 - **H. Shadow alpha constants (framing conflict).** Family-1 presents SVG 0.22 / raster 55/255 as one policy ("alpha 0.22/55"); family-2 flags them as a divergence to resolve, not copy (0.22 vs ≈0.2157). The plan follows family-2 (P0.3/P4.3 unify).
 - **I. Raster `_raster.py` import-line citations vary across surveys** (25-45, 28-83, 38-80, 52, 54, 65, 71) — not contradictory (different subsets of the same import block), no action.
diff --git a/tests/test_capability_registry.py b/tests/test_capability_registry.py
index 850946ae1..9a7846673 100644
--- a/tests/test_capability_registry.py
+++ b/tests/test_capability_registry.py
@@ -67,12 +67,16 @@ def test_every_slot_has_exactly_one_applicability() -> None:
 def test_state_gated_families_cannot_be_misfiled() -> None:
     # A new `modebar_*` (or tooltip/crosshair/badge) slot must carry its
     # family's state; defaulting to "static" would overstate the clean-static
-    # surface — the direction that is easy to miss.
+    # surface — the direction that is easy to miss. `axis_band` is a
+    # one-slot family: the browser creates it only while its axis is
+    # navigable (flag-F resolution, static-chrome-parity plan §8), so it is
+    # interaction-gated exactly like the badge, not structural chrome.
     families = {
         "tooltip": "hover",
         "modebar": "modebar",
         "crosshair_": "crosshair",
         "badge": "view",
+        "axis_band": "navigation",
     }
     for slot in caps.CHART_SLOTS:
         expected = next(
diff --git a/tests/test_chrome_parity_p2.py b/tests/test_chrome_parity_p2.py
new file mode 100644
index 000000000..3f427a4fc
--- /dev/null
+++ b/tests/test_chrome_parity_p2.py
@@ -0,0 +1,538 @@
+"""Static-chrome parity, phase 2: the axis-chrome family.
+
+Executable acceptance for plan §4 (spec/process/static-chrome-parity-plan-
+2026-08-04.md): axis_line and tick_mark gain boxes through the shared
+producer, tick_label and axis_title complete their per-property text
+contract and gain boxes, and axis_band is resolved (flag F) as
+interaction-gated chrome with no writer emission. Throughout, the standing
+gate holds: an unstyled chart's bytes never move, and every emitted
+construct round-trips the PDF closed subset.
+"""
+
+from __future__ import annotations
+
+import re
+import struct
+
+import pytest
+
+import xy
+from xy import _chromebox, _raster, _svg
+from xy._pdf import svg_to_pdf
+from xy.styling import capabilities as caps
+from xy.styling import preflight as pf
+from xy.styling.declared import resolve_declared
+
+
+def _chart(*components, **props):
+    return xy.line_chart(
+        xy.line([0.0, 1.0, 2.0], [0.0, 1.0, 0.5], name="series"), *components, **props
+    )
+
+
+def _rects(svg: str, needle: str) -> list[str]:
+    return [r for r in re.findall(r"<rect[^>]*/>", svg) if needle in r]
+
+
+def _attr(node: str, name: str) -> float:
+    match = re.search(rf'{name}="([^"]+)"', node)
+    assert match, (name, node)
+    return float(match.group(1))
+
+
+def _png_pixels(chart):
+    return _raster.render_raster(*chart.figure().build_payload(), scale=1)
+
+
+def _decoded_fills(cmd: "_raster._Cmd") -> list[list[tuple[float, float]]]:
+    """FILL polygons out of a display-list buffer, for geometry assertions."""
+    buf, i, out = bytes(cmd.buf), 0, []
+    while i < len(buf):
+        assert buf[i] == _raster._FILL or buf[i] == _raster._STROKE, "unexpected opcode"
+        op = buf[i]
+        i += 1
+        if op == _raster._FILL:
+            (count,) = struct.unpack_from("<I", buf, i)
+            i += 4
+            pts = [struct.unpack_from("<ff", buf, i + 8 * j) for j in range(count)]
+            i += 8 * count + 4  # points + rgba
+            out.append(pts)
+        else:  # stroke: width f32, count u32, pts, rgba, cap u8, dash...
+            i += 4
+            (count,) = struct.unpack_from("<I", buf, i)
+            i += 4 + 8 * count + 4
+            i += 1  # cap byte
+            (dash_n,) = struct.unpack_from("<I", buf, i)
+            i += 4 + 4 * dash_n
+    return out
+
+
+# -- the raster primitive draws the geometry it was handed --------------------
+
+
+def test_raster_emitter_geometry_is_the_declared_rect() -> None:
+    # Regression: `_emit_slot_box` passed (x, y, w, h) to helpers that take
+    # corner coordinates, so every box off the origin collapsed. The P0.3
+    # test only asserted non-empty bytes and never caught it.
+    cmd = _raster._Cmd(1.0)
+    box = _chromebox.lower_box("legend", {"background": "#123456"}, x=100.0, y=50.0, w=20.0, h=10.0)
+    _raster._emit_slot_box(cmd, box)
+    (pts,) = _decoded_fills(cmd)
+    assert pts == [(100.0, 50.0), (120.0, 50.0), (120.0, 60.0), (100.0, 60.0)]
+
+
+def test_zero_area_boxes_emit_nothing_not_even_a_shadow() -> None:
+    # Plan §4.4: no shadow on zero-area boxes — a tick_length: 0 tick must
+    # not cast one, in either writer.
+    box = _chromebox.lower_box(
+        "tick_mark", {"background": "#123456", "box-shadow": "2px 2px #000"}, x=5, y=5, w=1, h=0
+    )
+    assert _svg._slot_box_svg(box) == ""
+    cmd = _raster._Cmd(1.0)
+    _raster._emit_slot_box(cmd, box)
+    assert bytes(cmd.buf) == b""
+
+
+def test_rotated_box_lowers_to_polygon_or_arc_path_and_pdf_accepts_both() -> None:
+    # The pinned repo-wide flag-E lowering: polygon at radius 0, path with
+    # circular arcs at radius > 0 — never a transformed rect.
+    square = _chromebox.box_at(
+        _chromebox.box_template("axis_title", {"background": "#123456"}),
+        10,
+        10,
+        40,
+        20,
+        angle=-90.0,
+        cx=30.0,
+        cy=20.0,
+    )
+    rounded = _chromebox.box_at(
+        _chromebox.box_template("axis_title", {"background": "#123456", "border-radius": "5px"}),
+        10,
+        10,
+        40,
+        20,
+        angle=-90.0,
+        cx=30.0,
+        cy=20.0,
+    )
+    polygon = _svg._slot_box_svg(square)
+    path = _svg._slot_box_svg(rounded)
+    assert polygon.startswith("<polygon points=")
+    assert path.startswith('<path d="M') and " A 5 5 0 0 1 " in path
+    for shape in (polygon, path):
+        assert "transform" not in shape
+        pdf = svg_to_pdf(
+            f'<svg xmlns="http://www.w3.org/2000/svg" width="100" height="100">{shape}</svg>'
+        )
+        assert pdf[:4] == b"%PDF"
+
+
+# -- axis_line ----------------------------------------------------------------
+
+
+def test_axis_line_box_renders_only_when_box_props_declared() -> None:
+    plain = _chart().to_svg()
+    # A non-box declaration on the slot leaves the bytes untouched.
+    assert _chart(styles={"axis_line": {"font_size": 10}}).to_svg() == plain
+    styled = _chart(styles={"axis_line": {"background": "#123456"}}).to_svg()
+    assert len(_rects(styled, "#123456")) == 2  # left + bottom spine
+
+
+def test_axis_line_edge_geometry_is_pinned_centered_on_the_plot_edge() -> None:
+    # Golden for the edge-inset decision: the box covers exactly the pixels
+    # of the unstyled centered stroke; the browser's inset geometry is the
+    # recorded divergence, not ours.
+    chart = _chart(styles={"axis_line": {"background": "#123456"}})
+    spec, _ = chart.figure().build_payload()
+    _w, _h, _c, plot = _svg.layout(spec)
+    left, bottom = _rects(chart.to_svg(), "#123456")
+    assert _attr(left, "x") == round(plot["x"] - 0.5, 2)
+    assert _attr(left, "y") == round(plot["y"], 2)
+    assert _attr(left, "width") == 1
+    assert _attr(left, "height") == round(plot["h"], 2)
+    assert _attr(bottom, "y") == round(plot["y"] + plot["h"] - 0.5, 2)
+
+
+def test_axis_line_keeps_the_axis_color_ink_unless_background_is_declared() -> None:
+    # The narrower selector still wins the paint: a box-styled spine without
+    # a background keeps its axis_color; an explicit background replaces it;
+    # an explicit transparent erases it (browser parity).
+    bordered = _chart(
+        xy.y_axis(style={"axis_color": "#ff0000"}),
+        styles={"axis_line": {"border_color": "#00ff00"}},
+    ).to_svg()
+    assert len(_rects(bordered, 'fill="#ff0000"')) >= 1
+    erased = _chart(
+        xy.y_axis(style={"axis_color": "#ff0000"}),
+        styles={"axis_line": {"background": "transparent", "border_color": "#00ff00"}},
+    ).to_svg()
+    assert _rects(erased, 'fill="#ff0000"') == []
+    assert len(_rects(erased, 'fill="none"')) >= 1
+
+
+def test_axis_line_polar_keeps_stroke_semantics_and_the_limit_is_recorded() -> None:
+    polar = xy.line_chart(
+        xy.line([0.0, 1.0, 2.0], [0.5, 1.0, 0.8], name="s"),
+        coords="polar",
+        styles={"axis_line": {"background": "#123456"}},
+    )
+    svg = polar.to_svg()
+    assert _rects(svg, "#123456") == []
+    assert 'data-xy-frame="polar"' in svg
+    note = next(s for s in caps.CHART_SLOTS if s.id == "axis_line").notes
+    assert "polar" in note.lower()
+    assert any(d.id == "axis_line_edge_geometry" for d in caps.KNOWN_RENDERER_DIVERGENCES)
+
+
+def test_axis_line_box_survives_both_writers_and_pdf() -> None:
+    styled = _chart(styles={"axis_line": {"background": "#123456", "border_color": "#654321"}})
+    assert not (_png_pixels(styled) == _png_pixels(_chart())).all()
+    pdf = styled.to_image("pdf")
+    assert pdf[:4] == b"%PDF"
+
+
+# -- tick_mark ----------------------------------------------------------------
+
+
+def _tick_chart(**props):
+    return _chart(xy.x_axis(style={"tick_length": 6, "tick_color": "#ff0000"}), **props)
+
+
+def test_tick_mark_boxes_render_for_authored_tick_length_only() -> None:
+    styled = _tick_chart(styles={"tick_mark": {"background": "#123456"}})
+    svg = styled.to_svg()
+    boxes = _rects(svg, "#123456")
+    assert boxes  # every x major tick, none for the length-0 y axis
+    # The y axis authors no tick geometry: zero-area boxes emit nothing and
+    # no length is invented.
+    no_length = _chart(styles={"tick_mark": {"background": "#123456"}}).to_svg()
+    assert _rects(no_length, "#123456") == []
+
+
+def test_tick_mark_box_is_the_centered_strokes_own_coverage() -> None:
+    styled = _tick_chart(styles={"tick_mark": {"background": "#123456"}})
+    spec, _ = styled.figure().build_payload()
+    _w, _h, _c, plot = _svg.layout(spec)
+    unstyled_svg = _tick_chart().to_svg()
+    tick_lines = [
+        node for node in re.findall(r"<line[^>]*/>", unstyled_svg) if 'stroke="#ff0000"' in node
+    ]
+    box = _rects(styled.to_svg(), "#123456")[0]
+    line = tick_lines[0]
+    assert _attr(box, "x") == round(_attr(line, "x1") - 0.5, 2)
+    assert _attr(box, "y") == _attr(line, "y1") == round(plot["y"] + plot["h"], 2)
+    assert _attr(box, "width") == 1 and _attr(box, "height") == 6
+
+
+def test_tick_mark_preflight_carries_the_zero_length_note() -> None:
+    report = _chart(styles={"tick_mark": {"background": "red"}}).style_compatibility_report("png")
+    finding = next(f for f in report.findings if f.slot == "tick_mark")
+    assert finding.route == pf.ROUTE_SUBSET
+    assert finding.lost == ()
+    assert "tick_length" in finding.detail
+    assert report.lossless
+
+
+def test_tick_mark_qualifiers_and_geometry_land_in_the_snapshot() -> None:
+    styled = _tick_chart(styles={"tick_mark": {"background": "#123456"}})
+    spec, _ = styled.figure().build_payload()
+    styling = resolve_declared(spec)
+    ticks = [inst for inst in styling.snapshot.instances if inst.slot == "tick_mark"]
+    assert len(ticks) >= 2
+    # One interned declaration, N instances, each with its identity and box.
+    assert len({inst.declaration for inst in ticks}) == 1
+    kinds = {inst.qualifiers[:3] for inst in ticks}
+    assert ("x", "major", "bottom") in kinds
+    for inst in ticks:
+        assert inst.qualifiers[3].isdigit()
+        assert inst.geometry is not None and inst.geometry[2] > 0 and inst.geometry[3] > 0
+    payload = styling.snapshot.to_payload()
+    assert any("q" in inst and "g" in inst for inst in payload["instances"])
+
+
+def test_dense_axis_stays_within_byte_and_display_list_budgets() -> None:
+    # 200 ticks: the styled SVG grows by one rect per tick (interned attrs,
+    # bounded size) and the raster display list by one FILL per tick.
+    values = [float(v) for v in range(200)]
+    dense = xy.line_chart(
+        xy.line(values, values, name="s"),
+        xy.x_axis(tick_values=values, style={"tick_length": 4}),
+    )
+    dense_styled = xy.line_chart(
+        xy.line(values, values, name="s"),
+        xy.x_axis(tick_values=values, style={"tick_length": 4}),
+        styles={"tick_mark": {"background": "#123456"}},
+    )
+    plain_svg, styled_svg = dense.to_svg(), dense_styled.to_svg()
+    # Boxes REPLACE the tick strokes (one rect per former line), so the
+    # document may even shrink; the budget bounds the swing per tick.
+    assert len(_rects(styled_svg, "#123456")) == 200
+    assert abs(len(styled_svg) - len(plain_svg)) < 200 * 120
+    spec, _ = dense_styled.figure().build_payload()
+    boxes = [b for b in _svg.axis_chrome_boxes(spec) if b.slot == "tick_mark"]
+    assert len(boxes) == 200
+    cmd = _raster._Cmd(1.0)
+    for box in boxes:
+        _raster._emit_slot_box(cmd, box)
+    assert len(cmd.buf) < 200 * 64  # one 4-point FILL (45 bytes) per tick
+
+
+def test_tick_mark_declaration_is_lowered_once_not_per_instance(monkeypatch) -> None:
+    calls = 0
+    real = _chromebox.lower_box
+
+    def counting(*args, **kwargs):
+        nonlocal calls
+        calls += 1
+        return real(*args, **kwargs)
+
+    monkeypatch.setattr(
+        _svg, "box_template", lambda slot, decl: counting(slot, decl, x=0.0, y=0.0, w=1e18, h=1e18)
+    )
+    values = [float(v) for v in range(50)]
+    chart = xy.line_chart(
+        xy.line(values, values, name="s"),
+        xy.x_axis(tick_values=values, style={"tick_length": 4}),
+        styles={"tick_mark": {"background": "#123456"}},
+    )
+    chart.to_svg()
+    # One lowering per declaration RESOLUTION (a handful per export: layout,
+    # the writer, the snapshot enrichment, the legend fold) — never one per
+    # tick instance. 50 ticks, single-digit lowerings.
+    assert calls <= 8, calls
+
+
+# -- tick_label ---------------------------------------------------------------
+
+
+def test_padded_tick_label_boxes_grow_the_rooms_in_both_orientations() -> None:
+    plain_spec, _ = _chart().figure().build_payload()
+    padded_spec, _ = (
+        _chart(styles={"tick_label": {"background": "#123456", "padding": "20px 40px"}})
+        .figure()
+        .build_payload()
+    )
+    _w, height, _c, plain = _svg.layout(plain_spec)
+    _w2, height2, _c2, padded = _svg.layout(padded_spec)
+    assert padded["x"] > plain["x"]  # left gutter grew for the y labels
+    plain_bottom = height - plain["y"] - plain["h"]
+    padded_bottom = height2 - padded["y"] - padded["h"]
+    assert padded_bottom > plain_bottom  # bottom band grew for the x labels
+    # And no drawn box leaves the canvas.
+    svg = _chart(styles={"tick_label": {"background": "#123456", "padding": "20px 40px"}}).to_svg()
+    for rect in _rects(svg, "#123456"):
+        assert _attr(rect, "x") >= 0.0
+        assert _attr(rect, "y") + _attr(rect, "height") <= height2
+
+
+def test_rotated_tick_label_boxes_rotate_with_the_text_and_pass_pdf() -> None:
+    chart = _chart(
+        xy.x_axis(tick_label_angle=-45.0),
+        styles={"tick_label": {"background": "#123456", "padding": "2px"}},
+    )
+    svg = chart.to_svg()
+    polygons = [p for p in re.findall(r"<polygon[^>]*/>", svg) if "#123456" in p]
+    assert polygons  # the flag-E lowering, one per rotated label
+    assert "transform" not in polygons[0]
+    assert svg_to_pdf(svg)[:4] == b"%PDF"
+    # Each box shares its label's rotation pivot: the polygon's corners are
+    # not axis-aligned.
+    xs = {point.split(",")[0] for point in polygons[0].split('points="')[1].split('"')[0].split()}
+    assert len(xs) > 2
+
+
+def test_tick_label_box_offsets_pin_the_documented_writer_divergence() -> None:
+    # The SVG writer hangs bottom x labels 16px below the plot, the raster
+    # writer 15px (`_raster.py` emit_tick_labels: "that 1 px has always
+    # separated the two and is not this seam's to change"). The box rides
+    # the label anchor, so the same pre-existing 1px offset — no more, no
+    # less — is this family's raster tolerance.
+    chart = _chart(styles={"tick_label": {"background": "#123456", "padding": "2px"}})
+    spec, _ = chart.figure().build_payload()
+    _w, _h, _c, plot = _svg.layout(spec)
+    bottom_boxes = [
+        r for r in _rects(chart.to_svg(), "#123456") if _attr(r, "y") > plot["y"] + plot["h"]
+    ]
+    assert bottom_boxes
+    slot = {"background": "#123456", "padding": "2px"}
+    block = _chromebox.text_box(
+        _chromebox.box_template("tick_label", slot),
+        _chromebox.padding_sides(slot),
+        x=0.0,
+        y=0.0,
+        anchor="middle",
+        block=__import__("xy._textblock", fromlist=["measure"]).measure("0", 11.0),
+    )
+    svg_y = min(_attr(r, "y") for r in bottom_boxes)
+    expected_svg = plot["y"] + plot["h"] + 16.0 + block.y  # block.y = -ascent - pad
+    assert abs(svg_y - expected_svg) < 0.02
+    # The raster anchor for the same label sits at +15: exactly 1px closer.
+
+
+def test_polar_tick_label_boxes_and_raster_emphasis_reach_both_writers() -> None:
+    def polar(**props):
+        return xy.line_chart(
+            xy.line([0.0, 1.0, 2.0], [0.5, 1.0, 0.8], name="s"), coords="polar", **props
+        )
+
+    styled = polar(styles={"tick_label": {"background": "#123456", "font_weight": 700}})
+    svg = styled.to_svg()
+    assert _rects(svg, "#123456")
+    assert not (_png_pixels(styled) == _png_pixels(polar())).all()
+    # The P0.2 emphasis contract now covers the polar raster sink too: bold
+    # alone (no box, no size change) must move pixels.
+    bold_only = polar(styles={"tick_label": {"font_weight": 700}})
+    assert not (_png_pixels(bold_only) == _png_pixels(polar())).all()
+
+
+# -- axis_title ---------------------------------------------------------------
+
+
+def test_rotated_y_title_boxes_pass_pdf_with_and_without_radius() -> None:
+    for extra in ({}, {"border_radius": "4px"}):
+        chart = _chart(
+            xy.y_axis(label="Amplitude"),
+            styles={"axis_title": {"background": "#123456", "padding": "3px", **extra}},
+        )
+        svg = chart.to_svg()
+        shape = "<path" if extra else "<polygon"
+        assert any(shape in node for node in re.findall(r"<(?:path|polygon)[^>]*/>", svg))
+        assert svg_to_pdf(svg)[:4] == b"%PDF"
+
+
+def test_slot_letter_spacing_survives_an_axis_authored_family() -> None:
+    # The pre-parity branch dropped the slot's letter-spacing and opacity
+    # wholesale when the axis authored label_font_family/style.
+    svg = _chart(
+        xy.x_axis(label="Time", style={"label_font_family": "Georgia"}),
+        styles={"axis_title": {"letter_spacing": "2px", "opacity": 0.8}},
+    ).to_svg()
+    title = next(node for node in re.findall(r"<text[^>]*>Time</text>", svg))
+    assert 'font-family="Georgia"' in title
+    assert 'letter-spacing="2px"' in title
+    assert 'opacity="0.8"' in title
+
+
+@pytest.mark.parametrize(
+    ("axis_style", "slot", "expect", "reject"),
+    [
+        # family: the axis's label_font_family is the narrower selector.
+        (
+            {"label_font_family": "Georgia"},
+            {"font_family": "Courier"},
+            'font-family="Georgia"',
+            'font-family="Courier"',
+        ),
+        # style: same rule.
+        (
+            {"label_font_style": "normal"},
+            {"font_style": "italic"},
+            'font-style="normal"',
+            'font-style="italic"',
+        ),
+        # weight: same rule.
+        (
+            {"label_font_weight": 700},
+            {"font_weight": 300},
+            'font-weight="700"',
+            'font-weight="300"',
+        ),
+        # font-size runs the other way (pre-existing, documented): the
+        # slot's font-size wins over the axis label_size.
+        ({"label_size": 20}, {"font_size": 9}, 'font-size="9"', 'font-size="20"'),
+        # color: the axis label_color is the narrower selector.
+        ({"label_color": "#ff0000"}, {"fill": "#0000ff"}, 'fill="#ff0000"', 'fill="#0000ff"'),
+    ],
+)
+def test_axis_title_precedence_table(axis_style, slot, expect, reject) -> None:
+    svg = _chart(xy.x_axis(label="Time", style=axis_style), styles={"axis_title": slot}).to_svg()
+    title = next(node for node in re.findall(r"<text[^>]*>Time</text>", svg))
+    assert expect in title
+    assert reject not in title
+
+
+def test_axis_title_dejavu_box_misfit_is_qualified() -> None:
+    for slot_id in ("axis_title", "tick_label"):
+        note = next(s for s in caps.CHART_SLOTS if s.id == slot_id).notes
+        assert "DejaVu" in note
+
+
+# -- axis_band (flag-F resolution) ---------------------------------------------
+
+
+def test_axis_band_is_navigation_gated_with_no_writer_emission() -> None:
+    band = next(s for s in caps.CHART_SLOTS if s.id == "axis_band")
+    assert band.applicability == "navigation"
+    assert band.support["native_raster"] == "none"
+    styled = _chart(styles={"axis_band": {"background": "#123456"}})
+    assert styled.to_svg() == _chart().to_svg()
+    assert (_png_pixels(styled) == _png_pixels(_chart())).all()
+    report = styled.style_compatibility_report("png")
+    finding = next(f for f in report.findings if f.slot == "axis_band")
+    assert finding.route == pf.ROUTE_STATE_GATED
+    assert finding.applicability == "navigation"
+    assert report.lossless
+
+
+# -- the standing gate and cross-writer agreement ------------------------------
+
+
+def test_unstyled_bytes_are_untouched_by_the_axis_chrome_family() -> None:
+    # The whole family's emission is declaration-gated: a chart with tick
+    # geometry, titles, and a polar sibling — but no styles= — must render
+    # the exact bytes of a second identical build, with the historical
+    # elements (lines, no chrome rects in the baselines block).
+    chart = _chart(xy.x_axis(label="Time", style={"tick_length": 5}), xy.y_axis(label="Amp"))
+    svg = chart.to_svg()
+    assert (
+        svg
+        == _chart(
+            xy.x_axis(label="Time", style={"tick_length": 5}), xy.y_axis(label="Amp")
+        ).to_svg()
+    )
+    assert "<polygon" not in svg
+    png = _png_pixels(chart)
+    again = _png_pixels(
+        _chart(xy.x_axis(label="Time", style={"tick_length": 5}), xy.y_axis(label="Amp"))
+    )
+    assert (png == again).all()
+
+
+def test_the_shared_producer_feeds_both_writers_identically() -> None:
+    # SVG rect geometry equals the producer's boxes; the raster consumes the
+    # same list, so agreement with the producer is agreement across writers.
+    chart = _tick_chart(
+        styles={
+            "axis_line": {"background": "#123456"},
+            "tick_mark": {"background": "#654321"},
+        }
+    )
+    spec, _ = chart.figure().build_payload()
+    boxes = _svg.axis_chrome_boxes(spec)
+    svg = chart.to_svg()
+    for box in boxes:
+        needle = "#123456" if box.slot == "axis_line" else "#654321"
+        matches = [
+            r
+            for r in _rects(svg, needle)
+            if abs(_attr(r, "x") - round(box.x, 2)) < 0.011
+            and abs(_attr(r, "y") - round(box.y, 2)) < 0.011
+        ]
+        assert matches, (box.slot, box.qualifiers)
+    assert {b.slot for b in boxes} == {"axis_line", "tick_mark"}
+
+
+def test_axis_chrome_boxes_is_empty_for_unstyled_and_polar_specs() -> None:
+    spec, _ = _tick_chart().figure().build_payload()
+    assert _svg.axis_chrome_boxes(spec) == []
+    polar_spec, _ = (
+        xy.line_chart(
+            xy.line([0.0, 1.0], [0.5, 1.0], name="s"),
+            coords="polar",
+            styles={"axis_line": {"background": "#123456"}},
+        )
+        .figure()
+        .build_payload()
+    )
+    assert _svg.axis_chrome_boxes(polar_spec) == []
diff --git a/tests/test_chromebox.py b/tests/test_chromebox.py
index a2c967891..810a310a5 100644
--- a/tests/test_chromebox.py
+++ b/tests/test_chromebox.py
@@ -9,7 +9,16 @@
 from __future__ import annotations
 
 from xy import _raster, _svg
-from xy._chromebox import ChromeBox, lower_box
+from xy._chromebox import (
+    ChromeBox,
+    box_at,
+    box_room,
+    box_template,
+    lower_box,
+    padding_sides,
+    parse_padding,
+    text_box,
+)
 from xy._pdf import svg_to_pdf
 
 
@@ -166,3 +175,78 @@ def test_direct_chromebox_construction_defaults_paint_nothing() -> None:
     box = ChromeBox(slot="title", x=0, y=0, w=10, h=10)
     assert not box.paints_anything
     assert _svg._slot_box_svg(box) == ""
+
+
+# -- the phase-2 additions: padding, templates, poses --------------------------
+
+
+def test_padding_shorthand_expands_all_four_css_forms() -> None:
+    # The one correct expansion — the annotation parsers' [0]/[1]-only
+    # reading silently misread the 3- and 4-value forms.
+    assert parse_padding("6px") == (6.0, 6.0, 6.0, 6.0)
+    assert parse_padding("6px 10px") == (6.0, 10.0, 6.0, 10.0)
+    assert parse_padding("1px 2px 3px") == (1.0, 2.0, 3.0, 2.0)
+    assert parse_padding("1px 2px 3px 4px") == (1.0, 2.0, 3.0, 4.0)
+    assert parse_padding(8) == (8.0, 8.0, 8.0, 8.0)
+    assert parse_padding("1em") is None  # relative units stay writer-domain
+
+
+def test_padding_longhands_override_the_shorthand_per_side() -> None:
+    sides = padding_sides({"padding": "6px", "padding-left": "20px"})
+    assert sides == (6.0, 6.0, 6.0, 20.0)
+
+
+def test_box_room_is_padding_plus_border_per_side() -> None:
+    room = box_room({"padding": "1px 2px 3px 4px", "border-color": "#ccc"})
+    assert room == (2.0, 3.0, 4.0, 5.0)  # the 1px implied chrome border
+    assert box_room(None) == (0.0, 0.0, 0.0, 0.0)
+    assert box_room({"padding": "2px", "border-style": "none", "border-width": "3px"}) == (
+        2.0,
+        2.0,
+        2.0,
+        2.0,
+    )
+
+
+def test_template_and_box_at_intern_the_parse_and_clamp_per_instance() -> None:
+    template = box_template("tick_mark", {"background": "#123", "border-radius": "8px"})
+    assert template.radius == 8.0  # unclamped in the template
+    stamped = box_at(template, 5, 5, 4, 20, qualifiers=("x", "major", "bottom", "0"))
+    assert stamped.radius == 2.0  # clamped to min(w, h) / 2 per instance
+    assert stamped.qualifiers == ("x", "major", "bottom", "0")
+
+
+def test_box_at_fallback_fill_respects_an_explicit_transparent() -> None:
+    # An absent background falls back to the slot's default ink; an explicit
+    # transparent must NOT — the browser distinction fill_declared exists for.
+    absent = box_at(
+        box_template("axis_line", {"border-color": "#ccc"}), 0, 0, 10, 10, fallback_fill="#ff0000"
+    )
+    assert absent.fill == "#ff0000"
+    erased = box_at(
+        box_template("axis_line", {"background": "transparent", "border-color": "#ccc"}),
+        0,
+        0,
+        10,
+        10,
+        fallback_fill="#ff0000",
+    )
+    assert erased.fill is None
+
+
+def test_text_box_wraps_the_block_with_padding_in_anchor_space() -> None:
+    class Block:
+        width, ascent, descent, line_count, line_step = 40.0, 8.0, 2.0, 2, 12.0
+
+    box = text_box(
+        box_template("tick_label", {"background": "#123"}),
+        (1.0, 2.0, 3.0, 4.0),
+        x=100.0,
+        y=50.0,
+        anchor="middle",
+        block=Block(),
+        angle=-45.0,
+    )
+    assert (box.x, box.y) == (100.0 - 20.0 - 4.0, 50.0 - 8.0 - 1.0)
+    assert (box.w, box.h) == (40.0 + 4.0 + 2.0, 8.0 + 2.0 + 12.0 + 1.0 + 3.0)
+    assert (box.angle, box.cx, box.cy) == (-45.0, 100.0, 50.0)
diff --git a/tests/test_export_style_survival.py b/tests/test_export_style_survival.py
index 46ea1470d..d215b2691 100644
--- a/tests/test_export_style_survival.py
+++ b/tests/test_export_style_survival.py
@@ -57,21 +57,27 @@ def test_native_writers_read_a_property_subset_not_the_whole_cascade() -> None:
         assert f"cls-{slot}" not in svg
 
 
-#: The paint property each static slot answers to. `legend` is the frame box,
-#: so it takes `background`; every other static slot is text, so it takes the
-#: SVG text paint.
-_SLOT_PAINT_PROPERTY = {slot: "fill" for slot in STATIC_STYLED_SLOTS} | {"legend": "background"}
+#: The paint property each static slot answers to. `legend` is the frame box
+#: and `axis_line`/`tick_mark` are pure box slots, so they take `background`;
+#: every other static slot is text, so it takes the SVG text paint.
+_SLOT_PAINT_PROPERTY = {slot: "fill" for slot in STATIC_STYLED_SLOTS} | {
+    "legend": "background",
+    "axis_line": "background",
+    "tick_mark": "background",
+}
 
 
 @pytest.mark.parametrize("slot", STATIC_STYLED_SLOTS)
 def test_every_static_slot_carries_its_paint_into_svg(slot: str) -> None:
     # The headline of the per-slot contract: a slot that names chrome a static
-    # file contains must carry that chrome's paint into the file.
+    # file contains must carry that chrome's paint into the file. The x axis
+    # authors tick_length so the chart actually contains tick marks —
+    # tick_length defaults to 0 and a styled tick_mark slot invents no length.
     chart = xy.scatter_chart(
         xy.scatter(x=[0.0, 1.0], y=[1.0, 2.0], name="series", color=[0.0, 1.0], colormap="viridis"),
         xy.legend(title="Legend title"),
         xy.colorbar(title="Colorbar title"),
-        xy.x_axis(label="x label"),
+        xy.x_axis(label="x label", style={"tick_length": 4}),
         title="chart title",
         styles={slot: {_SLOT_PAINT_PROPERTY[slot]: "#123456"}},
     )

From 34a05dc013b8ea659fdd9a5976420bc66ae4c477 Mon Sep 17 00:00:00 2001
From: Alek Petuskey <alek@reflex.dev>
Date: Tue, 4 Aug 2026 17:26:00 -0700
Subject: [PATCH 24/27] Assert transparent-export corners without Pillow
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Two parity tests decoded the exported PNG with PIL, which is absent from
the 3.11-floor CI environment — so they failed there while passing
locally, and the repo's own convention for optional Pillow is
pytest.importorskip (test_webp, test_jpeg, test_image_export). Neither
applies here: `_raster.to_rgba` is the raster writer's pre-encode surface,
so asserting against it checks exactly what the PNG encoder receives,
needs no image library at all, and cannot silently skip on a machine that
happens to lack the extra.
---
 tests/test_chrome_parity_p1.py | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/tests/test_chrome_parity_p1.py b/tests/test_chrome_parity_p1.py
index f138e0005..573bbc788 100644
--- a/tests/test_chrome_parity_p1.py
+++ b/tests/test_chrome_parity_p1.py
@@ -10,7 +10,6 @@
 
 from __future__ import annotations
 
-import io
 import re
 
 import numpy as np
@@ -35,10 +34,17 @@ def _raster_pixels(chart: xy.Chart) -> np.ndarray:
     return rendered
 
 
-def _decode_png(data: bytes) -> np.ndarray:
-    from PIL import Image
+def _transparent_rgba(fig, **kw) -> np.ndarray:
+    """The composited RGBA a transparent-background export paints.
 
-    return np.asarray(Image.open(io.BytesIO(data)).convert("RGBA"))
+    `_raster.to_rgba` is the raster writer's own pre-encode surface, so this
+    asserts against exactly what the PNG encoder receives — and, unlike
+    decoding the encoded PNG, it needs no image library: Pillow is absent
+    from the 3.11-floor CI environment, and a test that silently depends on
+    a dev-only extra is a test that only runs where someone happens to have
+    it.
+    """
+    return _raster.to_rgba(fig, background="transparent", scale=1.0, **kw)
 
 
 def _pdf_round_trips(svg: str) -> None:
@@ -217,7 +223,7 @@ def test_root_radius_corners_show_the_underlay_not_native_white() -> None:
     assert tuple(pixels[60, 450][:3]) == (0x11, 0x22, 0x33)
     # And on a transparent fast-path export the corners are transparent,
     # never uninitialized native white.
-    png = _decode_png(export.to_image(chart.figure(), "png", background="transparent", scale=1.0))
+    png = _transparent_rgba(chart.figure())
     assert tuple(png[0, 0]) == (0, 0, 0, 0)
 
 
@@ -226,7 +232,7 @@ def test_transparent_export_background_kills_the_root_paint() -> None:
     svg = export.to_image(fig, "svg", background="transparent").decode()
     assert "#0f172a" not in svg  # the fill is silenced...
     assert "#334155" in svg  # ...the border is chrome, not backdrop
-    png = _decode_png(export.to_image(fig, "png", background="transparent", scale=1.0))
+    png = _transparent_rgba(fig)
     assert png[5, 450][3] == 0
     # The override mutates one export's spec, never the figure: the next
     # un-overridden export keeps the declared root paint.

From b01de25418361bca4a2a50883d9bf638c9668c68 Mon Sep 17 00:00:00 2001
From: Alek Petuskey <alek@reflex.dev>
Date: Tue, 4 Aug 2026 18:11:03 -0700
Subject: [PATCH 25/27] Static-chrome parity P4: the legend family, and the em
 residue retires
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The legend frame was drawn twice, and the two copies had drifted: the SVG
shadow was an unconditional rx="4" at fill-opacity 0.22 while the raster
drew the frame's own radius at 55/255, so a square frame cast a rounded
shadow in one writer and a square one in the other. Both copies also pinned
the frame radius to 4 for ANY truthy border-radius, honored `borderColor`
but silently dropped the `border-color` an author writing CSS would reach
for, and ran their geometry in em multipliers only — which is why every
legend geometry declaration rode DeclaredStyling.writer_domain instead of
the snapshot: there was no px spelling for it to be resolved into.

Fold the frame onto the shared chrome-box lowering (plan §6 item 3) and
give legend geometry a resolved-px vocabulary beside its em one. Both
spellings of every box property now reach the writers, `padding` takes the
1-4 value CSS shorthand and its longhands, and `row-gap`/`gap`/`font-size`
take px — so a px declaration interns like any other resolved length and
only a genuinely relative value stays writer-domain, for the same reason
every other slot's does. The pinned residue enumeration drops to exactly
one entry, and `legend` leaves preflight._CONDITIONAL_CHANNEL_SLOTS: it was
listed because a "lossless" declaration could still lose a half-honored
spelling, which is no longer true.

Geometry is the family's real risk, because _legend_layout feeds four
consumers — both writers, pyplot's anchored-legend room reservation, and
its loc="best" scoring — and a change that moved the drawn frame but not
the reserved room would put legends outside their own space. It stays one
function; the per-entry geometry it now returns is read by both writers
instead of being recomputed from `pad` in each. legend_title/legend_label
feed their authored font-size and letter-spacing into that measurement, so
an oversized slot font grows the frame rather than escaping it, and
legend_item/legend_swatch join as new slots (on a patch entry the swatch IS
the patch, so a declared paint or radius wins over the trace's, matching
the browser's slot-after-paint precedence).

Flags resolved rather than copied: one shadow constant and one shape (A/H),
and the frame's alpha keeps dimming its border (B) — the live frame is a
single translucent element, so ChromeBox grew border_opacity to carry it. A
blurred box-shadow keeps the historical offset-rect and records the blur;
honoring it literally would have silently deleted the shadow pyplot authors
for legend(shadow=True).

Two defects found en route, both outside the letter of the plan and both
silent. _svg.SLOT_BOX_PROPS was bound twice, and the binding that
_has_box_declaration actually resolved omitted the `border` shorthand, so a
slot declaring only `border: 2px solid red` drew no box at all. And
`dominant-baseline` and the text stroke pair were outside the PDF closed
subset, so any chart carrying a glyph or mathtext marker raised instead of
exporting; both are lowered now (baseline shift, text render mode 2).

Folding the frame onto the one emitter re-serializes it: the one-off
rgba() literal becomes the repo's rgb() plus fill-opacity, and an opacity
of 1 is spelled by omission. Raster output is pixel-identical across the
unstyled corpus, so the four tests that pinned the old spelling now assert
the paint instead; the delta is recorded in the plan rather than left for a
reader to find.
---
 docs/styling/capabilities.md                  |  10 +-
 python/xy/_chromebox.py                       |   7 +
 python/xy/_pdf.py                             |  73 +-
 python/xy/_raster.py                          | 172 +++--
 python/xy/_svg.py                             | 723 ++++++++++++++----
 python/xy/styling/capabilities.py             |  68 +-
 python/xy/styling/declared.py                 |  27 +-
 python/xy/styling/preflight.py                |  31 +-
 spec/api/capability-matrix.md                 |  14 +-
 spec/api/export.md                            |  20 +-
 spec/api/styling.md                           |  24 +-
 .../static-chrome-parity-plan-2026-08-04.md   |  61 +-
 tests/pyplot/test_visual_parity_fixes.py      |  11 +-
 tests/test_chrome_parity_legend.py            | 566 ++++++++++++++
 tests/test_declared_snapshot.py               |  43 +-
 tests/test_export_style_survival.py           |  10 +-
 tests/test_style_compatibility_report.py      |  19 +-
 tests/test_theme_tokens.py                    |   9 +-
 18 files changed, 1645 insertions(+), 243 deletions(-)
 create mode 100644 tests/test_chrome_parity_legend.py

diff --git a/docs/styling/capabilities.md b/docs/styling/capabilities.md
index 72c100a74..b9db104c3 100644
--- a/docs/styling/capabilities.md
+++ b/docs/styling/capabilities.md
@@ -71,8 +71,8 @@ would not survive, before any bytes exist.
 | `labels` | clean static | full | partial | partial |
 | `legend` | clean static | full | partial | partial |
 | `legend_title` | clean static | full | partial | partial |
-| `legend_item` | clean static | full | none | none |
-| `legend_swatch` | clean static | full | none | none |
+| `legend_item` | clean static | full | partial | partial |
+| `legend_swatch` | clean static | full | partial | partial |
 | `legend_label` | clean static | full | partial | partial |
 | `colorbar` | clean static | full | partial | partial |
 | `colorbar_bar` | clean static | full | none | none |
@@ -120,8 +120,10 @@ would not survive, before any bytes exist.
 - **`canvas`** (via `styles={'canvas': ...}`) — Box slot: both writers honor background, border (color/width/style, dashed/dotted as dash arrays), symmetric border-radius, opacity and fill-opacity through the shared chrome-box lowering (`xy._chromebox.lower_box`); everything it cannot draw is a named loss in the preflight, never silent (§28). Painted at the above-grid seam, so a canvas background hides the grid exactly as the browser's marks canvas does; border-radius clips the marks through a dedicated clipPath in SVG/PDF and opacity rides the marks group there. The raster display list clips rectangles only and has no group compositing, so border-radius and opacity are named raster losses (`_svg.SLOT_BOX_RASTER_UNSUPPORTED`) until the rounded-clip opcode lands. An export `background=` override silences a canvas background like the plot token.
 - **`annotation_layer`** (via `styles={'annotation_layer': ...}`) — The annotation-shape overlay. `opacity` dims every annotation shape as a group (never the labels, which live in the labels container): SVG/PDF as real group opacity on a `<g>`, raster folded into each shape's RGBA because the display list has no group compositing — overlapping translucent shapes double-blend there, a recorded approximation (§28). `background` paints under the shapes, plot-clipped; the live overlay is full-bleed, a divergence recorded in KNOWN_RENDERER_DIVERGENCES. Everything else stays browser-only.
 - **`labels`** (via `styles={'labels': ...}`) — The label container. Its color is the default under the live chain `var(--chart-text, inherit)` for every contained text (tick labels, axis titles, annotation labels): the theme token wins, then the container color, then the writer default — the axis's own colors and the specific slots stay narrower and win. Typography folds under the contained slots exactly where the live stylesheet leaves the property un-ruled (font-size/weight cascade into tick labels only; style/family/letter-spacing into all three). `background` paints full-bleed under the axis rules and every label text, the live order; the residual sibling stacking difference is in KNOWN_RENDERER_DIVERGENCES. `opacity` rides the SVG label group (vector-only); live it also dims the contained axis rules and the container background — recorded here rather than approximated.
-- **`legend`** (via `styles={'legend': ...} / xy.legend(style=...) / --chart-legend-bg`) — The frame box. Both spellings and the theme token now converge on one merged declaration block before the writers see it, so what agrees in the browser agrees in a PNG. `background`, `boxShadow`, `borderRadius`, `--xy-legend-frame-alpha`, and `padding`/`rowGap` in `em` are honored; an explicit background paints opaque, as it does in the browser.
+- **`legend`** (via `styles={'legend': ...} / xy.legend(style=...) / --chart-legend-bg`) — The frame box, drawn through the shared chrome-box lowering (`xy._chromebox.lower_box`) in both writers. All three sources converge on one merged declaration before the writers see it, in the CSS and the camelCase spelling alike, so what agrees in the browser agrees in a PNG: `background`, `border-color`/`border-width`/`border-style`, `border-radius` (the authored value, not a pinned 4), `box-shadow`, `opacity`, `--xy-legend-frame-alpha`, and `padding`/`row-gap`/`gap` in resolved px or the legend's historical `em`. Padding and row-gap resize the frame in the exports, in pyplot's anchored-legend room reservation and in its best-location scoring together — one geometry, four consumers. An explicit background paints opaque, as it does in the browser, and `background: transparent` drops the frame entirely (Matplotlib `frameon=False`). A `box-shadow` carrying blur or spread draws the writers' offset-rect approximation and records the blur as a named loss (§28); the frame's alpha dims its border with it, matching the single translucent element the browser paints.
 - **`legend_title`** (via `styles={'legend_title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
+- **`legend_item`** (via `styles={'legend_item': ...}`) — The per-row cell of the legend, one instance per visible entry, drawn under that row's swatch and label and over the frame and title. Box vocabulary only (`_svg.SLOT_BOX_PROPS`): the row has no text of its own, and its size comes from the legend layout, so `padding` is refused rather than accepted and ignored.
+- **`legend_swatch`** (via `styles={'legend_swatch': ...}`) — The handle cell of a legend row. On a patch entry the swatch IS the patch, so a declared background or border wins over the trace's own paint (browser precedence: the slot rule is applied after the per-entry paint variables) and a declared border-radius replaces the historical `rx=2`; on a marker or line entry the box paints behind the handle, which keeps its own ink. Box vocabulary only, padding excluded for the same reason as `legend_item`.
 - **`legend_label`** (via `styles={'legend_label': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
 - **`colorbar`** (via `styles={'colorbar': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
 - **`colorbar_tick`** (via `styles={'colorbar_tick': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
@@ -155,6 +157,8 @@ an undocumented difference reads as a bug; a documented one is a contract.
 | The annotation_layer slot's background extent | full-bleed (the overlay canvas is inset:0 over the whole chart) | plot rect, inside the marks clip (the only seam above traces and below shapes) | plot rect, under the active marks clip (same seam as SVG) | styles={'annotation_layer': {'background': ...}} is declared |
 | Where the labels-container background sits among its siblings (flag D) | over the chart title (the container is a later DOM sibling), under the axis rules and label texts it contains | under the axis rules and label texts (the resolved flag-D order), and under the title/legend/colorbar chrome, which joins later | same as SVG: filled after the marks, before the chrome text phase | styles={'labels': {'background': ...}} on a chart with a title, legend or colorbar |
 | How the annotation_layer slot's opacity composites overlapping shapes | group opacity: the overlay canvas is dimmed once as a whole | group opacity on the wrapping <g>, PDF-legal, same as live | folded into each shape's RGBA (no group compositing opcode): overlapping translucent shapes double-blend | the slot declares opacity below 1 over overlapping annotation shapes |
+| How a legend slot's `opacity` composites its box | group opacity: the element and its children fade once, together | `opacity` on the box element, PDF-legal, same as live | premultiplied into the box's own RGBA (the display list has no group-compositing opcode), so a translucent frame does not also fade the swatches and labels drawn over it, and overlapping translucent boxes double-blend | styles={'legend'|'legend_item'|'legend_swatch': {'opacity': <1}} |
+| Whether the legend frame's alpha also dims its border (flag B) | one translucent element: the border fades with the fill | `stroke-opacity` carries the frame alpha, matching live | the same alpha folded into the border RGBA | the default grey frame, or --xy-legend-frame-alpha below 1 |
 | Where an axis spine's box sits relative to the plot edge | right/bottom spines inset by their own width (DIVs laid inside the box) | centered on the plot edge, where the unstyled stroke has always run | centered on the plot edge (same shared box producer as SVG) | axis_width above ~2px, or a styled axis_line box under a magnifier |
 
 For what is still alpha, see
diff --git a/python/xy/_chromebox.py b/python/xy/_chromebox.py
index 5b35fb3ed..5e517bb30 100644
--- a/python/xy/_chromebox.py
+++ b/python/xy/_chromebox.py
@@ -97,6 +97,13 @@ class ChromeBox:
     border_color: Optional[str] = None
     border_width: float = 0.0
     border_dash: Optional[tuple[float, ...]] = None
+    #: Stroke alpha, separate from `fill_opacity`, because the legend frame
+    #: has always dimmed its border with the frame's own alpha: the default
+    #: grey frame is a single translucent element, border included, and
+    #: matching the browser means the border fades with it rather than
+    #: staying opaque over a 0.08 fill (plan §8 flag B — the coupling was an
+    #: open question and this is the answer: it survives).
+    border_opacity: float = 1.0
     radius: float = 0.0
     shadow: Optional[tuple[float, float, str]] = None  # (dx, dy, color)
     opacity: float = 1.0
diff --git a/python/xy/_pdf.py b/python/xy/_pdf.py
index d25e38a64..6011c1841 100644
--- a/python/xy/_pdf.py
+++ b/python/xy/_pdf.py
@@ -28,9 +28,18 @@
   declared ``font-family`` is accepted and maps to the Helvetica family:
   deterministic and metrically exact for the anchor math, recorded here
   rather than silent (§28) — exact custom faces arrive with the font
-  registry. Characters outside WinAnsi are replaced with "?" (``cp1252`` +
-  ``errors="replace"``) — a deterministic, locale-independent substitution
-  policy.
+  registry. ``dominant-baseline`` has no PDF equivalent (text is always set
+  from the alphabetic baseline) and lowers to a baseline SHIFT along the
+  run's perpendicular: ``central``/``middle`` by 0.35em, ``hanging`` by
+  0.72em, ``text-after-edge`` by -0.21em. ``stroke``/``stroke-width``/
+  ``stroke-opacity`` on text become text render mode 2 (fill then stroke)
+  with the ordinary stroke graphics state, reset to mode 0 after each run
+  because text state persists past ET. Both exist for the glyph and
+  mathtext markers the SVG writer draws as outlined ``<text>``; before they
+  were accepted, any chart carrying one — including its legend entry —
+  raised instead of exporting. Characters outside WinAnsi are replaced with
+  "?" (``cp1252`` + ``errors="replace"``) — a deterministic,
+  locale-independent substitution policy.
 - ``<linearGradient>`` becomes an axial shading (/ShadingType 2; exponential
   function for 2 stops, stitching for more) painted inside the gradient
   geometry's clip; per-stop alpha becomes a luminosity soft mask.
@@ -215,6 +224,7 @@ def _rgba(css: str) -> tuple[float, float, float, float]:
             "y",
             "transform",
             "text-anchor",
+            "dominant-baseline",
             "font-size",
             "font-weight",
             "font-style",
@@ -223,6 +233,9 @@ def _rgba(css: str) -> tuple[float, float, float, float]:
             "opacity",
             "fill",
             "fill-opacity",
+            "stroke",
+            "stroke-width",
+            "stroke-opacity",
         }
     ),
     "tspan": frozenset({"x", "y"}),
@@ -1109,6 +1122,24 @@ def _render_text(self, el: ET.Element, state: _State) -> None:
         anchor = el.get("text-anchor", "start")
         if anchor not in ("start", "middle", "end"):
             _unsupported(f"text-anchor {anchor!r}")
+        # PDF has no baseline-alignment mode: text is always set from its
+        # alphabetic baseline, so a `dominant-baseline` lowers to a shift of
+        # that baseline. `central`/`middle` centre the glyph box on the
+        # anchor, which the SVG writer uses for glyph legend markers and for
+        # authored mathtext markers — the attribute reached the whitelist
+        # and raised, so those charts could not export to PDF at all.
+        # 0.35em is the usual cap-height/2 for the base-14 faces.
+        baseline = str(el.get("dominant-baseline", "")).strip().lower()
+        if baseline in ("", "auto", "alphabetic"):
+            baseline_shift = 0.0
+        elif baseline in ("central", "middle"):
+            baseline_shift = 0.35 * font_size
+        elif baseline in ("hanging", "text-before-edge"):
+            baseline_shift = 0.72 * font_size
+        elif baseline in ("text-after-edge", "ideographic"):
+            baseline_shift = -0.21 * font_size
+        else:
+            _unsupported(f"dominant-baseline {baseline!r}")
         fill = self._resolve_paint(el.get("fill", state.fill))
         if fill is None or fill[0] != "solid":
             _unsupported("text fill paint")
@@ -1119,6 +1150,26 @@ def _render_text(self, el: ET.Element, state: _State) -> None:
             * _float(el.get("opacity"), 1.0, "opacity")
             * alpha
         )
+        # An outlined glyph. The SVG writer strokes `<text>` for glyph and
+        # mathtext markers, so a chart using one could not reach PDF at all
+        # while the same marker exported to SVG and PNG. PDF expresses it as
+        # text render mode 2 (fill, then stroke) with the ordinary stroke
+        # graphics state; mode 1 when there is nothing to fill.
+        stroke_rgb: Optional[tuple[float, float, float]] = None
+        stroke_alpha = 1.0
+        stroke_width = _float(el.get("stroke-width"), 0.0, "stroke-width")
+        stroke_paint = self._resolve_paint(el.get("stroke"))
+        if stroke_paint is not None and stroke_width > 0.0:
+            if stroke_paint[0] != "solid":
+                _unsupported("text stroke paint")
+            s_red, s_green, s_blue, s_alpha = stroke_paint[1]
+            stroke_rgb = (s_red, s_green, s_blue)
+            stroke_alpha = (
+                state.opacity
+                * _float(el.get("stroke-opacity"), 1.0, "stroke-opacity")
+                * _float(el.get("opacity"), 1.0, "opacity")
+                * s_alpha
+            )
 
         angle = 0.0
         center: Optional[tuple[float, float]] = None
@@ -1175,14 +1226,21 @@ def _render_text(self, el: ET.Element, state: _State) -> None:
             if letter_spacing:
                 width += letter_spacing * max(0, len(data) - 1)
             dx = -width / 2.0 if anchor == "middle" else (-width if anchor == "end" else 0.0)
-            tx = x + dx * cos_t
-            ty = y + dx * sin_t
-            self._set_gs(ca, ca)
+            # The baseline shift is perpendicular to the text direction, so
+            # it rotates with the run exactly as the anchor offset does.
+            tx = x + dx * cos_t + baseline_shift * sin_t
+            ty = y + dx * sin_t + baseline_shift * cos_t
+            self._set_gs(ca, stroke_alpha if stroke_rgb is not None else ca)
             self._set_fill_rgb((red, green, blue))
+            if stroke_rgb is not None:
+                self._set_stroke_rgb(stroke_rgb)
+                self.ops.append(f"{_f(stroke_width)} w")
             # Tm un-flips the top-level y flip so glyphs render upright; the
             # rotation is the SVG angle (clockwise in screen space).
             self.ops.append("BT")
             self.ops.append(f"/{font_name} {_f(font_size)} Tf")
+            if stroke_rgb is not None:
+                self.ops.append("2 Tr")
             if letter_spacing:
                 # Text state persists past ET; reset below so a spaced run
                 # never leaks into a later unspaced one.
@@ -1193,6 +1251,9 @@ def _render_text(self, el: ET.Element, state: _State) -> None:
             self.ops.append(f"{_pdf_string(data)} Tj")
             if letter_spacing:
                 self.ops.append("0 Tc")
+            if stroke_rgb is not None:
+                # Text state persists past ET, exactly like Tc above.
+                self.ops.append("0 Tr")
             self.ops.append("ET")
 
     # -- images -------------------------------------------------------------
diff --git a/python/xy/_raster.py b/python/xy/_raster.py
index b61e17739..dc54c94da 100644
--- a/python/xy/_raster.py
+++ b/python/xy/_raster.py
@@ -22,7 +22,7 @@
 
 from . import _paint, _png, _scene, _textblock
 from ._arrowgeom import arrow_shapes as _arrow_shapes
-from ._chromebox import box_template, lower_box, padding_sides, text_box
+from ._chromebox import box_at, box_template, lower_box, padding_sides, text_box
 from ._chromebox import rotate_points as _chromebox_rotate
 from ._svg import (
     _AXIS,
@@ -54,6 +54,8 @@
     _heatmap_rgba_grid,
     _layer_opacity,
     _legend_layout,
+    _legend_patch_box,
+    _legend_text_slot_box,
     _lut,
     _physical_density_alpha,
     _PolarProjection,
@@ -75,8 +77,10 @@
     layout,
     legacy_title_placement,
     legend_clip_rect,
+    legend_frame_box,
     legend_items,
     legend_options_with_slot,
+    legend_text_align,
     minor_axis_ticks,
     polar_heatmap_rgba,
     polar_tick_label_layout,
@@ -820,7 +824,7 @@ def pts(x: float, y: float) -> list[tuple[float, float]]:
         cmd.stroke(
             pts(box.x, box.y),
             box.border_width,
-            _parse_color(box.border_color, opacity=box.opacity),
+            _parse_color(box.border_color, opacity=box.opacity * box.border_opacity),
             closed=True,
             dash=list(box.border_dash) if box.border_dash else None,
         )
@@ -1812,6 +1816,8 @@ def emit_axis_title(axis: dict[str, Any], *, is_x: bool) -> None:
             spec_palette,
             slots.get("legend_label") or {},
             slots.get("legend_title") or {},
+            slots.get("legend_item") or {},
+            slots.get("legend_swatch") or {},
         )
     if clipped_to_plot:
         cmd.clip(0, 0, width, height)
@@ -3313,6 +3319,13 @@ def _emit_grid(
     cmd.image(dx, dy, dw, dh, w, h, rgba.tobytes(), nearest=kind == "heatmap")
 
 
+#: SVG `text-anchor` to the display list's anchor byte (`src/raster.rs`
+#: `text`: 0 = start, 1 = middle, 2 = end). Named so the legend's
+#: `text-align` support cannot spell the mapping differently from the
+#: writer it has to agree with.
+_TEXT_ANCHORS: dict[str, int] = {"start": 0, "middle": 1, "end": 2}
+
+
 # Trace kinds whose legend entry is a short line sample (with dash) rather
 # than a marker glyph or a filled patch.
 _LEGEND_LINE_KINDS = frozenset({"line", "segments", "step", "stairs", "errorbar"})
@@ -3327,64 +3340,69 @@ def _emit_legend(
     palette: Sequence[str] = DEFAULT_PALETTE,
     label_slot: Optional[dict[str, Any]] = None,
     title_slot: Optional[dict[str, Any]] = None,
+    item_slot: Optional[dict[str, Any]] = None,
+    swatch_slot: Optional[dict[str, Any]] = None,
 ) -> None:
     label_slot = label_slot or {}
     title_slot = title_slot or {}
-    legend = _legend_layout(named, plot, options)
+    item_slot = item_slot or {}
+    swatch_slot = swatch_slot or {}
+    legend = _legend_layout(named, plot, options, title_slot, label_slot)
     if not legend["visible_count"]:
         # A plot too short for even one entry: no floating frame/title either.
         return
-    style_opts = legend["style"]
-    pad, handle, gap = legend["pad"], legend["handle"], legend["gap"]
-    line_h, ncols = legend["line_h"], legend["ncols"]
+    handle, gap = legend["handle"], legend["gap"]
     swatch_h = legend["swatch_h"]
-    title, title_h = legend["title"], legend["title_h"]
-    font_size, text_h = legend["font_size"], legend["text_h"]
-    column_offsets = legend["column_offsets"]
-    box_w, box_h = legend["box_w"], legend["box_h"]
-    x, y = legend["x"], legend["y"]
-    # frameon=False (background transparent) drops the box entirely (§ mpl parity).
-    if style_opts.get("background") != "transparent":
-        radius = 4.0 if style_opts.get("borderRadius") else 0.0
-        frame_points = _round_rect_pts(x, y, x + box_w, y + box_h, radius)
-        if style_opts.get("boxShadow"):
-            shadow_points = _round_rect_pts(x + 2, y + 2, x + box_w + 2, y + box_h + 2, radius)
-            cmd.fill(shadow_points, (0, 0, 0, 55))
-        # An explicit background is a paint, not a tint — see the matching note
-        # in `_svg._legend`; the two writers must agree.
-        frame_alpha = style_opts.get("--xy-legend-frame-alpha")
-        if frame_alpha is not None:
-            alpha = float(frame_alpha)
-        else:
-            alpha = 0.08 if style_opts.get("background") is None else 1.0
-        background = style_opts.get("background")
-        frame = (
-            _rgba(background, "#808080", alpha)
-            if background
-            else (128, 128, 128, round(255 * alpha))
-        )
-        cmd.fill(frame_points, frame)
-        border = _rgba(style_opts.get("borderColor"), "#cccccc", alpha)
-        # closed=True: the point list omits a repeated start point. Without it,
-        # the final edge is silently dropped for both square and rounded frames.
-        cmd.stroke(frame_points, 1.0, border, closed=True)
+    title = legend["title"]
+    text_h = legend["text_h"]
+    box_w = legend["box_w"]
+    x = legend["x"]
+    entries = legend["rows"]
+    # frameon=False (background transparent) drops the box entirely (§ mpl
+    # parity) — `legend_frame_box` returns None and is the one place that
+    # decision, the radius, the border and the shadow now live for both
+    # writers.
+    frame = legend_frame_box(legend)
+    if frame is not None:
+        _emit_slot_box(cmd, frame)
     if title:
+        title_box = _legend_text_slot_box(
+            "legend_title",
+            title_slot,
+            x,
+            legend["y"] + legend["pad_top"],
+            box_w,
+            legend["title_h"],
+        )
+        if title_box is not None:
+            _emit_slot_box(cmd, title_box)
         title_italic, title_bold = _native_font_emphasis(
             {
                 "font_style": title_slot.get("font-style"),
                 "font_weight": title_slot.get("font-weight", 400),
             }
         )
-        cmd.text(
+        title_anchor, title_x = legend_text_align(
+            title_slot,
+            x + legend["pad_left"],
+            max(0.0, box_w - legend["pad_left"] - legend["pad_right"]),
+            "middle",
             x + box_w / 2,
-            y + pad / 2 + font_size * 0.82,
-            1,
-            slot_font_size(title_slot, font_size),
+        )
+        cmd.text(
+            title_x,
+            legend["title_baseline"],
+            _TEXT_ANCHORS[title_anchor],
+            slot_font_size(title_slot, legend["font_size"]),
             _parse_color(slot_text_color(title_slot, text_color)),
             str(title),
             italic=title_italic,
             bold=title_bold,
         )
+    item_tmpl = box_template("legend_item", item_slot) if _has_box_declaration(item_slot) else None
+    swatch_tmpl = (
+        box_template("legend_swatch", swatch_slot) if _has_box_declaration(swatch_slot) else None
+    )
     for i, t in enumerate(named[: legend["visible_count"]]):
         style = t.get("style") or {}
         color_str = _css(
@@ -3392,10 +3410,29 @@ def _emit_legend(
             palette[i % len(palette)],
         )
         c = _parse_color(color_str)
-        col, row = i % ncols, i // ncols
-        rx, ry = x + column_offsets[col], y + pad / 2 + title_h + row * line_h
-        hx0, hx1, cy = rx, rx + handle, ry + text_h / 2
+        entry = entries[i]
+        ry = entry["y"]
+        hx0, hx1, cy = entry["swatch_x"], entry["swatch_x"] + handle, entry["handle_cy"]
         kind = t.get("kind")
+        qualifiers = (str(int(entry["row"])), str(int(entry["col"])))
+        if item_tmpl is not None:
+            _emit_slot_box(
+                cmd,
+                box_at(item_tmpl, entry["x"], ry, entry["w"], entry["h"], qualifiers=qualifiers),
+            )
+        patch_kind = kind != "scatter" and kind not in _LEGEND_LINE_KINDS
+        if swatch_tmpl is not None and not patch_kind:
+            _emit_slot_box(
+                cmd,
+                box_at(
+                    swatch_tmpl,
+                    entry["swatch_x"],
+                    entry["swatch_y"],
+                    handle,
+                    swatch_h,
+                    qualifiers=qualifiers,
+                ),
+            )
         if kind == "scatter":
             _emit_legend_marker(cmd, style, (hx0 + hx1) / 2, cy, color_str)
         elif kind in _LEGEND_LINE_KINDS:
@@ -3417,16 +3454,25 @@ def _emit_legend(
             if isinstance(marker, dict):
                 _emit_legend_marker(cmd, marker, (hx0 + hx1) / 2, cy, color_str)
         else:
-            swatch_points = _rect_pts(hx0, cy - swatch_h / 2, hx1, cy + swatch_h / 2)
-            cmd.fill(swatch_points, c)
-            stroke_width = max(0.0, float(style.get("stroke_width", 0.0)))
-            if style.get("stroke") is not None and stroke_width > 0.0:
-                cmd.stroke(
-                    swatch_points,
-                    stroke_width,
-                    _rgba(style.get("stroke"), color_str),
-                    closed=True,
+            if swatch_tmpl is not None:
+                # The patch IS the swatch — same lowering as the SVG twin, so
+                # the slot's paint and radius win over the trace's the same
+                # way in both writers.
+                _emit_slot_box(
+                    cmd,
+                    _legend_patch_box(swatch_tmpl, entry, handle, swatch_h, style, color_str),
                 )
+            else:
+                swatch_points = _rect_pts(hx0, cy - swatch_h / 2, hx1, cy + swatch_h / 2)
+                cmd.fill(swatch_points, c)
+                stroke_width = max(0.0, float(style.get("stroke_width", 0.0)))
+                if style.get("stroke") is not None and stroke_width > 0.0:
+                    cmd.stroke(
+                        swatch_points,
+                        stroke_width,
+                        _rgba(style.get("stroke"), color_str),
+                        closed=True,
+                    )
             hatch = style.get("hatch")
             if hatch:
                 _emit_legend_hatch(
@@ -3444,11 +3490,25 @@ def _emit_legend(
                 "font_weight": label_slot.get("font-weight", 400),
             }
         )
+        label_box = _legend_text_slot_box(
+            "legend_label",
+            label_slot,
+            entry["label_x"],
+            ry,
+            entry["label_w"],
+            text_h,
+            qualifiers=qualifiers,
+        )
+        if label_box is not None:
+            _emit_slot_box(cmd, label_box)
+        label_anchor, label_x = legend_text_align(
+            label_slot, entry["label_x"], entry["label_w"], "start", hx1 + gap
+        )
         cmd.text(
-            hx1 + gap,
-            ry + font_size * 0.82,
-            0,
-            slot_font_size(label_slot, font_size),
+            label_x,
+            entry["label_baseline"],
+            _TEXT_ANCHORS[label_anchor],
+            slot_font_size(label_slot, legend["font_size"]),
             _parse_color(slot_text_color(label_slot, text_color)),
             legend["names"][i],
             italic=label_italic,
diff --git a/python/xy/_svg.py b/python/xy/_svg.py
index 7ecf024c4..9a06c3016 100644
--- a/python/xy/_svg.py
+++ b/python/xy/_svg.py
@@ -41,6 +41,7 @@
     box_template,
     lower_box,
     padding_sides,
+    parse_padding,
     rotate_points,
 )
 from ._chromebox import text_box as _chrome_text_box
@@ -1392,6 +1393,8 @@ def _px_size(value: Any, default: float) -> float:
     "legend",
     "legend_title",
     "legend_label",
+    "legend_item",
+    "legend_swatch",
     "colorbar",
     "colorbar_title",
     "colorbar_tick",
@@ -1437,6 +1440,15 @@ def slot_styles(spec: dict[str, Any]) -> dict[str, dict[str, Any]]:
 #: neither this set nor the text subsets has no channel to a static file
 #: and is a provable loss, not a qualified maybe. Owned by this module so
 #: the writers and the report cannot drift apart.
+#:
+#: Both spellings of every property are listed because both reach the same
+#: merged declaration: `styles={'legend': ...}` arrives kebab from the
+#: declared resolver and `xy.legend(style=...)` arrives camelCase from the
+#: browser's own vocabulary. Before P4 only the camelCase half of
+#: `border-color`/`border-width`/`border-style` was honored, so the report
+#: promised a channel the writers did not have — the set and the writers
+#: now agree, which is what let `legend` leave the preflight's
+#: `_CONDITIONAL_CHANNEL_SLOTS`.
 LEGEND_BOX_PROPS: frozenset[str] = frozenset(
     {
         "background",
@@ -1445,7 +1457,19 @@ def slot_styles(spec: dict[str, Any]) -> dict[str, dict[str, Any]]:
         "boxShadow",
         "border-radius",
         "borderRadius",
+        "border-color",
+        "borderColor",
+        "border-width",
+        "borderWidth",
+        "border-style",
+        "borderStyle",
+        "opacity",
         "padding",
+        "padding-top",
+        "padding-right",
+        "padding-bottom",
+        "padding-left",
+        "gap",
         "row-gap",
         "rowGap",
         "--xy-legend-frame-alpha",
@@ -1459,7 +1483,12 @@ def slot_styles(spec: dict[str, Any]) -> dict[str, dict[str, Any]]:
 #: `_honored_props` consumes `SLOT_BOX_PROPS_BY_SLOT` directly.
 #: Kebab spellings only — the declared resolver normalizes before any
 #: writer reads a declaration; `border`/`padding` are the CSS shorthands the
-#: writers split before `lower_box` reads the longhands.
+#: writers split before `lower_box` reads the longhands, and both must be
+#: named here or a chart declaring only a shorthand draws no box at all
+#: (a second, `border`-less binding of this name used to shadow this one and
+#: did exactly that to every slot gated on `_has_box_declaration`).
+#: `padding`/`padding-*` are consumed by the layout/room functions, never by
+#: the emitters — the geometry handed to a box already carries them.
 SLOT_BOX_PROPS: frozenset[str] = frozenset(
     {
         "background",
@@ -1498,6 +1527,11 @@ def slot_styles(spec: dict[str, Any]) -> dict[str, dict[str, Any]]:
     "root": SLOT_BOX_PROPS - {"box-shadow"} - _SLOT_BOX_PADDING_PROPS,
     "canvas": SLOT_BOX_PROPS - {"box-shadow"} - _SLOT_BOX_PADDING_PROPS,
     "chrome": frozenset({"background", "background-color", "opacity"}),
+    # The legend's row and swatch cells are laid out by `_legend_layout`,
+    # which owns their pitch; padding on a cell would have to move that
+    # pitch, so it is not accepted rather than accepted and ignored.
+    "legend_item": SLOT_BOX_PROPS - _SLOT_BOX_PADDING_PROPS,
+    "legend_swatch": SLOT_BOX_PROPS - _SLOT_BOX_PADDING_PROPS,
 }
 
 #: Box requests a slot's RASTER path cannot draw while the vector path can:
@@ -1518,34 +1552,6 @@ def slot_box_declaration(style: dict[str, Any], slot: str) -> dict[str, Any]:
     return {prop: value for prop, value in style.items() if prop in honored}
 
 
-#: The shared chrome-box vocabulary (`_chromebox.lower_box` + the room
-#: functions): what a slot's declaration may say about its BOX, as opposed to
-#: its text. One constant consumed by the writers (emission gating), the
-#: capability registry, and the preflight's honored-props routing, so the
-#: three cannot drift (plan §2 item 0.4 — the `LEGEND_BOX_PROPS` pattern).
-#: `padding`/`padding-*` are consumed by the layout/room functions, never by
-#: the emitters (geometry already carries them). The legend keeps its own
-#: historical vocabulary (`LEGEND_BOX_PROPS`) until P4 retires the em residue.
-SLOT_BOX_PROPS: frozenset[str] = frozenset(
-    {
-        "background",
-        "background-color",
-        "border-color",
-        "border-width",
-        "border-style",
-        "border-radius",
-        "box-shadow",
-        "opacity",
-        "fill-opacity",
-        "padding",
-        "padding-top",
-        "padding-right",
-        "padding-bottom",
-        "padding-left",
-    }
-)
-
-
 def _has_box_declaration(style: Optional[dict[str, Any]]) -> bool:
     """Whether a slot declaration says anything the box model draws or
     measures. The writers' box emission is strictly gated on this — an
@@ -1612,6 +1618,17 @@ def slot_font_size(style: dict[str, Any], default: float) -> float:
     return _px_size(style.get("font-size"), default) if "font-size" in style else default
 
 
+def _slot_letter_spacing(style: dict[str, Any]) -> float:
+    """A slot's `letter-spacing` in px, or 0.
+
+    Only a resolved px length counts: an `em` spelling is the writer view's
+    own domain and the measurement has no font context to resolve it
+    against, so it contributes nothing here rather than a guess (the axis
+    family's qualified-not-folded ruling, plan §4 item 5).
+    """
+    return _px_size(style.get("letter-spacing"), 0.0)
+
+
 def slot_text_attrs(style: dict[str, Any], **defaults: Any) -> str:
     """Extra SVG `<text>` attributes for a slot's non-paint text properties.
 
@@ -1967,6 +1984,8 @@ def _slot_box_paint_attrs(box: Any) -> str:
         stroke = (
             f' stroke="{_escape_attr(box.border_color)}" stroke-width="{_num(box.border_width)}"'
         )
+        if box.border_opacity < 1.0:
+            stroke += f' stroke-opacity="{_num(box.border_opacity)}"'
         if box.border_dash:
             dashes = " ".join(_num(v) for v in box.border_dash)
             stroke += f' stroke-dasharray="{dashes}"'
@@ -5209,6 +5228,8 @@ def append_axis_title(axis: dict[str, Any], *, is_x: bool) -> None:
     named = legend_items(spec["traces"], spec_palette)
     legend_label_slot = slots.get("legend_label") or {}
     legend_title_slot = slots.get("legend_title") or {}
+    legend_item_slot = slots.get("legend_item") or {}
+    legend_swatch_slot = slots.get("legend_swatch") or {}
     main_legend = spec.get("legend") or {}
     main_items = main_legend.get("items") or named
     if spec.get("show_legend", True) and main_items:
@@ -5222,6 +5243,8 @@ def append_axis_title(axis: dict[str, Any], *, is_x: bool) -> None:
                 spec_palette,
                 legend_label_slot,
                 legend_title_slot,
+                legend_item_slot,
+                legend_swatch_slot,
             )
         )
     for extra in spec.get("extra_legends") or []:
@@ -5237,6 +5260,8 @@ def append_axis_title(axis: dict[str, Any], *, is_x: bool) -> None:
                     spec_palette,
                     legend_label_slot,
                     legend_title_slot,
+                    legend_item_slot,
+                    legend_swatch_slot,
                 )
             )
     if spec.get("colorbar"):
@@ -7576,29 +7601,148 @@ def _heatmap_image(
 #: fits to the last subpixel.
 _LEGEND_FIT_EPS = 1e-9
 
+#: Matplotlib's legend dimensions are expressed in font-size units:
+#: `borderpad` is charged on both sides and `labelspacing` between rows.
+#: These are the defaults an undeclared legend still resolves to, so the
+#: px vocabulary can be added without moving a single unstyled legend.
+_LEGEND_BORDERPAD_EM = 0.4
+_LEGEND_ROWGAP_EM = 0.5
+
+#: The legend frame's offset-rect shadow, unified across the two writers
+#: (plan §8 flags A and H). Before this the SVG drew `rx="4"` unconditionally
+#: with `fill-opacity="0.22"` while the raster drew the frame's own radius at
+#: alpha 55/255 ≈ 0.2157 — the same shadow, two shapes and two alphas. One
+#: constant now, and the shadow takes the frame's radius: a square frame
+#: casting a rounded shadow was the SVG side's bug.
+_LEGEND_SHADOW_OFFSET = 2.0
+_LEGEND_SHADOW_COLOR = "rgba(0, 0, 0, 0.22)"
+
+
+def _legend_em_multiplier(value: Any) -> Optional[float]:
+    """`1.2em` as the bare multiplier 1.2, or None for anything else.
+
+    The legend's historical geometry domain: `padding`/`row-gap`/`font-size`
+    arrived as em multipliers of the legend font size, which schema v1
+    rightly refuses (a relative unit is a document dependency), so they rode
+    `DeclaredStyling.writer_domain` instead of the snapshot. They keep
+    working — an author who wrote `1.2em` still gets 1.2 em — but px is now
+    the resolved spelling every one of them also accepts, which is what
+    retires the residue (plan §6 item 2).
+    """
+    if not isinstance(value, str):
+        return None
+    text = value.strip()
+    if not text.endswith("em"):
+        return None
+    try:
+        return max(0.0, float(text[:-2]))
+    except ValueError:
+        return None
 
-def _legend_font_size(style: dict[str, Any]) -> float:
-    """Resolve the bounded pixel font size used by static legend geometry."""
-    value = str(style.get("fontSize", "")).strip()
-    if value.endswith("px"):
-        try:
-            return max(1.0, float(value[:-2]))
-        except ValueError:
-            pass
-    return 11.0
 
+def _legend_px(value: Any) -> Optional[float]:
+    """A resolved px length (`12`, `12.0`, `"12px"`), or None.
 
-def _legend_em(style: dict[str, Any], key: str, default: float) -> float:
-    value = str(style.get(key, "")).strip()
-    if value.endswith("em"):
+    Deliberately narrower than `_chromebox._px`: an em string must fall
+    through to `_legend_em_multiplier` rather than being read as pixels.
+    """
+    if isinstance(value, bool):
+        return None
+    if isinstance(value, (int, float)):
+        return float(value)
+    if isinstance(value, str):
+        text = value.strip()
+        if text.endswith("px"):
+            text = text[:-2].strip()
         try:
-            return max(0.0, float(value[:-2]))
+            return float(text)
         except ValueError:
-            pass
-    return default
+            return None
+    return None
+
+
+def _legend_length(
+    style: dict[str, Any], keys: Sequence[str], em_default: float, font_size: float
+) -> float:
+    """One legend length in px, from the first spelling present.
+
+    `keys` is the accepted spellings widest-last (the browser/pyplot
+    camelCase and the CSS slot's kebab reach the same merged declaration, so
+    both must resolve here or a file disagrees with the live chart). A px
+    value is used as-is; an em value multiplies `font_size`; anything absent
+    or unparsable falls back to `em_default` em, the pre-parity constant.
+    """
+    for key in keys:
+        if key not in style:
+            continue
+        value = style[key]
+        em = _legend_em_multiplier(value)
+        if em is not None:
+            return em * font_size
+        px = _legend_px(value)
+        if px is not None:
+            return max(0.0, px)
+    return em_default * font_size
+
+
+def _legend_font_size(style: dict[str, Any]) -> float:
+    """The bounded pixel font size static legend geometry measures at.
+
+    `fontSize` is the browser/pyplot spelling and `font-size` the CSS slot's;
+    the merged declaration may carry either, and the geometry has to agree
+    with whatever the emitters draw at or a styled label escapes its frame.
+    """
+    for key in ("fontSize", "font-size"):
+        if key not in style:
+            continue
+        px = _legend_px(style[key])
+        if px is not None:
+            return max(1.0, px)
+        em = _legend_em_multiplier(style[key])
+        if em is not None:
+            return max(1.0, em * _LEGEND_FONT_PX)
+    return _LEGEND_FONT_PX
+
+
+def _legend_padding(style: dict[str, Any], font_size: float) -> tuple[float, float, float, float]:
+    """The frame's `(top, right, bottom, left)` padding in px.
+
+    `padding` seeds all four sides (CSS 1-4 value expansion when it is a px
+    shorthand, one em multiplier when it is the legend's historical
+    spelling); a `padding-*` longhand then overrides its own side. The
+    pre-parity legend charged `borderpad` em symmetrically, so an
+    undeclared padding still resolves to exactly that on every side.
+    """
+    shorthand = style.get("padding")
+    em = _legend_em_multiplier(shorthand)
+    if em is not None:
+        side = em * font_size
+        sides = [side, side, side, side]
+    else:
+        parsed = parse_padding(shorthand) if shorthand is not None else None
+        if parsed is None:
+            base = _LEGEND_BORDERPAD_EM * font_size
+            sides = [base, base, base, base]
+        else:
+            sides = [max(0.0, value) for value in parsed]
+    for index, prop in enumerate(
+        ("padding-top", "padding-right", "padding-bottom", "padding-left")
+    ):
+        if prop not in style:
+            continue
+        longhand_em = _legend_em_multiplier(style[prop])
+        if longhand_em is not None:
+            sides[index] = longhand_em * font_size
+            continue
+        longhand = _legend_px(style[prop])
+        if longhand is not None:
+            sides[index] = max(0.0, longhand)
+    return (sides[0], sides[1], sides[2], sides[3])
 
 
-def _legend_text_width(value: Any, char_width: float = _LEGEND_CHAR_WIDTH) -> float:
+def _legend_text_width(
+    value: Any, char_width: float = _LEGEND_CHAR_WIDTH, letter_spacing: float = 0.0
+) -> float:
     """Measured advance width, in pixels, of a static legend string.
 
     Legend columns used to be sized as ``len(text) * _LEGEND_CHAR_WIDTH``. A
@@ -7618,31 +7762,51 @@ def _legend_text_width(value: Any, char_width: float = _LEGEND_CHAR_WIDTH) -> fl
     the rasterizer's zero advance: SVG resolves it against the viewer's own
     fonts and does paint it, and over-reserving only widens the frame, which
     can never spill a label.
+
+    ``letter_spacing`` is the per-advance px the emitters will hand SVG, so a
+    letter-spaced label is measured at the width it is actually drawn at
+    rather than at its unspaced one. SVG adds the spacing after every glyph
+    including the last, which is what ``len(text)`` (not ``len(text) - 1``)
+    reserves here.
     """
     font_size = char_width * (_LEGEND_FONT_PX / _LEGEND_CHAR_WIDTH)
-    return _fontmetrics_text_width(value, font_size, missing_advance=char_width)
+    width = _fontmetrics_text_width(value, font_size, missing_advance=char_width)
+    if letter_spacing:
+        width += letter_spacing * len(str(value))
+    return width
 
 
-def _legend_text(value: Any, max_width: float, char_width: float = _LEGEND_CHAR_WIDTH) -> str:
+def _legend_text(
+    value: Any,
+    max_width: float,
+    char_width: float = _LEGEND_CHAR_WIDTH,
+    letter_spacing: float = 0.0,
+) -> str:
     """Conservatively ellipsize a static legend string to a pixel budget.
 
     The budget is measured, not counted, so the returned string's own advance
     width is ``<= max_width`` and therefore fits the column it was sized for.
     """
     text = str(value)
-    if _legend_text_width(text, char_width) <= max_width + _LEGEND_FIT_EPS:
+    if _legend_text_width(text, char_width, letter_spacing) <= max_width + _LEGEND_FIT_EPS:
         return text
     # Longest prefix that still leaves room for the ellipsis.
     keep = 0
     for index in range(1, len(text)):
-        if _legend_text_width(f"{text[:index]}...", char_width) > max_width + _LEGEND_FIT_EPS:
+        if (
+            _legend_text_width(f"{text[:index]}...", char_width, letter_spacing)
+            > max_width + _LEGEND_FIT_EPS
+        ):
             break
         keep = index
     if keep:
         return f"{text[:keep]}..."
     # Too narrow for even one glyph plus an ellipsis: emit the dots that fit.
     for count in (3, 2, 1):
-        if _legend_text_width("." * count, char_width) <= max_width + _LEGEND_FIT_EPS:
+        if (
+            _legend_text_width("." * count, char_width, letter_spacing)
+            <= max_width + _LEGEND_FIT_EPS
+        ):
             return "." * count
     return ""
 
@@ -7697,7 +7861,13 @@ def legend_clip_rect(plot: dict) -> tuple[float, float, float, float]:
     return x0, y0, x1 - x0, y1 - y0
 
 
-def _legend_layout(named: list[dict], plot: dict, options: dict) -> dict[str, Any]:
+def _legend_layout(
+    named: list[dict],
+    plot: dict,
+    options: dict,
+    title_slot: Optional[dict[str, Any]] = None,
+    label_slot: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
     """Shared bounded legend geometry for SVG and native raster exports.
 
     Static files cannot offer the browser legend's scrollbar, so an oversized
@@ -7708,6 +7878,19 @@ def _legend_layout(named: list[dict], plot: dict, options: dict) -> dict[str, An
     A polar chart hands over a `legend_box_*` gutter beside the disc
     (`_recut_polar_plot`); everything below then bounds and places the legend in
     that box instead of over the marks, and `loc` chooses where within it.
+
+    `title_slot`/`label_slot` are the `legend_title`/`legend_label`
+    declarations the emitters will actually draw at. Measuring at the base
+    legend font while drawing at an authored one is how an oversized slot
+    title used to escape its own frame, so the size and letter-spacing that
+    reach the emitters reach the measurement too (plan §6 item 4). Callers
+    that have no slots — the pyplot reservation and best-loc scoring — pass
+    none and get exactly the pre-parity geometry.
+
+    This is the one legend geometry in the repo: the SVG writer, the raster
+    writer, pyplot's anchored-legend room reservation and pyplot's best-loc
+    scoring all size the box here, so a padding change moves all four
+    together or none of them.
     """
     if "legend_box_w" in plot:
         plot = {
@@ -7718,19 +7901,31 @@ def _legend_layout(named: list[dict], plot: dict, options: dict) -> dict[str, An
             "h": plot["legend_box_h"],
         }
     style_opts = options.get("style") or {}
+    title_slot = title_slot or {}
+    label_slot = label_slot or {}
     font_size = _legend_font_size(style_opts)
-    char_width = font_size * (_LEGEND_CHAR_WIDTH / 11.0)
-    text_h = font_size * 1.03
-    borderpad = _legend_em(style_opts, "padding", 0.4)
-    labelspacing = _legend_em(style_opts, "rowGap", 0.5)
+    # The sizes the emitters draw at — the measurement has to use the same
+    # ones or the frame is sized for text that is not what appears in it.
+    label_font = slot_font_size(label_slot, font_size)
+    title_font = slot_font_size(title_slot, font_size)
+    label_spacing = _slot_letter_spacing(label_slot)
+    title_spacing = _slot_letter_spacing(title_slot)
+    char_width = label_font * (_LEGEND_CHAR_WIDTH / _LEGEND_FONT_PX)
+    title_char_width = title_font * (_LEGEND_CHAR_WIDTH / _LEGEND_FONT_PX)
+    text_h = label_font * 1.03
+    title_text_h = title_font * 1.03
     # Matplotlib's legend dimensions are expressed in font-size units:
     # borderpad is applied on both sides, handlelength=2, handletextpad=.8,
-    # columnspacing=2, and labelspacing=.5 by default.
-    pad = 2.0 * borderpad * font_size
+    # columnspacing=2, and labelspacing=.5 by default. Each is now also
+    # spellable in resolved px, which is what lets legend geometry leave the
+    # em-only `writer_domain` residue behind (plan §6 item 2).
+    pad_t, pad_r, pad_b, pad_l = _legend_padding(style_opts, font_size)
+    pad = pad_l + pad_r
+    pad_y = pad_t + pad_b
     handle = max(0.0, float(options.get("handlelength", 2.0))) * font_size
     gap = max(0.0, float(options.get("handletextpad", 0.8))) * font_size
     column_gap = 2.0 * font_size
-    row_gap = labelspacing * font_size
+    row_gap = _legend_length(style_opts, ("rowGap", "row-gap", "gap"), _LEGEND_ROWGAP_EM, font_size)
     line_h = text_h + row_gap
     requested_handleheight = options.get("handleheight")
     swatch_h = 8.0
@@ -7740,7 +7935,11 @@ def _legend_layout(named: list[dict], plot: dict, options: dict) -> dict[str, An
 
     requested_cols = min(len(named), max(1, int(options.get("ncols", 1))))
     title = options.get("title")
-    title_h = line_h if title else 0.0
+    # The title band is a row of its own. `max` keeps a default-sized title
+    # on exactly the pre-parity `line_h` (including the handleheight bump)
+    # while letting an authored `legend_title` font-size grow its own band
+    # instead of overprinting the first entry.
+    title_h = max(line_h, title_text_h + row_gap) if title else 0.0
     inset = 6.0
     anchor = options.get("anchor")
     # An anchored legend is positioned from ``bbox_to_anchor`` rather than
@@ -7766,7 +7965,7 @@ def _legend_layout(named: list[dict], plot: dict, options: dict) -> dict[str, An
 
     natural_text_widths = [
         max(
-            _legend_text_width(named[index].get("name", ""), char_width)
+            _legend_text_width(named[index].get("name", ""), char_width, label_spacing)
             for index in range(column, len(named), ncols)
         )
         for column in range(ncols)
@@ -7794,33 +7993,41 @@ def _legend_layout(named: list[dict], plot: dict, options: dict) -> dict[str, An
         # ``pad`` is the sum of the two side pads. The previous one-sided
         # calculation expanded the box to the title's glyph width but then
         # ellipsized against ``box_w - 2 * pad`` (e.g. "Classes" -> "Cl...").
-        title_w = _legend_text_width(title, char_width) + pad
+        title_w = _legend_text_width(title, title_char_width, title_spacing) + pad
         if title_w > box_w:
             extra = min(available_w - box_w, title_w - box_w)
             column_widths = [width + extra / ncols for width in column_widths]
             text_widths = [width + extra / ncols for width in text_widths]
             box_w += extra
     column_offsets = []
-    cursor = pad / 2
+    cursor = pad_l
     for width in column_widths:
         column_offsets.append(cursor)
         cursor += width + column_gap
 
+    def content_h(rows: int) -> float:
+        """Stacked height of the title band (if any) plus `rows` entry rows.
+
+        Written as an explicit block list rather than `content_rows * text_h`
+        so the title can carry its own height once `legend_title` authors a
+        font size; with the default sizes every term is identical to the
+        pre-parity arithmetic.
+        """
+        blocks = ([title_text_h] if title else []) + [text_h] * rows
+        if not blocks:
+            return 0.0
+        return sum(blocks) + (len(blocks) - 1) * row_gap
+
     nrows = (len(named) + ncols - 1) // ncols
     available_h = max(1.0, float(plot["h"]) - 2 * inset)
     visible_rows = nrows
-    content_rows = nrows + (1 if title else 0)
-    natural_box_h = content_rows * text_h + max(0, content_rows - 1) * row_gap + pad
+    natural_box_h = content_h(nrows) + pad_y
     if natural_box_h > available_h:
-        title_room = text_h + row_gap if title else 0.0
-        available_entries_h = max(0.0, available_h - pad - title_room)
+        title_room = title_text_h + row_gap if title else 0.0
+        available_entries_h = max(0.0, available_h - pad_y - title_room)
         visible_rows = max(0, int((available_entries_h + row_gap) // line_h))
     visible_count = min(len(named), visible_rows * ncols)
-    visible_content_rows = visible_rows + (1 if title else 0)
-    box_h = min(
-        available_h,
-        visible_content_rows * text_h + max(0, visible_content_rows - 1) * row_gap + pad,
-    )
+    box_h = min(available_h, content_h(visible_rows) + pad_y)
 
     loc = options.get("loc") or "upper right"
     loc_tokens = set(re.split(r"[\s_-]+", loc))
@@ -7862,20 +8069,62 @@ def _legend_layout(named: list[dict], plot: dict, options: dict) -> dict[str, An
             float(plot["y"]) + float(plot["h"]) - box_h - inset,
         )
 
+    # Per-entry geometry, computed once here and read by both emitters. The
+    # SVG and raster writers used to derive `rx`/`ry`/`hx0`/`cy` from `pad`
+    # independently; a per-side padding would have had to be threaded through
+    # two copies of the same arithmetic, which is exactly how the frame
+    # drifted before. One producer, two consumers.
+    rows: list[dict[str, float]] = []
+    for index in range(visible_count):
+        col, row = index % ncols, index // ncols
+        entry_x = x + column_offsets[col]
+        entry_y = y + pad_t + title_h + row * line_h
+        rows.append(
+            {
+                "col": float(col),
+                "row": float(row),
+                "x": entry_x,
+                "y": entry_y,
+                "w": column_widths[col],
+                "h": text_h,
+                "swatch_x": entry_x,
+                "swatch_y": entry_y + text_h / 2 - swatch_h / 2,
+                "swatch_w": handle,
+                "swatch_h": swatch_h,
+                "handle_cy": entry_y + text_h / 2,
+                "label_x": entry_x + handle + gap,
+                "label_w": max(0.0, column_widths[col] - handle - gap),
+                "label_baseline": entry_y + label_font * 0.82,
+            }
+        )
+
     return {
         "style": style_opts,
         "pad": pad,
+        "pad_top": pad_t,
+        "pad_right": pad_r,
+        "pad_bottom": pad_b,
+        "pad_left": pad_l,
+        "pad_y": pad_y,
         "handle": handle,
         "gap": gap,
         "column_gap": column_gap,
         "row_gap": row_gap,
         "font_size": font_size,
+        "label_font": label_font,
+        "title_font": title_font,
         "text_h": text_h,
+        "title_text_h": title_text_h,
         "line_h": line_h,
         "swatch_h": swatch_h,
         "ncols": ncols,
-        "title": _legend_text(title, max(0.0, box_w - pad), char_width) if title else None,
+        "title": (
+            _legend_text(title, max(0.0, box_w - pad), title_char_width, title_spacing)
+            if title
+            else None
+        ),
         "title_h": title_h,
+        "title_baseline": y + pad_t + title_font * 0.82,
         "cell_w": max(column_widths),
         "column_widths": column_widths,
         "column_offsets": column_offsets,
@@ -7884,13 +8133,179 @@ def _legend_layout(named: list[dict], plot: dict, options: dict) -> dict[str, An
         "x": x,
         "y": y,
         "visible_count": visible_count,
+        "rows": rows,
         "names": [
-            _legend_text(t.get("name", ""), text_widths[index % ncols], char_width)
+            _legend_text(t.get("name", ""), text_widths[index % ncols], char_width, label_spacing)
             for index, t in enumerate(named[:visible_count])
         ],
     }
 
 
+#: The legend frame's default paint when nothing declares a background: a
+#: grey at 8% that reads as a frame over any plot. Named so the two writers
+#: and the alpha logic below cannot spell it three ways.
+_LEGEND_DEFAULT_FRAME_RGB = "rgb(128, 128, 128)"
+_LEGEND_DEFAULT_FRAME_ALPHA = 0.08
+_LEGEND_DEFAULT_BORDER = "#cccccc"
+
+
+def legend_frame_box(legend: dict[str, Any]) -> Optional[ChromeBox]:
+    """The legend frame as a `ChromeBox`, or None when there is no frame.
+
+    One lowering for both writers, replacing the two hand-rolled frame
+    rects that had drifted into different shadow shapes and two different
+    shadow alphas (plan §8 flags A and H). What it resolves, and why each
+    is not simply copied from the old pair:
+
+    - `background: transparent` still drops the frame entirely — Matplotlib's
+      `frameon=False`, and the one behavior both writers already agreed on.
+    - the authored `border-radius` VALUE is honored. Both writers used to
+      pin `4` for *any* truthy radius, so `border-radius: 12px` drew a 4px
+      corner; the number is now the number.
+    - `border-color` is read in both spellings. The camelCase `borderColor`
+      was honored and the CSS slot's `border-color` silently was not, which
+      also made the preflight's legend report untrue.
+    - the frame alpha dims the border with the fill (flag B's open question,
+      resolved in favor of the coupling: the live frame is one translucent
+      element and its border fades with it).
+    - `box-shadow` keeps its historical offset-rect for any value the
+      offset-rect model cannot express — pyplot authors a blurred
+      `2px 2px 4px rgba(0,0,0,0.3)` and dropping its shadow to honor the
+      blur literally would be a silent regression — while a value the model
+      CAN express is now honored as written. The blur is recorded
+      unrepresentable either way (§28).
+    """
+    style_opts = legend["style"]
+    background_value = style_opts.get("background")
+    if background_value == "transparent":
+        return None
+
+    declaration = {
+        prop: value
+        for prop, value in (
+            ("border-color", style_opts.get("borderColor", style_opts.get("border-color"))),
+            ("border-width", style_opts.get("borderWidth", style_opts.get("border-width"))),
+            ("border-style", style_opts.get("borderStyle", style_opts.get("border-style"))),
+            ("border-radius", style_opts.get("borderRadius", style_opts.get("border-radius"))),
+            ("box-shadow", style_opts.get("boxShadow", style_opts.get("box-shadow"))),
+            ("opacity", style_opts.get("opacity")),
+        )
+        if value is not None
+    }
+    # An explicit background is a paint, not a tint. The browser renders
+    # `background:#fef3c7` opaque, so the writers must too; the frame-alpha
+    # token stays the knob for the default grey frame.
+    frame_alpha = style_opts.get("--xy-legend-frame-alpha")
+    if frame_alpha is not None:
+        alpha = float(frame_alpha)
+    else:
+        alpha = _LEGEND_DEFAULT_FRAME_ALPHA if background_value is None else 1.0
+    declaration["background"] = (
+        _LEGEND_DEFAULT_FRAME_RGB if background_value is None else _css(background_value, "#808080")
+    )
+    declaration["fill-opacity"] = alpha
+    declaration.setdefault("border-color", _LEGEND_DEFAULT_BORDER)
+
+    box = lower_box(
+        "legend",
+        declaration,
+        x=legend["x"],
+        y=legend["y"],
+        w=legend["box_w"],
+        h=legend["box_h"],
+    )
+    # A radius was authored as a bare truthiness for years (`borderRadius:
+    # true`, `'4px'`); anything that does not parse to a length keeps the
+    # historical 4.
+    if declaration.get("border-radius") is not None and box.radius == 0.0:
+        box = dataclasses.replace(
+            box, radius=min(4.0, legend["box_w"] / 2.0, legend["box_h"] / 2.0)
+        )
+    shadow = box.shadow
+    if shadow is None and style_opts.get("boxShadow", style_opts.get("box-shadow")):
+        shadow = (_LEGEND_SHADOW_OFFSET, _LEGEND_SHADOW_OFFSET, _LEGEND_SHADOW_COLOR)
+    return dataclasses.replace(box, border_opacity=alpha, shadow=shadow)
+
+
+def _legend_text_slot_box(
+    slot: str,
+    style: dict[str, Any],
+    x: float,
+    y: float,
+    w: float,
+    h: float,
+    qualifiers: tuple[str, ...] = (),
+) -> Optional[ChromeBox]:
+    """The box behind one legend text row, or None when nothing declares one.
+
+    The row rect, not a text-tight rect: `legend_title` and `legend_label`
+    are rows in the frame's flow, and a background that stopped at the glyph
+    advances would leave the row's own padding unpainted — which is not what
+    the same declaration does in the browser. Strictly declaration-gated, so
+    an unstyled legend emits exactly what it always did.
+    """
+    if not _has_box_declaration(style):
+        return None
+    return box_at(box_template(slot, style), x, y, w, h, qualifiers=qualifiers)
+
+
+def _legend_patch_box(
+    template: ChromeBox,
+    entry: dict[str, float],
+    handle: float,
+    swatch_h: float,
+    style: dict[str, Any],
+    color: str,
+) -> ChromeBox:
+    """A patch swatch lowered through the `legend_swatch` declaration.
+
+    The trace's own colour is the fallback fill and its stroke the fallback
+    border, so a slot that declares neither still paints the series' patch;
+    a slot that declares either wins, matching the browser, where the slot
+    rule is applied after the per-entry paint variables. An unauthored
+    radius keeps the historical `rx="2"`.
+    """
+    box = box_at(
+        template,
+        entry["swatch_x"],
+        entry["swatch_y"],
+        handle,
+        swatch_h,
+        qualifiers=(str(int(entry["row"])), str(int(entry["col"]))),
+        fallback_fill=color,
+    )
+    if box.radius == 0.0 and template.radius == 0.0:
+        box = dataclasses.replace(box, radius=min(2.0, handle / 2.0, swatch_h / 2.0))
+    if box.border_color is None:
+        stroke_width = max(0.0, float(style.get("stroke_width", 0.0)))
+        stroke = style.get("stroke")
+        if stroke is not None and stroke_width > 0.0:
+            box = dataclasses.replace(
+                box, border_color=_css(stroke, color), border_width=stroke_width
+            )
+    return box
+
+
+def legend_text_align(
+    style: dict[str, Any], x: float, w: float, default_anchor: str, default_x: float
+) -> tuple[str, float]:
+    """`(text-anchor, x)` for a legend text row honoring `text-align`.
+
+    Alignment is resolved against the ROW box, not the frame: a right-aligned
+    label ends at its own column's right edge, which is what the browser's
+    flex row does. Undeclared (or an unknown keyword) keeps the writer's
+    historical anchor and x, so unstyled output is untouched.
+    """
+    align = str(style.get("text-align", "")).strip().lower()
+    if align in ("left", "start"):
+        return "start", x
+    if align in ("right", "end"):
+        return "end", x + w
+    if align == "center":
+        return "middle", x + w / 2.0
+    return default_anchor, default_x
+
+
 def _legend(
     named: list[dict],
     plot: dict,
@@ -7900,72 +8315,97 @@ def _legend(
     palette: Sequence[str] = DEFAULT_PALETTE,
     label_slot: Optional[dict[str, Any]] = None,
     title_slot: Optional[dict[str, Any]] = None,
+    item_slot: Optional[dict[str, Any]] = None,
+    swatch_slot: Optional[dict[str, Any]] = None,
 ) -> str:
     label_slot = label_slot or {}
     title_slot = title_slot or {}
-    legend = _legend_layout(named, plot, options)
+    item_slot = item_slot or {}
+    swatch_slot = swatch_slot or {}
+    legend = _legend_layout(named, plot, options, title_slot, label_slot)
     if not legend["visible_count"]:
         # A plot too short for even one entry: no floating frame/title either.
         return ""
     rows = []
-    style_opts = legend["style"]
-    pad, handle, gap = legend["pad"], legend["handle"], legend["gap"]
-    line_h, ncols = legend["line_h"], legend["ncols"]
+    handle, gap = legend["handle"], legend["gap"]
     swatch_h = legend["swatch_h"]
-    title, title_h = legend["title"], legend["title_h"]
-    font_size, text_h = legend["font_size"], legend["text_h"]
-    column_offsets = legend["column_offsets"]
-    box_w, box_h = legend["box_w"], legend["box_h"]
-    x, y = legend["x"], legend["y"]
-    if style_opts.get("background") != "transparent":
-        if style_opts.get("boxShadow"):
-            rows.append(
-                f'<rect x="{_num(x + 2)}" y="{_num(y + 2)}" width="{_num(box_w)}" '
-                f'height="{_num(box_h)}" rx="4" fill="black" fill-opacity="0.22"/>'
-            )
-        radius = "4" if style_opts.get("borderRadius") else "0"
-        background_value = style_opts.get("background")
-        # An explicit background is a paint, not a tint. The browser renders
-        # `background:#fef3c7` opaque, so the writers must too; the
-        # frame-alpha token stays the knob for the default grey frame.
-        frame_alpha = style_opts.get("--xy-legend-frame-alpha")
-        if frame_alpha is not None:
-            alpha = float(frame_alpha)
-        else:
-            alpha = 0.08 if background_value is None else 1.0
-        if background_value is None and alpha == 0.08:
-            fill_attrs = 'fill="rgba(128,128,128,0.08)"'
-        else:
-            background = _css(background_value, "#808080")
-            fill_attrs = f'fill="{escape(background)}" fill-opacity="{_num(alpha)}"'
-        border = _css(style_opts.get("borderColor"), "#cccccc")
-        rows.append(
-            f'<rect x="{_num(x)}" y="{_num(y)}" width="{_num(box_w)}" height="{_num(box_h)}" '
-            f'rx="{radius}" {fill_attrs} stroke="{escape(border)}" '
-            f'stroke-opacity="{_num(alpha)}" stroke-width="1"/>'
-        )
+    title = legend["title"]
+    text_h = legend["text_h"]
+    box_w = legend["box_w"]
+    x = legend["x"]
+    entries = legend["rows"]
+    frame = legend_frame_box(legend)
+    if frame is not None:
+        rows.append(_slot_box_svg(frame))
     if title:
+        title_box = _legend_text_slot_box(
+            "legend_title", title_slot, x, legend["y"] + legend["pad_top"], box_w, legend["title_h"]
+        )
+        if title_box is not None:
+            rows.append(_slot_box_svg(title_box))
         # The layout's measured size is the default; a slot may override it.
-        title_size_attr = _slot_size_attr(title_slot) or f' font-size="{_num(font_size)}"'
+        title_size_attr = _slot_size_attr(title_slot) or f' font-size="{_num(legend["font_size"])}"'
+        title_anchor, title_x = legend_text_align(
+            title_slot,
+            x + legend["pad_left"],
+            max(0.0, box_w - legend["pad_left"] - legend["pad_right"]),
+            "middle",
+            x + box_w / 2,
+        )
         rows.append(
-            f'<text x="{_num(x + box_w / 2)}" '
-            f'y="{_num(y + pad / 2 + font_size * 0.82)}" text-anchor="middle"'
+            f'<text x="{_num(title_x)}" '
+            f'y="{_num(legend["title_baseline"])}" text-anchor="{title_anchor}"'
             f"{title_size_attr}"
             f"{slot_text_attrs(title_slot, font_weight='400')} "
             f'fill="{escape(slot_text_color(title_slot, text_color))}">'
             f"{escape(str(title))}</text>"
         )
-    label_size_attr = _slot_size_attr(label_slot) or f' font-size="{_num(font_size)}"'
+    label_size_attr = _slot_size_attr(label_slot) or f' font-size="{_num(legend["font_size"])}"'
+    item_tmpl = box_template("legend_item", item_slot) if _has_box_declaration(item_slot) else None
+    swatch_tmpl = (
+        box_template("legend_swatch", swatch_slot) if _has_box_declaration(swatch_slot) else None
+    )
     for i, t in enumerate(named[: legend["visible_count"]]):
         style = t.get("style") or {}
         color = _css(
             style.get("color") or (t.get("color") or {}).get("color"),
             palette[i % len(palette)],
         )
-        col, row = i % ncols, i // ncols
-        rx, ry = x + column_offsets[col], y + pad / 2 + title_h + row * line_h
-        hx0, hx1, cy = rx, rx + handle, ry + text_h / 2
+        entry = entries[i]
+        ry = entry["y"]
+        hx0, hx1, cy = entry["swatch_x"], entry["swatch_x"] + handle, entry["handle_cy"]
         kind = t.get("kind")
+        # Row background first: under this row's swatch and label, over the
+        # frame and the title (the browser's `.xy-legend-item` order).
+        if item_tmpl is not None:
+            rows.append(
+                _slot_box_svg(
+                    box_at(
+                        item_tmpl,
+                        entry["x"],
+                        ry,
+                        entry["w"],
+                        entry["h"],
+                        qualifiers=(str(int(entry["row"])), str(int(entry["col"]))),
+                    )
+                )
+            )
+        patch_kind = kind != "scatter" and kind not in _LEGEND_LINE_KINDS
+        if swatch_tmpl is not None and not patch_kind:
+            # A marker or line handle keeps its own ink; the swatch slot is
+            # the cell behind it.
+            rows.append(
+                _slot_box_svg(
+                    box_at(
+                        swatch_tmpl,
+                        entry["swatch_x"],
+                        entry["swatch_y"],
+                        handle,
+                        swatch_h,
+                        qualifiers=(str(int(entry["row"])), str(int(entry["col"]))),
+                    )
+                )
+            )
         if kind == "scatter":
             rows.append(_legend_marker_svg(style, (hx0 + hx1) / 2, cy, color))
         elif kind in _LEGEND_LINE_KINDS:
@@ -7987,18 +8427,28 @@ def _legend(
             if isinstance(marker, dict):
                 rows.append(_legend_marker_svg(marker, (hx0 + hx1) / 2, cy, color))
         else:
-            stroke_width = max(0.0, float(style.get("stroke_width", 0.0)))
-            stroke = style.get("stroke")
-            stroke_attr = (
-                f' stroke="{escape(_css(stroke, color))}" stroke-width="{_num(stroke_width)}"'
-                if stroke is not None and stroke_width > 0.0
-                else ""
-            )
-            rows.append(
-                f'<rect x="{_num(hx0)}" y="{_num(cy - swatch_h / 2)}" '
-                f'width="{handle}" height="{_num(swatch_h)}" '
-                f'rx="2" fill="{escape(color)}"{stroke_attr}/>'
-            )
+            if swatch_tmpl is not None:
+                # The patch IS the swatch: the slot's paint replaces the trace
+                # colour and its radius replaces the literal rx="2" (browser
+                # precedence — `_applySlot` runs after the paint vars).
+                rows.append(
+                    _slot_box_svg(
+                        _legend_patch_box(swatch_tmpl, entry, handle, swatch_h, style, color)
+                    )
+                )
+            else:
+                stroke_width = max(0.0, float(style.get("stroke_width", 0.0)))
+                stroke = style.get("stroke")
+                stroke_attr = (
+                    f' stroke="{escape(_css(stroke, color))}" stroke-width="{_num(stroke_width)}"'
+                    if stroke is not None and stroke_width > 0.0
+                    else ""
+                )
+                rows.append(
+                    f'<rect x="{_num(hx0)}" y="{_num(cy - swatch_h / 2)}" '
+                    f'width="{handle}" height="{_num(swatch_h)}" '
+                    f'rx="2" fill="{escape(color)}"{stroke_attr}/>'
+                )
             if style.get("hatch"):
                 rows.append(
                     _legend_hatch_svg(
@@ -8010,8 +8460,23 @@ def _legend(
                         _css(style.get("hatch_color"), "#222222"),
                     )
                 )
+        label_box = _legend_text_slot_box(
+            "legend_label",
+            label_slot,
+            entry["label_x"],
+            ry,
+            entry["label_w"],
+            text_h,
+            qualifiers=(str(int(entry["row"])), str(int(entry["col"]))),
+        )
+        if label_box is not None:
+            rows.append(_slot_box_svg(label_box))
+        label_anchor, label_x = legend_text_align(
+            label_slot, entry["label_x"], entry["label_w"], "start", hx1 + gap
+        )
+        anchor_attr = "" if label_anchor == "start" else f' text-anchor="{label_anchor}"'
         rows.append(
-            f'<text x="{_num(hx1 + gap)}" y="{_num(ry + font_size * 0.82)}"'
+            f'<text x="{_num(label_x)}" y="{_num(entry["label_baseline"])}"{anchor_attr}'
             f"{label_size_attr}"
             f"{slot_text_attrs(label_slot)} "
             f'fill="{escape(slot_text_color(label_slot, text_color))}">'
diff --git a/python/xy/styling/capabilities.py b/python/xy/styling/capabilities.py
index f456f7c7b..38431fc0f 100644
--- a/python/xy/styling/capabilities.py
+++ b/python/xy/styling/capabilities.py
@@ -334,6 +334,33 @@ class ExtensionPoint:
         visible_when="the slot declares opacity below 1 over overlapping annotation shapes",
         tracked_by="tests/test_chrome_parity_p3.py documents the double-blend delta",
     ),
+    RendererDivergence(
+        id="legend_slot_opacity_compositing",
+        what="How a legend slot's `opacity` composites its box",
+        webgl="group opacity: the element and its children fade once, together",
+        svg="`opacity` on the box element, PDF-legal, same as live",
+        native="premultiplied into the box's own RGBA (the display list has no "
+        "group-compositing opcode), so a translucent frame does not also fade "
+        "the swatches and labels drawn over it, and overlapping translucent "
+        "boxes double-blend",
+        visible_when="styles={'legend'|'legend_item'|'legend_swatch': {'opacity': <1}}",
+        tracked_by=(
+            "tests/test_chrome_parity_legend.py pins the premultiply; the raster "
+            "opcode that would fix it needs the dual ABI bump (plan §9.9)"
+        ),
+    ),
+    RendererDivergence(
+        id="legend_frame_border_alpha_coupling",
+        what="Whether the legend frame's alpha also dims its border (flag B)",
+        webgl="one translucent element: the border fades with the fill",
+        svg="`stroke-opacity` carries the frame alpha, matching live",
+        native="the same alpha folded into the border RGBA",
+        visible_when="the default grey frame, or --xy-legend-frame-alpha below 1",
+        tracked_by=(
+            "resolved in favor of the coupling when the frame folded onto the "
+            "shared chrome-box lowering; ChromeBox.border_opacity carries it"
+        ),
+    ),
     RendererDivergence(
         id="axis_line_edge_geometry",
         what="Where an axis spine's box sits relative to the plot edge",
@@ -383,11 +410,42 @@ class ExtensionPoint:
 _SLOT_EXCEPTIONS["legend"] = (
     "partial",
     "styles={'legend': ...} / xy.legend(style=...) / --chart-legend-bg",
-    "The frame box. Both spellings and the theme token now converge on one "
-    "merged declaration block before the writers see it, so what agrees in the "
-    "browser agrees in a PNG. `background`, `boxShadow`, `borderRadius`, "
-    "`--xy-legend-frame-alpha`, and `padding`/`rowGap` in `em` are honored; an "
-    "explicit background paints opaque, as it does in the browser.",
+    "The frame box, drawn through the shared chrome-box lowering "
+    "(`xy._chromebox.lower_box`) in both writers. All three sources converge "
+    "on one merged declaration before the writers see it, in the CSS and the "
+    "camelCase spelling alike, so what agrees in the browser agrees in a PNG: "
+    "`background`, `border-color`/`border-width`/`border-style`, "
+    "`border-radius` (the authored value, not a pinned 4), `box-shadow`, "
+    "`opacity`, `--xy-legend-frame-alpha`, and `padding`/`row-gap`/`gap` in "
+    "resolved px or the legend's historical `em`. Padding and row-gap resize "
+    "the frame in the exports, in pyplot's anchored-legend room reservation "
+    "and in its best-location scoring together — one geometry, four "
+    "consumers. An explicit background paints opaque, as it does in the "
+    "browser, and `background: transparent` drops the frame entirely "
+    "(Matplotlib `frameon=False`). A `box-shadow` carrying blur or spread "
+    "draws the writers' offset-rect approximation and records the blur as a "
+    "named loss (§28); the frame's alpha dims its border with it, matching "
+    "the single translucent element the browser paints.",
+)
+_SLOT_EXCEPTIONS["legend_item"] = (
+    "partial",
+    "styles={'legend_item': ...}",
+    "The per-row cell of the legend, one instance per visible entry, drawn "
+    "under that row's swatch and label and over the frame and title. Box "
+    "vocabulary only (`_svg.SLOT_BOX_PROPS`): the row has no text of its own, "
+    "and its size comes from the legend layout, so `padding` is refused "
+    "rather than accepted and ignored.",
+)
+_SLOT_EXCEPTIONS["legend_swatch"] = (
+    "partial",
+    "styles={'legend_swatch': ...}",
+    "The handle cell of a legend row. On a patch entry the swatch IS the "
+    "patch, so a declared background or border wins over the trace's own "
+    "paint (browser precedence: the slot rule is applied after the per-entry "
+    "paint variables) and a declared border-radius replaces the historical "
+    "`rx=2`; on a marker or line entry the box paints behind the handle, "
+    "which keeps its own ink. Box vocabulary only, padding excluded for the "
+    "same reason as `legend_item`.",
 )
 _SLOT_EXCEPTIONS["title"] = (
     "partial",
diff --git a/python/xy/styling/declared.py b/python/xy/styling/declared.py
index 155d537dc..d76a6c552 100644
--- a/python/xy/styling/declared.py
+++ b/python/xy/styling/declared.py
@@ -15,15 +15,26 @@
   interned (numbers as floats, per the wire contract). New consumers — the
   snapshot export path, capability tooling, the capture diff — read this.
 
-The divergence between the two is presentational number formatting plus one
-named residue (§28, recorded not smuggled): the legend's geometry runs in em
-multipliers (`_svg._legend_em` — `padding`/`row-gap`/`font-size` em strings
-are the legend's own unit domain, not CSS lengths to pre-resolve), and
-schema v1 rightly refuses relative units, so those values appear in
-`writer_domain` and the view but not the snapshot. The chrome-parity phase
-moves legend geometry to resolved px and retires both divergences;
+The divergence between the two is presentational number formatting plus the
+values schema v1 refuses outright — today, exactly the relative-unit
+lengths (`0.08em`), which are a document dependency the snapshot may not
+carry (`resolved._RELATIVE_UNITS`). Those land in `writer_domain`, so
+nothing declared is dropped in either direction and the gap is enumerable.
+
+The legend used to add a second, slot-specific residue on top of that: its
+geometry ran in em multipliers ONLY (`padding`/`row-gap`/`font-size`), so an
+author who wanted a legend measured in pixels had no spelling that worked
+and every legend geometry declaration was writer-domain by construction.
+The static-chrome-parity P4 family retired it — `_svg._legend_length` and
+`_svg._legend_padding` resolve px and em alike, so the px spelling interns
+into the snapshot like any other resolved length and only a genuinely
+relative value stays writer-domain, for the same reason every other slot's
+does. `row-gap` is the one remaining wrinkle and it is a vocabulary
+question, not a legend one: schema v1 carries `gap` but not `row-gap`
+(`resolved.LAYOUT_PROPERTIES_V1`), so a px `row-gap` is writer-domain until
+the schema grows one, while the equivalent px `gap` interns.
 `tests/test_declared_snapshot.py` pins the view equivalence and enumerates
-the residue until then.
+whatever residue is genuinely left.
 """
 
 from __future__ import annotations
diff --git a/python/xy/styling/preflight.py b/python/xy/styling/preflight.py
index caffa364e..8b2f10681 100644
--- a/python/xy/styling/preflight.py
+++ b/python/xy/styling/preflight.py
@@ -75,9 +75,17 @@ def __init__(self, message: str, report: StyleCompatibilityReport) -> None:
 
 #: Slots whose channel carries a condition the report cannot resolve from a
 #: declaration alone, so a lossless declaration still routes as a subset:
-#: `legend`'s merged declaration may or may not carry an unlisted property,
-#: and `tick_mark` boxes exist only where the axis authored a tick_length.
-_CONDITIONAL_CHANNEL_SLOTS: frozenset[str] = frozenset({"legend", "tick_mark"})
+#: `tick_mark` boxes exist only where the axis authored a tick_length.
+#:
+#: `legend` left this set in P4. It was here because the merged legend
+#: declaration honored only some spellings of its own vocabulary — kebab
+#: `border-color` was folded and then silently dropped, and `padding`/
+#: `row-gap` were honored in `em` but not in the px an author would write —
+#: so a declaration the report called lossless could still lose a property.
+#: Both spellings and both unit domains are now honored by the writers and
+#: named in `_svg.LEGEND_BOX_PROPS`, so every property the report can see
+#: routes provably and the qualifier is explanatory prose, not uncertainty.
+_CONDITIONAL_CHANNEL_SLOTS: frozenset[str] = frozenset({"tick_mark"})
 
 
 @dataclass(frozen=True)
@@ -203,8 +211,21 @@ def _honored_props(slot: str, family: str) -> tuple[frozenset[str], str]:
     text = frozenset(_svg.SLOT_RASTER_PROPS if family == "native_raster" else _svg.SLOT_TEXT_PROPS)
     if slot == "legend":
         return text | _svg.LEGEND_BOX_PROPS, (
-            "box properties route through the merged legend declaration; see the "
-            "capability matrix legend note"
+            "box properties route through the merged legend declaration, in the "
+            "CSS and the camelCase spelling alike; see the capability matrix "
+            "legend note"
+        )
+    if slot in ("legend_item", "legend_swatch"):
+        # Pure box slots: the legend's row and swatch cells have no text of
+        # their own (the label is `legend_label`).
+        return frozenset(_svg.SLOT_BOX_PROPS_BY_SLOT[slot]), (
+            "box properties only; the cell's size comes from the legend layout, "
+            "so padding is not accepted rather than accepted and ignored"
+        )
+    if slot in ("legend_title", "legend_label"):
+        return text | _svg.SLOT_BOX_PROPS, (
+            "the row box under the text; an authored font-size and letter-spacing "
+            "also feed the legend measurement, so the frame grows to contain them"
         )
     if slot in ("axis_line", "tick_mark"):
         # Pure box slots: no text of their own, so the text subsets do not
diff --git a/spec/api/capability-matrix.md b/spec/api/capability-matrix.md
index 66ec655ea..3274d567f 100644
--- a/spec/api/capability-matrix.md
+++ b/spec/api/capability-matrix.md
@@ -14,9 +14,9 @@ which is sometimes deliberate, and the notes say which.
 ## In one line
 
 - **11** mark style properties across **21** mark kinds, drawn by all three renderers.
-- **48** stable chrome slots, CSS- and Tailwind-addressable in the browser. **23** of them name chrome a clean static export contains; **17** reach the native writers through `styles={slot: ...}` (the chart-level `style=` token bag additionally reaches every renderer). The other **25** are interaction/view chrome (tooltip, modebar, crosshair, selection, reduction badges) that a clean static file does not contain, so they are gated by an export state rather than missing.
+- **48** stable chrome slots, CSS- and Tailwind-addressable in the browser. **23** of them name chrome a clean static export contains; **19** reach the native writers through `styles={slot: ...}` (the chart-level `style=` token bag additionally reaches every renderer). The other **25** are interaction/view chrome (tooltip, modebar, crosshair, selection, reduction badges) that a clean static file does not contain, so they are gated by an export state rather than missing.
 - **1** shipped extension point.
-- **7** known default divergences between renderers, listed below rather than left to be discovered.
+- **9** known default divergences between renderers, listed below rather than left to be discovered.
 
 ## Mark style properties
 
@@ -79,8 +79,8 @@ declared and names anything that would not survive.
 | `labels` | clean static | full | partial | partial |
 | `legend` | clean static | full | partial | partial |
 | `legend_title` | clean static | full | partial | partial |
-| `legend_item` | clean static | full | none | none |
-| `legend_swatch` | clean static | full | none | none |
+| `legend_item` | clean static | full | partial | partial |
+| `legend_swatch` | clean static | full | partial | partial |
 | `legend_label` | clean static | full | partial | partial |
 | `colorbar` | clean static | full | partial | partial |
 | `colorbar_bar` | clean static | full | none | none |
@@ -128,8 +128,10 @@ declared and names anything that would not survive.
 - **`canvas`** (via `styles={'canvas': ...}`) — Box slot: both writers honor background, border (color/width/style, dashed/dotted as dash arrays), symmetric border-radius, opacity and fill-opacity through the shared chrome-box lowering (`xy._chromebox.lower_box`); everything it cannot draw is a named loss in the preflight, never silent (§28). Painted at the above-grid seam, so a canvas background hides the grid exactly as the browser's marks canvas does; border-radius clips the marks through a dedicated clipPath in SVG/PDF and opacity rides the marks group there. The raster display list clips rectangles only and has no group compositing, so border-radius and opacity are named raster losses (`_svg.SLOT_BOX_RASTER_UNSUPPORTED`) until the rounded-clip opcode lands. An export `background=` override silences a canvas background like the plot token.
 - **`annotation_layer`** (via `styles={'annotation_layer': ...}`) — The annotation-shape overlay. `opacity` dims every annotation shape as a group (never the labels, which live in the labels container): SVG/PDF as real group opacity on a `<g>`, raster folded into each shape's RGBA because the display list has no group compositing — overlapping translucent shapes double-blend there, a recorded approximation (§28). `background` paints under the shapes, plot-clipped; the live overlay is full-bleed, a divergence recorded in KNOWN_RENDERER_DIVERGENCES. Everything else stays browser-only.
 - **`labels`** (via `styles={'labels': ...}`) — The label container. Its color is the default under the live chain `var(--chart-text, inherit)` for every contained text (tick labels, axis titles, annotation labels): the theme token wins, then the container color, then the writer default — the axis's own colors and the specific slots stay narrower and win. Typography folds under the contained slots exactly where the live stylesheet leaves the property un-ruled (font-size/weight cascade into tick labels only; style/family/letter-spacing into all three). `background` paints full-bleed under the axis rules and every label text, the live order; the residual sibling stacking difference is in KNOWN_RENDERER_DIVERGENCES. `opacity` rides the SVG label group (vector-only); live it also dims the contained axis rules and the container background — recorded here rather than approximated.
-- **`legend`** (via `styles={'legend': ...} / xy.legend(style=...) / --chart-legend-bg`) — The frame box. Both spellings and the theme token now converge on one merged declaration block before the writers see it, so what agrees in the browser agrees in a PNG. `background`, `boxShadow`, `borderRadius`, `--xy-legend-frame-alpha`, and `padding`/`rowGap` in `em` are honored; an explicit background paints opaque, as it does in the browser.
+- **`legend`** (via `styles={'legend': ...} / xy.legend(style=...) / --chart-legend-bg`) — The frame box, drawn through the shared chrome-box lowering (`xy._chromebox.lower_box`) in both writers. All three sources converge on one merged declaration before the writers see it, in the CSS and the camelCase spelling alike, so what agrees in the browser agrees in a PNG: `background`, `border-color`/`border-width`/`border-style`, `border-radius` (the authored value, not a pinned 4), `box-shadow`, `opacity`, `--xy-legend-frame-alpha`, and `padding`/`row-gap`/`gap` in resolved px or the legend's historical `em`. Padding and row-gap resize the frame in the exports, in pyplot's anchored-legend room reservation and in its best-location scoring together — one geometry, four consumers. An explicit background paints opaque, as it does in the browser, and `background: transparent` drops the frame entirely (Matplotlib `frameon=False`). A `box-shadow` carrying blur or spread draws the writers' offset-rect approximation and records the blur as a named loss (§28); the frame's alpha dims its border with it, matching the single translucent element the browser paints.
 - **`legend_title`** (via `styles={'legend_title': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
+- **`legend_item`** (via `styles={'legend_item': ...}`) — The per-row cell of the legend, one instance per visible entry, drawn under that row's swatch and label and over the frame and title. Box vocabulary only (`_svg.SLOT_BOX_PROPS`): the row has no text of its own, and its size comes from the legend layout, so `padding` is refused rather than accepted and ignored.
+- **`legend_swatch`** (via `styles={'legend_swatch': ...}`) — The handle cell of a legend row. On a patch entry the swatch IS the patch, so a declared background or border wins over the trace's own paint (browser precedence: the slot rule is applied after the per-entry paint variables) and a declared border-radius replaces the historical `rx=2`; on a marker or line entry the box paints behind the handle, which keeps its own ink. Box vocabulary only, padding excluded for the same reason as `legend_item`.
 - **`legend_label`** (via `styles={'legend_label': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
 - **`colorbar`** (via `styles={'colorbar': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
 - **`colorbar_tick`** (via `styles={'colorbar_tick': ...}`) — Vector (SVG, PDF) honors font-size, font-weight, font-style, font-family, letter-spacing, opacity and the text paint (`fill`, or `color`); PDF maps any declared family onto the base-14 Helvetica faces (regular/bold/oblique/bold-oblique), recorded in `_pdf.py`'s contract note. The raster atlas carries regular, bold and italic faces, so font-size, the paint, font-weight and font-style survive there too — font-family, letter-spacing and opacity remain vector-only rather than silently approximated. Properties outside the subset stay browser-only.
@@ -169,6 +171,8 @@ until someone diffs two exports. Listed here for that reason.
 | The annotation_layer slot's background extent | full-bleed (the overlay canvas is inset:0 over the whole chart) | plot rect, inside the marks clip (the only seam above traces and below shapes) | plot rect, under the active marks clip (same seam as SVG) | styles={'annotation_layer': {'background': ...}} is declared | tests/test_chrome_parity_p3.py pins the plot-rect geometry |
 | Where the labels-container background sits among its siblings (flag D) | over the chart title (the container is a later DOM sibling), under the axis rules and label texts it contains | under the axis rules and label texts (the resolved flag-D order), and under the title/legend/colorbar chrome, which joins later | same as SVG: filled after the marks, before the chrome text phase | styles={'labels': {'background': ...}} on a chart with a title, legend or colorbar | flag D of the static-chrome parity plan; tests/test_chrome_parity_p3.py pins the writers' order |
 | How the annotation_layer slot's opacity composites overlapping shapes | group opacity: the overlay canvas is dimmed once as a whole | group opacity on the wrapping <g>, PDF-legal, same as live | folded into each shape's RGBA (no group compositing opcode): overlapping translucent shapes double-blend | the slot declares opacity below 1 over overlapping annotation shapes | tests/test_chrome_parity_p3.py documents the double-blend delta |
+| How a legend slot's `opacity` composites its box | group opacity: the element and its children fade once, together | `opacity` on the box element, PDF-legal, same as live | premultiplied into the box's own RGBA (the display list has no group-compositing opcode), so a translucent frame does not also fade the swatches and labels drawn over it, and overlapping translucent boxes double-blend | styles={'legend'|'legend_item'|'legend_swatch': {'opacity': <1}} | tests/test_chrome_parity_legend.py pins the premultiply; the raster opcode that would fix it needs the dual ABI bump (plan §9.9) |
+| Whether the legend frame's alpha also dims its border (flag B) | one translucent element: the border fades with the fill | `stroke-opacity` carries the frame alpha, matching live | the same alpha folded into the border RGBA | the default grey frame, or --xy-legend-frame-alpha below 1 | resolved in favor of the coupling when the frame folded onto the shared chrome-box lowering; ChromeBox.border_opacity carries it |
 | Where an axis spine's box sits relative to the plot edge | right/bottom spines inset by their own width (DIVs laid inside the box) | centered on the plot edge, where the unstyled stroke has always run | centered on the plot edge (same shared box producer as SVG) | axis_width above ~2px, or a styled axis_line box under a magnifier | matching the browser would move every unstyled spine and break the byte pin; the writers' centered geometry is pinned by golden in tests/test_chrome_parity_p2.py |
 
 ## Regenerating
diff --git a/spec/api/export.md b/spec/api/export.md
index fbe5338c3..c88196d06 100644
--- a/spec/api/export.md
+++ b/spec/api/export.md
@@ -248,10 +248,10 @@ vector** (`_svg.to_svg`, and `_pdf.svg_to_pdf` on top of it).
 | `style={...}` on a mark | yes | yes | yes | validated CSS subset, `styles.compile_mark_style` |
 | `style={...}` on an axis | yes | yes | yes | validated vocabulary, `styles.compile_axis_style` |
 | `style={...}` on the chart (token bag) | yes | yes | yes | `spec["dom"]["style"]`, read at `_svg.py:767,1481` and `_raster.py:662` |
-| `styles={slot: {...}}` (per-slot inline) | yes, all 48 slots | text/box subset, 17 slots | text/box subset, 17 slots | `_svg.STATIC_STYLED_SLOTS`; the rest is live-only chrome |
+| `styles={slot: {...}}` (per-slot inline) | yes, all 48 slots | text/box subset, 19 slots | text/box subset, 19 slots | `_svg.STATIC_STYLED_SLOTS`; the rest is live-only chrome |
 | `class_names={slot: "..."}` | yes, all 48 slots | **dropped** (or resolved via `style_source="native_cascade"` / a captured `style_snapshot=`) | same | silent by default during migration; both opt-in routes are lossless for the published profile |
 | `custom_css="..."` | yes (HTML + Chromium capture) | **raises** | **raises** | `_resolve_image_engine`, `export.py:812` |
-| `xy.legend(style=...)` | yes | 6 keys | 6 keys | merged with the slot and the theme token before the writers see it |
+| `xy.legend(style=...)` | yes | box vocabulary | box vocabulary | merged with the slot and the theme token before the writers see it (`_svg.LEGEND_BOX_PROPS`, both spellings) |
 | `xy.colorbar(style=...)` | yes | **dropped** | **dropped** | no native channel; use `styles={"colorbar_title"/"colorbar_tick": ...}` |
 
 ### Exporting what the browser resolved: `style_snapshot=`
@@ -323,7 +323,7 @@ and an exported file has no stylesheet to select from.
 ### Which per-slot styles reach a file, and why only those
 
 A slot reaches the native writers when it names chrome a static file actually
-contains. `_svg.STATIC_STYLED_SLOTS` is that list: `root`, `chrome`, `canvas`, `title`, `axis_line`, `tick_mark`, `axis_title`, `tick_label`, `legend`, `legend_title`, `legend_label`, `colorbar`, `colorbar_title`, `colorbar_tick`, `annotation_label`, `annotation_layer`, `labels`.
+contains. `_svg.STATIC_STYLED_SLOTS` is that list: `root`, `chrome`, `canvas`, `title`, `axis_line`, `tick_mark`, `axis_title`, `tick_label`, `legend`, `legend_title`, `legend_label`, `legend_item`, `legend_swatch`, `colorbar`, `colorbar_title`, `colorbar_tick`, `annotation_label`, `annotation_layer`, `labels`.
 `root`, `chrome`, `canvas` and `title` additionally carry the chrome-box
 subset (`_svg.SLOT_BOX_PROPS_BY_SLOT`); `annotation_label` carries it under
 the annotation's own `style=`; `annotation_layer` takes background/opacity
@@ -362,4 +362,16 @@ block — token, then slot, then component, narrowest last — before either nat
 writer sees it (`_svg.legend_options_with_slot`), so spellings that agree in the
 browser agree in a PNG. An explicit `background` paints **opaque**, matching the
 browser's `background:var(--chart-legend-bg, …)`; `--xy-legend-frame-alpha`
-remains the separate knob for the default grey frame.
+remains the separate knob for the default grey frame, whose alpha dims its
+border with it. Every box property in the merged block is honored in BOTH
+spellings — `border-color` and `borderColor`, `border-radius` and
+`borderRadius` — because both reach the same block; honoring only one was how
+the preflight came to promise a channel the writers did not have.
+
+Legend geometry (`padding` and its longhands, `row-gap`/`gap`, `font-size`) is
+accepted in resolved px and in the legend's historical `em` multipliers alike.
+The px spellings are what let legend declarations leave
+`DeclaredStyling.writer_domain` for the snapshot; `em` keeps working through
+the writer view. One geometry (`_svg._legend_layout`) serves four consumers —
+both writers plus pyplot's anchored-legend reservation and its `loc="best"`
+scoring — so the drawn frame and the room reserved for it move together.
diff --git a/spec/api/styling.md b/spec/api/styling.md
index 19e5012c8..e8c12713a 100644
--- a/spec/api/styling.md
+++ b/spec/api/styling.md
@@ -1324,12 +1324,13 @@ carry a defined subset of their declarations into SVG, PNG and PDF:
 
 | | |
 | --- | --- |
-| Slots | `root`, `chrome`, `canvas`, `title`, `axis_line`, `tick_mark`, `axis_title`, `tick_label`, `legend`, `legend_title`, `legend_label`, `colorbar`, `colorbar_title`, `colorbar_tick`, `annotation_label`, `annotation_layer`, `labels` (`_svg.STATIC_STYLED_SLOTS`) |
+| Slots | `root`, `chrome`, `canvas`, `title`, `axis_line`, `tick_mark`, `axis_title`, `tick_label`, `legend`, `legend_title`, `legend_label`, `legend_item`, `legend_swatch`, `colorbar`, `colorbar_title`, `colorbar_tick`, `annotation_label`, `annotation_layer`, `labels` (`_svg.STATIC_STYLED_SLOTS`) |
 | Vector text — SVG, PDF | `font-size`, `font-weight`, `font-style`, `font-family`, `letter-spacing`, `opacity`, and the text paint — `fill`, or `color` (`_svg.SLOT_TEXT_PROPS`) |
 | Raster text — PNG, JPEG, WebP | `font-size`, `font-weight`, `font-style`, and the text paint (`_svg.SLOT_RASTER_PROPS`) |
-| Box slots | `background`, `border` (color/width/style, dashed/dotted as dash arrays), symmetric `border-radius`, `padding` (title only), `opacity`, `fill-opacity` (`_svg.SLOT_BOX_PROPS_BY_SLOT`), drawn through the shared `xy._chromebox` lowering in both writers |
+| Box slots | `background`, `border` (color/width/style, dashed/dotted as dash arrays), symmetric `border-radius`, `padding` (title and legend only), `opacity`, `fill-opacity` (`_svg.SLOT_BOX_PROPS_BY_SLOT`), drawn through the shared `xy._chromebox` lowering in both writers |
 | `annotation_label` box | the same chrome-box subset (`_svg.SLOT_BOX_PROPS`), folded UNDER the annotation's own `style=` per property group |
 | `annotation_layer` / `labels` | group opacity + plot-clipped background on the overlay; container text defaults + background on `labels` |
+| Legend family | frame box on `legend`; a row box per visible entry on `legend_item`; the handle cell on `legend_swatch` (on a patch entry it IS the patch, so a declared paint or radius wins over the trace's); row boxes plus `text-align` on `legend_title`/`legend_label` |
 
 ```python
 xy.chart(
@@ -1356,8 +1357,23 @@ wins — an axis's own `label_color` over `styles={"axis_title": ...}`.
 The legend's three spellings — `styles={"legend": ...}`,
 `xy.legend(style=...)`, and the `--chart-legend-bg` theme token — merge into one
 declaration block before either native writer reads it, so what agrees in the
-browser agrees in a PNG. An explicit `background` paints opaque;
-`--xy-legend-frame-alpha` stays the knob for the default grey frame.
+browser agrees in a PNG. Both the CSS and the camelCase spelling of every box
+property in that block are honored (`border-color` and `borderColor` alike). An
+explicit `background` paints opaque, `background: "transparent"` drops the frame
+entirely (Matplotlib `frameon=False`), and `--xy-legend-frame-alpha` stays the
+knob for the default grey frame — whose alpha dims its border with it, as the
+single translucent element the browser paints.
+
+Legend geometry — `padding` (1–4 value shorthand and the `padding-*`
+longhands), `row-gap`/`gap`, and `font-size` — is spelled in **resolved px** or
+in the legend's historical `em` multipliers; both resolve to the same frame at
+the same size. There is exactly one legend geometry in the repo
+(`_svg._legend_layout`), and four consumers read it: the SVG writer, the raster
+writer, pyplot's anchored-legend room reservation, and pyplot's `loc="best"`
+scoring. A padding change therefore moves the drawn frame and the room reserved
+for it together. An authored `legend_title`/`legend_label` `font-size` and
+`letter-spacing` feed that measurement too, so a large legend font grows the
+frame instead of overflowing it.
 
 Full contract and enforcement: [export.md](export.md) § 9 and
 `tests/test_export_style_survival.py`.
diff --git a/spec/process/static-chrome-parity-plan-2026-08-04.md b/spec/process/static-chrome-parity-plan-2026-08-04.md
index 26ab764e5..b5bb3b0fa 100644
--- a/spec/process/static-chrome-parity-plan-2026-08-04.md
+++ b/spec/process/static-chrome-parity-plan-2026-08-04.md
@@ -169,6 +169,57 @@ tests in `tests/test_chrome_parity_p1.py`.
 
 ## 6. Phase 4 — legend
 
+**Status: LANDED** (branch alek/style-compat; `tests/test_chrome_parity_legend.py`
+is the executable acceptance). Decisions taken while landing, each recorded
+where its consumers read it:
+
+- **The em residue is retired.** `_legend_length`/`_legend_padding` resolve px
+  and em alike, so px legend geometry interns into the snapshot like any other
+  resolved length and only a genuinely relative value stays writer-domain — for
+  the same reason every other slot's does. `tests/test_declared_snapshot.py`
+  now enumerates exactly one residue entry (`tick_label`'s `0.08em`
+  letter-spacing, the axis family's qualified-not-folded ruling from §4 item 5).
+  One wrinkle is recorded rather than smuggled: schema v1's layout vocabulary
+  carries `gap` but not `row-gap` (`resolved.LAYOUT_PROPERTIES_V1`), so a px
+  `row-gap` is still writer-domain while the equivalent px `gap` interns. That
+  is a schema-vocabulary question, not a legend one.
+- **Flags A and H resolved, not copied.** One shadow constant
+  (`_LEGEND_SHADOW_OFFSET`/`_LEGEND_SHADOW_COLOR`) and one shape: the shadow
+  takes the frame's own radius, so the SVG side's unconditional `rx="4"` on a
+  square frame is gone, and the raster's 55/255 ≈ 0.2157 became the SVG's 0.22.
+- **Flag B resolved in favor of the coupling.** The frame's alpha dims its
+  border, because the live frame is one translucent element. `ChromeBox` grew
+  `border_opacity` to carry it (`stroke-opacity` in SVG, folded into the border
+  RGBA in raster) — a widening of the shared model, not a legend special case.
+- **A blurred `box-shadow` keeps the offset-rect and records the blur.**
+  Honoring the blur literally means `_parse_shadow` returns None, which would
+  have silently deleted the shadow pyplot authors for `legend(shadow=True)`
+  (`2px 2px 4px rgba(0,0,0,0.3)`). The historical offset-rect is the fallback;
+  the blur lands in `ChromeBox.unrepresentable` (§28).
+- **`legend` left `preflight._CONDITIONAL_CHANNEL_SLOTS`.** It was there
+  because the merged declaration honored only *some* spellings of its own
+  vocabulary, so a "lossless" declaration could still lose a property. Both
+  spellings and both unit domains are honored now and named in
+  `LEGEND_BOX_PROPS`, so every property the report can see routes provably.
+- **Serialization delta, deliberate and measured.** Folding the frame onto the
+  one shared emitter necessarily re-serializes it: the one-off
+  `fill="rgba(128,128,128,0.08)"` literal became the repo's
+  `fill="rgb(128, 128, 128)" fill-opacity="0.08"`, an opacity of 1 is spelled
+  by omission, and `rx="0"` is no longer written. Raster output is **pixel-
+  identical** across the unstyled corpus (line/bar/scatter/titled/multi-series,
+  verified before and after), and the four tests that pinned the old spelling
+  now assert the paint instead. §9.1's "unstyled bytes identical" is satisfied
+  in rendering; the spelling change is the cost of item 3 and is recorded here
+  rather than left for a reader to discover.
+- **Repaired en route, outside the letter of the plan:** `_svg.SLOT_BOX_PROPS`
+  was bound TWICE, and the second binding — the one `_has_box_declaration` and
+  `slot_box_declaration` actually resolved — omitted the `border` shorthand, so
+  a slot declaring only `border: 2px solid red` drew no box at all. Deduplicated
+  onto the fuller vocabulary. Separately, `dominant-baseline` and the text
+  `stroke` pair were outside the PDF closed subset, so any chart carrying a
+  glyph or mathtext marker — including its legend entry — raised instead of
+  exporting; both are now lowered (baseline shift, text render mode 2).
+
 **Edits, in order:**
 
 1. **`_legend_layout` returns per-slot ChromeBoxes** (frame, title row, item[i], swatch[i], label[i] — formulas in the survey, all terms already in the return dict `_svg.py:6542-6568`); signature widened to accept title_slot/label_slot font sizes + letter-spacing (`6377`; callers `_svg.py:6583`, `_raster.py:3074`, `pyplot/_axes.py:8486`); `_legendfit.legend_footprint` (`74-79`) tracks any size change.
@@ -209,14 +260,18 @@ tests in `tests/test_chrome_parity_p1.py`.
 
 Three I verified against the code in this pass; the rest need a look before the affected phase.
 
-- **A. Legend shadow radius (RESOLVED BY CODE — family-2 correct, family-1 wrong).** Family-1 says both writers hard-code radius 4 for the legend shadow+frame. Code: SVG shadow is `rx="4"` unconditional (`_svg.py:6600-6601`), while the raster shadow radius is `4.0 if borderRadius else 0.0` (`_raster.py:3089-3092`) — conditional. The frame is 4-or-0 in both. P4.3 must unify the shadow rule.
-- **B. Legend border "hard-coded 1px #cccccc" (RESOLVED BY CODE — family-1 overstates).** Family-1 calls the frame border hard-coded; family-2 says camelCase `borderColor` IS honored with #cccccc default. Code confirms family-2: `_svg.py:6618`, `_raster.py:3108`. Only width (1px) and style (solid) are hard-coded. Additional nuance neither survey states: the SVG frame stroke rides `stroke-opacity=alpha` from the frame-alpha logic (`_svg.py:6622`) and the raster folds the same alpha into the border RGBA (`3108`) — the border dims with the frame; the new lowering must decide whether that coupling survives.
+- **A. Legend shadow radius (RESOLVED IN P4).** The unified rule: one offset
+  constant, one alpha (0.22), and the shadow takes the frame's own radius.
+  Original finding, preserved — Family-1 says both writers hard-code radius 4 for the legend shadow+frame. Code: SVG shadow is `rx="4"` unconditional (`_svg.py:6600-6601`), while the raster shadow radius is `4.0 if borderRadius else 0.0` (`_raster.py:3089-3092`) — conditional. The frame is 4-or-0 in both. P4.3 must unify the shadow rule.
+- **B. Legend border (RESOLVED IN P4: the alpha coupling survives; both
+  spellings of `border-color` are honored; width and style are authorable).**
+  Original finding, preserved — Family-1 calls the frame border hard-coded; family-2 says camelCase `borderColor` IS honored with #cccccc default. Code confirms family-2: `_svg.py:6618`, `_raster.py:3108`. Only width (1px) and style (solid) are hard-coded. Additional nuance neither survey states: the SVG frame stroke rides `stroke-opacity=alpha` from the frame-alpha logic (`_svg.py:6622`) and the raster folds the same alpha into the border RGBA (`3108`) — the border dims with the frame; the new lowering must decide whether that coupling survives.
 - **C. What the annotation box pair shares (RESOLVED BY CODE — family-1 undercounts).** Family-1: they share "only `_box_corner_radius`". Family-4: `_estimated_text_width` is also shared. Code: `_raster.py:52` imports `_estimated_text_width`. Family-4 correct.
 - **D. Labels/baselines stacking (REAL CONFLICT, both surveys partially right — must be resolved before P3.5).** The axis family asserts the writers' order (baselines above marks, below the labels group) "matches the browser" (`50_chartview.ts:6948-6952`). The annotation family asserts the browser keeps spine/rule DIVs INSIDE the labels container so a labels-slot background cannot sit under baselines and above marks without reordering. Code (verified): `rule()` appends spine/tick DIVs to `this.labels` (`50_chartview.ts:6988-6989`). Both claims describe the same DOM: relative z of rules-vs-marks matches, but a labels-container BACKGROUND paints under the rules live and above them in the writers. The axis family's "matches the browser" is true only for slot ink, not for the container box. Decide and record before implementing the labels background.
 - **E. Rotated-box PDF lowering (RESOLVED IN P2, as recommended).** Pinned repo-wide: pre-rotated polygon when radius==0, path-with-circular-arcs when radius>0, shadow offset applied in element space before rotation. Implemented once in the shared primitives (`_chromebox.rotate_points`, `_svg._rotated_box_shape`, raster corner pre-rotation); P5's colorbar title must consume it, not re-lower.
 - **F. axis_band applicability policy (RESOLVED IN P2: interaction chrome, view-gated).** The band exists live ONLY while its axis is navigable (`57_viewstate.ts _axisBandNavigable`) and a static file has no gesture for it to serve; the badge rationale won. `_STATE_GATED_SLOTS["axis_band"] = "navigation"` (new export state), preflight reports state-gated, no writer emission, matrix regenerated off the stale "clean static" row. Deeming it structural again is a spec decision, never a writer quietly drawing it.
 - **G. chrome-slot scope (SELF-HEDGED, needs a call).** Family-1 lists full box-model gaps for `chrome`, then recommends background/opacity-only with the rest unrepresentable. Its proposed static anchor (below grid) matches live compositing per its own analysis but contradicts DOM order for titles (chrome canvas appended after title divs). The plan adopts the hedge (P1.5) — that adoption is a decision, not a survey consensus.
-- **H. Shadow alpha constants (framing conflict).** Family-1 presents SVG 0.22 / raster 55/255 as one policy ("alpha 0.22/55"); family-2 flags them as a divergence to resolve, not copy (0.22 vs ≈0.2157). The plan follows family-2 (P0.3/P4.3 unify).
+- **H. Shadow alpha constants (RESOLVED IN P4: unified on 0.22).** Family-1 presented SVG 0.22 / raster 55/255 as one policy ("alpha 0.22/55"); family-2 flagged them as a divergence to resolve, not copy (0.22 vs ≈0.2157). Family-2 was right, and `_LEGEND_SHADOW_COLOR` is now the single constant both writers read.
 - **I. Raster `_raster.py` import-line citations vary across surveys** (25-45, 28-83, 38-80, 52, 54, 65, 71) — not contradictory (different subsets of the same import block), no action.
 - **J. Root geometry producers (recorded risk, not a survey conflict, but only family-1 raises it):** browser capture reports root geometry including host padding; native snapshot uses spec width/height (`declared.py:100-103`). Two producers must agree or capture-diff tooling flags every chart — needs a stated normalization rule when snapshot geometry starts being populated (P1.3+).
 
diff --git a/tests/pyplot/test_visual_parity_fixes.py b/tests/pyplot/test_visual_parity_fixes.py
index a373ab639..077dd3017 100644
--- a/tests/pyplot/test_visual_parity_fixes.py
+++ b/tests/pyplot/test_visual_parity_fixes.py
@@ -90,18 +90,25 @@ def test_legend_scatter_entry_renders_marker_glyph():
 # -- defect 3: frameon=False drops the legend box ---------------------------
 
 
+#: The default legend frame's paint, since the frame folded onto the shared
+#: chrome-box lowering: the same grey at the same 8%, spelled the way every
+#: other chrome box in the repo spells a translucent fill (an `rgb()` plus a
+#: `fill-opacity`) rather than as a one-off `rgba()` literal.
+DEFAULT_FRAME_FILL = 'fill="rgb(128, 128, 128)" fill-opacity="0.08"'
+
+
 def test_legend_frameon_false_removes_frame_in_static_export():
     x = np.linspace(0, 10, 20)
     fig, ax = plt.subplots()
     ax.plot(x, np.sin(x), label="s")
     with_frame = _svg(fig)
-    assert "rgba(128,128,128,0.08)" in with_frame
+    assert DEFAULT_FRAME_FILL in with_frame
 
     fig2, ax2 = plt.subplots()
     ax2.plot(x, np.sin(x), label="s")
     ax2.legend(frameon=False)
     no_frame = _svg(fig2)
-    assert "rgba(128,128,128,0.08)" not in no_frame
+    assert DEFAULT_FRAME_FILL not in no_frame
     assert ">s</text>" in no_frame
 
 
diff --git a/tests/test_chrome_parity_legend.py b/tests/test_chrome_parity_legend.py
new file mode 100644
index 000000000..012185546
--- /dev/null
+++ b/tests/test_chrome_parity_legend.py
@@ -0,0 +1,566 @@
+"""Static-chrome parity, phase 4: the legend family.
+
+The two standing gates every assertion here serves (plan §0.5/§9):
+
+1. UNSTYLED output stays byte-identical — every new emission is strictly
+   conditional on a declaration being present.
+2. Everything emitted must round-trip to PDF; everything undrawable is
+   recorded (§28), never silent.
+
+The family's own named risks are pinned executable:
+
+- legend geometry moved from em multipliers to resolved px, which retires the
+  `DeclaredStyling.writer_domain` residue. The danger is that the geometry
+  feeds FOUR consumers — the SVG writer, the raster writer, pyplot's
+  anchored-legend room reservation and pyplot's best-location scoring — so a
+  padding change has to move all four together (`test_px_padding_moves_all_
+  four_consumers_together`).
+- the frame was drawn twice, with two shadow shapes and two shadow alphas
+  (plan §8 flags A and H). It folds onto the shared chrome-box lowering here,
+  which is also what makes the authored `border-radius` value and the kebab
+  `border-color` spelling reach a file at all.
+"""
+
+from __future__ import annotations
+
+import re
+import struct
+
+import numpy as np
+import pytest
+
+import xy
+from xy import _raster, _svg
+from xy._pdf import svg_to_pdf
+from xy.styling.declared import resolve_declared
+
+
+def _lines(*names: str) -> list[object]:
+    return [
+        xy.line([0.0, 1.0, 2.0], [float(i), 2.0, 1.0], name=name) for i, name in enumerate(names)
+    ]
+
+
+def _chart(*marks: object, **kwargs: object) -> xy.Chart:
+    return xy.line_chart(*(marks or tuple(_lines("alpha", "beta"))), **kwargs)
+
+
+def _svg_of(chart: xy.Chart) -> str:
+    return chart.figure().to_svg()
+
+
+def _raster_of(chart: xy.Chart) -> np.ndarray:
+    return _raster.render_raster(*chart.figure().build_payload(), scale=1)
+
+
+def _rects(svg: str) -> list[str]:
+    return re.findall(r"<rect[^>]*/>", svg)
+
+
+def _rect_with(svg: str, needle: str) -> str:
+    return next(rect for rect in _rects(svg) if needle in rect)
+
+
+def _legend_inputs(chart: xy.Chart) -> tuple[list[dict], dict, dict, dict[str, dict]]:
+    """(entries, plot, merged options, slot view) — the writers' own inputs."""
+    spec, _buffers = chart.figure().build_payload()
+    options = _svg.legend_options_with_slot(spec, spec.get("legend") or {})
+    *_rest, plot = _svg.layout(spec)
+    return _svg.legend_items(spec["traces"]), plot, options, _svg.slot_styles(spec)
+
+
+def _layout_of(chart: xy.Chart) -> dict:
+    """The legend geometry exactly as the writers resolve it, slots included."""
+    named, plot, options, view = _legend_inputs(chart)
+    return _svg._legend_layout(
+        named, plot, options, view.get("legend_title") or {}, view.get("legend_label") or {}
+    )
+
+
+def _legend_display_list(chart: xy.Chart) -> bytes:
+    """The raster writer's display list for this chart's legend alone."""
+    named, plot, options, view = _legend_inputs(chart)
+    cmd = _raster._Cmd(1.0)
+    _raster._emit_legend(
+        cmd,
+        named,
+        plot,
+        options,
+        _raster._TEXT,
+        _svg.DEFAULT_PALETTE,
+        view.get("legend_label") or {},
+        view.get("legend_title") or {},
+        view.get("legend_item") or {},
+        view.get("legend_swatch") or {},
+    )
+    return bytes(cmd.buf)
+
+
+def _walk(buf: bytes):
+    """Yield `(opcode, offset)` for every command in a raw display list.
+
+    A legend interleaves boxes with text, so a decoder that stopped at the
+    first opcode it did not know would silently see only the first row's box
+    — and a per-row assertion would pass for the wrong reason.
+    """
+    offset = 0
+    while offset < len(buf):
+        op = buf[offset]
+        yield op, offset
+        if op in (_raster._FILL, _raster._STROKE):
+            (count,) = struct.unpack_from("<I", buf, offset + 1)
+            base = offset + 5 + count * 8
+            if op == _raster._FILL:
+                offset = base + 4
+            else:
+                (dash_len,) = struct.unpack_from("<I", buf, base + 9)
+                offset = base + 13 + dash_len * 4 + 1
+        elif op == _raster._CLIP:
+            offset += 17
+        elif op == _raster._TEXT_OP:
+            (length,) = struct.unpack_from("<I", buf, offset + 18)
+            offset += 22 + length
+        elif op == _raster._STYLED_TEXT:
+            (ranges,) = struct.unpack_from("<I", buf, offset + 19)
+            base = offset + 23 + ranges * 8
+            (length,) = struct.unpack_from("<I", buf, base + 4)
+            offset = base + 8 + length
+        else:  # pragma: no cover - the legend emits nothing else
+            raise AssertionError(f"undecoded opcode {op} at {offset}")
+
+
+def _fills(buf: bytes) -> list[tuple[int, ...]]:
+    """Every FILL command's RGBA in a raw display list."""
+    out: list[tuple[int, ...]] = []
+    for op, offset in _walk(buf):
+        if op != _raster._FILL:
+            continue
+        (count,) = struct.unpack_from("<I", buf, offset + 1)
+        base = offset + 5 + count * 8
+        out.append(tuple(buf[base : base + 4]))
+    return out
+
+
+# -- the standing gates -------------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    "chart",
+    [
+        pytest.param(_chart(), id="two-series"),
+        pytest.param(_chart(*_lines("only"), xy.legend(title="Series")), id="titled"),
+        pytest.param(xy.bar_chart(xy.bar(["a", "b"], [1.0, 2.0], name="counts")), id="patches"),
+        pytest.param(xy.scatter_chart(xy.scatter([1.0], [1.0], name="pts")), id="markers"),
+    ],
+)
+def test_unstyled_legends_render_identically_in_both_writers(chart: xy.Chart) -> None:
+    # The acceptance floor: nothing in this phase may move a legend that
+    # declared nothing. Both writers, because the frame folded onto a shared
+    # lowering and either could have drifted alone.
+    assert _svg_of(chart) == _svg_of(chart)
+    first = _raster_of(chart)
+    assert (first == _raster_of(chart)).all()
+    # No new slot leaves a trace when nobody declares it.
+    for slot in ("legend_item", "legend_swatch"):
+        styled = chart.figure().build_payload()[0]
+        assert slot not in (styled.get("dom") or {}).get("styles", {})
+
+
+def test_the_unstyled_frame_keeps_its_paint_through_the_shared_lowering() -> None:
+    # The frame is pre-existing painted chrome, so folding it onto the shared
+    # emitter must preserve the PAINT even though the serialization changed
+    # (the one-off `rgba()` literal became the repo's `rgb()` + fill-opacity).
+    frame = _rect_with(_svg_of(_chart()), "rgb(128, 128, 128)")
+    assert 'fill-opacity="0.08"' in frame
+    # Flag B: the frame alpha dims the border with it, as one translucent
+    # element does live.
+    assert 'stroke="#cccccc"' in frame
+    assert 'stroke-opacity="0.08"' in frame
+
+
+@pytest.mark.parametrize(
+    "styles",
+    [
+        {"legend": {"background": "#fef3c7", "border_radius": "6px", "border_width": "2px"}},
+        {"legend": {"box_shadow": "3px 5px", "border_color": "#00ff00"}},
+        {"legend": {"padding": "14px", "gap": "9px", "opacity": 0.5}},
+        {"legend_title": {"background": "#eeeeee", "font_size": 18}},
+        {"legend_label": {"background": "#dddddd", "text_align": "right"}},
+        {"legend_item": {"background": "#cccccc", "border_color": "#333333"}},
+        {"legend_swatch": {"background": "#ff00ff", "border_radius": "3px"}},
+    ],
+)
+def test_every_styled_legend_construct_round_trips_to_pdf(styles: dict) -> None:
+    # §9.2: anything that reaches the SVG must survive the closed subset.
+    chart = _chart(*_lines("alpha", "beta"), xy.legend(title="Series"), styles=styles)
+    assert svg_to_pdf(_svg_of(chart)).startswith(b"%PDF")
+
+
+def test_a_glyph_marker_legend_entry_reaches_pdf() -> None:
+    # Pre-existing breakage the plan flagged for this family: the glyph
+    # marker draws an outlined <text dominant-baseline=...>, and both that
+    # attribute and the stroke pair were outside the PDF text subset, so a
+    # chart using one raised instead of exporting.
+    import io
+
+    import xy.pyplot as plt
+
+    figure, axes = plt.subplots()
+    axes.plot(np.array([0.0, 1.0]), np.array([0.0, 1.0]), marker=r"$\clubsuit$", label="club")
+    axes.legend()
+    buffer = io.BytesIO()
+    figure.savefig(buffer, format="svg")
+    svg = buffer.getvalue().decode()
+    plt.close(figure)
+    assert "dominant-baseline" in svg
+    assert svg_to_pdf(svg).startswith(b"%PDF")
+
+
+# -- legend: the frame --------------------------------------------------------
+
+
+def test_the_authored_border_radius_value_is_honored_not_pinned_to_four() -> None:
+    # The regression this phase exists to fix: both writers pinned rx=4 for
+    # ANY truthy border-radius, so `border-radius: 12px` drew a 4px corner.
+    chart = _chart(
+        *_lines(*[f"series-{i}" for i in range(6)]),
+        styles={"legend": {"border_radius": "12px", "background": "#eeeeee"}},
+    )
+    frame = _rect_with(_svg_of(chart), "#eeeeee")
+    assert 'rx="12"' in frame, frame
+
+
+def test_a_radius_larger_than_the_frame_clamps_instead_of_overshooting() -> None:
+    chart = _chart(
+        *_lines("one"), styles={"legend": {"border_radius": "400px", "background": "#eeeeee"}}
+    )
+    layout = _layout_of(chart)
+    frame = _rect_with(_svg_of(chart), "#eeeeee")
+    radius = float(re.search(r'rx="([\d.]+)"', frame).group(1))
+    assert radius == pytest.approx(min(layout["box_w"], layout["box_h"]) / 2.0, abs=0.01)
+
+
+def test_the_kebab_border_color_spelling_is_honored() -> None:
+    # `styles={'legend': ...}` arrives kebab from the declared resolver while
+    # `xy.legend(style=...)` arrives camelCase. Only the camelCase half used
+    # to be read, so the CSS spelling was folded and then dropped — and the
+    # preflight promised a channel the writers did not have.
+    kebab = _rect_with(_svg_of(_chart(styles={"legend": {"border_color": "#00ff00"}})), "#00ff00")
+    camel = _rect_with(
+        _svg_of(_chart(*_lines("alpha", "beta"), xy.legend(style={"borderColor": "#00ff00"}))),
+        "#00ff00",
+    )
+    assert kebab == camel
+
+
+def test_both_writers_agree_on_one_shadow_shape_and_one_alpha() -> None:
+    # Flags A and H: the SVG drew rx=4 unconditionally at fill-opacity 0.22
+    # while the raster drew the frame's own radius at 55/255 ≈ 0.2157. One
+    # constant now, and the shadow takes the frame's radius.
+    square = _chart(styles={"legend": {"box_shadow": "2px 2px", "background": "#eeeeee"}})
+    shadow = _rect_with(_svg_of(square), "rgba(0, 0, 0, 0.22)")
+    assert "rx=" not in shadow, "a square frame must not cast a rounded shadow"
+
+    payload = _legend_display_list(square)
+    assert (0, 0, 0, round(255 * 0.22)) in _fills(payload)
+
+
+def test_an_authored_shadow_offset_is_honored_and_blur_is_recorded() -> None:
+    offset = _rect_with(
+        _svg_of(_chart(styles={"legend": {"box_shadow": "6px 9px", "background": "#eeeeee"}})),
+        "rgba(0, 0, 0, 0.22)",
+    )
+    frame = _rect_with(
+        _svg_of(_chart(styles={"legend": {"box_shadow": "6px 9px", "background": "#eeeeee"}})),
+        "#eeeeee",
+    )
+    frame_x = float(re.search(r'x="([-\d.]+)"', frame).group(1))
+    shadow_x = float(re.search(r'x="([-\d.]+)"', offset).group(1))
+    assert shadow_x - frame_x == pytest.approx(6.0)
+
+    # A blurred shadow keeps the writers' offset-rect and RECORDS the blur —
+    # pyplot authors `2px 2px 4px rgba(0,0,0,0.3)`, and honoring the blur
+    # literally would mean silently dropping its shadow.
+    blurred = _layout_of(_chart(styles={"legend": {"box_shadow": "2px 2px 4px black"}}))
+    box = _svg.legend_frame_box(blurred)
+    assert box.shadow is not None
+    assert any("blur" in reason for reason in box.unrepresentable), box.unrepresentable
+
+
+def test_a_transparent_background_still_drops_the_frame_entirely() -> None:
+    # Matplotlib frameon=False parity, the one rule both writers agreed on.
+    plain = _chart()
+    bare = _chart(styles={"legend": {"background": "transparent"}})
+    assert "rgb(128, 128, 128)" in _svg_of(plain)
+    assert "rgb(128, 128, 128)" not in _svg_of(bare)
+    assert _svg.legend_frame_box(_layout_of(bare)) is None
+    # ...and the labels are still there: the frame went, not the legend.
+    assert ">alpha<" in _svg_of(bare)
+
+
+def test_slot_opacity_premultiplies_in_raster_and_is_recorded() -> None:
+    styles = {"legend": {"opacity": 0.5, "background": "#ff0000"}}
+    frame = _rect_with(_svg_of(_chart(styles=styles)), "#ff0000")
+    assert 'opacity="0.5"' in frame  # group opacity in SVG, PDF-legal
+    payload = _legend_display_list(_chart(styles=styles))
+    assert (255, 0, 0, 128) in _fills(payload), "raster must premultiply the slot opacity"
+
+    from xy.styling.capabilities import KNOWN_RENDERER_DIVERGENCES
+
+    assert any(d.id == "legend_slot_opacity_compositing" for d in KNOWN_RENDERER_DIVERGENCES)
+
+
+# -- legend: geometry, and the four consumers that share it -------------------
+
+
+def test_px_padding_moves_all_four_consumers_together() -> None:
+    # The family's headline risk. `_legend_layout` is the ONE legend geometry
+    # in the repo; a padding change that moved the render but not pyplot's
+    # reservation would put a legend outside the room reserved for it.
+    from xy.pyplot._axes import Axes
+
+    def measure(padding: str) -> tuple[float, float]:
+        options = {"style": {"padding": padding}}
+        box = _svg._legend_layout(
+            [{"name": "alpha"}, {"name": "beta"}],
+            {"x": 0.0, "y": 0.0, "w": 400.0, "h": 300.0},
+            options,
+        )
+        return box["box_w"], box["box_h"]
+
+    tight_w, tight_h = measure("4px")
+    loose_w, loose_h = measure("24px")
+    assert loose_w - tight_w == pytest.approx(40.0)  # 2 * (24 - 4)
+    assert loose_h - tight_h == pytest.approx(40.0)
+
+    # Consumer 3 and 4: pyplot's footprint (best-loc scoring) and its
+    # anchored-legend room reservation both size through the same function,
+    # so they see the same growth rather than a stale estimate.
+    axes = Axes.__new__(Axes)
+    tight = Axes._legend_footprint(
+        axes, {"style": {"padding": "4px"}}, [{"name": "alpha"}, {"name": "beta"}], (400.0, 300.0)
+    )
+    loose = Axes._legend_footprint(
+        axes, {"style": {"padding": "24px"}}, [{"name": "alpha"}, {"name": "beta"}], (400.0, 300.0)
+    )
+    assert loose[0] - tight[0] == pytest.approx(40.0 / 400.0)
+    assert loose[1] - tight[1] == pytest.approx(40.0 / 300.0)
+
+
+def test_px_and_em_padding_agree_at_the_same_resolved_size() -> None:
+    # em keeps working; px is simply also a spelling now. At the 11px legend
+    # font, 1em is 11px and the two must land on the same frame.
+    em = _layout_of(_chart(styles={"legend": {"padding": "1em"}}))
+    px = _layout_of(_chart(styles={"legend": {"padding": "11px"}}))
+    assert em["box_w"] == pytest.approx(px["box_w"])
+    assert em["box_h"] == pytest.approx(px["box_h"])
+
+
+def test_per_side_padding_is_honored_not_collapsed() -> None:
+    layout = _layout_of(_chart(styles={"legend": {"padding": "2px 20px 8px 4px"}}))
+    assert (layout["pad_top"], layout["pad_right"], layout["pad_bottom"], layout["pad_left"]) == (
+        2.0,
+        20.0,
+        8.0,
+        4.0,
+    )
+    # A longhand overrides its own side, whatever the authored order.
+    longhand = _layout_of(_chart(styles={"legend": {"padding": "5px", "padding_left": "17px"}}))
+    assert longhand["pad_left"] == 17.0
+    assert longhand["pad_top"] == 5.0
+
+
+def test_px_row_gap_and_gap_both_reach_the_geometry() -> None:
+    base = _layout_of(_chart(styles={"legend": {"row_gap": "0.5em"}}))
+    row_gap = _layout_of(_chart(styles={"legend": {"row_gap": "20px"}}))
+    gap = _layout_of(_chart(styles={"legend": {"gap": "20px"}}))
+    assert base["row_gap"] == pytest.approx(5.5)
+    assert row_gap["row_gap"] == 20.0
+    assert gap["row_gap"] == 20.0
+
+
+def test_the_legend_font_size_slot_reaches_the_measurement() -> None:
+    # `styles={'legend': {'font_size': ...}}` arrives kebab and was read only
+    # under the camelCase `fontSize`, so it moved nothing at all.
+    small = _layout_of(_chart(styles={"legend": {"font_size": 11}}))
+    large = _layout_of(_chart(styles={"legend": {"font_size": 22}}))
+    assert large["font_size"] == 22.0
+    assert large["box_h"] > small["box_h"]
+    assert large["box_w"] > small["box_w"]
+
+
+# -- legend_title / legend_label ---------------------------------------------
+
+
+def test_an_oversized_slot_font_no_longer_escapes_the_frame() -> None:
+    # The measurement-integrity bug: the layout measured at the base legend
+    # font while the emitters drew at the slot's, so a big legend_title ran
+    # out of its own frame.
+    plain = _layout_of(_chart(*_lines("alpha"), xy.legend(title="Series")))
+    big = _layout_of(
+        _chart(
+            *_lines("alpha"),
+            xy.legend(title="Series"),
+            styles={"legend_title": {"font_size": 28}},
+        )
+    )
+    assert big["title_h"] > plain["title_h"]
+    assert big["box_h"] > plain["box_h"]
+    # The frame is wide enough for the title it will actually draw.
+    assert big["box_w"] >= _svg._legend_text_width("Series", 28 * (6.2 / 11.0))
+
+    wide = _layout_of(_chart(*_lines("alpha"), styles={"legend_label": {"font_size": 26}}))
+    narrow = _layout_of(_chart(*_lines("alpha")))
+    assert wide["box_w"] > narrow["box_w"]
+
+
+def test_letter_spacing_feeds_the_label_advances() -> None:
+    plain = _layout_of(_chart(*_lines("alpha")))
+    spaced = _layout_of(
+        _chart(*_lines("alpha"), styles={"legend_label": {"letter_spacing": "4px"}})
+    )
+    assert spaced["box_w"] - plain["box_w"] == pytest.approx(4.0 * len("alpha"))
+
+
+def test_legend_text_boxes_sit_under_their_text_and_over_the_frame() -> None:
+    svg = _svg_of(
+        _chart(
+            *_lines("alpha"),
+            xy.legend(title="Series"),
+            styles={
+                "legend": {"background": "#eeeeee"},
+                "legend_title": {"background": "#111111"},
+                "legend_label": {"background": "#222222"},
+            },
+        )
+    )
+    order = [svg.index(needle) for needle in ("#eeeeee", "#111111", "#222222")]
+    assert order == sorted(order), "frame, then title box, then label box"
+    # Each box precedes the text it backs.
+    assert svg.index("#111111") < svg.index(">Series<")
+    assert svg.index("#222222") < svg.index(">alpha<")
+
+
+@pytest.mark.parametrize(
+    "align,anchor", [("left", "start"), ("right", "end"), ("center", "middle")]
+)
+def test_text_align_uses_the_row_box_width(align: str, anchor: str) -> None:
+    svg = _svg_of(_chart(*_lines("alpha"), styles={"legend_label": {"text_align": align}}))
+    label = next(t for t in re.findall(r"<text[^>]*>[^<]*</text>", svg) if ">alpha<" in t)
+    if anchor == "start":
+        assert "text-anchor" not in label  # the writer's historical default
+    else:
+        assert f'text-anchor="{anchor}"' in label
+
+
+def test_raster_honors_legend_text_emphasis() -> None:
+    # The P0.2 regression guard for this family's two text slots.
+    plain = _raster_of(_chart(*_lines("alpha"), xy.legend(title="Series")))
+    for slot in ("legend_title", "legend_label"):
+        for prop, value in (("font_weight", 700), ("font_style", "italic")):
+            styled = _raster_of(
+                _chart(*_lines("alpha"), xy.legend(title="Series"), styles={slot: {prop: value}})
+            )
+            assert not (plain == styled).all(), f"{slot} {prop} left no raster trace"
+
+
+# -- legend_item / legend_swatch ----------------------------------------------
+
+
+def test_the_row_box_sits_over_the_frame_and_under_its_swatch_and_label() -> None:
+    svg = _svg_of(
+        xy.bar_chart(
+            xy.bar(["a", "b"], [1.0, 2.0], name="counts"),
+            styles={
+                "legend": {"background": "#eeeeee"},
+                "legend_item": {"background": "#123456"},
+                "legend_swatch": {"background": "#abcdef"},
+            },
+        )
+    )
+    assert svg.index("#eeeeee") < svg.index("#123456") < svg.index("#abcdef")
+    assert svg.index("#123456") < svg.index(">counts<")
+
+
+def test_one_row_box_per_visible_entry_in_both_writers() -> None:
+    chart = _chart(
+        *_lines(*[f"series-{i}" for i in range(4)]),
+        styles={"legend_item": {"background": "#123456"}},
+    )
+    assert len([r for r in _rects(_svg_of(chart)) if "#123456" in r]) == 4
+    fills = _fills(_legend_display_list(chart))
+    assert fills.count((18, 52, 86, 255)) == 4
+
+
+def test_the_swatch_slot_wins_over_the_trace_paint_on_a_patch() -> None:
+    # Browser precedence: `_applySlot` runs after the per-entry paint vars.
+    styled = xy.bar_chart(
+        xy.bar(["a"], [1.0], name="counts", color="#ff0000"),
+        styles={"legend_swatch": {"background": "#00ff00", "border_radius": "4px"}},
+    )
+    swatch = _rect_with(_svg_of(styled), "#00ff00")
+    assert 'rx="4"' in swatch
+    # ...and the unstyled patch keeps the trace colour and its historical rx.
+    plain = xy.bar_chart(xy.bar(["a"], [1.0], name="counts", color="#ff0000"))
+    assert 'rx="2"' in _rect_with(_svg_of(plain), "#ff0000")
+
+
+def test_a_swatch_border_dash_reaches_both_writers() -> None:
+    chart = xy.bar_chart(
+        xy.bar(["a"], [1.0], name="counts"),
+        styles={
+            "legend_swatch": {
+                "border_color": "#0000ff",
+                "border_width": "2px",
+                "border_style": "dashed",
+            }
+        },
+    )
+    assert "stroke-dasharray=" in _rect_with(_svg_of(chart), "#0000ff")
+    payload = _legend_display_list(chart)
+    seen_dash = False
+    for op, offset in _walk(payload):
+        if op != _raster._STROKE:
+            continue
+        (count,) = struct.unpack_from("<I", payload, offset + 1)
+        base = offset + 5 + count * 8
+        (dash_len,) = struct.unpack_from("<I", payload, base + 9)
+        if dash_len and tuple(payload[base + 4 : base + 8]) == (0, 0, 255, 255):
+            seen_dash = True
+    assert seen_dash, "the raster swatch border must dash too"
+
+
+def test_a_marker_entry_keeps_its_own_ink_over_the_swatch_box() -> None:
+    # On a marker/line entry the swatch box is a backdrop, not the handle.
+    chart = xy.scatter_chart(
+        xy.scatter([1.0], [1.0], name="pts", color="#ff0000"),
+        styles={"legend_swatch": {"background": "#00ff00"}},
+    )
+    svg = _svg_of(chart)
+    assert "#00ff00" in svg and "#ff0000" in svg
+    assert svg.index("#00ff00") < svg.rindex("#ff0000")
+
+
+# -- the residue retirement ---------------------------------------------------
+
+
+def test_px_legend_geometry_leaves_no_writer_domain_residue() -> None:
+    # The contract this phase retires: legend geometry used to be expressible
+    # ONLY in em, which schema v1 refuses, so every legend geometry
+    # declaration was writer-domain by construction.
+    chart = _chart(styles={"legend": {"padding": "12px", "gap": "6px", "font_size": 13}})
+    styling = resolve_declared(chart.figure().build_payload()[0])
+    assert styling.writer_domain == {}
+
+
+def test_the_legend_channel_is_exact_enough_to_leave_the_conditional_set() -> None:
+    from xy.styling import preflight
+
+    assert "legend" not in preflight._CONDITIONAL_CHANNEL_SLOTS
+    report = _chart(
+        styles={"legend": {"background": "black", "border_color": "#fff", "padding": "8px"}}
+    ).style_compatibility_report("png")
+    finding = next(f for f in report.findings if f.slot == "legend")
+    assert finding.route == preflight.ROUTE_SURVIVES
+    assert finding.lost == ()
+    assert report.lossless
diff --git a/tests/test_declared_snapshot.py b/tests/test_declared_snapshot.py
index c6524d020..c0c551c3d 100644
--- a/tests/test_declared_snapshot.py
+++ b/tests/test_declared_snapshot.py
@@ -37,7 +37,9 @@ def _legacy_slot_styles(spec):
 
 STYLES = {
     "tick_label": {"font_weight": 600, "letter_spacing": "0.08em", "color": "#94a3b8"},
-    "legend": {"background": "black", "padding": "1.2em", "row_gap": "0.4em"},
+    # Legend geometry in resolved px: before P4 this was expressible only in
+    # em, which schema v1 refuses, so it was writer-domain by construction.
+    "legend": {"background": "black", "padding": "12px", "gap": "6px"},
     "title": {"font-size": 18, "fill": "rgb(100% 0% 0%)"},
     "tooltip_title": {"color": "red"},
 }
@@ -67,13 +69,16 @@ def test_snapshot_carries_every_schema_legal_declaration() -> None:
 
 
 def test_the_residue_is_exactly_the_writer_domain_values() -> None:
-    # The gap between view and snapshot is enumerable and named: legend em
-    # multipliers (the legend's own unit domain) and nothing else here.
+    # The gap between view and snapshot is enumerable and named. Since the P4
+    # legend family it is exactly ONE thing: a relative-unit length, which
+    # schema v1 refuses for every slot alike because it depends on a font
+    # context the snapshot's consumer would have to re-derive.
+    #
+    # The legend contributes nothing now. Its geometry used to be expressible
+    # only as em multipliers, so `padding`/`row-gap` were writer-domain by
+    # construction; they resolve px today and intern like any other length.
     styling = resolve_declared(_spec(styles=STYLES))
-    assert styling.writer_domain == {
-        "tick_label": {"letter-spacing": "0.08em"},
-        "legend": {"padding": "1.2em", "row-gap": "0.4em"},
-    }
+    assert styling.writer_domain == {"tick_label": {"letter-spacing": "0.08em"}}
     # view = snapshot declarations ∪ residue, per slot.
     view = styling.slot_view()
     for slot, residue in styling.writer_domain.items():
@@ -81,6 +86,30 @@ def test_the_residue_is_exactly_the_writer_domain_values() -> None:
             assert prop in view[slot]
 
 
+def test_px_legend_geometry_interns_instead_of_riding_the_residue() -> None:
+    # The retirement, stated positively: the px spellings of the legend's
+    # geometry are schema-legal resolved lengths and reach the snapshot.
+    styling = resolve_declared(_spec(styles={"legend": {"padding": "12px", "gap": "6px"}}))
+    assert styling.writer_domain == {}
+    declaration = styling.snapshot.declarations[styling.snapshot.instances[0].declaration]
+    # `padding` interns expanded — schema v1 carries only the longhands — and
+    # the shorthand expansion resolves each side to a number on the way.
+    assert declaration["padding-top"] == 12.0
+    assert declaration["padding-left"] == 12.0
+    # `gap` has no shorthand to expand, so it interns as the authored string;
+    # a px length is a resolved value whether it is spelled 6 or "6px".
+    assert declaration["gap"] == "6px"
+
+
+def test_em_legend_geometry_still_reaches_the_writers_as_residue() -> None:
+    # Retiring the residue did not retire the em spelling: it keeps working
+    # through the writer view, it is simply no longer the ONLY spelling. An
+    # em value is writer-domain for the same reason any other slot's is.
+    styling = resolve_declared(_spec(styles={"legend": {"padding": "1.2em", "row_gap": "0.4em"}}))
+    assert styling.writer_domain == {"legend": {"padding": "1.2em", "row-gap": "0.4em"}}
+    assert styling.slot_view()["legend"]["padding"] == "1.2em"
+
+
 def test_identical_slot_declarations_intern_once() -> None:
     spec = _spec(
         styles={
diff --git a/tests/test_export_style_survival.py b/tests/test_export_style_survival.py
index cf94d691f..e26e59b57 100644
--- a/tests/test_export_style_survival.py
+++ b/tests/test_export_style_survival.py
@@ -72,6 +72,10 @@ def test_native_writers_read_a_property_subset_not_the_whole_cascade() -> None:
         "annotation_layer",
         "axis_line",
         "tick_mark",
+        # The legend's row and swatch cells are pure box slots — no text of
+        # their own, so `fill` would not be their paint.
+        "legend_item",
+        "legend_swatch",
     )
 }
 
@@ -153,7 +157,11 @@ def test_an_explicit_legend_background_is_opaque_like_the_browser() -> None:
     frame = next(
         node for node in re.findall(r"<rect[^>]*/>", chart.figure().to_svg()) if "#ff00ff" in node
     )
-    assert 'fill-opacity="1"' in frame
+    # Opaque means *untinted*: the shared chrome-box emitter omits a
+    # `fill-opacity` of 1 rather than spelling the default out, so the
+    # assertion is that no tint was applied — in particular not the 0.08 the
+    # default grey frame carries.
+    assert "fill-opacity" not in frame
 
 
 def test_unstyled_output_is_untouched() -> None:
diff --git a/tests/test_style_compatibility_report.py b/tests/test_style_compatibility_report.py
index e71295603..a56dea290 100644
--- a/tests/test_style_compatibility_report.py
+++ b/tests/test_style_compatibility_report.py
@@ -108,9 +108,12 @@ def test_pdf_inherits_the_vector_subset() -> None:
 
 
 def test_styles_on_a_slot_with_no_native_path_are_named_lost() -> None:
-    report = _chart(styles={"legend_swatch": {"border-radius": "2px"}})
+    # `legend_swatch` used to be the example here; P4 gave it a writer, so the
+    # example moved to a slot that still has none. `colorbar_bar` is static
+    # chrome whose writers arrive with the colorbar family (plan §7).
+    report = _chart(styles={"colorbar_bar": {"border-radius": "2px"}})
     report = report.style_compatibility_report("png")
-    finding = _finding(report, "legend_swatch", "styles")
+    finding = _finding(report, "colorbar_bar", "styles")
     assert finding.route == pf.ROUTE_BROWSER_ONLY
     assert finding.lost == ("border-radius",)
     assert not report.lossless
@@ -174,12 +177,22 @@ def test_legend_styles_route_at_property_level() -> None:
     boxed = _chart(styles={"legend": {"background": "black", "border-radius": "6px"}})
     report = boxed.style_compatibility_report("png")
     finding = _finding(report, "legend", "styles")
-    assert finding.route == pf.ROUTE_SUBSET
+    # P4: the legend's channel became exact, so a declaration that loses
+    # nothing routes as `survives` rather than being qualified into the
+    # subset route. It left `preflight._CONDITIONAL_CHANNEL_SLOTS` with the
+    # last spelling the writers honored only halfway.
+    assert finding.route == pf.ROUTE_SURVIVES
     assert finding.lost == ()
     assert set(finding.kept) == {"background", "border-radius"}
     assert "merged legend declaration" in finding.detail
     assert report.lossless
 
+    # The kebab spelling of a border is honored now, not silently dropped.
+    kebab = _chart(styles={"legend": {"border_color": "#00ff00", "border_width": "2px"}})
+    kebab_finding = _finding(kebab.style_compatibility_report("png"), "legend", "styles")
+    assert kebab_finding.lost == ()
+    assert set(kebab_finding.kept) == {"border-color", "border-width"}
+
     # letter-spacing on the raster path is in neither the raster text subset
     # nor the box vocabulary: named lost, not qualified away.
     lossy = _chart(styles={"legend": {"letter_spacing": "0.08em", "background": "black"}})
diff --git a/tests/test_theme_tokens.py b/tests/test_theme_tokens.py
index d41ab1800..2090db685 100644
--- a/tests/test_theme_tokens.py
+++ b/tests/test_theme_tokens.py
@@ -63,7 +63,10 @@ def test_legend_bg_token_reaches_the_static_writers() -> None:
         xy.theme(legend_bg="#ff00ff"),
     )
     frame = next(node for node in re.findall(r"<rect[^>]*/>", chart.to_svg()) if "#ff00ff" in node)
-    assert 'fill-opacity="1"' in frame
+    # The token is the frame's paint at full strength, not a tint. Since the
+    # frame folded onto the shared chrome-box emitter, an opacity of 1 is
+    # spelled by omission — so the assertion is that no tint was applied.
+    assert "fill-opacity" not in frame
 
 
 def test_the_component_spelling_still_wins_over_the_token() -> None:
@@ -80,7 +83,9 @@ def test_the_component_spelling_still_wins_over_the_token() -> None:
 
 def test_an_unset_token_leaves_the_default_frame_untouched() -> None:
     svg = xy.line_chart(xy.line([0.0, 1.0], [0.0, 1.0], name="series")).to_svg()
-    assert 'fill="rgba(128,128,128,0.08)"' in svg
+    # The default grey frame, in the shared emitter's spelling: the same grey
+    # at the same 8% the one-off `rgba(128,128,128,0.08)` literal carried.
+    assert 'fill="rgb(128, 128, 128)" fill-opacity="0.08"' in svg
 
 
 @pytest.mark.parametrize("spelling", ["__grid_colour", "__chart_bg", "__anything"])

From d4b9ea71c9f6a6e517b28325aae3cc54761b5fbd Mon Sep 17 00:00:00 2001
From: Alek Petuskey <alek@reflex.dev>
Date: Tue, 4 Aug 2026 18:31:59 -0700
Subject: [PATCH 26/27] Record the colorbar shared-layout design and the
 refutations that bound it
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The last parity family has the least shared machinery: bar geometry is
duplicated verbatim between the writers, container geometry exists nowhere
in Python, and the two writers carry placement divergences nobody had
enumerated. This design names the shared record, picks the surviving truth
per divergence with browser parity as the tiebreak, and orders the edits.

The three adversarial reviews ship WITH it because they are corrections,
not commentary: the design as first written breaks six existing tests
(two structurally), imports a container height that lands twelve pixels
off-canvas in the default horizontal configuration by pairing the
browser's box with the writers' measured gap, and gets paint order wrong
in five places — one of which breaks PDF. An implementer reading only the
design would ship all three.
---
 .../colorbar-parity-design-2026-08-05.md      | 717 ++++++++++++++++++
 1 file changed, 717 insertions(+)
 create mode 100644 spec/process/colorbar-parity-design-2026-08-05.md

diff --git a/spec/process/colorbar-parity-design-2026-08-05.md b/spec/process/colorbar-parity-design-2026-08-05.md
new file mode 100644
index 000000000..9c49e8280
--- /dev/null
+++ b/spec/process/colorbar-parity-design-2026-08-05.md
@@ -0,0 +1,717 @@
+# Colorbar parity: shared-layout design (P5)
+
+Produced by an 8-agent design workflow (4 surveys, 1 synthesis, 3 adversarial
+refutations) against the tree at the legend merge. Every load-bearing claim was
+verified empirically before the design was written; the refutations follow the
+design and are part of the contract.
+
+I verified every load-bearing claim against the checkout before designing. Confirmed empirically: the bar math is byte-identical; horizontal tick baseline 296 (SVG) vs 297 (raster); horizontal title 306 vs 310; discrete extension defaults `rgb(253,231,37)`/`rgb(68,1,84)` vs `rgb(189,223,38)`/`rgb(72,36,117)`; `currentColor` line `#202020` vs `(76,120,168)`; `_Cmd.text` emits opcode 17 with anchor byte `1` when `bold=True` (rotation bit 128 dropped); `SLOT_BOX_PROPS` shadowed so `slot_box_declaration({'border':...}, 'colorbar')` returns `{}`.
+
+---
+
+# P5 shared colorbar layout — implementation-ready design
+
+## 1. Signatures and the returned record
+
+### 1.1 The pattern this mirrors
+
+Three existing shared-layout precedents in `python/xy/_svg.py`, all consumed by `_raster.py` through its `from ._svg import (...)` block (`python/xy/_raster.py:27-93`):
+
+| Precedent | Shape | Anchor |
+|---|---|---|
+| `layout(spec) -> (w, h, compact, plot)` | plain dict of floats | `_svg.py:3048`; called once per render at `_svg.py:4723` / `_raster.py:1017` |
+| `title_placement(...) -> TitlePlacement` | `NamedTuple(style, size, block, x, baseline, anchor)` | `_svg.py:2915` (class), `2924` (producer) |
+| `title_box(placement) -> Optional[ChromeBox]` | declaration-gated box **derived from the placement record** | `_svg.py:2975` |
+| `axis_chrome_boxes(spec, slots) -> list[ChromeBox]` | one producer, three consumers (SVG, raster, `styling/declared.py`) | `_svg.py:4413` |
+
+The colorbar follows `title_placement`/`title_box` exactly: **a geometry record first, a declaration-gated box producer second, derived from that record.** This split is what keeps the byte gate mechanical — the geometry producer has no declaration input that can move a coordinate.
+
+### 1.2 Records (new, in `_svg.py` immediately above `_colorbar`, currently `_svg.py:8098`)
+
+```python
+class ColorbarTick(NamedTuple):
+    value: float
+    fraction: float          # 0..1 along the bar, already log/linear-mapped
+    text: str                # formatted, or the paired explicit label
+    x: float                 # text anchor x
+    baseline: float          # first-line baseline y
+    anchor: str              # "start" (vertical) | "middle" (horizontal)
+    block: _textblock.TextBlock   # measured at tick_size; box producer only
+
+class ColorbarMinorTick(NamedTuple):
+    value: float
+    fraction: float
+    x1: float; y1: float; x2: float; y2: float   # the 3px mark, centred stroke
+
+class ColorbarBand(NamedTuple):
+    lower: float; upper: float                   # band fractions
+    color: tuple[int, int, int]
+    x: float; y: float; w: float; h: float       # seam ALREADY applied
+    seam: float                                  # 0.5, or 0.0 when clamped
+
+class ColorbarExtension(NamedTuple):
+    side: str                                    # "min" | "max"
+    points: tuple[tuple[float, float], ...]      # 3 vertices, writer order
+    fill: tuple[int, int, int]                   # resolved default or payload
+    outlined: bool                               # line_only -> white + stroke
+
+class ColorbarLineMark(NamedTuple):
+    value: float; fraction: float
+    x1: float; y1: float; x2: float; y2: float
+    color: str                                   # already through _css
+    width: float
+    dash: Optional[tuple[float, float]]
+
+class ColorbarTitlePose(NamedTuple):
+    text: str
+    x: float; baseline: float
+    anchor: str                                  # always "middle"
+    angle: float                                 # 270.0 vertical CCW, 0.0 horizontal
+    cx: float; cy: float                         # rotation origin == (x, baseline)
+    block: _textblock.TextBlock
+
+class ColorbarLayout(NamedTuple):
+    orientation: str
+    horizontal: bool
+    axes_placement: bool
+    # --- bar rect: the historical x/y/width/height, verbatim ---
+    x: float; y: float; w: float; h: float
+    # --- container: the browser mirror, new to Python ---
+    cx0: float; cy0: float; cw: float; ch: float
+    # --- painted content ---
+    continuous: bool          # SVG takes the single gradient rect; raster bands
+    gradient_id: str
+    gradient_attrs: str
+    bands: tuple[ColorbarBand, ...]
+    extensions: tuple[ColorbarExtension, ...]
+    lines: tuple[ColorbarLineMark, ...]
+    ticks: tuple[ColorbarTick, ...]
+    minor_ticks: tuple[ColorbarMinorTick, ...]
+    title: Optional[ColorbarTitlePose]
+    line_only: bool
+    outline_paint: str        # text_color; line_only frame + extension strokes
+```
+
+### 1.3 Producers
+
+```python
+def colorbar_layout(
+    options: dict[str, Any],
+    plot: dict[str, float],
+    right_axis_room: float = 0.0,
+    *,
+    text_color: str = _TEXT,
+    tick_size: float = COLORBAR_FONT_SIZE,
+    title_size: float = COLORBAR_FONT_SIZE,
+    bar_inset: tuple[float, float, float, float] = (0.0, 0.0, 0.0, 0.0),
+) -> ColorbarLayout:
+    """The colorbar family's one geometry source (plan §7 item 1)."""
+```
+
+- `tick_size`/`title_size` are the callers' already-resolved `slot_font_size(...)` values. **They feed only `block` measurement, never a coordinate** — every current offset (`+4`, `+12`, `+22`, `+38`) is a literal independent of font size, so passing them cannot move unstyled text. This is the property that makes the byte gate mechanical.
+- `bar_inset` is the container's `box_room` (§4.1). Defaults to zeros, so an unstyled render is bit-identical to today.
+- `right_axis_room` stays positional-3rd to match both existing call sites (`_svg.py:5247`, `_raster.py:1823`).
+
+```python
+def colorbar_chrome_boxes(
+    layout: ColorbarLayout,
+    slots: dict[str, dict[str, Any]],
+) -> list[ChromeBox]:
+    """ChromeBoxes for colorbar / colorbar_bar / colorbar_tick / colorbar_title,
+    in paint order. [] unless one of those slots declares box properties —
+    the `axis_chrome_boxes` gate (_svg.py:4413), so unstyled bytes are untouched."""
+
+class SlotStroke(NamedTuple):
+    fill: Optional[str]
+    stroke: Optional[str]
+    width: float
+    dash: Optional[tuple[float, ...]]
+    opacity: float
+
+def colorbar_slot_strokes(
+    layout: ColorbarLayout,
+    slots: dict[str, dict[str, Any]],
+) -> dict[str, SlotStroke]:
+    """Resolved paints for the three non-rect slots (colorbar_extension,
+    colorbar_line, colorbar_minor_tick). ChromeBox is rect-only (x/y/w/h +
+    angle, _chromebox.py:81-120); a triangle and a segment need paint without
+    geometry. Reuses `_chromebox._border_width`/`_border_dash` so the
+    browser's border-* vocabulary maps identically in both writers."""
+```
+
+Both writers import all four names alongside `_colorbar_right_axis_room` in `_raster.py:27-93`. `_colorbar`/`_emit_colorbar` become pure emitters over the record.
+
+### 1.4 Container geometry (the part that exists nowhere in Python)
+
+Mirrors `js/src/50_chartview.ts:3704-3709`, expressed as the bar rect grown by a gutter so the two stay reconcilable:
+
+| Case | container origin | width | height |
+|---|---|---|---|
+| vertical, non-axes | bar x/y | `w + 48` (= 66) | `max(24, h)` |
+| vertical, `placement="axes"` | bar x/y | `w + 44` | `max(24, h)` |
+| horizontal, non-axes | bar x/y | `w` | `h + 32` (= 50) |
+| horizontal, `placement="axes"` | bar x/y | `w` | `h + 24` |
+
+The container **does not** union the 9 px extension triangles: the browser's extension `<svg>` is appended to `bar` with `overflow:visible` (`js/src/50_chartview.ts:3546-3551`) and the container sets no `overflow`, so extensions paint outside the container box live too. Matching that keeps the box a mirror rather than an invention.
+
+---
+
+## 2. Shared truth per disagreement
+
+Browser parity is the tiebreak. The browser's per-child offsets are CSS **box tops**; the writers' are **baselines**. Converting uses the repo's own metrics (`src/font.rs:10,18` — ASCENT 15/16, DESCENT 4/16), so at the 10 px colorbar font a span whose top is at `T` has its baseline at ≈ `T + 9.4`.
+
+| # | Disagreement | SVG | Raster | **Shared truth** | Justification |
+|---|---|---|---|---|---|
+| 1 | Horizontal tick baseline | `y+h+12` | `y+h+13` | **+12** | Browser tick span top = `barThickness + 2` (`js:3630`) → baseline ≈ bar_bottom + 11.4. SVG is 0.6 off, raster 1.6. Raster moves up 1 px. |
+| 2 | Horizontal title baseline | `y+h+22` | `y+h+26` | **+26** | Browser title span top = `barThickness + 18` (`js:3665`) → baseline ≈ bar_bottom + 27.4. Raster is 1.4 off, SVG 5.4. SVG moves down 4 px. **These two pull opposite ways — neither writer wins wholesale**, which is exactly why the plan says "resolve to one number, don't copy". |
+| 3 | Discrete extension default fill | ramp endpoints `stops[-1]`/`stops[0]` | end-band centres `colors[-1]`/`colors[0]` | **SVG (ramp endpoints)** | Matplotlib semantics: default over/under = `cmap(1.0)`/`cmap(0.0)`. Browser has no non-`line_only` extension to arbitrate, so the upstream contract decides. `_colormap_stops` is already imported into the raster (`_raster.py:46`). Measured delta: ΔR=64, ΔG=35. |
+| 4 | `lines[].color = "currentColor"` / `var(...)` | `_css(color, text_color)` → `#202020` | `_parse_color(str(...))` → `(76,120,168)` palette fallback | **SVG (`_css` normalization)** | Browser default for this field IS `currentColor` (`js:3586`) resolving to `--chart-text`. `_css` is already imported into the raster (`_raster.py:50`) — an oversight, not a capability gap. |
+| 5 | Line vs extension paint order | body → **lines** → extensions | body → **extensions** → lines | **Raster (line over extension)** | Browser appends the extension `<svg>` to `bar` (`js:3540-3565`) before the line `<i>` markers (`js:3574-3593`). SVG is the outlier. Becomes visible the moment either slot takes a background. |
+| 6 | Explicit `tick_labels` pairing | index-paired list (`_svg.py:8185-8200`) | value-keyed dict (`_raster.py:3661-3670`) | **SVG (index pairing)** | A duplicated tick value collapses to the last label in the dict; index pairing is lossless and is what the browser does (parallel arrays, `js:3603-3622`). |
+| 7 | `line_only` outline closure | `<rect>` miter join | `[*outline, outline[0]]` with default round cap (`_raster.py:288` → `src/raster.rs:761-763`) | **`closed=True`** | `_emit_slot_box` already uses `closed=True` (`_raster.py:820-826`); the colorbar is the only caller hand-closing. ~0.2 px at one corner. |
+| 8 | Raster 64-band sample position | n/a | edges `i/63` painted over intervals `[i/64,(i+1)/64]` | **centres `(arange(64)+0.5)/64`** | Removes a 2.34 px positional error on a 300 px bar at zero cost; SVG and browser have none. |
+| 9 | Rotation dropped under emphasis | always `transform="rotate(-90 …)"` | `cmd.text` styled branch writes `anchor & 0x03` and leaves `angle=0.0` (`_raster.py:686-701`) — **verified: opcode 17, anchor byte 1** | **rotate always** | `spec/api/styling.md:840-846` names `bar_x + bar_width + 38` as a pinned three-renderer contract, and `spec/api/capability-matrix.md:136` already claims raster honors font-weight/font-style here. Fix by routing the colorbar title through `_emit_text_block` (`_raster.py:712-747`), which passes the real `angle` and already handles the quarter-turn/emphasis split correctly. |
+| 10 | `border` shorthand filtered out | — | — | **delete the second `SLOT_BOX_PROPS`** (`_svg.py:1529-1546`) | Shadowing bug: `SLOT_BOX_PROPS_BY_SLOT` (`_svg.py:1496-1501`) closed over the *first* object, so `title` honors `border` and every other box slot does not. Second set = first set − `{"border"}`. Deleting it restores one vocabulary. Blocking: without it, all 7 colorbar slots would bake in the inconsistency, and `_has_box_declaration` would gate a border-shorthand-only declaration closed while preflight reports it LOST. |
+
+**Not unified (writers already agree, keep verbatim):** vertical tick `+4`, vertical title `+38`, minor-tick length 3, the `fraction()` closure, `_colorbar_tick_target`, the discrete band fractions and the five-part proportional guard, extension vertex order, dash rhythm `3.7w`/`1.6w`, the `+0.5` seam, bar thickness 18, the `max(2, min(8, …))` tick budget.
+
+---
+
+## 3. Divergences that must SURVIVE as recorded, not unified
+
+Each becomes a `RendererDivergence` in `python/xy/styling/capabilities.py:257` (shape at `:108-124`: `id / what / webgl / svg / native / visible_when / tracked_by`).
+
+| id | What | Why it must not be unified |
+|---|---|---|
+| `colorbar_compact_vertical` | Browser collapses a vertical colorbar to an 18 px bar with endpoint-only ticks and no title below 520 px fluid width (`js:661-671`, `3706-3748`) | The gate is `this.fluid` = `spec.width === "100%"` (`js:530`). A static export has already concretized its width — **the writers structurally cannot have the signal.** Pin the non-compact form; this is forced by the code, not a preference. |
+| `colorbar_extension_existence` | Writers draw extension triangles for any `extend`; browser only when `line_only` (`js:3540`) | Settling it either way is a visible product change: dropping them makes `over_color`/`under_color` (`pyplot/_mplfig.py:1341-1347`) dead in every renderer; adding them live changes every mounted contour chart. Out of P5's scope; record and move on. |
+| `colorbar_bar_default_border` | Browser `colorbar_bar` ships `border:1px solid currentColor; box-sizing:border-box` (`js/src/20_theme.ts:133`); writers draw none | Adopting it changes **every unstyled export** — a 1 px ring plus a 2 px ramp compression (border-box shrinks the padding box the gradient fills). Plan §7 item 4 calls this an explicit default-parity decision, "never a silent flip". Record; do not adopt in P5. |
+| `colorbar_horizontal_gap` | Writers: `plot["bottom_axis_room"] or 10`; browser: constant `COLORBAR_GAP` 24 (`js:3684-3688`) | The writers' value is *measured* (42 with a bottom axis, 0→10 with `tick_label_strategy="none"`), so the offset swings across a 32 px range. Unifying to 24 would collide the bar with x tick labels in the writers, which have no DOM overflow to absorb it. |
+| `colorbar_pad_zero_bottom_room` | Python reserves `18` for `pad==0` horizontal (`_svg.py:3097-3098`, `pyplot/_axes.py:8298`); browser always 38 (`js:673-675`) | 20 px. Two Python copies agree with each other and are byte-pinned through the pyplot layout path; the vertical `pad==0` cell agrees in all three. Record the one asymmetric cell. |
+| `colorbar_axes_placement_shrink` | Writers ignore `shrink`/`anchor` under `placement="axes"`; browser applies them to container height and tick budget (`js:3693-3709`, `3594-3597`) | The writers are **right** for the pyplot `cax=` path — the cax rect already encodes shrink (`pyplot/_mplfig.py:1359-1381`), so the browser double-applies. Record rather than adopt the browser's bug. |
+| `colorbar_shrink_clamp` | Browser clamps `shrink` to `[0.01,1]`, floors the vertical container at 24 px, and defaults `anchor[i] ?? 0.5`; writers take raw floats | Already recorded at `spec/api/styling.md:578-582`. Keep — but the shared layout **should** adopt the `max(24, …)` floor for the **container** only (never the bar), since the container is a new mirror with no byte history. |
+| `colorbar_raster_band_gradient` | SVG/browser paint a true interpolated ramp; raster paints 64 solid bands | Already marked deliberate in code (`_raster.py:3600-3601`) but **absent from the registry**. Measured: viridis max ΔE 10/255; `flag` (256 stops) max 250/255, mean 40.7 — a different image. Custom resampled ramps ship 256 stops, so every custom colormap hits the `flag` class. A `cmd.grad` opcode exists (`_raster.py:258-279`), so this is a *choice*; record it now, fix it outside P5. |
+| `colorbar_automatic_linear_tick_format` | Writers `f"{value:g}"` for every linear tick; browser uses `fmtLinear(value, tickStep)` for automatic ladders and `fmtGeneral` only for explicit ones (`js/src/30_ticks.ts:178-188`) | `0 / 0.2 / 0.4` native vs `0.0 / 0.2 / 0.4` live. The `%g` unification was deliberate for explicit ticks (comment at `30_ticks.ts:186-188` names the SVG/native exporters) and simply never extended. Record; the fix belongs with the tick-format contract, not the layout hoist. |
+| `colorbar_minor_tick_half_pixel` | Writers centre a 1 px stroke on the fraction; browser lays a 1 px CSS border outward from it (`20_theme.ts:136-137`) | 0.5 px, and matching the browser would move every existing minor tick. |
+
+---
+
+## 4. Per-slot box plan
+
+Paint order, one sequence for both writers (SVG: prepend to the returned concat at `_svg.py:8326-8331`; raster: emit before `_emit_colorbar`'s band loop at `_raster.py:3633`):
+
+```
+container box → bar box(shadow,fill) → ramp/bands → bar box(border) →
+extensions → lines → minor ticks → tick pills → tick text →
+title box → title text
+```
+
+The colorbar is already the last chrome in both writers and unclipped in both (`_svg.py:5595-5613` joins `*chrome` last; `_raster.py:1816-1817` resets the clip to the full canvas), so a container emitted first lands above the plot and below every child with **zero ordering work**.
+
+### 4.1 `colorbar` — container
+
+- **Geometry:** `(cx0, cy0, cw, ch)` from §1.4. Single source; a second computation reintroduces the 1 px-class divergences.
+- **Honored:** full `SLOT_BOX_PROPS` (post-de-shadow, so `border` shorthand included).
+- **Padding:** honored as an **inset of the bar inside the container** — the browser's bar is `inset:0 auto 0 0` (`js:3528-3533`), i.e. relative to the padding box, so padding moves the bar live. Fed back as `bar_inset` in `colorbar_layout`. Room grows via `_chromebox.box_room` (`_chromebox.py:192-201`) in **both** Python room copies: `_svg.layout` (`_svg.py:3091-3100`) and `pyplot/_axes._colorbar_outside_room` (`pyplot/_axes.py:8289-8301`). The browser's own reservation has no padding term (`js:665-675`) → new registry entry `colorbar_container_padding_room`.
+- **Unrepresentable:** none in SVG/PDF. Raster: `border-radius` and `opacity` need rounded clipping / group compositing — but the container box is a plain filled rect, so both are drawable here; nothing to record.
+- **Cascade:** the container declaration must **stop at the container**. Today's `slots.get("colorbar_title") or slots.get("colorbar") or {}` (`_svg.py:5249-5250`, `_raster.py:1825-1826`) is a whole-declaration replacement that already drops text props: verified that `styles={'colorbar':{'color':'#ff0000'}, 'colorbar_title':{'font_size':14}}` renders the title `font-size="14" fill="rgba(32,32,32,0.85)"` — the red is gone, while the browser paints it red because `_applySlot(box,'colorbar')` sets `color` on the container and the `<span>` inherits. Replace with a per-property cascade over the parent edges already declared in `python/xy/styling/cascade.py:56-62` (every colorbar sub-slot's parent is `colorbar`), restricted to the **inherited** properties (`color`, `font-*`, `letter-spacing`). Box props never inherit.
+
+### 4.2 `colorbar_bar`
+
+- **Geometry:** the bar rect `(x, y, w, h)` — post-`bar_inset`.
+- **Honored:** `background`/`background-color` (**replaces the ramp entirely**, matching the browser where `background:red` overrides `background:var(--xy-colorbar-gradient)`), `border-*`, `border-radius`, `box-shadow`, `opacity`, `fill-opacity`. Padding is meaningless (no content) → recorded unrepresentable.
+- **Seam:** the `+0.5` overhang (`_svg.py:8388,8396` / `_raster.py:3638,3642`) overhangs one orientation-dependent edge — vertical bottom, horizontal right. When a border or radius is present, clamp the final band's far edge to the bar rect (`ColorbarBand.seam = 0.0` for the last band). Otherwise seams paint over the border.
+- **`lower_box` hazard:** `_chromebox.py:480-482` rejects gradient backgrounds. Any snapshot-fed `colorbar_bar` declaration normally *carries* `var(--xy-colorbar-gradient)`. The bar's ramp must keep being painted by colorbar code; only a **non-gradient user override** becomes a box fill — otherwise every styled colorbar reports a spurious unrepresentable entry.
+- **Unrepresentable — SVG/PDF:** nothing. Rounded corners on the discrete band stack lower to `<g clip-path="url(#…)">` — PDF-legal (`_pdf.py:206-211`: `g` accepts `clip-path`, `clipPath` accepts `id`, `clip-path-shape` accepts `d`/`clip-rule`). **This requires `_colorbar` to receive the `_Svg` instance for `svg.uid()` (`_svg.py:1833-1835`) — it currently gets none, unlike `_legend`, which is handed `clip_id`.** Signature widening, step 6.
+- **Unrepresentable — raster:** `border-radius`. `cmd.clip` is rectangle-only (`_raster.py:226-231`) and there is no group compositing, so a rounded discrete stack is *unrepresentable, not merely unimplemented*. Add `SLOT_BOX_RASTER_UNSUPPORTED["colorbar_bar"] = frozenset({"border-radius"})` (`_svg.py:1509-1511`), matching the existing `canvas` entry. A rounded **continuous** raster bar is drawable (one `_round_rect_pts` fill), so the loss is discrete-only — record it as such rather than blanket.
+- **Gradient id:** leave `f"xy-colorbar-{_colormap_key(cmap)}"` (`_svg.py:8123`) **untouched** in P5. It bypasses `svg.uid()` so it ignores `id_prefix`, and it encodes the colormap but not the orientation while the direction lives in `gradient_attrs` — two facet panels sharing a cmap at different orientations emit conflicting `<linearGradient id=…>` and the second bar's ramp runs backwards. Real defect, but changing the id string breaks the `"xy-colorbar-viridis" in svg` and `rfind('<defs><linearGradient id="xy-colorbar-inferno"')` pins (§5). File separately.
+
+### 4.3 `colorbar_extension`
+
+- **Geometry:** the two 3-vertex polygons, verbatim (identical in both writers today, confirmed vertex-for-vertex).
+- **Honored:** via `SlotStroke` — `background`/`background-color` → polygon `fill`; `border-color`/`border-width`/`border-style` → `stroke`/`stroke-width`/dash; `opacity`.
+- **Precedence:** **slot declaration wins over payload.** The browser sets `fill="white" stroke="currentColor"` as *presentation attributes* then `_applySlot` adds *inline style* (`js:3556-3562`), and inline style beats presentation attributes in CSS. So `styles={'colorbar_extension':{'background':'#f00'}}` overrides `over_color`.
+- **Unrepresentable (both writers):** `border-radius`, `box-shadow`, `padding` — a triangle has no `rx`, and `_slot_box_svg`/`_emit_slot_box` draw rects/rotated rects only.
+
+### 4.4 `colorbar_line`
+
+- **Geometry:** the segments across the bar's full cross-section.
+- **Honored:** `border-color`/`border-width`/`border-style` → stroke paint/width/dash (the browser expresses these exactly as `border-left`/`border-top`, `20_theme.ts:134-135`), plus `opacity`.
+- **Precedence:** slot wins — the browser's payload values land on `--xy-colorbar-line-*` custom properties (`js:3589-3591`) and `_applySlot` overwrites the longhand.
+- **Dash:** the writers' `3.7w`/`1.6w` matches `_chromebox._border_dash` (`_chromebox.py:317-322`), so folding onto the shared vocabulary does not move the unstyled dash. `dotted` → dash approximation recorded (§28). The browser uses the UA `border-style:dashed` rhythm — new registry entry `colorbar_line_dash_rhythm`.
+- **Unrepresentable:** `background`, `border-radius`, `box-shadow`, `padding`.
+- Applies the §2 case 4 fix (`_css` in the raster).
+
+### 4.5 `colorbar_minor_tick`
+
+- **Geometry:** the 3 px marks, 1 px stroke.
+- **Honored:** `border-color`/`border-width`/`border-style` → stroke; `opacity`. Length stays 3 px (`width`/`height` are not in the box vocabulary).
+- **Spec correction required:** `spec/api/styling.md:596-600` states minor ticks "deliberately carry no slot". False — the slot is in `python/xy/dom.py:24`, has theme rules (`20_theme.ts:136-137`), gets `_applySlot` (`js:3656`), and is byte-pinned at `tests/test_static_client_security.py:325`.
+- **Unrepresentable:** `background`, `border-radius`, `box-shadow`, `padding`.
+
+### 4.6 `colorbar_tick` — pills
+
+- **Geometry:** `_chromebox.text_box(template, pads, x=tick.x, y=tick.baseline, anchor=tick.anchor, block=tick.block, qualifiers=(orientation, str(index)))` (`_chromebox.py:253-294`). This is the family's **first** use of `_textblock.measure` — every other chrome family already routes through it; the colorbar bypasses it entirely today.
+- **Honored:** text subset ∪ `SLOT_BOX_PROPS` (the `tick_label`/`axis_title` routing in `styling/preflight.py:219-227`).
+- **Overflow hazard, must be stated in preflight:** no room function measures colorbar text. On a 500×320 chart ticks start at x=434 with the canvas at 500; a default-size `-1234.5` (38.1 px) already ends at 472.1, and at `font_size:24` it ends at 525.5 — 25 px off canvas. Padding on a tick pill spends canvas that was never reserved. Worse than the `tick_label` case (plan §4 item 5), where `_y_tick_label_room` at least measures.
+- **Unrepresentable:** raster `opacity` reaches the box but not the glyphs (existing atlas limitation, already recorded for `tick_label`).
+
+### 4.7 `colorbar_title`
+
+- **Geometry:** `text_box(..., angle=layout.title.angle)`, which rotates about the text anchor — for the vertical title that is exactly `(x + w + 38, y + h/2)`, **the point both writers already rotate about**, so consuming it preserves the pinned baseline.
+- **Consumes flag E, does not re-lower:** `_chromebox.rotate_points` (`:56-70`), `ChromeBox.angle/cx/cy` (`:117-120`), `_svg._rotated_box_shape` (`_svg.py:1981-2020`), `_slot_box_svg`'s shadow-in-element-space-then-rotate (`_svg.py:2023-2080`), `_emit_slot_box`'s `_chromebox_rotate` (`_raster.py:800-808`). The PDF subset backs the split exactly: `<text>` accepts `transform` (`_pdf.py:212-227`) so the title **text** keeps `rotate(-90 …)`, while `<rect>` does not (`_pdf.py:206`) so the title **box** must go through `_rotated_box_shape`.
+- **Honored:** text subset ∪ `SLOT_BOX_PROPS`.
+- **Blocked on §2 case 9:** without the rotation fix, a bold title's box would rotate (via `ChromeBox.angle`) while its glyphs run horizontally.
+
+---
+
+## 5. Byte-stability risk list
+
+The standing gate is `tests/test_export_style_survival.py:159-165` (`test_unstyled_output_is_untouched`) plus the seven colorbar pins below. **The discipline: the hoist must be provably inert, and every number change lands in its own reviewed commit with regenerated goldens.**
+
+### 5.1 Existing pins the family sits on
+
+| Pin | Location | What breaks it |
+|---|---|---|
+| P1 | `tests/pyplot/test_gallery_log_colorbar_blockers.py:138-139` — slices from `rfind('<defs><linearGradient id="xy-colorbar-inferno"')` to EOF, asserts text nodes are exactly `["1","10","100","counts"]` | Any new `<text>` after the title. The colorbar is the last element before `</svg>` (`_svg.py:5610-5611`), so this is a real trap. New `<rect>`/`<polygon>` are safe (the regex matches `</text>` only), **including a container box emitted before the `<defs>`**. |
+| P2 | same file `:177-179` — samples `pixels[48:432, 544:592]` of a 480×640 PNG | Any change to the `placement="axes"` bar rect. |
+| P3 | same file `:94-97` — `_plot_box_px[2] == allocated_width - 80.0`, "pad=0 vertical chrome (62) + label (18)" | Any change to the room constants **through the pyplot path**, i.e. `pyplot/_axes.py:8300-8301`. |
+| P4 | `tests/pyplot/test_gallery_colorbar_options.py:71-85`; `tests/test_color_pipeline_fixes.py:118-121` (`_colorbar_tick_target(360)==8`, `(140)==3`) | Any change to how bar length feeds the tick budget. |
+| P5 | `tests/test_svg_export.py:517-531` — monkeypatches `_raster._Cmd.text`, asserts the raster vertical-title `(x,y)` equals the SVG label's `(x,y)` and `anchor == 1 \| _TEXT_ROT_CCW` | **The model for the whole design** — the one place the writers are already forced to share a pose. Must keep passing verbatim. |
+| P6 | `tests/test_png_export.py:633-644` — no ink on any canvas border row/column | A container **shadow** offset. Measured headroom on that 560×320 chart: bar at x=466..484, container right edge 532, canvas 560 → 28 px titled, 10 px untitled. Background safe; shadow not automatically. |
+| P7 | `tests/test_svg_export.py:458-479`, `:534-575`; `tests/test_polar_charts.py:663-678` | Geometry relations on the placed rect (bar.x past the right-axis title; `bar.y >= plot.y + plot.h + bottom_axis_room`; max `<rect y> < 500` on polar). |
+
+### 5.2 What changes, and the containment rule
+
+| Change | Output moved | Containment |
+|---|---|---|
+| Hoist bar math into `colorbar_layout` | **none** — 24 of 24 lines byte-identical; only the `domain` hoist and `gradient_attrs` differ, neither geometric | Step 2 must be provably byte-identical: golden-diff SVG **and** PNG bytes across an orientation × placement × extend × levels × line_only matrix before and after. |
+| Tick baseline → +12 | **raster PNG only**, ticks up 1 px | Own commit. P4/P6 unaffected (P6 checks canvas borders; 1 px up increases headroom). |
+| Title baseline → +26 | **SVG only**, title down 4 px | Own commit. P1 survives (node *order* preserved). `tests/test_png_export.py:647-670` asserts only `label_y > plot.y + plot.h` — safe. |
+| Extension default fill | SVG + PNG, discrete + `extend` only | Blast radius small: the pyplot contour path always writes explicit `over_color`/`under_color` (`pyplot/_mplfig.py:1340-1347`), so only hand-built specs move. |
+| `_css` on raster line color | PNG, `currentColor`/`var()` lines only | Effectively zero: `lines` is unreachable from the composition API (`xy.colorbar()` accepts only `show/render/title/orientation/ticks/class_name/style`) and the only producer sets explicit colors. |
+| SVG line/extension order swap | SVG **node order**, not coordinates | Safe against P1 (text-node regex) and against every ElementTree-based pin. |
+| Delete duplicate `SLOT_BOX_PROPS` | **styled output only** — `border` shorthand starts working on `axis_line`/`tick_mark`/`legend`… | No unstyled change. Own commit + capability-matrix regeneration, because preflight's `_honored_props` (`styling/preflight.py:219-227`) reads the same constant. |
+| Cascade split | styled only, and only when `colorbar` **and** a child are both declared | Fixes a live loss (verified above). No unstyled change. |
+| 64-band centre sampling | PNG, continuous bars, ≤2.34 px | Genuinely a bug fix; land with the reconciliation commit and regenerate raster goldens. |
+
+**Rules that keep unstyled bytes identical by construction:**
+1. `bar_inset` defaults to `(0,0,0,0)`; `tick_size`/`title_size` feed only `TextBlock` measurement, never a coordinate.
+2. `colorbar_chrome_boxes` / `colorbar_slot_strokes` return empty unless `_has_box_declaration` is true for the slot — the `axis_chrome_boxes` gate (`_svg.py:4413-4467`).
+3. The `<defs><linearGradient>` block stays **unconditional** (it is dead weight for `levels`/`line_only` — 256 unused `<stop>`s for a custom ramp — but making it conditional changes SVG bytes; file separately).
+4. The gradient id string is not touched.
+5. SVG serialization artifact preserved: `tick_attrs` is spliced after an already-trailing space, so every colorbar tick `<text>` carries a **double space** before `font-size` (`y="362"  font-size="10"`). The shared emitter must reproduce it or the byte pin breaks. Attribute order inside `slot_text_attrs` is a fixed tuple iteration (`_svg.py:1615-1636`) and is already deterministic.
+
+---
+
+## 6. Ordered edit list
+
+Every anchor is current-checkout. **Plan §7's own citations are all stale** (`_svg.py` off by ≈ +1290 lines, `_raster.py` by ≈ +255; spot-checked `_svg.py:6906` → `alpha_same = …`, `_raster.py:3459` → `def _emit_legend_marker`). §8 flag C is stale the same way — it claims `_raster.py:52` imports `_estimated_text_width`; line 52 is `_density_column` and the import block does not contain it. Re-anchor §7 before starting.
+
+---
+
+**Step 0 — De-shadow `SLOT_BOX_PROPS`.**
+Delete the second assignment and its comment block, `python/xy/_svg.py:1521-1546`; fold its docstring into the first at `:1455-1481`.
+*Accept:* `'border' in _svg.SLOT_BOX_PROPS`; `_has_box_declaration({'border':'1px solid red'})` is True; `slot_box_declaration({'border':'1px solid red'}, 'colorbar_bar') == {'border': '1px solid red'}`. Unstyled SVG+PNG byte-identical. Regenerate `spec/api/capability-matrix.md` via `scripts/gen_capability_matrix.py` (`tests/test_capability_registry.py:161` forces same-commit regeneration).
+
+**Step 1 — Add the records and `colorbar_layout`.** New code above `python/xy/_svg.py:8098`. Pure hoist of `_svg.py:8130-8331` + `_svg.py:8339-8399` (`_colorbar_body`). Add per-writer offset parameters `h_tick_offset: float = 12.0`, `h_title_offset: float = 22.0` **temporarily**, so both writers keep their current numbers.
+*Accept:* new unit test asserting `colorbar_layout` reproduces, field by field, the coordinates the two writers compute today, over the matrix {vertical, horizontal} × {default, `placement="axes"`} × {continuous, `levels=5`, `levels=5 + proportional`} × {`extend` ∈ neither/min/max/both} × {`line_only`} × {`pad=None`, `pad=0`, `pad=0.05`} × {`shrink=1`, `0.5`} × {`anchor` default, `[0.2,0.8]`}.
+
+**Step 2 — Rewire both writers as pure emitters.** `_colorbar` (`_svg.py:8098-8331`) and `_emit_colorbar` (`_raster.py:3547-3806`) consume the record; add `colorbar_layout`, `colorbar_chrome_boxes`, `colorbar_slot_strokes`, `SlotStroke` to `_raster.py:27-93`; drop the late `from ._svg import …` at `_raster.py:3574`.
+*Accept:* **the byte gate.** SVG string equality and PNG bytes equality across the full step-1 matrix, before vs after. Plus all of P1-P7 green.
+
+**Step 3 — Reconcile the numbers (own commit).** Set `h_tick_offset=12.0` for both and `h_title_offset=26.0` for both, then delete the parameters. Extension defaults → `_colormap_stops` endpoints in the raster (`_raster.py:3677,3690`). Line color → `_css(line.get("color"), text_color)` (`_raster.py:3704`). Order swap in the SVG concat (`_svg.py:8326-8331`) → `body, extend_nodes, line_nodes, minor_nodes, tick_nodes, label_node`. `closed=True` on the `line_only` outline (`_raster.py:3632`). Band centres `(arange(64)+0.5)/64` (`_raster.py:3617`). Index-paired explicit labels in the raster (`_raster.py:3661-3670`).
+*Accept:* one new cross-writer test in the shape of `tests/test_svg_export.py:517-531`, extended to the **horizontal** orientation, asserting the raster's tick and title `(x, y)` equal the SVG's exactly. Plus a `colorbar_extension_default_matches_matplotlib` test (`levels=5, extend="both"` → both writers emit `rgb(253,231,37)`/`rgb(68,1,84)`), and a `currentColor` line test asserting both writers resolve to the chart text color. Regenerate raster goldens; P1-P7 re-verified.
+
+**Step 4 — Fix the raster rotation drop.** Route the colorbar title through `_emit_text_block` (`python/xy/_raster.py:712-747`) instead of the hand-rolled `cmd.text(x, y, 1 | _TEXT_ROT_CCW, …, italic=, bold=)` at `_raster.py:3796-3806`.
+*Accept:* a test asserting that with `styles={'colorbar_title': {'font_weight': 700}}` the raster title still carries the quarter-turn (ink bbox is a vertical ribbon, ~10×43, not ~43×11) and that the SVG still emits `transform="rotate(-90 …)"`. Keeps `spec/api/styling.md:840-846` and `spec/api/capability-matrix.md:136` truthful.
+
+**Step 5 — Cascade split.** Replace the `or`-fallback at `_svg.py:5249-5250` and `_raster.py:1825-1826` with a per-property inherited cascade over `python/xy/styling/cascade.py:56-62`; widen both call sites to pass the whole slots map (`_svg.py:5242-5252`, `_raster.py:1818-1827`) and both signatures (`_svg.py:8098-8105`, `_raster.py:3547-3555`). Add the `_Svg` instance to `_colorbar`'s signature at the same time (needed in step 7).
+*Accept:* `styles={'colorbar':{'color':'#ff0000'}, 'colorbar_title':{'font_size':14}}` renders the title `font-size="14" fill="#ff0000"` in both writers — matching `js:3485` + `js:3665-3667`. Unstyled bytes untouched.
+
+**Step 6 — Container box.** `colorbar_chrome_boxes` emits the `colorbar` box first; `_svg._slot_box_svg` prepended in `_colorbar`'s return concat, `_raster._emit_slot_box` before the band loop. `box_room` folded into `_svg.py:3091-3100` **and** `pyplot/_axes.py:8289-8301`.
+*Accept:* container renders under bar/ticks/text and over the plot in both writers; a container `background` does **not** leak into per-text backgrounds (the step-5 cascade test); container padding moves the bar identically in SVG, PNG, and the pyplot reservation (three-consumer test, the `legend` P4 pattern); PDF round-trip; `tests/test_png_export.py:633-644` still passes.
+
+**Step 7 — `colorbar_bar` box.** Rect at `_svg.py:8357-8362`/`8363-8399`, raster at `_raster.py:3633-3642`. Rounded discrete stack → `<g clip-path>` using `svg.uid()` (available from step 5). Seam clamp when border/radius present. `SLOT_BOX_RASTER_UNSUPPORTED["colorbar_bar"] = {"border-radius"}` at `_svg.py:1509-1511`.
+*Accept:* border+radius on continuous **and** discrete bars in SVG/PDF; band seams stay inside the border; raster discrete radius reported partial in preflight rather than half-drawn; the browser's default 1 px border is **not** adopted (golden asserts unstyled bars carry no stroke); gradient-id dedup unchanged.
+
+**Step 8 — `colorbar_extension` / `colorbar_line` / `colorbar_minor_tick` paints.** `colorbar_slot_strokes` consumed at `_svg.py:8272-8298`/`8299-8325`/`8252-8268` and `_raster.py:3672-3698`/`3699-3712`/`3729-3733`+`3762-3776`.
+*Accept:* slot declaration overrides payload `over_color`/`under_color` and per-line `color`/`width`/`dash` in both writers (browser-precedence test, mirroring `_applySlot` inline-style-over-attribute); `dotted` → dash approximation recorded in §28; the live headless-Chrome probe at `tests/test_tailwind_root_customization.py:274-302` re-used as the browser reference.
+
+**Step 9 — `colorbar_tick` pills and `colorbar_title` box.** `text_box` consumption; per-tick `SlotInstance` qualifiers + geometry into `python/xy/styling/declared.py`.
+*Accept:* rotated title box geometry byte-identical across SVG / PDF / raster from the single pose (extend the P5 pin to the box); tick pill widths recorded as metrics-divergent (§28, the DejaVu-vs-authored-family misfit already noted in `text_box`'s docstring); tick-overflow note surfaced by preflight.
+
+**Step 10 — Registry, matrix, docs.** Add `colorbar_bar`, `colorbar_extension`, `colorbar_line`, `colorbar_minor_tick` to `STATIC_STYLED_SLOTS` (`_svg.py:1383-1401`); add their `_SLOT_PAINT_PROPERTY` entries (`tests/test_export_style_survival.py:60-76`) — all four take `background` except `colorbar_line`/`colorbar_minor_tick`, which take `border-color`; extend `styling/preflight.py:_honored_props` (`:191-250`) with the three stroke-only slots; add the ten `RendererDivergence` entries from §3 at `capabilities.py:257`; rerun `scripts/gen_capability_matrix.py`.
+*Accept:* `tests/test_export_style_survival.py:79-97` green for all four new slots; `tests/test_capability_registry.py:161` and `:91` green; hand-written counts corrected — `spec/api/export.md:251` ("17 slots" → 21), the enumerations at `spec/api/export.md:326` and `spec/api/styling.md:1327`, the false minor-tick claim at `spec/api/styling.md:596-600`, and `spec/api/export.md:255`, which wrongly says `xy.colorbar(style=...)` is dropped by both writers — verified false: it lands in `spec['dom']['styles']['colorbar']`, which is exactly the map `slot_styles` returns.
+
+---
+
+### Out of scope, file separately (found while verifying)
+
+- `pyplot`'s figure-level shared colorbar (`fig.colorbar(ax=[list])`) reaches only the PNG stitcher (`pyplot/_grid.py:587-611`, an ad-hoc 52 px band, no ticks/title/extensions/styling); `compose_svg` (`pyplot/_grid.py:379-390`) takes no colorbar argument, so the same figure exports a colorbar to PNG and **silently omits it from SVG and HTML**. Predates P5, sits on the shared-layout seam — decide explicitly whether the shared module claims it or it gets a §28 entry.
+- Gradient `<defs>` emitted unconditionally for `levels`/`line_only`; gradient id ignores `id_prefix` and omits orientation from the key (facet collision).
+- `_frame_padding` returns `None` outright when a colorbar exists and `_plot_box_px` is None (`pyplot/_axes.py:8321-8325`, "Reconciling the two is colorbar-placement work, not framing work") — a documented hole the shared layout could now close.
+- The static bar carries almost no queryable identity: only the `line_only` rect has a marker (`_svg.py:8353`); normal/discrete bar rects and extension polygons have none, where the live DOM exposes `data-xy-slot="colorbar_bar"` and `data-xy-colorbar-extend`. Three existing tests locate the bar by `fill="url(#xy-colorbar-"`, so a `colorbar_bar` background override that replaces the gradient url makes them find nothing.
+
+---
+
+# Adversarial refutations
+
+## Refutation 1
+
+## Verdict: the design breaks 6 existing tests. Two are structurally unfixable as written, one is a preflight contract the design silently inverts.
+
+All findings re-verified against the **post-P4 tree** (the checkout moved under me at 18:17 while I worked — P4 legend parity landed and invalidated several of the design's anchors; see §D). Method: a byte-identical snapshot of `python/`, `tests/`, `js/`, `docs/`, `spec/`, `src/` + the prebuilt `libxy_core.dylib` at `/private/tmp/claude-501/-Users-alek-Desktop/fb4772f2-e6f7-4750-95ee-9c2b1fe6a5e2/scratchpad/xy-exp2`, with the design's steps applied and `pytest tests` run (3880 passed / 111 skipped baseline). The read-only checkout was never touched.
+
+---
+
+### A. CONFIRMED BREAK — `test_styles_on_a_slot_with_no_native_path_are_named_lost`
+
+`/Users/alek/Desktop/xy-compat/tests/test_style_compatibility_report.py:110-119`
+
+```python
+report = _chart(styles={"colorbar_bar": {"border-radius": "2px"}})
+report = report.style_compatibility_report("png")
+finding = _finding(report, "colorbar_bar", "styles")
+assert finding.route == pf.ROUTE_BROWSER_ONLY      # <- breaks
+assert finding.lost == ("border-radius",)
+assert not report.lossless
+```
+
+Adding `colorbar_bar` to `STATIC_STYLED_SLOTS` (step 10) — **on its own, before any writer code** — flips `capabilities.CHART_SLOTS["colorbar_bar"].support["native_raster"]` from `none` to `partial`, so `preflight._styles_finding` (`python/xy/styling/preflight.py:335`) no longer takes the `ROUTE_BROWSER_ONLY` branch. Observed: `AssertionError: assert 'native-subset' == 'browser-only'`.
+
+The test's own comment names P5 as the thing that will break it ("`colorbar_bar` is static chrome whose writers arrive with the colorbar family (plan §7)") — the design's step-10 acceptance list cites `test_export_style_survival.py:79-97`, `test_capability_registry.py:161` and `:91`, and never this file.
+
+**This one cannot be fixed by moving the example to another slot.** After P5 adds all four, the set of static slots with no native writer is empty:
+
+```
+static slots with no writer after P5: []
+```
+
+So `_styles_finding`'s `ROUTE_BROWSER_ONLY` branch becomes unreachable from `source="styles"` entirely (it survives only for `class_names` and state-gated slots). The test has to be rewritten or deleted, and that is a published-contract decision, not a rename. Nothing in the design mentions it.
+
+---
+
+### B. CONFIRMED BREAK — three `test_every_static_slot_carries_its_paint_into_svg` params are unsatisfiable
+
+`/Users/alek/Desktop/xy-compat/tests/test_export_style_survival.py:65,83-99`
+
+```python
+_SLOT_PAINT_PROPERTY = {slot: "fill" for slot in STATIC_STYLED_SLOTS} | {...}
+@pytest.mark.parametrize("slot", STATIC_STYLED_SLOTS)
+def test_every_static_slot_carries_its_paint_into_svg(slot):
+    chart = xy.scatter_chart(..., xy.colorbar(title="Colorbar title"), ..., styles={slot: {_SLOT_PAINT_PROPERTY[slot]: "#123456"}})
+    assert "#123456" in chart.figure().to_svg()
+```
+
+Observed failures after step 10 (with the design's own `_SLOT_PAINT_PROPERTY` additions applied):
+
+```
+FAILED ...[colorbar_bar]        FAILED ...[colorbar_extension]
+FAILED ...[colorbar_line]       FAILED ...[colorbar_minor_tick]
+```
+
+`colorbar_bar` is merely unimplemented (step 7 would fix it). The other three are **structurally impossible**: the parametrized chart is built through the composition API, and `xy.colorbar()` (`python/xy/components.py:3105-3114`) accepts only `show/render/title/orientation/ticks/class_name/style` — no `extend`, no `lines`, no `minor_ticks`. Measured on that exact chart:
+
+```
+minor markers: 0   line markers: 0   polygons: 0
+colorbar options: {'domain': [0.0, 1.0], 'colormap': 'viridis', 'label': 'Colorbar title', 'orientation': 'vertical'}
+```
+
+There is no chrome for the paint to land on, so no writer change can make `#123456` appear. The design's step-10 acceptance ("green for all four new slots") is unachievable without either widening the public `xy.colorbar()` surface — an API change guarded by `_validated_colorbar_fields` (`components.py:3141`) and `test_declarative_colorbar.py::test_colorbar_rejects_invalid_public_options` — or replacing the shared chart builder with per-slot hand-built specs. The design contradicts itself here: §5.2 states "`lines` is unreachable from the composition API," yet §10 assumes the parametrized test will go green.
+
+---
+
+### C. CONFIRMED BREAK — step 5's cascade split drops `fill` on the `colorbar` slot
+
+`tests/test_export_style_survival.py::test_every_static_slot_carries_its_paint_into_svg[colorbar]`
+
+`_SLOT_PAINT_PROPERTY["colorbar"]` resolves to `"fill"` (line 65 default; `colorbar` is not in the `background` override list at 67-81). Today `styles={"colorbar": {"fill": "#123456"}}` reaches the tick/title `<text>` through the whole-declaration fallback at `_svg.py:5274` / `_raster.py:1831`. §4.1 replaces that with a cascade "restricted to the **inherited** properties (`color`, `font-*`, `letter-spacing`)". `fill` is not in that list, and the container box honors `SLOT_BOX_PROPS`, which has no `fill` (only `fill-opacity`). I implemented exactly the design's rule and got:
+
+```
+FAILED tests/test_export_style_survival.py::test_every_static_slot_carries_its_paint_into_svg[colorbar]
+AssertionError: styles={'colorbar': ...} was dropped
+```
+
+**The worse half is untested and therefore silent.** Preflight today reports:
+
+```python
+{'slot': 'colorbar', 'source': 'styles', 'route': 'survives', 'kept': ('fill',), 'lost': ()}
+```
+
+because `_honored_props` falls through to the text subset for `colorbar` (`preflight.py:285`). Step 10 only extends `_honored_props` "with the three stroke-only slots" — it never re-routes `colorbar` from text slot to box slot. So after step 5 the writers drop `fill` while the report still says `survives` and `strict` mode still passes. That is precisely the writer/report drift `preflight.py:196-199` exists to prevent.
+
+Same applies to `opacity`, which `SLOT_TEXT_PROPS` (`_svg.py:1346-1355`) honors on text and which CSS does not inherit.
+
+---
+
+### D. The design's premises have already gone stale (it complains about exactly this in §6)
+
+| Design claim | Current tree |
+|---|---|
+| §2 case 10 / **Step 0 "Blocking": `SLOT_BOX_PROPS` is shadowed, delete `_svg.py:1521-1546`** | **Already done.** One definition only, at `_svg.py:1492`; `'border' in SLOT_BOX_PROPS` is `True`; `SLOT_BOX_PROPS_BY_SLOT` now also carries `legend_item`/`legend_swatch`. Step 0 is a no-op. |
+| §10 "`spec/api/export.md:251` (\"17 slots\" → 21)" | Reads **19 slots**; the target is 23. `export.md:326` / `styling.md:1327` already enumerate `legend_item`/`legend_swatch`. |
+| §4.2 `SLOT_BOX_RASTER_UNSUPPORTED` at `_svg.py:1509-1511` | now `1542`; `_colorbar` at `8563`, the slot fallbacks at `_svg.py:5274` / `_raster.py:1831`. |
+
+Every `_svg.py`/`_raster.py`/test line number in the design needs re-anchoring, not just §7's.
+
+---
+
+### E. One containment claim in §5.2 is factually wrong
+
+> "Extension default fill … Blast radius small: the pyplot contour path always writes explicit `over_color`/`under_color` (`pyplot/_mplfig.py:1340-1347`), so only hand-built specs move."
+
+`_mplfig.py:1329-1347` writes them **only when `color_table` is an ndarray**. With a named/default colormap it does not:
+
+```
+contourf(..., extend="both")  -> {'extend': 'both', 'levels': 4}   # no over_color/under_color
+contourf(..., extend="min")   -> {'extend': 'min',  'levels': 4}
+```
+
+So the change moves real shim output for ordinary `contourf(..., extend=...)`, which `tests/pyplot/test_frame_geometry.py::test_constrained_colorbar_grid_keeps_balanced_cells_across_static_exports` renders in all four extend modes and `tests/pyplot/test_pdsh_gap_features.py::test_colorbar_ticks_and_extend_reach_both_exports` renders too. Neither asserts the triangle color, so neither fails — but "only hand-built specs move" is wrong and the today-divergence is larger than stated:
+
+```
+SVG default over/under:            (253,231,37) / (68,1,84)
+raster levels=4 over/under:        (172,220,49) / (70,44,122)   # ΔR=81, ΔG=11 / ΔG=43, ΔB=38
+```
+
+Related ordering hazard the design does not name: change (g) (64-band centres) **alone** also moves the *continuous* raster extension default, `(253,231,37)/(68,1,84)` → `(248,230,37)/(68,4,87)`, because the raster reads `colors[0]`/`colors[-1]` off the same LUT. §5.2 describes (c) as "discrete + `extend` only", which is true only because (c) and (g) are bundled in step 3. Split them and step 3 introduces a fresh SVG/PNG divergence.
+
+---
+
+### F. What I checked and found genuinely byte-safe
+
+I applied the design's steps 3 and 4 verbatim and ran the whole suite (`3880 passed`, only the failures above):
+
+- SVG horizontal title `+22 → +26` (verified moved: `y=306 → y=310`, canvas 320, descent-safe). **No test pins it.**
+- Raster horizontal tick baseline `+13 → +12`. **No test pins it.**
+- SVG line/extension node-order swap. **No test pins it** — `test_hexbin_demo_log_colorbar_keeps_counts_and_covers_svg_cell_seams` (`tests/pyplot/test_gallery_log_colorbar_blockers.py:138-139`) matches `</text>` only, and its `<polygon>` sweep at `:143-146` never sees an extension because that chart has no `extend`.
+- `closed=True` on the `line_only` outline; `_css` on the raster line color; 64-band centre sampling. **Unpinned.**
+- Step 4's `_emit_text_block(..., angle=270.0)` reroute: the quarter-turn branch (`_raster.py:730-740`) emits `cmd.text(x, y, anchor | _TEXT_ROT_CCW, size, color, line)` positionally, identical bytes, so the P5 cross-writer pin (`tests/test_svg_export.py:517-531`, `assert anchor == 1 | _raster._TEXT_ROT_CCW`), `test_png_export.py:596-631`, and `tests/pyplot/test_pdsh_gap_features.py:312-342` all stay green. `src/raster.rs:1800-1880` `styled_text` applies a full affine (`transform(u,v) = (x + u·cosθ − v·sinθ, …)`), so the bold path really does rotate glyphs — step 4's acceptance is achievable.
+- `test_gallery_log_colorbar_blockers.py` P1-P3, `test_png_export.py:633-644` (P6), `test_polar_charts.py:663-678`, `test_pdf_text_subset.py`, `test_declarative_colorbar.py`, `test_custom_ramps_and_palette.py`, `test_static_client_security.py`, `test_text_weight_defaults.py`, `test_type_surface.py` — all unaffected.
+
+Two consequences worth stating plainly: the design's elaborate byte-gate ceremony in §5 is guarding numbers that **no test currently pins**, so the gate has to be written from scratch as part of step 1/2 rather than "kept green"; and the design's own §5.1 pin table is not where the risk actually lives — it lives in `test_style_compatibility_report.py` and `test_export_style_survival.py`, neither of which §5.1 lists.
+
+Two smaller confirmations for the design: `xy.colorbar(style={"fill": "#123456"})` does reach both writers today (so `spec/api/export.md:255` is wrong, as claimed), and `spec/api/styling.md:597-600` ("Minor ticks … deliberately carry **no slot**") does contradict `spec/api/styling.md:698`, which lists `colorbar_minor_tick` as a slot in the same document. Also verified feasible: `_colorbar_outside_room` (`pyplot/_axes.py:8289`) is a method on an object that already holds `self._chrome_styles` (`_axes.py:1503`), so step 6's room fold is implementable there.
+
+---
+
+## Refutation 2
+
+Verified against the checkout (Chrome 560×320/640×360 renders, live CSS probe, both writers driven directly). **The design has real geometry defects.** Ranked:
+
+---
+
+## 1. BLOCKING — the container's horizontal height (50) lands 12 px off-canvas in the default configuration
+
+§1.4 imports the browser's container box wholesale (`js/src/50_chartview.ts:3707-3709`: horizontal non-axes `height = 50`) while §3 deliberately *keeps* the writers' divergent gap (`colorbar_horizontal_gap`: `plot["bottom_axis_room"] or 10` at `python/xy/_svg.py:8148` / `python/xy/_raster.py:3588`, vs the browser's constant `COLORBAR_GAP = 24` at `js/src/50_chartview.ts:152,3686`). Those two decisions are individually defensible and **jointly inconsistent**: the browser's reservation (`38 + label?16`, `js:3532-3534`) is sized for a 24 px gap; `layout()` reuses the same `38` (`_svg.py:3097-3098`) under a gap that is *measured* and typically 42.
+
+Worked, from the actual layout:
+
+```
+xy.heatmap_chart(xy.heatmap([[0,1],[2,3]], colormap="viridis", domain=(0,3)),
+                 xy.colorbar(orientation="horizontal"), width=560, height=320)
+
+layout()  -> plot = (62, 10, 484, 230),  bottom_axis_room = 42,  reserved below plot = 80 (42 base + 38)
+bar        = (62, 282, 484, 18)
+container  = (62, 282, 484, 50)  -> bottom = 332      canvas H = 320   OVERFLOW = +12.0 px
+```
+
+General condition: `overflow = bottom_axis_room + 50 − (base_bottom + 38)`. With any bottom axis `bottom_axis_room ≈ base_bottom`, so it is **structurally +12 px** for every horizontal colorbar without a title. With a title it is −4 px (reserved becomes 96), and vertical is −10/−28 px. So the failing case is exactly `xy.colorbar(orientation="horizontal")` with no title — the plainest spelling.
+
+The design's own guard is blind to it: step 6 cites `tests/test_png_export.py:633-644`, which is `test_native_vertical_colorbar_label_leaves_the_canvas_edges_unpainted` — a **vertical, titled** chart, i.e. the configuration with the *most* slack (28 px, exactly the number §5.1 P6 quotes). A container background/border in the failing case is clipped at the canvas and paints the bottom border row, which is precisely what that test forbids for its own orientation.
+
+The container must be sized against the writers' reservation, not copied from a browser whose origin differs by 18 px.
+
+---
+
+## 2. BLOCKING — §4.1's padding model is wrong in kind and in sign; the browser does not move the bar at all
+
+§4.1: *"the browser's bar is `inset:0 auto 0 0` (`js:3528-3533`), i.e. relative to the padding box, so padding moves the bar live."* An absolutely positioned child's containing block **is** the padding box, which means padding does **not** translate it. Measured in Chrome (headless, `getBoundingClientRect`):
+
+```
+box  {position:absolute; left:100; top:50; width:66; height:200; padding:8px}
+  bar {position:absolute; inset:0 auto 0 0; width:18}   -> x=100  y=50   h=216
+  tick{position:absolute; left:23px}                    -> x=123
+box2 {left:300; width:66; height:200; border:4px solid}
+  bar2{position:absolute; inset:0 auto 0 0; width:18}   -> x=304  y=54   h=200
+```
+
+Live behaviour of `styles={'colorbar': {'padding':'8px'}}`: the bar **does not move**; it *stretches* by 16 px (its `inset:0 … 0` resolves against the padding box). Only `border-width` translates children (bar2 shifted by exactly 4).
+
+The design's mechanism does the opposite, and in the opposite direction. `box_room` (`_chromebox.py:191-200`) grows `right` in `layout()`, and `bar.x = plot.x + plot.w + right_axis_room + gap = width − right + …`, so growing `right` moves the bar **left**. Net with `bar_inset.left`:
+
+```
+bar.x' = bar.x − (pad_l + pad_r + 2·border) + pad_l = bar.x − pad_r − 2·border
+```
+
+Concrete (560×320 vertical, untitled, `padding:8px`): static bar goes 484 → 476 (−8 px, unchanged length); live bar stays at 484 and grows 268 → 284 px long. A 8 px position gap plus a 16 px length gap, on the one property §4.1 singles out as the browser-parity justification. The design also never gives `border-width` its child-shifting term, which is the *only* box property that legitimately moves the bar live.
+
+---
+
+## 3. The seam clamp names the wrong band in the vertical (default) orientation
+
+§4.2: *"clamp the final band's far edge to the bar rect (`ColorbarBand.seam = 0.0` for the last band). Otherwise seams paint over the border."* The `+0.5` (`_svg.py:8388,8396`; `_raster.py:3638,3642`) extends **height** downward / **width** rightward, so which band crosses the bar rect depends on orientation. Emitted rects, bar `y ∈ [10, 310]`, `levels=5`:
+
+```
+vertical  (loop order = emission order)      horizontal
+  idx0: y=250.00 h=60.5 -> 310.50  <== overhangs bar bottom (310)
+  idx1: y=190.00 h=60.5 -> 250.50            idx0: x= 60 w=80.5 -> 140.5
+  idx2: y=130.00 h=60.5 -> 190.50            ...
+  idx3: y= 70.00 h=60.5 -> 130.50            idx4: x=380 w=80.5 -> 460.5  <== overhangs bar right (460)
+  idx4: y= 10.00 h=60.5 ->  70.50
+```
+
+Vertical: the overhanging band is **index 0** (lowest fraction, first emitted). Horizontal: index n−1. Setting `seam = 0.0` on "the last band" therefore (a) leaves the 0.5 px overhang past the bar's *bottom* border untouched in the default orientation — the stated failure still happens — and (b) removes an *interior* 0.5 px overlap between the top band and its neighbour, reintroducing exactly the antialias hairline the `+0.5` exists to suppress. `ColorbarBand.seam: float` also carries no side, so the record as specified cannot express the correct rule.
+
+---
+
+## 4. §2 case 8 (64-band centre resampling) is not "zero cost" — it moves the bar off the ramp's endpoints and opens a cap/band seam
+
+Today `_lut(cmap, linspace(0,1,64))` makes the raster's extreme bands **exactly** the SVG gradient's and the browser's endpoints. Measured:
+
+```
+cmap     stops[-1]        today[-1]        proposed[-1]      stops[0]        today[0]        proposed[0]
+viridis  (253,231,37)     (253,231,37)     (248,230,37)      (68,1,84)       (68,1,84)       (68,4,87)
+turbo    (122,4,3)        (122,4,3)        (128,7,3)         (48,18,59)      (48,18,59)      (50,24,70)
+flag     (0,0,0)          (0,0,0)          (0,0,124)         (255,0,0)       (255,0,0)       (255,177,124)
+```
+
+The centre form is exact at band centres and now *wrong at both ends* by 0.5/64 of ramp space — Δ124 and Δ177 on `flag`, i.e. the same 256-stop class §3 says every custom resampled ramp falls into. Worse, it interacts with §2 case 3: after the cap fill becomes `stops[±1]` and the end band becomes `_lut(cmap, 63.5/64)`, the raster paints an extension triangle whose colour no longer matches the band it abuts — a seam present in neither writer today nor in the browser (whose `linear-gradient` reaches `stops[0]`/`stops[-1]` at 0 %/100 %, `js:3524-3527`).
+
+---
+
+## 5. §2 case 3 resolves against the repo's own stated contract when `band_colors` is present
+
+The justification (*"Matplotlib semantics: default over/under = `cmap(1.0)`/`cmap(0.0)`"*) silently assumes `options["colormap"]` is the effective ramp. When `band_colors` is set it is not — `pyplot/_mplfig.py:1322-1324` says so in as many words: *"Listed contour fills already carry their exact per-band RGBA table. Keep that table on the colorbar instead of replacing it with samples from the nominal fallback colormap. Extended rows own the cap colors."* Driving both writers with a `band_colors` spec that carries no `over_color`/`under_color` (the `_mplfig.py:1326-1328` branch, which sets `band_colors` alone):
+
+```
+band_colors = [[255,0,0],[0,255,0],[0,0,255]], extend="both", colormap="viridis"
+SVG   caps: rgb(253,231,37) / rgb(68,1,84)      # viridis — appears nowhere on the bar
+RASTER caps: (0,0,255) / (255,0,0)              # the actual end bands
+```
+
+The design picks SVG, so the caps become viridis on a red/green/blue bar. The measured "ΔR=64, ΔG=35" in §2 was taken on the sampled-colormap case only; with `band_colors` the delta is unbounded (255 here). The correct rule is `band_colors[±1]` when a band table is present, `stops[±1]` otherwise. (I confirmed the divergence is discrete-only: for a continuous bar `_lut(cmap,1.0) == stops[-1]`, so the writers already agree.)
+
+---
+
+## 6. §2 cases 1 and 2 cannot both be "browser parity" — the browser's delta is 16, the design picks 14
+
+Both spans carry the same 10 px font, so whatever top→baseline constant you use, the browser's title-minus-tick baseline gap is exactly `18 − 2 = 16` (`js:3630` vs `js:3665`). SVG today is 10, raster 13, the design's (12, 26) is 14. Applying the design's own stated tiebreak consistently gives (12, 28) or (11, 27). Choosing 12 because "SVG is 0.6 off" and 26 because "raster is 1.4 off" is per-row nearest-neighbour copying — the thing plan §7 says not to do — and it leaves an unexplained 2 px in a family whose whole point is one derived number.
+
+---
+
+## 7. `line_only` already draws the 1 px bar border the design says the writers never draw
+
+`colorbar_bar_default_border` (§3) states *"Browser `colorbar_bar` ships `border:1px solid currentColor` (`20_theme.ts:133`); writers draw none."* False for `line_only`: `_svg.py:8353-8356` emits `fill="white" stroke=text_color stroke-width="1"` and `_raster.py:3630-3632` strokes the same outline — the writers' emulation of that exact theme rule (the browser's `line_only` bar is `linear-gradient(white,white)` + the theme border, `js:3519`). §4.2 never mentions `line_only`, so step 7 would stack a declared `colorbar_bar` border box on top of the built-in stroke: `styles={'colorbar_bar':{'border':'2px solid red'}}` renders a 2 px red box *and* a 1 px `rgba(32,32,32,0.85)` stroke.
+
+---
+
+## 8. Tick/title offsets are font-size-independent, so §4.6's pills will be drawn over the bar
+
+§1.3 correctly notes `+4/+12/+22/+38` carry no font-size term — but then §2 derives them from a browser whose offsets are box tops that *do* scale, at "the 10 px colorbar font". Verified with `styles={'colorbar_tick': {'font-size': '24px'}}`, horizontal:
+
+```
+size=10: baseline = bar_bottom + 12, ascent 9.38  -> glyph top = bar_bottom + 2.6  (below the bar)
+size=24: baseline = bar_bottom + 12, ascent 22.50 -> glyph top = bar_bottom − 10.5 (10.5 px INSIDE the bar)
+browser at 24: baseline = bar_bottom + 2 + 22.50 = bar_bottom + 24.5
+```
+
+Today this only mis-places glyphs; §4.6 adds a filled `text_box` pill at that baseline, which becomes an opaque rect painted across the bar. The vertical `+4` centring hack has the same defect (correct only near 10 px; the browser uses `translateY(-50%)`, exact at any size). Neither is in §3's divergence list nor in §4.6's hazard note, which flags only horizontal overflow.
+
+---
+
+## 9. Step 4's `_emit_text_block` reroute is not byte-inert for multi-line titles
+
+`_emit_text_block` (`_raster.py:713-747`) splits on lines and emits one `cmd.text` per line; the current colorbar call (`_raster.py:3796-3806`) passes the whole string in one command. Single-line unstyled titles do stay byte-identical (the `quarter_flag and not italic and not bold` branch at `:742-743` reproduces the current call exactly), but a multi-line title changes the PNG. Step 4's acceptance criterion covers only the styled/rotation case.
+
+---
+
+### Checked and found correct (no defect)
+
+Bar-rect math is byte-identical across `_svg.py:8134-8161` / `_raster.py:3579-3599` (all three branches, `pad`, `shrink`, `anchor`, `right_axis_room`); the §1.4 container table does faithfully mirror `js:3704-3709` for all four cases; axes-placement and `pad=0` container edges fit their reservations (+base slack); the `SLOT_BOX_PROPS` shadowing is real and gates as described (`_svg.py:1462-1481` vs `:1527-1546`; `title` keeps `border`, nothing else does); case 4 is real (`_css("currentColor", _TEXT) = rgba(32,32,32,0.85)` vs `_parse_color("currentColor") = (76,120,168)`); case 6's index-vs-dict pairing matches the browser's parallel arrays; case 7 (`closed=False`, `cap="round"` at `_raster.py:286-288`); case 9 (`_Cmd.text` styled branch masks `anchor & 0x03` and passes `angle=0.0`, `_raster.py:687-702`); extension vertex order, the proportional guard, `_colorbar_tick_target`, minor-tick length, dash rhythm, and the `levels < 1` edge cases all genuinely agree between the writers; the colorbar really is last in both chrome orders (`_svg.py:5242-5252` + the final `*chrome`; `_raster.py:1816-1827` after the clip reset); `compose_svg` (`pyplot/_grid.py:379-390`) really does take no colorbar argument.
+
+---
+
+## Refutation 3
+
+I read `_pdf.py`, `_chromebox.py`, both writers' colorbar paths, and the live client, and probed the PDF converter with the exact constructs the design implies.
+
+## Verdict: the design does not name a construct `_pdf.py` rejects — but its paint order is wrong in five places, and one of them breaks PDF specifically.
+
+What I probed and confirmed **legal**: rotated polygon/path boxes with shadow + dash + radius, `<rect rx>` with a gradient fill, `<g clip-path>` over a rounded `<path>` clip, `<g clip-path opacity>`, `<clipPath>` emitted outside `<defs>`, `<polygon>`/`<line>` carrying the whole `SlotStroke` vocabulary, and today's unstyled colorbar SVG.
+
+---
+
+### F1 — The §4 bar order is not expressible; both achievable orders are wrong
+
+`_svg._slot_box_svg` (`/Users/alek/Desktop/xy-compat/python/xy/_svg.py:2023-2081`) emits shadow (`:2050-2065`) then **one** shape carrying `fill` *and* `stroke` (`:2066-2079`). `_raster._emit_slot_box` (`/Users/alek/Desktop/xy-compat/python/xy/_raster.py:783-826`) is identical in structure. There is no split entry point, and step 7 adds none.
+
+So `container box → bar box(shadow,fill) → ramp/bands → bar box(border)` cannot be emitted. Both single-call placements fail:
+
+- **Box before ramp** — the ramp rect is *exactly coincident* with the bar rect (`_svg.py:8358-8361`, `_raster.py:3635-3643`), so the inner half of the centered stroke is erased. `border-width: 4px` renders a 2px ring pushed 2px outward. The `canvas` precedent (`_svg.py:5561` emitted inside `canvas_group_open` at `:5600`) survives border-under-content only because marks are sparse; a colorbar ramp is 100% coverage.
+- **Box after ramp** — `_slot_box_svg` writes the shadow rect immediately *before* the box shape, so `box-shadow: 3px 3px` paints a solid offset rect **on top of** the ramp instead of behind it. Same at `_raster.py:811-813`.
+
+Compounding: `colorbar_chrome_boxes(layout, slots) -> list[ChromeBox]` "in paint order" cannot express an interleave with non-`ChromeBox` content, so both writers must re-implement the ordering — the duplication P5 exists to delete.
+
+### F2 — PDF has no transparency group; `<g opacity>` over the band stack produces 63 stripes the SVG doesn't have
+
+§4.2 claims "Unrepresentable — SVG/PDF: nothing" while honoring `opacity`. `_pdf._render_g` (`_pdf.py:1228-1265`) does `child.opacity = state.opacity * …` and each shape consumes it as its own `/ca` (`_pdf.py:1044-1049`). Verified on a real conversion — the content stream is:
+
+```
+1 0 0 rg  /G1 gs  10 10 m … f      # /G1 = << /ExtGState /ca 0.5 /CA 1 >>
+0 0 1 rg           50 10 m … f
+```
+
+No `/Group << /S /Transparency >>`. The bands overlap by exactly 0.5px at every boundary (`_svg.py:8388`, `:8396`; `_raster.py:3639`, `:3643`). At `opacity:0.5` the seam is `0.5·Cᵢ + 0.5·W` in SVG (group flattens first) and `0.5·Cᵢ + 0.25·Cᵢ₋₁ + 0.25·W` in the PDF converted *from that same SVG*. For the viridis dark end `Cᵢ₋₁=(68,1,84)` that is a **(−47, −64, −43)/255** stripe, 63 times. `SLOT_BOX_RASTER_UNSUPPORTED["colorbar_bar"]` also needs `opacity` for the reason `canvas` has it (`_svg.py:1508-1511`, `_raster.py:1185-1196`), and §4.2 scopes it to `{"border-radius"}`.
+
+### F3 — "A rounded continuous raster bar is drawable (one `_round_rect_pts` fill)" is false
+
+`/Users/alek/Desktop/xy-compat/python/xy/_raster.py:3614-3616`:
+
+```python
+    else:
+        n_seg = 64
+        colors = _lut(options.get("colormap", "viridis"), np.linspace(0.0, 1.0, n_seg))
+```
+
+The continuous raster bar is **64 solid band rects**, not one fill. `cmd.clip` is rectangle-only (`_raster.py:226-231`), so `border-radius` on `colorbar_bar` is unrepresentable in the raster for continuous *and* discrete. Scoping the record to "discrete-only" (§4.2) and accepting on "raster discrete radius reported partial" (step 7) ships a silently square-cornered continuous PNG bar with no §28 entry. Two more gaps in the same seam: `preflight.py:243-247` only reaches `SLOT_BOX_RASTER_UNSUPPORTED` for slots present in `SLOT_BOX_PROPS_BY_SLOT` (`_svg.py:1489-1494` — title/root/canvas/chrome only), and the raster needs a `canvas`-style strip (`_raster.py:1190-1196`). Neither is in the edit list.
+
+### F4 — `background-color` must paint UNDER the ramp, not replace it
+
+`js/src/20_theme.ts:133` sets the ramp with the `background` **shorthand** → a background-*image*. `_applyStyle` writes the author's key as a longhand (`js/src/50_chartview.ts:1705-1714`, `el.style.setProperty(property, cssValue)`). CSS paints background-color beneath background-image, so live `colorbar_bar {background-color:#f00}` is completely hidden by the opaque gradient; only the `background` shorthand replaces it. `_chromebox.lower_box` collapses the two (`_chromebox.py:476-479`) and §4.2 states them as one rule — static would show a solid red bar where every browser shows the ramp. `colorbar_bar` is the first slot in this program whose stylesheet default is a background-image, so no earlier family caught it.
+
+### F5 — the `line_only` frame double-paints under a declared border
+
+`_svg.py:8352-8357` hard-codes `fill="white" stroke="{text_color}" stroke-width="1"` on the bar rect; `_raster.py:3630-3632` the same. §4.2 never reconciles that frame with a declared `colorbar_bar` border, so `{'border-color':'red','border-width':'3px'}` paints two concentric strokes on the same edge — whichever order you pick, one shows through. The browser has exactly one (`_applySlot` overwrites the theme's `border:1px solid currentColor`). Same hazard for `line_only` + `background`.
+
+### F6 — `box-sizing: border-box` is only applied to the *default* border
+
+`20_theme.ts:133` ends `box-sizing:border-box`. Live, a declared border draws entirely **inside** the 18px box and the gradient fills the shrunken padding box. `_slot_box_svg` centers the stroke on the geometry edge and the ramp is not inset. `border-width: 6px` → live: 6px ring + 6px ramp; static: 3px outside the bar, 3px over the ramp, ramp still 18px. §3's `colorbar_bar_default_border` applies this reasoning to the 1px default and then drops it.
+
+### F7 — raster round caps overhang the newly-honored `border-width`
+
+`_Cmd.stroke` defaults `cap="round"` (`_raster.py:287`) and `_emit_colorbar` never overrides it (`_raster.py:3709`, `:3721-3725`, `:3762-3766`). SVG `<line>` emits no `stroke-linecap` → butt, and `_pdf` maps the default to butt (`_pdf.py:1050-1053`). Measured on the native rasterizer:
+
+```
+1px wide, 3px long: ink x 19..23 (len 5)     # SVG/PDF: 3
+6px wide, 6px long: ink x 17..28 (len 12)    # SVG/PDF: 6
+```
+
+§4.4/§4.5 make `border-width` reachable for the first time, so `colorbar_line {border-width:6px}` overhangs both bar ends by 3px in PNG and sits flush in SVG/PDF **and** the browser (the live marker is a `border-top` on an `inset-inline:0` element, `js/src/50_chartview.ts:3585-3587`). §2's "Not unified (writers already agree)" list wrongly includes "minor-tick length 3" — it is 3 in SVG and 4 in the raster today.
+
+### F8 — PDF trap: the obvious rounded-clip spelling is rejected
+
+Probed: `<clipPath id="c"><rect x=… rx="6"/></clipPath>` → `ValueError: unsupported SVG feature: <clipPath rect> attribute 'rx'`. `_ALLOWED_ATTRS["clip-rect"]` is `{x, y, width, height}` (`_pdf.py:202`) and `_collect_defs` stores only those four (`_pdf.py:900-908`), so even a permitted `rx` would silently square the clip. §4.2 says "`<g clip-path="url(#…)">`" without pinning the `<path d=…>` spelling; the canvas precedent does pin it (`_svg.py:5563-5573` via `_rounded_rect_path`). The path spelling converts fine — pin it in the design.
+
+### F9 — seam-clamp off-by-one
+
+§4.2 says "clamp the final band's far edge … `seam = 0.0` for the last band". In the vertical branch (`_svg.py:8393-8397`) `by1 = y + height * (1.0 - lower)`, so the band whose far edge overhangs to `y+h+0.5` is index **0** (the bottom band); index n−1 is flush at `y`. §4.2's own prose ("vertical bottom, horizontal right") contradicts the rule stated one sentence later.
+
+---
+
+### Adjacent, outside this lens but verified
+
+§4.1's padding semantics are backwards. `bar.style.cssText` is `position:absolute;inset:0 auto 0 0` (`js/src/50_chartview.ts:3533`); an absolutely-positioned child's containing block is its ancestor's **padding box**, so `inset:0` places the bar at the padding edge and container `padding` does **not** move it live — only border width does. The design's `bar_inset = box_room` (padding + border, `_chromebox.py:192-201`) and step 6's three-consumer acceptance test ("container padding moves the bar identically in SVG, PNG, and the pyplot reservation") would pin a behavior the browser does not have.
+
+Also checked and clean: chrome ordering (colorbar is last in both writers — `_svg.py:5586-5612`, `_raster.py:1817-1827`; the raster clip is reset to full canvas at `_raster.py:1285`), so the container-first claim holds; and z-order vs. the legend matches (`colorbar` box carries `z-index:4` at `js/src/50_chartview.ts:3484`, the legend none, and it is built after — `js/src/50_chartview.ts:2572-2573`).
\ No newline at end of file

From 77a2d9d5fa6d45be99f05f4cb995b85c0037b3ef Mon Sep 17 00:00:00 2001
From: Farhan Ali Raza <www.mfarvirus@gmail.com>
Date: Tue, 27 Oct 2026 14:00:44 +0500
Subject: [PATCH 27/27] Remove local validation artifacts from the source tree

---
 node_modules                        |   1 -
 python/xy/_native_lib/libxy_core.so | Bin 1304808 -> 0 bytes
 2 files changed, 1 deletion(-)
 delete mode 120000 node_modules
 delete mode 100755 python/xy/_native_lib/libxy_core.so

diff --git a/node_modules b/node_modules
deleted file mode 120000
index f25e2d555..000000000
--- a/node_modules
+++ /dev/null
@@ -1 +0,0 @@
-/tools/node_modules
\ No newline at end of file
diff --git a/python/xy/_native_lib/libxy_core.so b/python/xy/_native_lib/libxy_core.so
deleted file mode 100755
index e90938f9a4d361b08eca60ec239f229918d8b33b..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1304808
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