plotlet 0.1.3__tar.gz → 0.2.0__tar.gz

{plotlet-0.1.3/src/plotlet.egg-info → plotlet-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plotlet
-Version: 0.1.3
+Version: 0.2.0
 Summary: Small, hackable Python library that emits matplotlib-style SVG plots.
 Author: gitbamboo42
 License-Expression: MIT
@@ -74,7 +74,7 @@ pip install plotlet
 
 Pass at construction (`pt.chart(data, title=..., grid=True, ...)`) or as chained setters (`c.title(...)`, etc.):
 
-`title`, `xlabel`, `ylabel`, `xlim=(a, b)`, `ylim=(a, b)`, `xscale="linear"|"log"|"category"` (chained: `c.xscale("category", order=[...], padding=0)`), `yscale=...`, `grid=True/False`, `legend=True/False`, `width`, `height`
+`title`, `xlabel`, `ylabel`, `xlim=(a, b)`, `ylim=(a, b)`, `xscale="linear"|"log"|"category"` (chained: `c.xscale("category", order=[...], padding=0)`), `yscale=...`, `grid=True/False`, `legend=True/False`, `data_width`, `data_height` (the data region — preferred), or `canvas_width`, `canvas_height` (the full SVG canvas — mutually exclusive with the data form). Sizes accept bare pixels (`400`) or unit-suffixed strings (`"4in"`, `"10cm"`, `"100mm"`, `"72pt"`).
 
 String-valued data on either axis (`scatter(["a","b","c"], ...)`, `bar`, …) auto-switches to a categorical scale, alphabetical by default. `padding=0` makes category bands contiguous (heatmap-track look).
 

{plotlet-0.1.3 → plotlet-0.2.0}/README.md

@@ -45,7 +45,7 @@ pip install plotlet
 
 Pass at construction (`pt.chart(data, title=..., grid=True, ...)`) or as chained setters (`c.title(...)`, etc.):
 
-`title`, `xlabel`, `ylabel`, `xlim=(a, b)`, `ylim=(a, b)`, `xscale="linear"|"log"|"category"` (chained: `c.xscale("category", order=[...], padding=0)`), `yscale=...`, `grid=True/False`, `legend=True/False`, `width`, `height`
+`title`, `xlabel`, `ylabel`, `xlim=(a, b)`, `ylim=(a, b)`, `xscale="linear"|"log"|"category"` (chained: `c.xscale("category", order=[...], padding=0)`), `yscale=...`, `grid=True/False`, `legend=True/False`, `data_width`, `data_height` (the data region — preferred), or `canvas_width`, `canvas_height` (the full SVG canvas — mutually exclusive with the data form). Sizes accept bare pixels (`400`) or unit-suffixed strings (`"4in"`, `"10cm"`, `"100mm"`, `"72pt"`).
 
 String-valued data on either axis (`scatter(["a","b","c"], ...)`, `bar`, …) auto-switches to a categorical scale, alphabetical by default. `padding=0` makes category bands contiguous (heatmap-track look).
 

{plotlet-0.1.3 → plotlet-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "plotlet"
-version = "0.1.3"
+version = "0.2.0"
 description = "Small, hackable Python library that emits matplotlib-style SVG plots."
 readme = "README.md"
 license = "MIT"

{plotlet-0.1.3 → plotlet-0.2.0}/src/plotlet/__init__.py

@@ -26,4 +26,4 @@ from .registry import ArtistSpec, add_artist
 __all__ = ["chart", "Chart", "figure", "Figure", "SPEC", "TAB10", "colors",
            "colormap", "list_colormaps", "grid", "legend",
            "ArtistSpec", "add_artist"]
-__version__ = "0.1.3"
+__version__ = "0.2.0"

{plotlet-0.1.3 → plotlet-0.2.0}/src/plotlet/chart.py

@@ -33,15 +33,31 @@ from .registry import get_artist, all_artist_names
 
 
 class Chart:
-    def __init__(self, data=None, *, width: int | None = None, height: int | None = None,
+    def __init__(self, data=None, *,
+                 data_width: int | float | str | None = None,
+                 data_height: int | float | str | None = None,
+                 canvas_width: int | float | str | None = None,
+                 canvas_height: int | float | str | None = None,
                  margin: dict | None = None,
                  title: str | None = None,
                  xlabel: str | None = None, ylabel: str | None = None,
                  xlim: tuple | None = None, ylim: tuple | None = None,
                  xscale: str | None = None, yscale: str | None = None,
                  legend: bool | None = None, grid: bool | None = None,
-                 share_x: "Chart | None" = None, share_y: "Chart | None" = None):
-        self._fig = Figure(width=width, height=height, margin=margin)
+                 share_x: "Chart | None" = None, share_y: "Chart | None" = None,
+                 **kwargs):
+        # Migration error — see Figure.__init__ for the rationale.
+        if "width" in kwargs or "height" in kwargs:
+            raise TypeError(
+                "pt.chart() no longer accepts `width=` / `height=` (changed in 0.2.0). "
+                "Pass `data_width=` / `data_height=` for the data region (preferred) "
+                "or `canvas_width=` / `canvas_height=` for the full SVG canvas."
+            )
+        if kwargs:
+            raise TypeError(f"Chart() got unexpected keyword arguments: {list(kwargs)!r}")
+        self._fig = Figure(data_width=data_width, data_height=data_height,
+                           canvas_width=canvas_width, canvas_height=canvas_height,
+                           margin=margin)
         self._data = data
         # Composition state. Leaves: _layout_kind is None, _children is empty.
         self._parent: Chart | None = None
@@ -100,7 +116,9 @@ class Chart:
 
     def legend(self, *args, names: dict | None = None,
                group_by_chart: bool | None = None,
-               width: int | None = None, height: int | None = None) -> "Chart":
+               canvas_width: int | float | str | None = None,
+               canvas_height: int | float | str | None = None,
+               **kwargs) -> "Chart":
         """Toggle the in-frame overlay (leaf) or attach a layout-level legend (parent).
 
         On a leaf, this is the existing `chart.legend([bool])` toggle for
@@ -108,11 +126,22 @@ class Chart:
 
         On a parent, this is sugar for the panel form: `parent.legend(*sources)`
         is equivalent to `parent | pt.legend(*sources)` (or `parent / ...` for
-        a vertical parent), with `names=` / `group_by_chart=` / `width=` /
-        `height=` forwarded to the constructor. Grids raise — place
+        a vertical parent), with `names=` / `group_by_chart=` / `canvas_width=` /
+        `canvas_height=` forwarded to the constructor. Grids raise — place
         `pt.legend(...)` in an explicit cell instead. Returns `self` for
         chaining; remember that further composition (`|` / `/`) appends
         children *after* the legend, so decorate last."""
+        if "width" in kwargs or "height" in kwargs:
+            raise TypeError(
+                "Chart.legend() no longer accepts `width=` / `height=` "
+                "(changed in 0.2.0). Use `canvas_width=` / `canvas_height=` "
+                "instead — legend leaves have no data axes, so the canvas "
+                "is the only meaningful dimension."
+            )
+        if kwargs:
+            raise TypeError(
+                f"Chart.legend() got unexpected keyword arguments: {list(kwargs)!r}"
+            )
         if self._is_parent:
             if self._layout_kind == "grid":
                 raise ValueError(
@@ -122,18 +151,19 @@ class Chart:
             from .legend import legend as _make_legend
             gbc = True if group_by_chart is None else group_by_chart
             leg = _make_legend(*args, names=names, group_by_chart=gbc,
-                               width=width, height=height)
+                               canvas_width=canvas_width, canvas_height=canvas_height)
             self._children.append(leg)
             leg._parent = self
             return self
         # Leaf: today's in-frame overlay toggle. Reject parent-only kwargs.
         if (names is not None or group_by_chart is not None
-                or width is not None or height is not None):
+                or canvas_width is not None or canvas_height is not None):
             raise TypeError(
-                "names=, group_by_chart=, width=, height= are layout-level "
-                "options for parent.legend(); on a leaf, chart.legend() takes "
-                "an optional bool. To attach a layout-level legend to a single "
-                "chart, compose first: (chart | pt.legend()).show()."
+                "names=, group_by_chart=, canvas_width=, canvas_height= are "
+                "layout-level options for parent.legend(); on a leaf, "
+                "chart.legend() takes an optional bool. To attach a "
+                "layout-level legend to a single chart, compose first: "
+                "(chart | pt.legend()).show()."
             )
         if args and not isinstance(args[0], bool):
             raise TypeError(

{plotlet-0.1.3 → plotlet-0.2.0}/src/plotlet/core.py

@@ -17,6 +17,7 @@ behaves as before.
 from __future__ import annotations
 
 import math
+import re
 from dataclasses import dataclass, field
 from pathlib import Path
 
@@ -79,6 +80,10 @@ class _PanelOpts:
     `suppress_*_labels` drops tick labels on a side whose axis is shared
     with a neighbor that already labels it; set only on the panel that
     actually shares, never propagated by grid alignment.
+    `M_eff`, when set, is the layout-pre-pass-resolved effective margin
+    for a body-first leaf — it has already incorporated measure-driven
+    growth and per-column/row coordination. Canvas-first leaves leave
+    this `None` and fall through to `_scaled_margin` at render time.
     """
     x_axis: _AxisDescriptor | None = None
     y_axis: _AxisDescriptor | None = None
@@ -88,6 +93,7 @@ class _PanelOpts:
     hide_bottom: bool = False
     suppress_left_labels:   bool = False
     suppress_bottom_labels: bool = False
+    M_eff:       dict | None = None
 
 
 def _rotated_text(s, x, y, size, angle, axis):
@@ -131,13 +137,131 @@ def _record_ticks(st, axis, args, kw):
     if "marks" in kw:     st[f"{axis}_marks"]     = bool(kw["marks"])
 
 
+# Conversion factors to pixels, CSS standard: 1 in = 96 px, 1 in = 2.54 cm,
+# 1 in = 72 pt. Internal layout math is always pixels — string units are
+# parsed once at the constructor boundary and stored as ints, so SVG output
+# stays byte-identical regardless of input form.
+_UNIT_PX = {
+    "px": 1.0,
+    "in": 96.0,
+    "cm": 96.0 / 2.54,
+    "mm": 96.0 / 25.4,
+    "pt": 96.0 / 72.0,
+}
+_DIM_RE = re.compile(r"^\s*([+-]?\d*\.?\d+)\s*([a-zA-Z]*)\s*$")
+
+
+def _to_px(value):
+    """Resolve a dim value to integer pixels.
+
+    Accepts:
+      - `int` / `float`: bare pixels.
+      - `str`: a number with an optional unit suffix
+        (`"4in"`, `"10cm"`, `"100mm"`, `"72pt"`, `"30px"` or `"30"`).
+        Whitespace and case insensitive (`"5 IN"` works).
+      - `None`: passthrough (constructors interpret as "use default").
+    """
+    if value is None:
+        return None
+    if isinstance(value, bool):
+        # Guard against `True`/`False` slipping through `int` — almost never
+        # what the user meant for a dimension.
+        raise TypeError(f"dim value cannot be bool; got {value!r}")
+    if isinstance(value, (int, float)):
+        return int(round(value))
+    if not isinstance(value, str):
+        raise TypeError(
+            f"dim value must be int, float, or str; got {type(value).__name__}"
+        )
+    m = _DIM_RE.match(value)
+    if not m:
+        raise ValueError(
+            f"could not parse dim value {value!r}; expected '<number>[unit]' "
+            f"where unit is one of: {', '.join(sorted(_UNIT_PX))}"
+        )
+    num = float(m.group(1))
+    unit = m.group(2).lower() or "px"
+    if unit not in _UNIT_PX:
+        raise ValueError(
+            f"unknown unit {unit!r} in {value!r}; expected one of: "
+            f"{', '.join(sorted(_UNIT_PX))}"
+        )
+    return int(round(num * _UNIT_PX[unit]))
+
+
+def _spec_canvas_dims() -> tuple[int, int]:
+    """Spec-default canvas size, derived from data region + spec margin.
+
+    The dimensional primitive is the data region (`spec.size.data_width` /
+    `data_height`); this helper rebuilds the implied canvas size so legacy
+    canvas-based math (`_scaled_margin`, layout allocation) keeps a single
+    well-defined reference point."""
+    M = _SIZESPEC["margin"]
+    return (_SIZESPEC["data_width"]  + M["left"] + M["right"],
+            _SIZESPEC["data_height"] + M["top"]  + M["bottom"])
+
+
 class Figure:
-    def __init__(self, width: int | None = None, height: int | None = None,
-                 margin: dict | None = None):
+    def __init__(self,
+                 data_width: int | float | str | None = None,
+                 data_height: int | float | str | None = None,
+                 *,
+                 canvas_width: int | float | str | None = None,
+                 canvas_height: int | float | str | None = None,
+                 margin: dict | None = None,
+                 **kwargs):
+        # Migration error: 0.1.x accepted `width=`/`height=` (canvas dims).
+        # 0.2.0 splits this into data_* (data region — the new primitive) and
+        # canvas_* (full SVG). Surface the rename loudly rather than silently
+        # accepting and producing a different-sized figure.
+        if "width" in kwargs or "height" in kwargs:
+            raise TypeError(
+                "Figure no longer accepts `width=` / `height=` (changed in 0.2.0). "
+                "For the data region (the new dimensional primitive), pass "
+                "`data_width=` / `data_height=` — positional also works: "
+                "`Figure(400, 300)`. For the full SVG canvas, pass "
+                "`canvas_width=` / `canvas_height=`."
+            )
+        if kwargs:
+            raise TypeError(f"Figure() got unexpected keyword arguments: {list(kwargs)!r}")
+
+        data_set   = (data_width   is not None) or (data_height   is not None)
+        canvas_set = (canvas_width is not None) or (canvas_height is not None)
+        if data_set and canvas_set:
+            raise ValueError(
+                "Pass either data_width/data_height (the data region — preferred) "
+                "or canvas_width/canvas_height (the full SVG canvas), not both."
+            )
+
+        # Resolve unit-suffixed strings (`"4in"`, `"10cm"`, …) once at the
+        # boundary so internal math stays in pixels.
+        data_width    = _to_px(data_width)
+        data_height   = _to_px(data_height)
+        canvas_width  = _to_px(canvas_width)
+        canvas_height = _to_px(canvas_height)
+
         self._calls: list[tuple[str, list, dict]] = []
-        self._width = width if width is not None else _SIZESPEC["width"]
-        self._height = height if height is not None else _SIZESPEC["height"]
-        self._margin = margin if margin is not None else dict(_SIZESPEC["margin"])
+        self._margin = dict(margin) if margin is not None else dict(_SIZESPEC["margin"])
+
+        if canvas_set:
+            # Canvas path: user picked the SVG canvas; effective margin scales
+            # by canvas/spec_canvas (legacy 0.1.x behavior). Data region falls
+            # out as canvas - effective margin.
+            spec_cw, spec_ch = _spec_canvas_dims()
+            self._canvas_width  = canvas_width  if canvas_width  is not None else spec_cw
+            self._canvas_height = canvas_height if canvas_height is not None else spec_ch
+            self._canvas_explicit = True
+            M_eff = _scaled_margin(self._margin, self._canvas_width, self._canvas_height)
+            self._data_width  = self._canvas_width  - M_eff["left"] - M_eff["right"]
+            self._data_height = self._canvas_height - M_eff["top"]  - M_eff["bottom"]
+        else:
+            # Data path (default): user picked the data region exactly. Margin
+            # is used unscaled (only floored). Canvas falls out as data + margin.
+            self._data_width  = data_width  if data_width  is not None else _SIZESPEC["data_width"]
+            self._data_height = data_height if data_height is not None else _SIZESPEC["data_height"]
+            self._canvas_width  = self._data_width  + self._margin["left"] + self._margin["right"]
+            self._canvas_height = self._data_height + self._margin["top"]  + self._margin["bottom"]
+            self._canvas_explicit = False
 
     def __getattr__(self, name):
         # Recordable if it's a frame method or a registered artist
@@ -192,8 +316,38 @@ class Figure:
         return st
 
     # ------------------------------------------------------------- render
+    def _effective_margin(self, st: dict | None = None) -> dict:
+        """Margin actually used at render time.
+
+        Canvas path: scales by canvas dims (legacy 0.1.x behavior); text
+        overflow is the user's responsibility because canvas size is
+        promised exactly.
+
+        Data path: combines `_enforce_floors(spec/user margin)` with the
+        content-driven `_required_margin(st, data_w, data_h)` by taking
+        the per-side max — so the canvas grows as needed to fit long tick
+        labels, titles, and axis labels rather than letting them overflow.
+        Caller passes the replayed `st`; callers without one (legacy code
+        paths) get only the floor-applied spec margin."""
+        if self._canvas_explicit:
+            return _scaled_margin(self._margin, self._canvas_width, self._canvas_height)
+        M_floor = _enforce_floors(self._margin)
+        if st is None:
+            return M_floor
+        M_req = _required_margin(st, self._data_width, self._data_height)
+        return {side: max(M_floor[side], M_req[side]) for side in M_floor}
+
     def to_svg(self) -> str:
-        return _render(self._replay(), self._width, self._height, self._margin)
+        st = self._replay()
+        M_eff = self._effective_margin(st)
+        # Canvas-path keeps its promised canvas; data-path canvas grows
+        # to fit the (possibly measure-driven-expanded) margin.
+        if self._canvas_explicit:
+            W, H = self._canvas_width, self._canvas_height
+        else:
+            W = self._data_width  + M_eff["left"] + M_eff["right"]
+            H = self._data_height + M_eff["top"]  + M_eff["bottom"]
+        return _render(st, W, H, M_eff)
 
     def to_html(self, full_page: bool = False) -> str:
         svg = self.to_svg()
@@ -223,8 +377,15 @@ class Figure:
         return self
 
 
-def figure(width: int | None = None, height: int | None = None, **opts) -> Figure:
-    return Figure(width=width, height=height, **opts)
+def figure(data_width: int | float | str | None = None,
+           data_height: int | float | str | None = None,
+           *,
+           canvas_width: int | float | str | None = None,
+           canvas_height: int | float | str | None = None,
+           **opts) -> Figure:
+    return Figure(data_width, data_height,
+                  canvas_width=canvas_width, canvas_height=canvas_height,
+                  **opts)
 
 
 # ---------------------------------------------------------------------------
@@ -268,13 +429,28 @@ def _resolve_domain(lo, hi, user_lim, scale_kind, force_zero=False):
     return _nice_domain(lo, hi)
 
 
+def _enforce_floors(M):
+    """Apply per-side margin floors without any scaling. Used by the
+    data-region path: the user (or spec) declared the margin in absolute
+    pixels, so we just round and floor — never shrink."""
+    return {
+        "top":    max(_MARGIN_FLOOR["top"],    int(round(M["top"]))),
+        "bottom": max(_MARGIN_FLOOR["bottom"], int(round(M["bottom"]))),
+        "left":   max(_MARGIN_FLOOR["left"],   int(round(M["left"]))),
+        "right":  max(_MARGIN_FLOOR["right"],  int(round(M["right"]))),
+    }
+
+
 def _scaled_margin(M, W, H):
-    """Shrink margins for small panels, with a per-side floor so tick labels
-    and titles still fit. Floors live in `spec.size.margin_floor`; base
-    margins (defaulted from spec, overridable via `pt.chart(margin=...)`)
-    scale by `min(1, panel_size / spec_size)` per axis."""
-    fw = min(1.0, W / _SIZESPEC["width"])
-    fh = min(1.0, H / _SIZESPEC["height"])
+    """Shrink margins for small canvases, with a per-side floor so tick
+    labels and titles still fit. Used by the canvas-explicit path
+    (`Figure(canvas_width=…)` and the layout's per-panel allocation),
+    where the canvas size is fixed and margins must scale to fit. Floors
+    live in `spec.size.margin_floor`; the reference canvas is derived
+    from `spec.size.data_width/height + spec margin`."""
+    spec_W, spec_H = _spec_canvas_dims()
+    fw = min(1.0, W / spec_W)
+    fh = min(1.0, H / spec_H)
     return {
         "top":    max(_MARGIN_FLOOR["top"],    int(round(M["top"]    * fh))),
         "bottom": max(_MARGIN_FLOOR["bottom"], int(round(M["bottom"] * fh))),
@@ -373,6 +549,127 @@ def _y_descriptor(st) -> _AxisDescriptor:
     return _AxisDescriptor(kind=st["yscale"], lo=y_min, hi=y_max)
 
 
+def _rotated_label_bbox(label_w: float, label_h: float, rot_deg: float) -> tuple[float, float]:
+    """Bounding-box (width, height) of a rotated text label. Conservative —
+    uses the simple `|cos|·w + |sin|·h` envelope, which is exact for the
+    AABB of an axis-aligned rectangle rotated by any angle."""
+    if rot_deg == 0:
+        return label_w, label_h
+    rad = math.radians(abs(rot_deg))
+    sin_r = math.sin(rad)
+    cos_r = math.cos(rad)
+    return (label_w * cos_r + label_h * sin_r,
+            label_w * sin_r + label_h * cos_r)
+
+
+def _required_margin(st, dw, dh) -> dict:
+    """Margin a body-first leaf actually needs to fit its title, axis
+    labels, and tick labels without overflow.
+
+    Returns a plain dict with the same keys as `_margin` — the caller
+    combines this with the user/spec margin (and the per-side floor) by
+    taking max per side. Body-first specifically: data dims are fixed,
+    so tick density and labels are deterministic and the computation is
+    a single pass (no chicken-and-egg with margin).
+
+    The geometry mirrors `_render_inner`'s placement formulas — keep them
+    in sync if either changes."""
+    tick_size  = _FONTSPEC["tick_size"]
+    label_size = _FONTSPEC["label_size"]
+    title_size = _FONTSPEC["title_size"]
+
+    # Title sits at y = -10 from the data top (see _render_inner), so it
+    # needs ≥ title_size + ~4 px of top margin to clear.
+    top = title_size + 6 if st["title"] else 0
+
+    # Provisional scales at the fixed data dims — body-first means iw/ih
+    # are decided up front, no iteration needed.
+    x_axis = _x_descriptor(st)
+    y_axis = _y_descriptor(st)
+    x_scale = x_axis.build(0, dw)
+    y_scale = y_axis.build(0, dh) if y_axis.kind == "category" else y_axis.build(dh, 0)
+
+    # Same tick-density rule as `_render_inner`.
+    x_n = max(2, min(8, int(dw // 65)))
+    y_n = max(2, min(8, int(dh // 40)))
+    x_ticks  = st["x_ticks"]  if st["x_ticks"]  is not None else x_scale.ticks(x_n)
+    y_ticks  = st["y_ticks"]  if st["y_ticks"]  is not None else y_scale.ticks(y_n)
+    x_labels = (st["x_labels"] if st["x_labels"] is not None
+                else [_fmt_tick(t) for t in x_ticks])
+    y_labels = (st["y_labels"] if st["y_labels"] is not None
+                else [_fmt_tick(t) for t in y_ticks])
+
+    x_size = st["x_fontsize"] if st["x_fontsize"] is not None else tick_size
+    y_size = st["y_fontsize"] if st["y_fontsize"] is not None else tick_size
+    x_rot  = st["x_rotation"] or 0
+    y_rot  = st["y_rotation"] or 0
+    x_dir, y_dir = st["x_direction"], st["y_direction"]
+    x_marks, y_marks = st["x_marks"], st["y_marks"]
+
+    # Outward / inout tick marks reach past the spine; "in" is internal only.
+    out_x = _TICK_LEN if x_marks and x_dir != "in" else 0
+    out_y = _TICK_LEN if y_marks and y_dir != "in" else 0
+
+    # X-tick label bbox (after rotation).
+    if x_labels:
+        max_xtl_w = max((_measure_text(str(l), x_size) for l in x_labels), default=0.0)
+        last_xtl_w = _measure_text(str(x_labels[-1]), x_size)
+        _, xtl_bbox_h = _rotated_label_bbox(max_xtl_w, x_size, x_rot)
+        last_bbox_w, _ = _rotated_label_bbox(last_xtl_w, x_size, x_rot)
+    else:
+        xtl_bbox_h = 0.0
+        last_bbox_w = 0.0
+
+    # Y-tick label width (after rotation).
+    if y_labels:
+        max_ytl_w = max((_measure_text(str(l), y_size) for l in y_labels), default=0.0)
+        ytl_bbox_w, _ = _rotated_label_bbox(max_ytl_w, y_size, y_rot)
+    else:
+        ytl_bbox_w = 0.0
+
+    # Bottom: outward tick + tick_pad + 8 px buffer + tick label bbox + xlabel.
+    # The "+8" mirrors the literal in _render_inner's tick-label baseline y.
+    bottom = out_x + _TICK_PAD + 8 + xtl_bbox_h
+    if st["xlabel"]:
+        bottom += label_size + 8
+
+    # Left: outward tick + tick_pad + tick label bbox + ylabel allowance.
+    # ylabel sits at canvas-left + 12 px (rotated -90), so it occupies
+    # roughly `label_size` in the horizontal direction.
+    left = out_y + _TICK_PAD + ytl_bbox_w
+    if st["ylabel"]:
+        left += label_size + 8
+
+    # Right: outward tick OR the rightmost x-tick label's overhang past
+    # the spine (centered text extends half its width past the tick).
+    right_overhang = last_bbox_w / 2.0
+    right = max(out_y, right_overhang)
+
+    # Long-text overflow: a title / xlabel longer than `dw` is centered on
+    # `iw/2`, so it sticks out past the data area on both left and right
+    # by `(text_w - dw) / 2`. A ylabel (rotated -90, centered on `ih/2`)
+    # is the same story but vertical: text longer than `dh` spills past
+    # top and bottom equally. Margins grow by the overhang amount so the
+    # rendered text fits inside the canvas.
+    if st["title"]:
+        title_overhang = max(0.0, (_measure_text(st["title"], title_size) - dw) / 2.0)
+        left  = max(left,  title_overhang)
+        right = max(right, title_overhang)
+    if st["xlabel"]:
+        xlabel_overhang = max(0.0, (_measure_text(st["xlabel"], label_size) - dw) / 2.0)
+        left  = max(left,  xlabel_overhang)
+        right = max(right, xlabel_overhang)
+    if st["ylabel"]:
+        ylabel_overhang = max(0.0, (_measure_text(st["ylabel"], label_size) - dh) / 2.0)
+        top    = max(top,    ylabel_overhang)
+        bottom = max(bottom, ylabel_overhang)
+
+    return {"top":    int(round(top)),
+            "right":  int(round(right)),
+            "bottom": int(round(bottom)),
+            "left":   int(round(left))}
+
+
 def _build_xy_scales(st, iw, ih, panel_opts: _PanelOpts):
     """Instantiate pixel-bound scales. `panel_opts.x_axis` / `y_axis` come
     from the layout pre-pass when set; otherwise we compute them from the
@@ -391,7 +688,10 @@ def _build_xy_scales(st, iw, ih, panel_opts: _PanelOpts):
 # ---------------------------------------------------------------------------
 
 def _render(st, W, H, M):
-    M = _scaled_margin(M, W, H)
+    """Emit one SVG. (W, H) = canvas dims; M = effective margin already
+    resolved by the caller (`Figure._effective_margin` or layout's
+    `_effective_margin`). Splitting margin resolution out of `_render` is
+    what lets the data-path skip canvas-based scaling."""
     iw = W - M["left"] - M["right"]
     ih = H - M["top"] - M["bottom"]
     return (