coeftable 0.4.0__tar.gz → 0.5.0__tar.gz

coeftable-0.5.0/AGENTS.md

@@ -0,0 +1,7 @@
+# Agent guidelines
+
+## Changelog
+
+Never edit `CHANGELOG.md`. It is generated by release automation
+(`.github/release.yml`) from merged PR titles; Describe changes in the PR
+description instead.

{coeftable-0.4.0 → coeftable-0.5.0}/CHANGELOG.md

@@ -1,7 +1,18 @@
-## Unreleased
+<a id="v0.4.0"></a>
+# [v0.4.0](https://github.com/kylejcaron/coeftable/releases/tag/v0.4.0) - 2026-08-14
+
+<!-- Release notes generated using configuration in .github/release.yml at v0.4.0 -->
+
+## What's Changed
+### Maintenance
+* build: align hatchling metadata floor by [@kylejcaron](https://github.com/kylejcaron) in [#30](https://github.com/kylejcaron/coeftable/pull/30)
+* feature: support plot annotations by [@kylejcaron](https://github.com/kylejcaron) in [#31](https://github.com/kylejcaron/coeftable/pull/31)
+
+
+**Full Changelog**: https://github.com/kylejcaron/coeftable/compare/v0.3.1...v0.4.0
+
+[Changes][v0.4.0]
 
-### Features
-- Add typed rule and band annotations to forest plots and sparklines, including row-specific field binding and domain-aware layering.
 
 <a id="v0.3.1"></a>
 # [v0.3.1](https://github.com/kylejcaron/coeftable/releases/tag/v0.3.1) - 2026-08-14
@@ -97,6 +108,7 @@
 [Changes][v0.1.0]
 
 
+[v0.4.0]: https://github.com/kylejcaron/coeftable/compare/v0.3.1...v0.4.0
 [v0.3.1]: https://github.com/kylejcaron/coeftable/compare/v0.3.0...v0.3.1
 [v0.3.0]: https://github.com/kylejcaron/coeftable/compare/v0.2.1...v0.3.0
 [v0.2.1]: https://github.com/kylejcaron/coeftable/compare/v0.2.0...v0.2.1

{coeftable-0.4.0 → coeftable-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coeftable
-Version: 0.4.0
+Version: 0.5.0
 Summary: Publication-quality summary tables for estimates with uncertainty.
 Project-URL: Homepage, https://github.com/kylejcaron/coeftable
 Project-URL: Repository, https://github.com/kylejcaron/coeftable
@@ -414,6 +414,36 @@ trend = pl.DataFrame(
 )
 ```
 
+**Forest plots take `autoscale` too.** A single extreme interval (say a
++3000% lift among sub-1% metrics) otherwise stretches the shared domain
+and flattens every other bar:
+
+```python
+lifts = pl.DataFrame(
+    {
+        "metric": ["Checkout CVR", "Signup Rate", "Retention D7", "AOV", "Rare Event"],
+        "rel": [0.03, -0.05, 0.08, 0.02, 30.0],
+        "rel_lb": [0.01, -0.09, 0.04, -0.01, 22.0],
+        "rel_ub": [0.05, -0.01, 0.12, 0.05, 41.0],
+    }
+)
+
+(
+    ct.CoefTable(lifts, rows="metric")
+    .estimate("Lift %", "rel", ci=("rel_lb", "rel_ub"), fmt=ct.Percent(signed=True))
+    # "robust" fits an IQR/Tukey fence over the pooled values instead of
+    # the raw min/max, so the outlier stops dictating the axis. Composes
+    # with symmetric= (fence first, then mirror around ref); ylim= still
+    # overrides everything.
+    .forest("Lift Plot", of="Lift %", ref=0.0, autoscale="robust")
+)
+```
+
+A discounted interval is never hidden: bars in a clipping domain plot
+against a slightly inset region and the clipped interval continues into
+the reserved margin as a gradient fade, reading as "extends beyond the
+axis". Buckets with nothing clipped render exactly as before.
+
 **No reference, or a hidden one.** `ref` also drives the dashed line and
 colour resolution; two ways to opt out, for data with no meaningful
 zero (revenue, durations, absolute counts):

{coeftable-0.4.0 → coeftable-0.5.0}/README.md

@@ -360,6 +360,36 @@ trend = pl.DataFrame(
 )
 ```
 
+**Forest plots take `autoscale` too.** A single extreme interval (say a
++3000% lift among sub-1% metrics) otherwise stretches the shared domain
+and flattens every other bar:
+
+```python
+lifts = pl.DataFrame(
+    {
+        "metric": ["Checkout CVR", "Signup Rate", "Retention D7", "AOV", "Rare Event"],
+        "rel": [0.03, -0.05, 0.08, 0.02, 30.0],
+        "rel_lb": [0.01, -0.09, 0.04, -0.01, 22.0],
+        "rel_ub": [0.05, -0.01, 0.12, 0.05, 41.0],
+    }
+)
+
+(
+    ct.CoefTable(lifts, rows="metric")
+    .estimate("Lift %", "rel", ci=("rel_lb", "rel_ub"), fmt=ct.Percent(signed=True))
+    # "robust" fits an IQR/Tukey fence over the pooled values instead of
+    # the raw min/max, so the outlier stops dictating the axis. Composes
+    # with symmetric= (fence first, then mirror around ref); ylim= still
+    # overrides everything.
+    .forest("Lift Plot", of="Lift %", ref=0.0, autoscale="robust")
+)
+```
+
+A discounted interval is never hidden: bars in a clipping domain plot
+against a slightly inset region and the clipped interval continues into
+the reserved margin as a gradient fade, reading as "extends beyond the
+axis". Buckets with nothing clipped render exactly as before.
+
 **No reference, or a hidden one.** `ref` also drives the dashed line and
 colour resolution; two ways to opt out, for data with no meaningful
 zero (revenue, durations, absolute counts):

{coeftable-0.4.0 → coeftable-0.5.0}/src/coeftable/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.4.0'
-__version_tuple__ = version_tuple = (0, 4, 0)
+__version__ = version = '0.5.0'
+__version_tuple__ = version_tuple = (0, 5, 0)
 
 __commit_id__ = commit_id = None

{coeftable-0.4.0 → coeftable-0.5.0}/src/coeftable/spec.py

@@ -30,6 +30,7 @@ from coeftable.format import (
     render_interval,
 )
 from coeftable.svg import (
+    CLIP_MARGIN,
     Trace,
     forest_axis,
     forest_bar,
@@ -378,22 +379,24 @@ def _bucket_domain(
     max_domain: float | None,
     autoscale: Autoscale = "tight",
     required: Sequence[float] = (),
+    symmetric: bool = False,
 ) -> tuple[float, float]:
-    """Resolve one domain bucket for `Sparkline.prepare`.
+    """Resolve one domain bucket for `Sparkline.prepare` or `Forest.prepare`.
 
     `override` wins outright; otherwise a tight fit uses all `values` and
     a robust fit first applies an IQR/Tukey fence. Required annotation
     coordinates are joined to those retained data inputs before one padding
     pass, so a coordinate within the retained data extent leaves the
     automatic fit unchanged. `max_domain`, when set, then narrows the result
-    around `ref`.
+    around `ref`. `symmetric=True` mirrors the padded fit around `ref`
+    (`Forest`'s option; requires `ref`, enforced by `_pad_domain`).
     """
     if override is not None:
         return override
     fit_values = _robust_inliers(values) if autoscale == "robust" else values
     finite_required = _finite(list(required)) if required else []
     inputs = [*fit_values, *finite_required] if finite_required else fit_values
-    domain = _pad_domain(inputs, ref)
+    domain = _pad_domain(inputs, ref, symmetric=symmetric)
     return _clamp_domain(domain, ref, max_domain) if max_domain is not None else domain
 
 
@@ -453,6 +456,7 @@ class _ForestState:
     value: list[float | None]
     low: list[float | None]
     high: list[float | None]
+    clipped: frozenset[Any]
     annotations: PreparedAnnotations
 
 
@@ -475,6 +479,16 @@ class Forest:
     symmetric
         When `ylim` is not set, symmetrize the auto-computed domain
         around `ref` instead of fitting tightly to the data.
+    autoscale
+        Strategy for the auto-computed domain when `ylim` is not set.
+        `"tight"` (default) fits to the exact min/max of the bucket's
+        pooled values. `"robust"` fits an IQR/Tukey fence over them
+        instead, so a single extreme interval stops flattening every
+        other bar; a discounted interval clips against the resulting
+        domain edge and continues into a reserved margin as a gradient
+        fade rather than being hidden. Colour resolution is unaffected --
+        it always reads a row's true values, never the domain they are
+        plotted against.
     width
         Bar width in pixels.
     height
@@ -496,6 +510,7 @@ class Forest:
     scale: Scale = "table"
     ylim: tuple[float, float] | None = None
     symmetric: bool = False
+    autoscale: Autoscale = "tight"
     width: int = 220
     height: int | None = None
     show_axis: bool = True
@@ -525,16 +540,30 @@ class Forest:
         )
 
         buckets: dict[Any, list[float]] = {}
+        required: dict[Any, list[float]] = {}
         for i in range(len(scan.row_keys)):
             key = _domain_key(self, scan.row_keys[i], scan.group_keys[i], scan.split_keys[i])
             inputs = buckets.setdefault(key, [])
             inputs.extend(_finite([value[i], low[i], high[i]]))
             if not is_missing(value[i]):
-                inputs.extend(domain_values(annotations.by_row[i], axis="x"))
+                required.setdefault(key, []).extend(domain_values(annotations.by_row[i], axis="x"))
         domains = {
-            key: self.ylim or _pad_domain(vals, self.ref, symmetric=self.symmetric)
+            key: _bucket_domain(
+                vals,
+                self.ref,
+                override=self.ylim,
+                max_domain=None,
+                autoscale=self.autoscale,
+                required=required.get(key, ()),
+                symmetric=self.symmetric,
+            )
             for key, vals in buckets.items()
         }
+        clipped = frozenset(
+            key
+            for key, vals in buckets.items()
+            if any(v < domains[key][0] or v > domains[key][1] for v in vals)
+        )
 
         def footer_key(row_key: Any, group: Any, split: Any) -> Any:
             return _domain_key(self, row_key, group, split)
@@ -547,6 +576,7 @@ class Forest:
                 low=low,
                 high=high,
                 annotations=annotations,
+                clipped=clipped,
             ),
             footer_key=footer_key if self.show_axis else None,
             shared_footer=self.scale in ("table", "split_column"),
@@ -573,6 +603,7 @@ class Forest:
             theme=ctx.theme,
             width=self.width,
             height=_plot_height((state.source,), self.height),
+            margin=CLIP_MARGIN if key in state.clipped else 0,
             annotations=state.annotations.by_row[ctx.index],
         )
 
@@ -585,6 +616,7 @@ class Forest:
             fmt=self.axis_fmt or state.source.fmt,
             theme=ctx.theme,
             width=self.width,
+            margin=CLIP_MARGIN if ctx.key in state.clipped else 0,
         )
 
 
@@ -1371,6 +1403,7 @@ class CoefTable:
         scale: Scale = "table",
         ylim: tuple[float, float] | None = None,
         symmetric: bool = False,
+        autoscale: Autoscale = "tight",
         width: int = 220,
         height: int | None = None,
         show_axis: bool = True,
@@ -1394,6 +1427,15 @@ class CoefTable:
         symmetric
             When `ylim` is not set, symmetrize the auto-computed domain
             around `ref` instead of fitting tightly to the data.
+        autoscale
+            Strategy for the auto-computed domain when `ylim` is not set.
+            `"tight"` (default) fits to the exact min/max of the bucket's
+            pooled values. `"robust"` fits an IQR/Tukey fence over them
+            instead, so a single extreme interval stops flattening every
+            other bar; a discounted interval clips against the resulting
+            domain edge and continues into a reserved margin as a
+            gradient fade rather than being hidden. Composes with
+            `symmetric`: the fence runs first, then the mirrored padding.
         width
             Bar width in pixels.
         height
@@ -1420,6 +1462,7 @@ class CoefTable:
                 scale=scale,
                 ylim=ylim,
                 symmetric=symmetric,
+                autoscale=autoscale,
                 width=width,
                 height=height,
                 show_axis=show_axis,

{coeftable-0.4.0 → coeftable-0.5.0}/src/coeftable/svg.py

@@ -849,6 +849,48 @@ def _esc(text: str) -> str:
     return html.escape(text, quote=False)
 
 
+CLIP_MARGIN = 18
+# Pixel reserve on each side of a forest bar's plotting region when its
+# domain bucket contains clipped values -- the strip a `_fade_cap` bleeds
+# into. Shared with `spec.Forest`, which decides per bucket whether to
+# reserve it at all.
+
+
+def _fade_id(color: str, flip: bool) -> str:
+    """Return a deterministic id for a `_fade_cap` gradient.
+
+    Same collision reasoning as `_hard_clip_id`: SVG ids share one
+    namespace across an embedding page, so the id is built from the
+    gradient's full content -- its colour and direction. Two calls share
+    an id exactly when their gradients are identical, which makes any
+    collision harmless.
+    """
+    safe = "".join(c if c.isalnum() else "_" for c in color)
+    return f"fade{'l' if flip else 'r'}_{safe}"
+
+
+def _fade_cap(
+    x: float, top: float, fade_width: float, bar_height: int, color: str, *, flip: bool
+) -> str:
+    """Continue a clipped bar into the reserved margin as a gradient fade.
+
+    The rectangle starts at the domain edge the bar clipped against and
+    fades from the bar's own fill to transparent across `fade_width` px,
+    reading as "extends beyond the axis" rather than ending abruptly.
+    `flip=True` fades leftward for a low-edge clip.
+    """
+    gid = _fade_id(color, flip)
+    x_attrs = 'x1="1" y1="0" x2="0" y2="0"' if flip else 'x1="0" y1="0" x2="1" y2="0"'
+    return (
+        f'<defs><linearGradient id="{gid}" {x_attrs}>'
+        f'<stop offset="0" stop-color="{color}" stop-opacity="0.75"/>'
+        f'<stop offset="1" stop-color="{color}" stop-opacity="0"/>'
+        f"</linearGradient></defs>"
+        f'<rect x="{x:.2f}" y="{top:.2f}" width="{fade_width:.2f}" '
+        f'height="{bar_height}" fill="url(#{gid})"/>'
+    )
+
+
 def forest_bar(
     estimate: float | None,
     lower: float | None,
@@ -862,14 +904,18 @@ def forest_bar(
     height: int = 18,
     bar_height: int = 9,
     inset: int = 3,
+    margin: int = 0,
     annotations: Sequence[ResolvedAnnotation] = (),
 ) -> str:
     """Render one interval as an inline SVG bar.
 
     The bar spans the interval, a light tick marks the point estimate, and a
     dashed line marks `ref` when it falls inside `domain`.  A bound outside the
-    domain, including an unbounded one, draws to the edge with a triangular cap
-    so that clipping is visible rather than silently misleading.
+    domain, including an unbounded one, is clipped visibly rather than
+    silently: with `margin=0` it draws to the edge with a triangular cap;
+    with `margin > 0` the bars plot against the inner
+    `[margin, width - margin]` region and a clipped bound continues into
+    the margin as a gradient fade to transparent (see `_fade_cap`).
 
     Parameters
     ----------
@@ -889,6 +935,10 @@ def forest_bar(
         Resolved x-axis rules and bands rendered around the existing bar.
     width, height, bar_height, inset
         Geometry in pixels.
+    margin
+        Pixel reserve on each side of the plotting region for the fade
+        treatment of clipped bounds. `0` (the default) keeps the full
+        width for bars and marks clipping with triangular caps instead.
 
     Returns
     -------
@@ -896,7 +946,12 @@ def forest_bar(
         A complete ``<svg>`` element.
     """
     low, high = domain
-    project = _projector(domain, width, inset)
+    plot_width = width - 2 * margin
+    inner_project = _projector(domain, plot_width, inset)
+
+    def project(v: float) -> float:
+        return margin + inner_project(v)
+
     low_value = low if lower is None or is_missing(lower) else lower
     high_value = high if upper is None or is_missing(upper) else upper
     clipped_low = is_missing(lower) or low_value < low
@@ -928,19 +983,26 @@ def forest_bar(
             f'y2="{top + bar_height:.2f}" stroke="{theme.surface}" stroke-width="1.5"/>'
         )
 
-    cap = bar_height * 0.6
-    if clipped_high:
-        tip = width - inset / 2
-        parts.append(
-            f'<polygon points="{tip:.2f},{middle:.2f} {tip - cap:.2f},{middle - cap:.2f} '
-            f'{tip - cap:.2f},{middle + cap:.2f}" fill="{color}"/>'
-        )
-    if clipped_low:
-        tip = inset / 2
-        parts.append(
-            f'<polygon points="{tip:.2f},{middle:.2f} {tip + cap:.2f},{middle - cap:.2f} '
-            f'{tip + cap:.2f},{middle + cap:.2f}" fill="{color}"/>'
-        )
+    if margin:
+        fade_width = float(margin - inset)
+        if clipped_high:
+            parts.append(_fade_cap(x1, top, fade_width, bar_height, color, flip=False))
+        if clipped_low:
+            parts.append(_fade_cap(x0 - fade_width, top, fade_width, bar_height, color, flip=True))
+    else:
+        cap = bar_height * 0.6
+        if clipped_high:
+            tip = width - inset / 2
+            parts.append(
+                f'<polygon points="{tip:.2f},{middle:.2f} {tip - cap:.2f},{middle - cap:.2f} '
+                f'{tip - cap:.2f},{middle + cap:.2f}" fill="{color}"/>'
+            )
+        if clipped_low:
+            tip = inset / 2
+            parts.append(
+                f'<polygon points="{tip:.2f},{middle:.2f} {tip + cap:.2f},{middle - cap:.2f} '
+                f'{tip + cap:.2f},{middle + cap:.2f}" fill="{color}"/>'
+            )
     if not annotations:
         return _svg(width, height, "".join(parts))
     area = _PlotArea(
@@ -948,8 +1010,8 @@ def forest_bar(
         y_domain=None,
         project_x=project,
         project_y=None,
-        left=inset,
-        right=width - inset,
+        left=margin + inset,
+        right=width - margin - inset,
         top=0,
         bottom=height,
     )
@@ -1078,6 +1140,7 @@ def forest_axis(
     width: int = 220,
     height: int = 22,
     inset: int = 3,
+    margin: int = 0,
     target_ticks: int = 4,
 ) -> str:
     """Render the shared x-axis for a set of forest bars.
@@ -1094,6 +1157,10 @@ def forest_axis(
         Supplies the axis colour and label size.
     width, height, inset
         Geometry in pixels.
+    margin
+        Pixel reserve on each side matching the bars' own `margin`; the
+        axis spine and projection span only the inner region so ticks
+        stay aligned with the bars.
     target_ticks
         Approximate number of ticks wanted.
 
@@ -1103,10 +1170,15 @@ def forest_axis(
         A complete ``<svg>`` element.
     """
     low, high = domain
-    project = _projector(domain, width, inset)
+    inner_project = _projector(domain, width - 2 * margin, inset)
+
+    def project(v: float) -> float:
+        return margin + inner_project(v)
+
     baseline = 4.0
     parts = [
-        f'<line x1="{inset}" y1="{baseline:.2f}" x2="{width - inset}" y2="{baseline:.2f}" '
+        f'<line x1="{margin + inset}" y1="{baseline:.2f}" '
+        f'x2="{width - margin - inset}" y2="{baseline:.2f}" '
         f'stroke="{theme.axis}" stroke-width="0.75"/>'
     ]
     if low <= ref <= high:

{coeftable-0.4.0 → coeftable-0.5.0}/tests/test_frame.py

@@ -562,6 +562,94 @@ def test_explicit_ylim_wins_over_symmetric():
     assert out.axis_rows
 
 
+OUTLIER_RAW = {
+    "area": ["Core"] * 4,
+    "metric": ["A", "B", "C", "Rare"],
+    "variant": ["B", "B", "B", "B"],
+    "rel": [0.5, -0.2, 0.1, 300.0],
+    "rel_lb": [0.3, -0.5, -0.1, 220.0],
+    "rel_ub": [0.7, 0.1, 0.3, 410.0],
+}
+
+
+def test_forest_autoscale_robust_discounts_outlier_and_flags_bucket_clipped():
+    table = base(pl.DataFrame(OUTLIER_RAW)).forest("Plot", of="Lift %", autoscale="robust")
+    state = _forest_state(table)
+    (domain,) = state.domains.values()
+    assert domain[1] < 220.0
+    assert state.clipped == set(state.domains)
+
+
+def test_forest_autoscale_tight_default_fits_outlier_with_no_clip():
+    table = base(pl.DataFrame(OUTLIER_RAW)).forest("Plot", of="Lift %")
+    state = _forest_state(table)
+    (domain,) = state.domains.values()
+    assert domain[1] >= 410.0
+    assert state.clipped == frozenset()
+
+
+def test_forest_autoscale_robust_composes_with_symmetric():
+    table = base(pl.DataFrame(OUTLIER_RAW)).forest(
+        "Plot", of="Lift %", ref=0.0, autoscale="robust", symmetric=True
+    )
+    state = _forest_state(table)
+    (domain,) = state.domains.values()
+    assert domain[0] == -domain[1]
+    assert domain[1] < 220.0
+
+
+def test_forest_explicit_ylim_wins_over_robust_and_still_flags_clipping():
+    table = base(pl.DataFrame(OUTLIER_RAW)).forest(
+        "Plot", of="Lift %", autoscale="robust", ylim=(-1.0, 1.0)
+    )
+    state = _forest_state(table)
+    (domain,) = state.domains.values()
+    assert domain == (-1.0, 1.0)
+    assert state.clipped == set(state.domains)
+
+
+def test_forest_clipped_bucket_renders_margin_fade_in_html():
+    table = base(pl.DataFrame(OUTLIER_RAW)).forest("Plot", of="Lift %", autoscale="robust")
+    html = table.gt()._repr_html_()
+    assert "linearGradient" in html
+
+
+def test_forest_unclipped_table_renders_no_fade_in_html():
+    table = base(pl.DataFrame(RAW)).forest("Plot", of="Lift %")
+    html = table.gt()._repr_html_()
+    assert "linearGradient" not in html
+
+
+def test_forest_robust_domain_retains_annotation_outside_inlier_range():
+    # Under autoscale="robust" a forest annotation coordinate rides the
+    # `required` join past the IQR fence: it expands the domain even though a
+    # genuine data outlier in the same bucket is fenced out. The two live
+    # bounds pin both halves -- the annotation (2.0) is retained while the
+    # data outlier (6.0) is discounted, so the domain lands near 2.0, not 6.0.
+    raw = pl.DataFrame(
+        {
+            "metric": ["A", "B", "C", "D", "E"],
+            "est": [0.30, 0.32, 0.28, 0.31, 5.00],
+            "low": [0.20, 0.22, 0.18, 0.21, 4.00],
+            "high": [0.40, 0.42, 0.38, 0.41, 6.00],
+        }
+    )
+    table = (
+        CoefTable(raw, rows="metric")
+        .estimate("Effect", "est", ci=("low", "high"))
+        .forest(
+            "Plot",
+            of="Effect",
+            ref=0.0,
+            autoscale="robust",
+            annotations=(Rule(2.0, axis="x"),),
+        )
+    )
+    _, high = _forest_state(table).domains[("table",)]
+    assert high >= 2.0  # annotation retained past the fence
+    assert high < 4.0  # data outlier fenced out, not driving the domain
+
+
 def test_plot_height_picks_stacked_layout_default():
     estimate = Estimate("Lift %", "rel", ci=("lb", "ub"))
     forest = Forest("Plot", of="Lift %")

{coeftable-0.4.0 → coeftable-0.5.0}/tests/test_svg.py

@@ -124,6 +124,42 @@ def test_forest_bar_without_clipping_has_no_cap():
     assert "<polygon" not in svg
 
 
+def test_forest_bar_margin_fades_clipped_upper_bound_instead_of_cap():
+    svg = forest_bar(
+        1.0, 0.5, 99.0, domain=(0.0, 2.0), ref=0.0, color="#000", theme=DEFAULT, margin=18
+    )
+    assert "linearGradient" in svg
+    assert "<polygon" not in svg
+
+
+def test_forest_bar_margin_fades_clipped_lower_bound_with_flipped_gradient():
+    svg = forest_bar(
+        1.0, -99.0, 1.5, domain=(0.0, 2.0), ref=0.0, color="#000", theme=DEFAULT, margin=18
+    )
+    assert 'id="fadel_' in svg
+
+
+def test_forest_bar_margin_without_clipping_draws_no_fade():
+    svg = forest_bar(
+        1.0, 0.5, 1.5, domain=(0.0, 2.0), ref=0.0, color="#000", theme=DEFAULT, margin=18
+    )
+    assert "linearGradient" not in svg
+    assert "<polygon" not in svg
+
+
+def test_forest_bar_margin_offsets_projection_into_inner_region():
+    # A bar spanning the whole domain starts at margin + inset, not inset.
+    svg = forest_bar(
+        1.0, 0.0, 2.0, domain=(0.0, 2.0), ref=0.0, color="#000", theme=DEFAULT, margin=18
+    )
+    assert 'x="21.00"' in svg
+
+
+def test_forest_axis_margin_spans_inner_region():
+    axis = forest_axis(domain=(0.0, 2.0), ref=0.0, fmt=Number(), theme=DEFAULT, margin=18)
+    assert 'x1="21"' in axis
+
+
 def test_forest_bar_survives_zero_width_domain():
     svg = forest_bar(1.0, 1.0, 1.0, domain=(1.0, 1.0), ref=0.0, color="#000", theme=DEFAULT)
     assert svg.startswith("<svg")