diff --git a/CHANGELOG.md b/CHANGELOG.md
index beab7b5..ee6c9fc 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,10 +3,55 @@
 ## Unreleased
 
 ### cnplot package
+- Clone names are set in the regular weight: the clone labels beside the integer-CN profile
+  and the `<label> (<pct>%)` row-block labels on the heatmap. The CN key's `CNA` title is
+  regular as well.
 - `BAF_LIM = (-0.01, 1.01)`: default limits for a BAF-like axis on [0, 1], exported from
   `cnplot`. The pad keeps points at exactly 0 or 1 off the spine while the ticks still run
   0.0 to 1.0. Used by the gallery/README BAF row (`ylim`) and the RDR-vs-BAF scatter
   (`xlim`), which previously used `(-0.05, 1.05)` and `(0, 1)`.
+- Fonts are configured in one module, `cnplot.cnplot_style`: the family list
+  (`FONT_FAMILY`), the embedding types (`FONT_TYPE`), the `FS_*` sizes, and `apply_style()`,
+  which writes them into rcParams on import. No other module names a family, a size or an
+  embedding type. `FONT_FAMILY` and `apply_style` are exported from `cnplot`.
+- One type scale for every figure. The heatmap page, the integer-CN profile, the CN key,
+  the proportion legends and the 2D scatter no longer carry their own literal font sizes
+  (6 to 15 pt); they take `FS_TICK`, `FS_LEGEND`, `FS_AXLABEL`, `FS_AXTITLE` and `FS_TITLE`,
+  and the same sizes are set as rc defaults on import so text drawn without an explicit
+  size (a colorbar's ticks) follows. `FS_ANNOT` is new, for labels written on the data.
+- Layout measured instead of assumed, so it holds at any font size:
+  - the CN key labels each state `(a,b)` and wraps its groups onto further rows until the
+    widest label fits under one swatch; it never shrinks the type or the notation;
+  - `plot_strip_legend` stacks legends by their rendered height. Its `entry_h` argument is
+    removed and `gap` defaults to half a legend line;
+  - the heatmap colorbar grows until neighbouring tick labels clear each other, and the
+    strip legends start to the right of its rendered tick labels;
+  - the `plot_heatmap_cnp` title is anchored above the mesh rather than at a fixed
+    figure height.
+- Genome-axis labels are placed so they clear each other at the type scale:
+  - chromosome names keep their `rotation` (60 degrees by default); names closer together
+    than a line at that angle are nudged apart along the axis, and on an axes too narrow
+    to hold them in one row, alternate crowded names go on a second row (`chrname_tiers`
+    tells a layout which case applies);
+  - in Mb mode an Mb label within a line of the previous one is left blank (its tick mark
+    stays), the chromosome names under the Mb labels are offset in points rather than as a
+    fraction of the axes, and on a stacked page only the last row labels its Mb ticks;
+  - the gap between a row and the profile under it is sized in inches from the labels it
+    holds (`genome_label_room`) by `plot_scatter_1d_multisample` and `plot_heatmap_cnp`,
+    and `plot_heatmap_cnp` no longer opens the same gap between the profile and its key.
+- The README gallery is drawn 20 in wide, the width the type scale assumes.
+- `FigureSaver.close()` can be called twice on every supported matplotlib.
+- Importing cnplot stops matplotlib's PDF backend storing rasterized layers as `/Indexed`
+  palette images. With `pdf.compression` on, the backend converts any RGB raster of 256 or
+  fewer colours to a palette and packs the indices at 1, 2 or 4 bits per pixel when the
+  palette is small, which vector editors misread, so a copy-number raster opened in the
+  wrong colours. Rasters are now written at 8 bits per component in DeviceRGB, still
+  Flate-compressed. The hook is on `PdfFile._writeImg`, so it applies to every PDF the
+  process writes, through `FigureSaver`, `PdfPages` or `Figure.savefig`. Rendered pixels
+  are unchanged; a PDF holding such rasters is larger.
+  This works around a known matplotlib bug, wrong colours when such a PDF is opened in
+  Adobe Illustrator ([matplotlib#27893](https://github.com/matplotlib/matplotlib/issues/27893)),
+  for which matplotlib has no setting; remove the hook once that is fixed upstream.
 - `FigureSaver` no longer holds a whole-figure raster buffer per rasterized artist.
   matplotlib renders each rasterized artist into a buffer the size of the entire figure
   and passes the PDF backend a view of it, and the backend keeps every image until the
diff --git a/README.md b/README.md
index cf42d3f..e7b59bf 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 # CN-Plot
 
-[![Version](https://img.shields.io/badge/version-0.1.1-blue.svg)](VERSION)
+[![Version](https://img.shields.io/badge/version-0.1.1b2-blue.svg)](VERSION)
 [![Python](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://www.python.org/downloads/)
 [![Code style: Ruff](https://img.shields.io/badge/code%20style-ruff-000000.svg)](https://github.com/astral-sh/ruff)
 
@@ -47,7 +47,7 @@ from cnplot import plot_cnv_profile
 
 seg_df = pd.read_table("sample.seg.ucn.tsv")
 
-fig, (ax, ax_leg) = plt.subplots(2, 1, figsize=(12, 3), height_ratios=[3, 1])
+fig, (ax, ax_leg) = plt.subplots(2, 1, figsize=(20, 3.5), height_ratios=[3, 1])
 plot_cnv_profile(ax, seg_df, genome_axis, sample_id="S1", ax_leg=ax_leg,
                  title="Integer copy-number profile")
 fig.savefig("profile.png", bbox_inches="tight")   # returns None; you own the figure
@@ -140,6 +140,7 @@ fig = plot_heatmap_cnp(
     title="Single-cell RDR heatmap",
     row_labels=cell_labels, cmap=cmap, norm=norm,
     cbar_label="RDR", cbar_ticks=ticks,
+    figsize=(20, 9),
     mb_ticks=True,                       # Mb ticks every 50Mb per chromosome
     strips=[
         {"name": "Copy-typing", "matrix": posteriors, "order": clones, "cmap": clone_cmap},
diff --git a/VERSION b/VERSION
index 17e51c3..696eb95 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.1.1
+0.1.1b2
diff --git a/examples/fcn_ab.png b/examples/fcn_ab.png
index 07e0e91..eb1bb61 100644
Binary files a/examples/fcn_ab.png and b/examples/fcn_ab.png differ
diff --git a/examples/heatmap_baf.png b/examples/heatmap_baf.png
index eac81d1..d9ff807 100644
Binary files a/examples/heatmap_baf.png and b/examples/heatmap_baf.png differ
diff --git a/examples/heatmap_rdr.png b/examples/heatmap_rdr.png
index 794dc26..297ab98 100644
Binary files a/examples/heatmap_rdr.png and b/examples/heatmap_rdr.png differ
diff --git a/examples/plot_gallery.py b/examples/plot_gallery.py
index 1be66f2..8bf98c6 100644
--- a/examples/plot_gallery.py
+++ b/examples/plot_gallery.py
@@ -28,6 +28,7 @@
 
 from cnplot import (  # noqa: E402
     BAF_LIM,
+    FS_TITLE,
     GenomeAxis,
     get_baf_cmap,
     get_log2rdr_cmap,
@@ -50,7 +51,7 @@ def save(fig, name):
 
 
 def suptitle(fig, text, y=1.0):
-    fig.suptitle(text, fontsize=14, fontweight="bold", y=y)
+    fig.suptitle(text, fontsize=FS_TITLE, fontweight="bold", y=y)
 
 
 genome_axis = GenomeAxis(*reference())
@@ -64,7 +65,7 @@ def suptitle(fig, text, y=1.0):
 )
 
 # 1. integer copy-number profile
-fig, (ax, lg) = plt.subplots(2, 1, figsize=(12, 3), height_ratios=[3, 1])
+fig, (ax, lg) = plt.subplots(2, 1, figsize=(20, 3.5), height_ratios=[3, 1])
 plot_cnv_profile(
     ax, sim.seg_ucn, genome_axis, sample_id="S1", ax_leg=lg, show_pi_viol=False
 )
@@ -166,6 +167,7 @@ def suptitle(fig, text, y=1.0):
         cbar_label=label,
         cbar_ticks=ticks,
         strips=strips,
+        figsize=(20, 9),
         mb_ticks=True,
         profile_kwargs={"show_pi_viol": False},
     )
diff --git a/examples/profile.png b/examples/profile.png
index 28f8f99..007c18d 100644
Binary files a/examples/profile.png and b/examples/profile.png differ
diff --git a/examples/scatter_1d.png b/examples/scatter_1d.png
index 35b384c..ff9f48f 100644
Binary files a/examples/scatter_1d.png and b/examples/scatter_1d.png differ
diff --git a/examples/scatter_2d.png b/examples/scatter_2d.png
index 6191288..65c4d77 100644
Binary files a/examples/scatter_2d.png and b/examples/scatter_2d.png differ
diff --git a/src/cnplot/__init__.py b/src/cnplot/__init__.py
index 14217a9..2e3dc9f 100644
--- a/src/cnplot/__init__.py
+++ b/src/cnplot/__init__.py
@@ -49,16 +49,21 @@
 from .cnplot_heatmap import plot_column_strips, plot_heatmap, plot_strip_legend
 from .cnplot_intcnp import plot_cnv_profile
 from .cnplot_io_utils import read_bed, read_chr_sizes
-from .cnplot_utils import (
-    AXIS_LABELS,
-    BAF_LIM,
-    CN_PREFIX,
-    EXP_PREFIX,
+from .cnplot_style import (
+    FONT_FAMILY,
+    FS_ANNOT,
     FS_AXLABEL,
     FS_AXTITLE,
     FS_LEGEND,
     FS_TICK,
     FS_TITLE,
+    apply_style,
+)
+from .cnplot_utils import (
+    AXIS_LABELS,
+    BAF_LIM,
+    CN_PREFIX,
+    EXP_PREFIX,
     MARKER_SIZE_LARGE,
     MARKER_SIZE_SMALL,
     MAX_NDOTS,
@@ -68,10 +73,12 @@
     U_PREFIX,
     FigureSaver,
     adaptive_dot_size,
+    chrname_tiers,
     decorate_genome_axis,
     display_label,
     draw_chr_boundaries,
     draw_segment_boundaries,
+    genome_label_room,
     get_clone_ylabels,
     get_transparency,
     resolve_colors,
@@ -104,6 +111,7 @@ def _read_version() -> str:
 __version__ = _read_version()
 
 __all__ = [
+    "apply_style",
     "AXIS_LABELS",
     "BAF_COLORS",
     "BAF_LIM",
@@ -112,6 +120,8 @@ def _read_version() -> str:
     "DATASET_CMAP",
     "DEFAULT_EXCLUDED_CHROMS",
     "EXP_PREFIX",
+    "FONT_FAMILY",
+    "FS_ANNOT",
     "FS_AXLABEL",
     "FS_AXTITLE",
     "FS_LEGEND",
@@ -138,7 +148,9 @@ def _read_version() -> str:
     "__version__",
     "adaptive_dot_size",
     "annotate_landmarks",
+    "chrname_tiers",
     "decorate_genome_axis",
+    "genome_label_room",
     "display_label",
     "draw_chr_boundaries",
     "draw_segment_boundaries",
diff --git a/src/cnplot/cnplot_1d.py b/src/cnplot/cnplot_1d.py
index f9edc51..67f97e2 100644
--- a/src/cnplot/cnplot_1d.py
+++ b/src/cnplot/cnplot_1d.py
@@ -22,11 +22,13 @@
 from matplotlib.collections import LineCollection
 
 from .cnplot_genome_axis import GenomeAxis
-from .cnplot_utils import (
-    EXP_PREFIX,
+from .cnplot_style import (
     FS_AXLABEL,
     FS_AXTITLE,
     FS_LEGEND,
+)
+from .cnplot_utils import (
+    EXP_PREFIX,
     decorate_genome_axis,
     display_label,
     draw_chr_boundaries,
diff --git a/src/cnplot/cnplot_2d.py b/src/cnplot/cnplot_2d.py
index 5ca4b31..4293809 100644
--- a/src/cnplot/cnplot_2d.py
+++ b/src/cnplot/cnplot_2d.py
@@ -28,6 +28,11 @@
     get_clone_states,
     select_sample,
 )
+from .cnplot_style import (
+    FS_ANNOT,
+    FS_AXTITLE,
+    FS_LEGEND,
+)
 from .cnplot_utils import (
     EXP_PREFIX,
     NORMAL_CLONE,
@@ -100,7 +105,7 @@ def annotate_landmarks(
     landmarks: list,
     markersize: float = 30,
     linewidth: float = 1.0,
-    fontsize: int = 9,
+    fontsize: int = FS_ANNOT,
     color="black",
 ) -> None:
     """Draw hollow markers with repelled ``(a, b)`` labels.
@@ -411,7 +416,7 @@ def plot_scatter_2d(
                 grid.ax_joint.legend(
                     handles=handles,
                     loc="best",
-                    fontsize="small",
+                    fontsize=FS_LEGEND,
                     fancybox=True,
                     framealpha=0.7,
                     handlelength=0,
@@ -421,9 +426,9 @@ def plot_scatter_2d(
     grid.set_axis_labels(
         xlabel=display_label(xcol if xlabel is None else xlabel),
         ylabel=display_label(ycol if ylabel is None else ylabel),
-        fontsize=12,
+        fontsize=FS_AXTITLE,
     )
     if title is not None:
-        grid.figure.suptitle(title, fontsize=12, fontweight="bold")
+        grid.figure.suptitle(title, fontsize=FS_AXTITLE, fontweight="bold")
     grid.figure.tight_layout()
     return grid
diff --git a/src/cnplot/cnplot_figures.py b/src/cnplot/cnplot_figures.py
index b8aae65..1ccf23d 100644
--- a/src/cnplot/cnplot_figures.py
+++ b/src/cnplot/cnplot_figures.py
@@ -29,16 +29,27 @@
     plot_cnv_profile,
     select_sample,
 )
-from .cnplot_utils import (
+from .cnplot_style import (
     FS_AXLABEL,
+    FS_LEGEND,
+    FS_TITLE,
+)
+from .cnplot_utils import (
     NORMAL_CLONE,
     SAMPLE_COL,
+    chrname_tiers,
     display_label,
+    genome_label_room,
     resolve_marker_size,
 )
 
 logger = logging.getLogger(__name__)
 
+# Share of a figure's width its main axes takes under matplotlib's default margins.
+_AXES_FRAC = 0.775
+# Space left between a profile and the key under it, in inches.
+_KEY_GAP_IN = 0.25
+
 __all__ = [
     "make_row_spec",
     "plot_heatmap_cnp",
@@ -89,7 +100,7 @@ def _draw_prop_legend(
         handles=handles,
         loc="center left",
         bbox_to_anchor=(1.01, 0.5),
-        fontsize="small",
+        fontsize=FS_LEGEND,
         fancybox=True,
         framealpha=0.7,
         handlelength=0,
@@ -263,7 +274,10 @@ def plot_scatter_1d_multisample(
     has_profile = seg_df is not None
     rows_h = row_height * n_rows * n_groups
     profile_h = 2.0 if has_profile else 0.0
-    fig_h = rows_h + profile_h + 0.5
+    # NB: the rows-to-profile gap holds the profile's names and the last row's Mb labels
+    tiers = chrname_tiers(genome_axis, _AXES_FRAC * row_width)
+    room = genome_label_room(mb_ticks=mb_ticks, tiers=tiers) if has_profile else 0.0
+    fig_h = rows_h + profile_h + 0.5 + room
     fig = plt.figure(figsize=(row_width, fig_h))
 
     # Nested so the three gaps stay independent: rows within a group, group to
@@ -271,6 +285,9 @@ def plot_scatter_1d_multisample(
     # NB: a top-side xlabel sits in the rows-to-profile gap; 0.2 clears the row above.
     gap = max(profile_hspace, 0.2) if xlabel is not None else profile_hspace
     if has_profile:
+        # NB: hspace is a fraction of the mean cell height; solve it for `room` inches
+        avail = (0.97 - fig.subplotpars.bottom) * fig_h
+        gap = max(gap, 2.0 * room / max(avail - room, room))
         outer = GridSpec(
             2,
             1,
@@ -337,6 +354,9 @@ def plot_scatter_1d_multisample(
                 mb_tick_step=mb_tick_step,
                 rasterized=rasterized,
             )
+            if mb_ticks and not (last_row and last_group):
+                # NB: stacked rows share the x axis; only the last one labels it
+                ax.tick_params(axis="x", labelbottom=False)
             if last_row and show_props and seg_df is not None:
                 _draw_prop_legend(
                     ax, seg_df, group, group_col, normal, display_min_clone_prop
@@ -425,9 +445,13 @@ def plot_heatmap_cnp(
         raise ValueError("profile must be 'cnv' or 'ascn'")
     if profile_hspace is None:
         base = 0.45 if heatmap_kwargs.get("mb_ticks") else 0.35
-        # NB: hspace is a fraction of axes height; the labels are not, so short pages
-        # need a larger fraction to hold the same band.
-        profile_hspace = max(base, 4.5 / figsize[1])
+        # NB: hspace is a fraction of the mean axes height; solve it for inches
+        room = genome_label_room(
+            mb_ticks=bool(heatmap_kwargs.get("mb_ticks")),
+            tiers=chrname_tiers(genome_axis, _AXES_FRAC * figsize[0]),
+        )
+        avail = (top - plt.rcParams["figure.subplot.bottom"]) * figsize[1]
+        profile_hspace = max(base, 3.0 * room / max(avail - 2.0 * room, room))
     heatmap_kwargs.setdefault("show_colorbar", True)
     heatmap_kwargs.setdefault("show_block_labels", False)
     heatmap_kwargs["plot_chrname"] = False
@@ -439,6 +463,10 @@ def plot_heatmap_cnp(
         3, 1, figsize=figsize, gridspec_kw={"height_ratios": list(height_ratios)}
     )
     fig.subplots_adjust(top=top, hspace=profile_hspace)
+    # NB: hspace also opens the profile-to-key gap, which holds no labels; close it
+    prof, key = axes[1].get_position(), axes[2].get_position()
+    lift = max(prof.y0 - key.y1 - _KEY_GAP_IN / figsize[1], 0.0)
+    axes[2].set_position([key.x0, key.y0 + lift, key.width, key.height])
 
     plot_heatmap(axes[0], matrix, coords_df, genome_axis, **heatmap_kwargs)
     draw_profile(
@@ -450,5 +478,7 @@ def plot_heatmap_cnp(
         **profile_kwargs,
     )
     if title is not None:
-        fig.suptitle(title, fontsize=14, fontweight="bold", y=0.98)
+        # NB: anchored to the mesh, so a taller title grows the page upward
+        y = axes[0].get_position().y1 + 0.5 * FS_TITLE / 72.0 / figsize[1]
+        fig.suptitle(title, fontsize=FS_TITLE, fontweight="bold", y=y, va="bottom")
     return fig
diff --git a/src/cnplot/cnplot_heatmap.py b/src/cnplot/cnplot_heatmap.py
index 1baabe9..1e68f88 100644
--- a/src/cnplot/cnplot_heatmap.py
+++ b/src/cnplot/cnplot_heatmap.py
@@ -24,6 +24,12 @@
 from matplotlib.patches import Patch, Rectangle
 
 from .cnplot_genome_axis import GenomeAxis
+from .cnplot_style import (
+    FS_AXLABEL,
+    FS_AXTITLE,
+    FS_LEGEND,
+    FS_TICK,
+)
 from .cnplot_utils import (
     decorate_genome_axis,
     draw_chr_boundaries,
@@ -156,9 +162,9 @@ def plot_heatmap(
 
     ax.set_ylim(0.0, height)
     if ylabel is not None:
-        ax.set_ylabel(ylabel, rotation=90, va="center")
+        ax.set_ylabel(ylabel, rotation=90, va="center", fontsize=FS_AXLABEL)
     if title is not None:
-        ax.set_title(title)
+        ax.set_title(title, fontsize=FS_AXTITLE)
     decorate_genome_axis(
         ax,
         genome_axis,
@@ -177,17 +183,25 @@ def plot_heatmap(
     # right-side chrome, left to right: colorbar, then one legend per strip
     right = None
     if show_colorbar:
-        ax.figure.canvas.draw()
+        fig = ax.figure
+        fig.canvas.draw()
         box = ax.get_position()
-        # short bar (Copytyping uses height / 5), bottom-aligned to the mesh
-        cax = ax.figure.add_axes([box.x1 + 0.012, box.y0, 0.01, box.height * cbar_frac])
-        cbar = ax.figure.colorbar(mesh, cax=cax)
+        x0 = box.x1 + 0.012
+        cax = fig.add_axes([x0, box.y0, 0.01, box.height * cbar_frac])
+        cbar = fig.colorbar(mesh, cax=cax)
         if cbar_ticks is not None:
             cbar.set_ticks(cbar_ticks)
+        cax.tick_params(labelsize=FS_TICK)
+        # NB: the bar grows until neighbouring tick labels clear each other
+        pitch = 1.25 * FS_TICK / 72.0 / fig.get_figheight()
+        fit = pitch * (len(cbar.get_ticks()) - 1)
+        bar_h = min(box.height, max(box.height * cbar_frac, fit))
+        cax.set_position([x0, box.y0, 0.01, bar_h])
         if cbar_label is not None:
-            # label above the bar rather than alongside it
-            cax.set_title(cbar_label, fontsize=10, fontweight="bold", pad=4)
-        right = box.x1 + 0.06
+            cax.set_title(cbar_label, fontsize=FS_LEGEND, fontweight="bold", pad=4)
+        fig.canvas.draw()
+        extent = cax.get_tightbbox()
+        right = extent.x1 / fig.bbox.width + 0.01
 
     if strips:
         info = plot_column_strips(ax.figure, ax, y_edges, strips)
@@ -236,7 +250,7 @@ def _draw_row_blocks(
 
     if show_block_labels:
         ax.set_yticks(yticks)
-        ax.set_yticklabels(yticklabels, fontsize=11, fontweight="bold")
+        ax.set_yticklabels(yticklabels, fontsize=FS_TICK)
     else:
         ax.set_yticks([])
 
@@ -391,7 +405,7 @@ def _finish_strip_axis(ax: plt.Axes, label: str, base_ax: plt.Axes) -> None:
         base_ax: Heatmap axes whose y-limits the strip matches.
     """
     ax.set_xticks([0.5])
-    ax.set_xticklabels([label], rotation=90, fontsize=11, fontweight="bold")
+    ax.set_xticklabels([label], rotation=90, fontsize=FS_TICK, fontweight="bold")
     ax.tick_params(axis="x", labeltop=True, labelbottom=False, top=False, bottom=False)
     ax.set_yticks([])
     ax.set_ylim(base_ax.get_ylim())
@@ -462,8 +476,7 @@ def plot_strip_legend(
     base_ax: plt.Axes,
     legends_info: list,
     x0: float,
-    entry_h: float = 0.038,
-    gap: float = 0.06,
+    gap: float | None = None,
 ) -> float:
     """Stack one categorical legend per strip, top-aligned, at figure-x ``x0``.
 
@@ -472,8 +485,8 @@ def plot_strip_legend(
         base_ax: Heatmap axes the legends align to at the top.
         legends_info: The list :func:`plot_column_strips` returns.
         x0: Left edge of the legends, in figure fraction.
-        entry_h: Height of one legend entry, in figure fraction.
-        gap: Space between legends, in figure fraction.
+        gap: Space between legends, in figure fraction; None takes half a
+            legend line. Each legend's own height is measured, not assumed.
 
     Returns:
         The y of the last legend's bottom, for anything stacked below.
@@ -481,20 +494,24 @@ def plot_strip_legend(
     fig.canvas.draw()
     bbox = base_ax.get_position()
     y_top = bbox.y1
+    pt = 1.0 / 72.0 / fig.get_figheight()
+    if gap is None:
+        gap = 0.5 * FS_LEGEND * pt
     for name, color_dict, prop_dict in legends_info:
         # a continuous strip contributes a horizontal colorbar, not a swatch legend
         if "__cbar__" in color_dict:
             cmap, norm, ticks = color_dict["__cbar__"]
             cbar_w, cbar_h = 0.1, 0.012
-            cax = fig.add_axes([x0, y_top - entry_h, cbar_w, cbar_h])
+            y_top -= 1.5 * FS_LEGEND * pt + cbar_h
+            cax = fig.add_axes([x0, y_top, cbar_w, cbar_h])
             sm = ScalarMappable(norm=norm, cmap=cmap)
             sm.set_array([])
             cbar = fig.colorbar(sm, cax=cax, orientation="horizontal")
             if ticks is not None:
                 cbar.set_ticks(ticks)
-            cax.tick_params(labelsize=9)
-            cax.set_title(name, fontsize=13, fontweight="bold", pad=4)
-            y_top -= entry_h * 2.5 + gap
+            cax.tick_params(labelsize=FS_TICK)
+            cax.set_title(name, fontsize=FS_LEGEND, fontweight="bold", pad=4)
+            y_top -= 1.5 * FS_TICK * pt + gap
             continue
         handles = [
             Patch(facecolor=col, label=f"{v}: {prop_dict.get(v, 0.0) * 100:.2f}%")
@@ -506,10 +523,10 @@ def plot_strip_legend(
             loc="upper left",
             bbox_to_anchor=(x0, y_top),
             frameon=False,
-            fontsize=13,
-            title_fontsize=15,
+            fontsize=FS_LEGEND,
+            title_fontsize=FS_LEGEND,
         )
         leg.get_title().set_fontweight("bold")
         fig.add_artist(leg)
-        y_top -= entry_h * (len(handles) + 1) + gap
+        y_top -= leg.get_window_extent().height / fig.bbox.height + gap
     return y_top
diff --git a/src/cnplot/cnplot_intcnp.py b/src/cnplot/cnplot_intcnp.py
index 31f5a7c..b2e4bab 100644
--- a/src/cnplot/cnplot_intcnp.py
+++ b/src/cnplot/cnplot_intcnp.py
@@ -23,6 +23,12 @@
 
 from .cnplot_colormap import get_ascn_cmap, get_cn_cmap
 from .cnplot_genome_axis import GenomeAxis
+from .cnplot_style import (
+    FS_AXLABEL,
+    FS_AXTITLE,
+    FS_LEGEND,
+    FS_TICK,
+)
 from .cnplot_utils import (
     CN_PREFIX,
     NORMAL_CLONE,
@@ -120,17 +126,19 @@ def _finish_clone_axis(
         clone_props=clone_props,
     )
     if label_fontweight is None:
-        ax.set_yticklabels(labels, fontsize=8, va="center")
+        ax.set_yticklabels(labels, fontsize=FS_TICK, va="center")
     else:
-        ax.set_yticklabels(labels, fontsize=8, fontweight=label_fontweight, va="center")
+        ax.set_yticklabels(
+            labels, fontsize=FS_TICK, fontweight=label_fontweight, va="center"
+        )
     ax.set_ylim(0, height)
     ax.tick_params(
         axis="y", which="major", left=True, right=False, length=4, pad=tick_pad
     )
     if ylabel is not None:
-        ax.set_ylabel(ylabel, rotation=0, ha="right", va="center")
+        ax.set_ylabel(ylabel, rotation=0, ha="right", va="center", fontsize=FS_AXLABEL)
     if title is not None:
-        ax.set_title(title)
+        ax.set_title(title, fontsize=FS_AXTITLE)
 
 
 def _mirrored_bins(states: np.ndarray) -> np.ndarray:
@@ -200,51 +208,6 @@ def _draw_chevrons(
         )
 
 
-def _draw_mirror_swatch(
-    ax: plt.Axes,
-    leg_x: float,
-    pair_w: float = 2.0,
-    pair_h: float = 0.6,
-    fontsize: int = 10,
-) -> float:
-    """Draw the mirrored-CNA swatch: a "/"-hatched white box labeled "mirrored".
-
-    Args:
-        ax: Axes to draw on.
-        leg_x: Left edge of the swatch.
-        pair_w: Swatch width.
-        pair_h: Swatch height.
-        fontsize: Label font size.
-
-    Returns:
-        The x position just past the swatch.
-    """
-    ax.add_patch(
-        Rectangle(
-            (leg_x, 0.0),
-            pair_w,
-            pair_h,
-            facecolor="white",
-            edgecolor="black",
-            hatch="/",
-        )
-    )
-    ax.text(
-        leg_x + pair_w / 2.0,
-        -0.2,
-        "mirrored",
-        ha="center",
-        va="top",
-        fontsize=fontsize,
-    )
-    return leg_x + pair_w
-
-
-# =============================================================================
-# seg.ucn parsing
-# =============================================================================
-
-
 def select_sample(
     seg_df: pd.DataFrame,
     sample_id: str | None = None,
@@ -538,7 +501,7 @@ def plot_cnv_profile(
         props,
         ylabel,
         title,
-        label_fontweight="bold",
+        label_fontweight=None,
         tick_pad=4,
     )
     if ax_leg is not None:
@@ -549,18 +512,65 @@ def plot_cnv_profile(
         )
 
 
+def _text_width_pt(ax: plt.Axes, text: str, fontsize: float) -> float:
+    """Rendered width of ``text`` at ``fontsize``, in points.
+
+    Args:
+        ax: Axes whose figure supplies the renderer.
+        text: String to measure.
+        fontsize: Font size in points.
+
+    Returns:
+        The width in points.
+    """
+    fig = ax.figure
+    probe = ax.text(0, 0, text, fontsize=fontsize)
+    width = probe.get_window_extent().width
+    probe.remove()
+    return width * 72.0 / fig.dpi
+
+
+def _wrap_groups(widths: list, n_rows: int) -> list:
+    """Split consecutive groups into ``n_rows`` rows of near-equal width.
+
+    Args:
+        widths: Width of each group, in order.
+        n_rows: Number of rows wanted.
+
+    Returns:
+        One list of group indices per row; fewer than ``n_rows`` only when
+        there are fewer groups.
+    """
+    target = sum(widths) / n_rows
+    rows, row, acc = [], [], 0.0
+    for i, w in enumerate(widths):
+        if row and acc + w / 2.0 > target and len(rows) < n_rows - 1:
+            rows.append(row)
+            row, acc = [], 0.0
+        row.append(i)
+        acc += w
+    rows.append(row)
+    return rows
+
+
 def _plot_cnv_legend(
     ax: plt.Axes,
     has_mirror: bool = True,
     pair_w: float = 2.0,
     pair_h: float = 0.6,
-    fontsize: int = 10,
+    fontsize: int = FS_LEGEND,
 ) -> None:
     """Draw the integer copy-number legend, grouped by total copy number.
 
     Mirrored pairs share a swatch since (1, 2) and (2, 1) share a color; the "/"
     hatch distinguishes them. A trailing box covers total CN above 7.
 
+    Each state is labelled ``(a,b)`` under its swatch. The key takes as many
+    rows as it needs for the widest label to fit under one swatch at
+    ``fontsize``: groups wrap to further rows below the axes, the notation and
+    the font size stay as they are. Rows past the first are drawn outside the
+    axes, so save with a tight bounding box.
+
     Args:
         ax: Axes to draw on. Its own frame is turned off.
         has_mirror: Append the mirrored-CNA swatch. :func:`plot_cnv_profile`
@@ -573,65 +583,78 @@ def _plot_cnv_legend(
     state_style, tcn_states = get_cn_cmap()
     ax.axis("off")
 
-    gap_pairs = 0.0
     gap_groups = 0.75 * pair_w
     mirror_gap = 1.5 * pair_w
-    leg_x = 0.0
+    left = 2.0
+    y_lo, y_hi = -0.8, pair_h + 0.8
 
+    groups = []
     for _total, states in sorted(tcn_states.items()):
         uniq_pairs = sorted({tuple(sorted(s, reverse=True)) for s in states})
-        group_x0 = leg_x
-        for i, pair in enumerate(uniq_pairs):
-            x0 = group_x0 + i * (pair_w + gap_pairs)
-            ax.add_patch(
-                Rectangle(
-                    (x0, 0.0),
-                    pair_w,
-                    pair_h,
-                    facecolor=state_style[pair],
-                    edgecolor="black",
-                )
-            )
-            ax.text(
-                x0 + pair_w / 2.0,
-                -0.2,
-                f"{pair}",
-                ha="center",
-                va="top",
-                fontsize=fontsize,
-            )
-        group_w = len(uniq_pairs) * pair_w + (len(uniq_pairs) - 1) * gap_pairs
-        leg_x = group_x0 + group_w + gap_groups
-
-    ax.add_patch(
-        Rectangle(
-            (leg_x, 0.0),
-            pair_w,
-            pair_h,
-            facecolor=state_style["default"],
-            edgecolor="black",
+        groups.append(
+            [(f"({a},{b})", state_style[(a, b)], None) for a, b in uniq_pairs]
         )
-    )
-    ax.text(leg_x + pair_w / 2.0, -0.2, ">7", ha="center", va="top", fontsize=fontsize)
-    leg_x += pair_w + gap_groups
-
+    groups.append([(">7", state_style["default"], None)])
+    label_pt = max(_text_width_pt(ax, lab, fontsize) for g in groups for lab, _, _ in g)
+    lead = [0.0] * len(groups)
     if has_mirror:
-        leg_x = _draw_mirror_swatch(
-            ax, leg_x + mirror_gap, pair_w=pair_w, pair_h=pair_h, fontsize=fontsize
-        )
-        leg_x += mirror_gap
+        groups.append([("mirrored", "white", "/")])
+        lead.append(mirror_gap)
+    widths = [len(g) * pair_w for g in groups]
+
+    def span(row):
+        return sum(widths[i] + lead[i] for i in row) + gap_groups * (len(row) - 1)
+
+    fig = ax.figure
+    ax_w_pt = ax.get_position().width * fig.get_figwidth() * 72.0
+    ax_h_pt = ax.get_position().height * fig.get_figheight() * 72.0
+    for n_rows in range(1, len(groups) + 1):
+        rows = _wrap_groups(widths, n_rows)
+        total = left + max(span(row) for row in rows)
+        if ax_w_pt * pair_w / total >= 1.5 * label_pt:
+            break
+
+    # NB: one row is a swatch, its label, and a gap of half a label
+    unit_pt = ax_h_pt / (y_hi - y_lo)
+    pitch = pair_h + 0.2 + 1.7 * fontsize / unit_pt
+    for r, row in enumerate(rows):
+        y0 = -r * pitch
+        x = 0.0
+        for i in row:
+            x += lead[i]
+            for label, color, hatch in groups[i]:
+                ax.add_patch(
+                    Rectangle(
+                        (x, y0),
+                        pair_w,
+                        pair_h,
+                        facecolor=color,
+                        edgecolor="black",
+                        hatch=hatch,
+                        clip_on=False,
+                    )
+                )
+                ax.text(
+                    x + pair_w / 2.0,
+                    y0 - 0.2,
+                    label,
+                    ha="center",
+                    va="top",
+                    fontsize=fontsize,
+                )
+                x += pair_w
+            x += gap_groups
 
     ax.text(
         -0.5,
         pair_h / 2.0,
         "CNA",
-        fontsize=fontsize + 2,
-        fontweight="bold",
+        fontsize=fontsize,
         ha="right",
         va="center",
     )
-    ax.set_xlim(-2.0, leg_x)
-    ax.set_ylim(-0.8, pair_h + 0.8)
+    ax.set_xlim(-left, total - left)
+    ax.set_ylim(y_lo, y_hi)
     ax.set_aspect("auto")
 
 
@@ -802,7 +825,7 @@ def plot_ascn_profile(
         minor_positions += [k * h + y_gap + h_sub * 0.5, k * h + y_gap + h_sub * 1.5]
         minor_labels += ["B", "A"]
     ax.set_yticks(minor_positions, minor=True)
-    ax.set_yticklabels(minor_labels, minor=True, fontsize=6)
+    ax.set_yticklabels(minor_labels, minor=True, fontsize=FS_TICK)
     ax.tick_params(axis="y", which="minor", left=False, right=False, pad=2)
 
     _finish_clone_axis(
@@ -831,7 +854,7 @@ def _plot_ascn_legend(
     box_w: float = 1.2,
     box_h: float = 0.4,
     tick_len: float = 0.08,
-    label_fontsize: int = 12,
+    label_fontsize: int = FS_LEGEND,
     show_mirror: bool = True,
 ) -> None:
     """Draw the allele copy-number legend as a horizontal ramp.
diff --git a/src/cnplot/cnplot_style.py b/src/cnplot/cnplot_style.py
new file mode 100644
index 0000000..80646b6
--- /dev/null
+++ b/src/cnplot/cnplot_style.py
@@ -0,0 +1,90 @@
+"""Typography for every cnplot figure: the one place fonts are configured.
+
+Nothing else in the package names a font family, a font size or a font
+embedding type. The drawing modules import the ``FS_*`` sizes from here, and
+:func:`apply_style` writes the same values into matplotlib's rcParams when the
+package is imported, so text drawn without an explicit size - a colorbar's
+ticks, a caller's own axes on the same figure - follows too. To restyle the
+package, edit the constants below.
+
+The values follow manuscript figure rules: text in Arial or Helvetica, nothing
+under 18 pt because a panel is drawn wide and reproduced a few inches wide,
+and fonts embedded so text stays text in a vector editor.
+
+``FONT_FAMILY`` is a preference list and the first installed family is used;
+DejaVu Sans closes it so a machine without the others falls back instead of
+raising. ``FONT_TYPE`` replaces matplotlib's Type 3 default, which a vector
+editor imports as outlines. ``FS_ANNOT`` is the one size under the floor, for
+labels written on the data, which share the plotting area with the marks.
+"""
+
+import contextlib
+
+import matplotlib.font_manager
+import matplotlib.pyplot as plt
+
+__all__ = [
+    "FONT_FAMILY",
+    "FONT_TYPE",
+    "FS_ANNOT",
+    "FS_AXLABEL",
+    "FS_AXTITLE",
+    "FS_LEGEND",
+    "FS_TICK",
+    "FS_TITLE",
+    "apply_style",
+]
+
+# NB: preference order, first installed wins; DejaVu Sans ships with matplotlib
+FONT_FAMILY = ("Arial", "Helvetica", "DejaVu Sans")
+
+# NB: Type 42 embeds TrueType; "none" keeps SVG text as text
+FONT_TYPE = {"pdf.fonttype": 42, "ps.fonttype": 42, "svg.fonttype": "none"}
+
+# NB: points
+FS_TICK = 18
+FS_AXLABEL = 22
+FS_AXTITLE = 18
+FS_TITLE = 24
+FS_LEGEND = 18
+# NB: labels written on the data
+FS_ANNOT = 15
+
+_RC_SIZES = {
+    "font.size": FS_TICK,
+    "axes.labelsize": FS_AXLABEL,
+    "axes.titlesize": FS_AXTITLE,
+    "xtick.labelsize": FS_TICK,
+    "ytick.labelsize": FS_TICK,
+    "legend.fontsize": FS_LEGEND,
+    "legend.title_fontsize": FS_LEGEND,
+    "figure.titlesize": FS_TITLE,
+}
+
+
+def apply_style() -> None:
+    """Write the family, sizes and embedding types above into rcParams.
+
+    Mathtext is set in the same face as the text, so an exponent in an axis
+    label is not in a different face from the words beside it; that needs the
+    name of a family that is actually installed, which is resolved here.
+
+    Called once when cnplot is imported, because a figure drawn by cnplot may be
+    saved by a caller that never touches rcParams. Call it again after anything
+    that resets rcParams.
+    """
+    plt.rcParams["font.family"] = "sans-serif"
+    plt.rcParams["font.sans-serif"] = list(FONT_FAMILY)
+    plt.rcParams.update(_RC_SIZES)
+    plt.rcParams.update(FONT_TYPE)
+    with contextlib.suppress(Exception):
+        installed = {f.name for f in matplotlib.font_manager.fontManager.ttflist}
+        family = next((f for f in FONT_FAMILY if f in installed), FONT_FAMILY[-1])
+        plt.rcParams["mathtext.fontset"] = "custom"
+        plt.rcParams["mathtext.rm"] = family
+        plt.rcParams["mathtext.it"] = f"{family}:italic"
+        plt.rcParams["mathtext.bf"] = f"{family}:bold"
+        plt.rcParams["mathtext.default"] = "regular"
+
+
+apply_style()
diff --git a/src/cnplot/cnplot_utils.py b/src/cnplot/cnplot_utils.py
index b5d54b4..1cdf9cd 100644
--- a/src/cnplot/cnplot_utils.py
+++ b/src/cnplot/cnplot_utils.py
@@ -10,7 +10,10 @@
 """
 
 import contextlib
+import functools
 import logging
+import math
+import threading
 
 import matplotlib.colors as mcolors
 import matplotlib.pyplot as plt
@@ -18,8 +21,10 @@
 import pandas as pd
 from matplotlib.backends import backend_pdf
 from matplotlib.backends.backend_pdf import PdfPages
+from matplotlib.transforms import ScaledTranslation
 
 from .cnplot_genome_axis import GenomeAxis
+from .cnplot_style import FS_TICK
 
 logger = logging.getLogger(__name__)
 
@@ -36,7 +41,9 @@
     "SAMPLE_COL",
     "U_PREFIX",
     "adaptive_dot_size",
+    "chrname_tiers",
     "decorate_genome_axis",
+    "genome_label_room",
     "draw_chr_boundaries",
     "draw_segment_boundaries",
     "get_clone_ylabels",
@@ -72,13 +79,6 @@
 # off the spine; ticks still run 0.0 to 1.0, the pad being too small to label.
 BAF_LIM = (-0.01, 1.01)
 
-# Fontsizes
-FS_TICK = 14
-FS_AXLABEL = 18
-FS_AXTITLE = 16
-FS_TITLE = 20
-FS_LEGEND = 12
-
 # Display names for plotted quantities. A log2 ratio still reads as "RDR" on an
 # axis, which is how the heatmap already labels its colorbar; the 1D rows follow
 # so the two figures name the same quantity the same way.
@@ -211,6 +211,159 @@ def _mb_tick_positions(genome_axis: GenomeAxis, step: float) -> tuple:
     return positions, labels
 
 
+# Mean glyph advance of the figure face, as a fraction of the font size.
+_GLYPH_ADVANCE = 0.55
+# Characters in the longest label of each kind: "chr22", "200".
+_CHRNAME_CHARS = 5
+_MB_CHARS = 3
+# Mb labels sit this far under the chromosome-name size.
+_MB_SHRINK = 3
+# Space one line of text needs across its height, in font sizes.
+_LINE = 1.1
+
+
+def _label_extent_pt(n_chars: int, fontsize: float, rotation: float) -> float:
+    """How far a rotated tick label reaches away from its axis, in points.
+
+    Args:
+        n_chars: Characters in the label.
+        fontsize: Font size in points.
+        rotation: Rotation in degrees.
+
+    Returns:
+        The extent perpendicular to the axis.
+    """
+    length = _GLYPH_ADVANCE * fontsize * n_chars
+    angle = math.radians(rotation)
+    return length * abs(math.sin(angle)) + fontsize * abs(math.cos(angle))
+
+
+def _chrname_pitch(fontsize: float, rotation: float) -> float:
+    """Spacing along the axis two neighbouring chromosome names need, in points.
+
+    Parallel labels clear each other either side by side, a line apart across
+    their height, or end to end, a label length apart along their baseline;
+    the smaller of the two spacings is enough.
+
+    Args:
+        fontsize: Name font size in points.
+        rotation: Label rotation in degrees.
+
+    Returns:
+        The spacing in points.
+    """
+    angle = math.radians(rotation)
+    length = _GLYPH_ADVANCE * fontsize * (_CHRNAME_CHARS + 1)
+    side_by_side = _LINE * fontsize / max(abs(math.sin(angle)), 1e-6)
+    end_to_end = length / max(abs(math.cos(angle)), 1e-6)
+    return min(side_by_side, end_to_end)
+
+
+def genome_label_room(
+    mb_ticks: bool = False,
+    chrnames: bool = True,
+    fontsize: float = FS_TICK,
+    rotation: float = 60,
+    pad: float = 10.0,
+    tiers: int = 1,
+) -> float:
+    """Height the genome-axis labels between two stacked axes need, in inches.
+
+    The gap between a row and the profile under it holds the profile's
+    chromosome names and, in Mb mode, the row's Mb tick labels. A layout sizes
+    that gap from this instead of from a fixed fraction, so the two sets of
+    labels clear each other at any font size.
+
+    Args:
+        mb_ticks: The upper axes labels its x axis in Mb along its bottom.
+        chrnames: The lower axes writes chromosome names along its top.
+        fontsize: Chromosome-name font size; Mb labels are derived from it as
+            :func:`decorate_genome_axis` does.
+        rotation: Label rotation in degrees, of the names and the Mb labels.
+        pad: Clear space added around the labels, in points.
+        tiers: Rows of chromosome names, from :func:`chrname_tiers`.
+
+    Returns:
+        The room in inches.
+    """
+    room = pad
+    if chrnames:
+        room += tiers * _label_extent_pt(_CHRNAME_CHARS, fontsize, rotation)
+        room += pad / 2
+    if mb_ticks:
+        room += _label_extent_pt(_MB_CHARS, max(fontsize - _MB_SHRINK, 4), rotation)
+        room += pad / 2
+    return room / 72.0
+
+
+def _positions_pt(ax: plt.Axes, positions) -> np.ndarray:
+    """Axis x positions as points along the axes, for spacing labels.
+
+    Args:
+        ax: Axes with its x limits already set.
+        positions: X positions in data coordinates.
+
+    Returns:
+        The positions in points from the axes' left edge.
+    """
+    x0, x1 = ax.get_xlim()
+    width_pt = ax.get_position().width * ax.figure.get_figwidth() * 72.0
+    return (np.asarray(positions, dtype=float) - x0) / (x1 - x0) * width_pt
+
+
+def chrname_tiers(
+    genome_axis: GenomeAxis,
+    axes_width_in: float,
+    fontsize: float = FS_TICK,
+    rotation: float = 60,
+) -> int:
+    """How many rows the chromosome names need on an axes this wide: 1 or 2.
+
+    Rotated names need a line of clearance each. Names closer than that are
+    nudged apart along the axis (:func:`decorate_genome_axis`), which works as
+    long as the axes is wide enough to hold them all in one row; past that,
+    every second crowded name goes on a second row and a layout has to leave
+    room for it.
+
+    Args:
+        genome_axis: Axis supplying the name positions.
+        axes_width_in: Width of the axes in inches.
+        fontsize: Name font size in points.
+        rotation: Name rotation in degrees.
+
+    Returns:
+        2 where one row cannot hold every name, else 1.
+    """
+    n = len(genome_axis.xtick_chrs)
+    return 2 if n * _chrname_pitch(fontsize, rotation) > axes_width_in * 72.0 else 1
+
+
+def _spread(at: np.ndarray, need: float) -> np.ndarray:
+    """Positions moved the least that leaves neighbours ``need`` apart.
+
+    The mean of a left-to-right and a right-to-left sweep: each sweep is the
+    closest feasible placement that only pushes one way, and their mean stays
+    feasible while sharing the displacement between both neighbours.
+
+    Args:
+        at: Positions, in any order.
+        need: Smallest spacing wanted between neighbours.
+
+    Returns:
+        The adjusted positions, in the input's order.
+    """
+    order = np.argsort(at)
+    fwd = at[order].astype(float)
+    back = fwd.copy()
+    for i in range(1, len(fwd)):
+        fwd[i] = max(fwd[i], fwd[i - 1] + need)
+    for i in range(len(back) - 2, -1, -1):
+        back[i] = min(back[i], back[i + 1] - need)
+    out = np.empty(len(at), dtype=float)
+    out[order] = (fwd + back) / 2.0
+    return out
+
+
 def decorate_genome_axis(
     ax: plt.Axes,
     genome_axis: GenomeAxis,
@@ -240,6 +393,10 @@ def decorate_genome_axis(
         rotation: Tick label rotation in degrees, applied to the chromosome names
             or, with ``mb_ticks``, to the Mb labels; rotating keeps the dense Mb
             labels from overlapping. Chromosome names stay upright in that mode.
+            Chromosome names closer together than one line at this angle keep
+            the angle and are nudged apart along the axis; on an axes too
+            narrow to hold them in one row, every second crowded name goes on a
+            second row. Mb labels too close to the previous one are left blank.
         fontsize: Label font size; defaults to the module-level FS_TICK.
         hide_spines: Hide all four spines.
         pad_axis: Use the padded limits instead of tight genome ends.
@@ -269,28 +426,42 @@ def decorate_genome_axis(
     if mb_ticks:
         positions, labels = _mb_tick_positions(genome_axis, mb_tick_step)
         ax.set_xticks(positions)
+        # NB: a label nearer than one rotated line to the last one kept is left blank
+        need = max(fontsize - _MB_SHRINK, 4) / max(
+            math.sin(math.radians(rotation)), 0.5
+        )
+        kept = -math.inf
+        labels = list(labels)
+        for i, x in enumerate(_positions_pt(ax, positions)):
+            if x - kept < need:
+                labels[i] = ""
+            else:
+                kept = x
         ax.set_xticklabels(
             labels,
-            fontsize=max(fontsize - 3, 4),
+            fontsize=max(fontsize - _MB_SHRINK, 4),
             rotation=rotation,
             ha="left" if on_top else "right",
             rotation_mode="anchor",
         )
         ax.tick_params(axis="x", length=2, labeltop=on_top, labelbottom=not on_top)
         if plot_chrname:
-            y = 1.10 if on_top else -0.10
-            va = "bottom" if on_top else "top"
+            # NB: offset in points, so the names clear the Mb labels at any axes height
+            mb_fs = max(fontsize - _MB_SHRINK, 4)
+            clear = _label_extent_pt(_MB_CHARS, mb_fs, rotation) + 8.0
             for x, name in zip(
                 genome_axis.xtick_chrs, genome_axis.xlab_chrs, strict=True
             ):
-                ax.text(
-                    x,
-                    y,
+                ax.annotate(
                     str(name).upper().removeprefix("CHR"),
+                    xy=(x, 1.0 if on_top else 0.0),
+                    xycoords=ax.get_xaxis_transform(),
+                    xytext=(0, clear if on_top else -clear),
+                    textcoords="offset points",
                     ha="center",
-                    va=va,
+                    va="bottom" if on_top else "top",
                     fontsize=fontsize,
-                    transform=ax.get_xaxis_transform(),
+                    annotation_clip=False,
                 )
         return
 
@@ -301,6 +472,26 @@ def decorate_genome_axis(
 
     ax.set_xticks(genome_axis.xtick_chrs)
     ax.set_xticklabels(genome_axis.xlab_chrs, rotation=rotation, fontsize=fontsize)
+    at = _positions_pt(ax, genome_axis.xtick_chrs)
+    need = _chrname_pitch(fontsize, rotation)
+    if len(at) > 1 and float(np.diff(np.sort(at)).min()) < need:
+        ticks = ax.xaxis.get_major_ticks()
+        width_pt = ax.get_position().width * ax.figure.get_figwidth() * 72.0
+        if len(at) * need <= width_pt:
+            # NB: nudged apart along the axis; no tick mark is drawn to betray it
+            for tick, dx in zip(ticks, _spread(at, need) - at, strict=True):
+                shift = ScaledTranslation(dx / 72.0, 0, ax.figure.dpi_scale_trans)
+                for label in (tick.label1, tick.label2):
+                    label.set_transform(label.get_transform() + shift)
+        else:
+            # NB: one row cannot hold them; alternate crowded names go up a row
+            lift = _label_extent_pt(_CHRNAME_CHARS, fontsize, rotation) + 4.0
+            last = [-math.inf, -math.inf]
+            base = plt.rcParams["xtick.major.pad"]
+            for i in np.argsort(at):
+                tier = 0 if at[i] - last[0] >= need else 1
+                last[tier] = at[i]
+                ticks[i].set_pad(base + tier * lift)
     ax.tick_params(
         axis="x",
         labeltop=on_top,
@@ -666,6 +857,129 @@ def imageObject(self, image):
         backend_pdf.PdfFile.imageObject = original
 
 
+class _TrueColorImage:
+    """Stand-in for ``PIL.Image`` while ``PdfFile._writeImg`` runs.
+
+    Every image it builds reports more colours than a palette can hold, so the
+    backend takes its continuous-tone path: 8 bits per component, DeviceRGB,
+    Flate with a PNG predictor. Everything else is the real module's.
+
+    Attributes:
+        calls: Images built so far, so the hook can tell it is still consulted.
+    """
+
+    def __init__(self, module):
+        """Wrap the real ``PIL.Image`` module.
+
+        Args:
+            module: The ``PIL.Image`` module the backend imported.
+        """
+        self._module = module
+        self.calls = 0
+
+    def __getattr__(self, name):
+        """Defer every other attribute to the real module.
+
+        Args:
+            name: Attribute requested by the backend.
+
+        Returns:
+            The real module's attribute.
+        """
+        return getattr(self._module, name)
+
+    def fromarray(self, *args, **kwargs):
+        """Build an image that declines to enumerate its colours.
+
+        Args:
+            *args: Passed to ``PIL.Image.fromarray``.
+            **kwargs: Passed to ``PIL.Image.fromarray``.
+
+        Returns:
+            The image, with ``getcolors`` answering None.
+        """
+        self.calls += 1
+        img = self._module.fromarray(*args, **kwargs)
+        img.getcolors = lambda *a, **k: None
+        return img
+
+
+def _write_truecolor_images() -> bool:
+    """Stop the PDF backend storing rasterized layers as palette images.
+
+    With ``pdf.compression`` on, ``PdfFile._writeImg`` stores an RGB raster of
+    256 or fewer distinct colours as an ``/Indexed`` image, and the index stream
+    is packed at 1, 2 or 4 bits per pixel when the palette is small. Vector
+    editors read sub-byte packed indices unreliably and draw the layer in the
+    wrong colours. A copy-number raster has a few state colours, so it always
+    takes that branch. matplotlib tracks the symptom in issue 27893 and has no
+    setting for it.
+
+    The backend decides by asking Pillow for the image's colours. For the
+    duration of each ``_writeImg`` call the backend's ``Image`` module is swapped
+    for :class:`_TrueColorImage`, which sends the raster down the backend's own
+    continuous-tone path. Nothing of matplotlib's is reimplemented, compression
+    stays on for every stream, and the rendered pixels are unchanged.
+
+    Installed on import rather than inside :class:`FigureSaver`: the backend
+    writes images when the file is finalized, not when a figure is saved, and a
+    caller that opens its own ``PdfPages`` or calls ``Figure.savefig`` must get
+    the same output.
+
+    ``_writeImg`` and the backend's ``Image`` name are private to matplotlib. If
+    either is missing the hook is skipped with a warning and output is whatever
+    that matplotlib writes. If both exist but a compressed image is written
+    without the backend building it through ``Image``, the hook no longer
+    decides the encoding and says so once. The swap is held under a lock, so
+    figures saved from several threads get the same encoding.
+
+    References:
+        https://github.com/matplotlib/matplotlib/issues/27893
+
+    Returns:
+        True if the hook was installed; False if it already was, or if this
+        matplotlib lacks the internals it relies on.
+    """
+    original = getattr(backend_pdf.PdfFile, "_writeImg", None)
+    pil_image = getattr(backend_pdf, "Image", None)
+    if original is None or pil_image is None:
+        logger.warning(
+            "matplotlib PDF backend changed; rasterized layers may be written "
+            "as palette images"
+        )
+        return False
+    if getattr(original, "_cnplot_truecolor", False):
+        return False
+    proxy = _TrueColorImage(pil_image)
+    lock = threading.RLock()
+    warned = []
+
+    @functools.wraps(original)
+    def _writeImg(self, *args, **kwargs):
+        with lock:
+            seen = proxy.calls
+            backend_pdf.Image = proxy
+            try:
+                return original(self, *args, **kwargs)
+            finally:
+                backend_pdf.Image = pil_image
+                bypassed = plt.rcParams["pdf.compression"] and proxy.calls == seen
+                if bypassed and not warned:
+                    warned.append(True)
+                    logger.warning(
+                        "matplotlib PDF backend no longer builds images through "
+                        "PIL.Image; rasterized layers may be written as palette "
+                        "images"
+                    )
+
+    _writeImg._cnplot_truecolor = True
+    backend_pdf.PdfFile._writeImg = _writeImg
+    return True
+
+
+_write_truecolor_images()
+
+
 class FigureSaver:
     """Multi-figure writer, a drop-in for ``PdfPages``.
 
@@ -727,9 +1041,10 @@ def savefig(self, fig: plt.Figure, *args, **kwargs) -> None:
         self._page += 1
 
     def close(self) -> None:
-        """Close the multi-page PDF, if one was opened."""
+        """Close the multi-page PDF, if one is open. Safe to call again."""
         if self._pdf is not None:
             self._pdf.close()
+            self._pdf = None
 
     def __enter__(self) -> "FigureSaver":
         """Enter the context manager.
diff --git a/tests/test_backends.py b/tests/test_backends.py
new file mode 100644
index 0000000..7ea801a
--- /dev/null
+++ b/tests/test_backends.py
@@ -0,0 +1,46 @@
+"""Measured layout works on a canvas that has no Agg renderer of its own."""
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pytest
+
+from cnplot import get_baf_cmap, plot_cnv_profile, plot_heatmap_cnp
+
+
+@pytest.fixture(params=["pdf", "svg"])
+def backend(request):
+    """Switch to a vector backend for one test, then back."""
+    previous = plt.get_backend()
+    plt.switch_backend(request.param)
+    yield request.param
+    plt.switch_backend(previous)
+
+
+def test_profile_key_draws(backend, axis, sim, tmp_path):
+    fig, (ax, key) = plt.subplots(2, 1, figsize=(12, 3), height_ratios=[3, 1])
+    plot_cnv_profile(ax, sim.seg_ucn, axis, sample_id="S1", ax_leg=key)
+    assert key.texts
+    fig.savefig(tmp_path / f"profile.{backend}", bbox_inches="tight")
+    plt.close(fig)
+
+
+def test_heatmap_page_draws(backend, axis, sim, tmp_path):
+    cmap, norm, _ = get_baf_cmap()
+    celltype = np.where(sim.heatmap_labels == "normal", "normal", "tumor")
+    fig = plot_heatmap_cnp(
+        sim.heatmap_baf,
+        sim.bins,
+        axis,
+        sim.seg_ucn,
+        sample_id="S1",
+        title="page",
+        row_labels=sim.heatmap_labels,
+        cmap=cmap,
+        norm=norm,
+        cbar_label="BAF",
+        cbar_ticks=[0, 0.5, 1],
+        strips=[{"name": "cell_type", "values": celltype}],
+    )
+    assert fig.legends
+    fig.savefig(tmp_path / f"page.{backend}", bbox_inches="tight")
+    plt.close(fig)
diff --git a/tests/test_genome_axis.py b/tests/test_genome_axis.py
index 4ff5bb1..4d4169e 100644
--- a/tests/test_genome_axis.py
+++ b/tests/test_genome_axis.py
@@ -88,7 +88,8 @@ def test_mb_ticks_labels_are_mb_and_drop_zero(axis_keep):
 
     fig, ax = plt.subplots()
     decorate_genome_axis(ax, axis_keep, mb_ticks=True, mb_tick_step=20_000_000)
-    labels = [t.get_text() for t in ax.get_xticklabels()]
+    # crowded ticks keep their mark and lose their label
+    labels = [t.get_text() for t in ax.get_xticklabels() if t.get_text()]
     assert labels and all(lbl.isdigit() for lbl in labels)  # Mb integers
     assert "0" not in labels  # chromosome-start tick dropped
     # chromosome names drawn as off-axis text, one per chromosome
diff --git a/tests/test_heatmap.py b/tests/test_heatmap.py
index b3f6f95..14e447c 100644
--- a/tests/test_heatmap.py
+++ b/tests/test_heatmap.py
@@ -249,7 +249,8 @@ def test_mb_ticks_on_heatmap(axis, sim, saved):
         mb_ticks=True,
         mb_tick_step=20_000_000,
     )
-    labels = [t.get_text() for t in ax.get_xticklabels()]
+    # crowded ticks keep their mark and lose their label
+    labels = [t.get_text() for t in ax.get_xticklabels() if t.get_text()]
     assert labels and all(lbl.isdigit() for lbl in labels)  # Mb integers
     assert "0" not in labels  # chromosome-start tick dropped
     # chromosome names drawn as bold off-axis text, one per chromosome
diff --git a/tests/test_pdf_images.py b/tests/test_pdf_images.py
new file mode 100644
index 0000000..c2f9839
--- /dev/null
+++ b/tests/test_pdf_images.py
@@ -0,0 +1,94 @@
+"""Rasterized layers are written as 8-bit DeviceRGB, whichever writer is used."""
+
+import re
+from pathlib import Path
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pytest
+from matplotlib.backends import backend_pdf
+from matplotlib.backends.backend_pdf import PdfPages
+from matplotlib.colors import ListedColormap
+
+from cnplot import FigureSaver
+from cnplot.cnplot_utils import _write_truecolor_images
+
+# NB: 2, 3 and 12 colours pack at 1, 2 and 4 bits in an unpatched backend
+N_COLORS = [2, 3, 12]
+
+
+def _raster(n_colors):
+    fig, ax = plt.subplots(figsize=(4, 2))
+    values = np.arange(40 * 200).reshape(40, 200) % n_colors
+    cmap = ListedColormap(plt.cm.tab20.colors[:n_colors])
+    ax.imshow(values, cmap=cmap, aspect="auto", interpolation="nearest")
+    ax.images[0].set_rasterized(True)
+    return fig
+
+
+def _write(writer, out, n_colors):
+    """Write one raster page to ``{out}.pdf`` through the named writer."""
+    fig = _raster(n_colors)
+    path = f"{out}.pdf"
+    if writer == "savefig":
+        fig.savefig(path, dpi=100)
+    elif writer == "pdfpages":
+        with PdfPages(path) as pdf:
+            pdf.savefig(fig, dpi=100)
+    else:
+        with FigureSaver(str(out), "pdf", dpi=100) as saver:
+            saver.savefig(fig)
+    plt.close(fig)
+    return path
+
+
+def _image_encodings(path):
+    """(has a palette, bits per component of every image) read from the PDF bytes."""
+    raw = Path(path).read_bytes()
+    assert b"/Subtype /Image" in raw
+    depths = [int(d) for d in re.findall(rb"/BitsPerComponent (\d+)", raw)]
+    return b"/Indexed" in raw, depths
+
+
+@pytest.mark.parametrize("n_colors", N_COLORS)
+@pytest.mark.parametrize("writer", ["savefig", "pdfpages", "figuresaver"])
+def test_few_colour_raster_is_8bit_rgb(tmp_path, writer, n_colors):
+    indexed, depths = _image_encodings(_write(writer, tmp_path / "page", n_colors))
+    assert not indexed
+    assert depths and set(depths) == {8}
+
+
+def test_hook_is_installed_once_and_leaves_pillow_in_place(tmp_path):
+    assert _write_truecolor_images() is False
+    _write("savefig", tmp_path / "page", 3)
+    assert backend_pdf.Image.__name__ == "PIL.Image"
+
+
+def test_hook_warns_when_the_backend_bypasses_it(monkeypatch, caplog):
+    monkeypatch.setattr(backend_pdf.PdfFile, "_writeImg", lambda self: None)
+    assert _write_truecolor_images() is True
+    with caplog.at_level("WARNING", logger="cnplot.cnplot_utils"):
+        backend_pdf.PdfFile._writeImg(None)
+        backend_pdf.PdfFile._writeImg(None)
+    assert [r.message for r in caplog.records].count(caplog.records[0].message) == 1
+    assert "palette" in caplog.records[0].message
+
+
+def test_stock_backend_writes_a_palette(tmp_path, monkeypatch):
+    monkeypatch.setattr(
+        backend_pdf.PdfFile, "_writeImg", backend_pdf.PdfFile._writeImg.__wrapped__
+    )
+    indexed, _ = _image_encodings(_write("savefig", tmp_path / "stock", 12))
+    assert indexed
+
+
+def test_pixels_match_the_uncompressed_raster(tmp_path):
+    fitz = pytest.importorskip("fitz")
+
+    def render(path):
+        return fitz.open(path)[0].get_pixmap(dpi=100).samples
+
+    patched = render(_write("savefig", tmp_path / "patched", 12))
+    with plt.rc_context({"pdf.compression": 0}):
+        exact = render(_write("savefig", tmp_path / "exact", 12))
+    assert patched == exact
diff --git a/tests/test_type_scale.py b/tests/test_type_scale.py
new file mode 100644
index 0000000..b8a45b0
--- /dev/null
+++ b/tests/test_type_scale.py
@@ -0,0 +1,83 @@
+"""Text is drawn on the shared type scale, and the CN key wraps instead of shrinking."""
+
+import math
+
+import matplotlib.pyplot as plt
+import pytest
+
+from cnplot import FS_ANNOT, FS_LEGEND, FS_TICK, chrname_tiers, decorate_genome_axis
+from cnplot.cnplot_intcnp import _plot_cnv_legend, _wrap_groups
+
+
+def _key_rows(width):
+    fig, ax = plt.subplots(figsize=(width, 1.0))
+    _plot_cnv_legend(ax, has_mirror=True)
+    labels = [t for t in ax.texts if t.get_text() != "CNA"]
+    rows = {round(t.get_position()[1], 6) for t in labels}
+    plt.close(fig)
+    return labels, rows
+
+
+def test_wrap_groups_keeps_order_and_balances():
+    rows = _wrap_groups([2, 4, 4, 6, 6, 8, 8, 2], 2)
+    assert [i for row in rows for i in row] == list(range(8))
+    assert len(rows) == 2
+    assert _wrap_groups([2, 4], 5) == [[0], [1]]
+
+
+@pytest.mark.parametrize("width", [60.0, 16.0, 8.0])
+def test_cn_key_keeps_its_type_size_and_notation(width):
+    labels, _ = _key_rows(width)
+    assert {t.get_fontsize() for t in labels} == {FS_LEGEND}
+    states = [t.get_text() for t in labels if t.get_text().startswith("(")]
+    assert states and all(" " not in s and "|" not in s for s in states)
+
+
+def test_cn_key_wraps_when_the_axes_is_narrow():
+    _, wide = _key_rows(60.0)
+    _, narrow = _key_rows(8.0)
+    assert len(wide) == 1
+    assert len(narrow) > 1
+
+
+def test_rc_defaults_are_on_the_scale():
+    for key in ("font.size", "xtick.labelsize", "ytick.labelsize", "legend.fontsize"):
+        assert plt.rcParams[key] >= FS_ANNOT
+
+
+def _line_gaps_pt(fig, labels, rotation):
+    """Clearance across the text height between neighbouring parallel labels."""
+    fig.canvas.draw()
+    boxes = [t.get_window_extent() for t in labels if t.get_text()]
+    x_pt = sorted((b.x0 + b.x1) / 2.0 * 72.0 / fig.dpi for b in boxes)
+    sine = math.sin(math.radians(rotation))
+    return [(b - a) * sine for a, b in zip(x_pt, x_pt[1:], strict=False)]
+
+
+@pytest.mark.parametrize("width", [20.0, 12.0, 10.0])
+def test_chromosome_names_keep_their_angle_and_clear_each_other(axis, width):
+    fig, ax = plt.subplots(figsize=(width, 3))
+    decorate_genome_axis(ax, axis, label_pos="top", rotation=60)
+    labels = [t.label2 for t in ax.xaxis.get_major_ticks()]
+    assert {t.get_fontsize() for t in labels} == {FS_TICK}
+    assert {t.get_rotation() for t in labels} == {60.0}
+    assert min(_line_gaps_pt(fig, labels, 60)) >= FS_TICK * 0.99
+    plt.close(fig)
+
+
+def test_narrow_axes_needs_a_second_row_of_names(axis):
+    assert chrname_tiers(axis, 20.0) == 1
+    assert chrname_tiers(axis, 4.0) == 2
+
+
+def test_kept_mb_labels_are_a_line_apart(axis):
+    fig, ax = plt.subplots(figsize=(12, 3))
+    decorate_genome_axis(ax, axis, mb_ticks=True, plot_chrname=False, rotation=60)
+    fig.canvas.draw()
+    kept = [t for t in ax.get_xticklabels() if t.get_text()]
+    assert len(kept) > len(axis.chrs) / 2
+    # rotated labels clear each other when their baselines are a line apart
+    x_pt = sorted(ax.transData.transform((t.get_position()[0], 0))[0] for t in kept)
+    gap_pt = min(b - a for a, b in zip(x_pt, x_pt[1:], strict=False)) * 72 / fig.dpi
+    assert gap_pt * math.sin(math.radians(60)) >= kept[0].get_fontsize() * 0.99
+    plt.close(fig)