plotlet 0.6.0__tar.gz → 0.6.4__tar.gz

plotlet-0.6.4/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: plotlet
+Version: 0.6.4
+Summary: Python library for reproducible, multi-panel scientific figures, with byte-identical output across machines and an extension API for custom plot types.
+Author: gitbamboo42
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/gitbamboo42/plotlet
+Project-URL: Repository, https://github.com/gitbamboo42/plotlet
+Project-URL: Issues, https://github.com/gitbamboo42/plotlet/issues
+Keywords: plot,svg,scientific,visualization,jupyter,reproducible
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Classifier: Topic :: Multimedia :: Graphics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fonttools>=4.0
+Requires-Dist: scipy>=1.10
+Requires-Dist: resvg_py>=0.3
+Provides-Extra: dev
+Requires-Dist: jupyter; extra == "dev"
+Requires-Dist: nbconvert; extra == "dev"
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Requires-Dist: pandas; extra == "test"
+Provides-Extra: pdf
+Requires-Dist: cairosvg; extra == "pdf"
+Dynamic: license-file
+
+# plotlet
+
+plotlet is a Python library for reproducible, multi-panel scientific figures, built for AI authorship: figures are written, inspected, and verified as data, not pixels. Byte-identical output across machines, a standard plotting vocabulary, built-in Cartesian and circular coordinate systems, and an easy way to add your own plot types.
+
+## Documentation
+
+Online documentation is available at [gitbamboo42.github.io/plotlet](https://gitbamboo42.github.io/plotlet/).
+
+The docs include a [tutorial](https://gitbamboo42.github.io/plotlet/tutorial.html), a [plot-type reference](https://gitbamboo42.github.io/plotlet/reference.html), a [cookbook](https://gitbamboo42.github.io/plotlet/cookbook.html), an [extensions gallery](https://gitbamboo42.github.io/plotlet/extensions.html), [deep-dive guides](https://gitbamboo42.github.io/plotlet/docs-api.html), and a [page for AI agents](https://gitbamboo42.github.io/plotlet/agents.html).
+
+## Dependencies
+
+plotlet supports Python 3.10+.
+
+Required: `fonttools`, `scipy`, `resvg_py`. numpy / pandas / polars inputs work transparently.
+
+Optional: `cairosvg` for PDF export (`pip install plotlet[pdf]`).
+
+## Installation
+
+```bash
+pip install plotlet
+```
+
+## For AI assistants
+
+Tell your assistant to run plotlet's `skill()` and follow it. The guides, docs, and worked examples ship inside the installed package; the [page for AI agents](https://gitbamboo42.github.io/plotlet/agents.html) shows the full workflow.
+
+## Development
+
+Development takes place on GitHub. Please submit bugs to the issue tracker with a reproducible example.
+
+## License
+
+MIT

plotlet-0.6.4/README.md

@@ -0,0 +1,35 @@
+# plotlet
+
+plotlet is a Python library for reproducible, multi-panel scientific figures, built for AI authorship: figures are written, inspected, and verified as data, not pixels. Byte-identical output across machines, a standard plotting vocabulary, built-in Cartesian and circular coordinate systems, and an easy way to add your own plot types.
+
+## Documentation
+
+Online documentation is available at [gitbamboo42.github.io/plotlet](https://gitbamboo42.github.io/plotlet/).
+
+The docs include a [tutorial](https://gitbamboo42.github.io/plotlet/tutorial.html), a [plot-type reference](https://gitbamboo42.github.io/plotlet/reference.html), a [cookbook](https://gitbamboo42.github.io/plotlet/cookbook.html), an [extensions gallery](https://gitbamboo42.github.io/plotlet/extensions.html), [deep-dive guides](https://gitbamboo42.github.io/plotlet/docs-api.html), and a [page for AI agents](https://gitbamboo42.github.io/plotlet/agents.html).
+
+## Dependencies
+
+plotlet supports Python 3.10+.
+
+Required: `fonttools`, `scipy`, `resvg_py`. numpy / pandas / polars inputs work transparently.
+
+Optional: `cairosvg` for PDF export (`pip install plotlet[pdf]`).
+
+## Installation
+
+```bash
+pip install plotlet
+```
+
+## For AI assistants
+
+Tell your assistant to run plotlet's `skill()` and follow it. The guides, docs, and worked examples ship inside the installed package; the [page for AI agents](https://gitbamboo42.github.io/plotlet/agents.html) shows the full workflow.
+
+## Development
+
+Development takes place on GitHub. Please submit bugs to the issue tracker with a reproducible example.
+
+## License
+
+MIT

{plotlet-0.6.0 → plotlet-0.6.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "plotlet"
-version = "0.6.0"
+version = "0.6.4"
 description = "Python library for reproducible, multi-panel scientific figures, with byte-identical output across machines and an extension API for custom plot types."
 readme = "README.md"
 license = "MIT"
@@ -70,4 +70,8 @@ namespaces = true
 # draw/fonts/*.txt are the font licenses — DejaVu (Bitstream Vera–derived)
 # and Arimo (SIL OFL 1.1) both require the license text to accompany
 # redistribution, so they must ship in the wheel next to the TTFs.
-plotlet = ["spec.json", "themes/*.json", "draw/fonts/*.ttf", "draw/fonts/*.txt", "_datasets/*.csv"]
+plotlet = ["spec.json", "themes/*.json", "draw/fonts/*.ttf", "draw/fonts/*.txt", "_datasets/*.csv", "_datasets/*.npz",
+           # AI onboarding: pt.skill() reads skills/, and the guides point
+           # at the shipped docs/ and examples/ so an installed package is
+           # self-sufficient — no repo clone, no web access needed.
+           "skills/*.md", "docs/*.md", "examples/*.py"]

{plotlet-0.6.0 → plotlet-0.6.4}/src/plotlet/__init__.py

@@ -1,15 +1,17 @@
 """plotlet — pure-Python deferred-rendering SVG plot library.
 
     import plotlet as pt
+    from plotlet import aes
+
     c = pt.chart(df, title="...", xlabel="x", ylabel="y", legend=True, gridlines=True)
-    c.line(x="time", y="value", color="series")
+    c.add_line(aes(x="time", y="value", color="series"))
     c                         # auto-renders in Jupyter
 
 Chart methods chain for incremental composition:
 
     df = {"x": [1, 2, 3], "y": [1, 4, 9]}
     c = pt.chart()
-    c.line(df, x="x", y="y", label="squares")
+    c.add_line(df, aes(x="x", y="y"), label="squares")
     c.title("Hello").legend().gridlines(True)
     c
 """
@@ -17,21 +19,23 @@ from ._spec import SPEC
 from .draw import TAB10, palette, list_palettes
 from .draw import colormap, list_colormaps, register_colormap
 from . import artists  # noqa: F401  — registers built-in artists on import
-from .chart import Chart, Layout, chart, grid
-from .legend import legend
+from .record.chart import Chart, Layout, chart, grid
+from .utils import aes
+from .record.legend import legend
 from .registry import ArtistSpec, add_artist, artist_table, declare_coord_support
 from .sectors import Sectors
 from .layout_diagram import layout_diagram
 from .themes import load_theme, list_themes, register_theme
-from .facet import facet, FacetGrid
+from .record.facet import facet, FacetGrid
 from .datasets import load_dataset, list_datasets
 from .cluster import linkage, linkage_split, SplitTree
 from .formatters import (register_formatter, list_formatters,
                          superscript, subscript)
 from ._coord_registry import register_coord_codec
-from ._journal import (to_journal, from_journal, to_json, from_json,
+from .record.journal import (to_journal, from_journal, to_json, from_json,
                        JournalNode, Journal)
-from ._ir import to_ir, from_ir, resolve_ir, FigureIR, IRNode
+from .record.figure_ir import to_ir, from_ir, FigureIR, IRNode
+from .skill import skill
 from . import draw, utils
 
 
@@ -41,7 +45,7 @@ def __getattr__(name):
     # the render half loads on first render (or first touch of this
     # name). Enforced by tests/test_import_boundary.py.
     if name == "CircularCoordinate":
-        from .render.coordinates import CircularCoordinate
+        from .render._coord_circular import CircularCoordinate
         return CircularCoordinate
     raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
 
@@ -60,7 +64,8 @@ __all__ = ["chart", "Chart", "Layout", "SPEC", "TAB10",
            "superscript", "subscript",
            "to_json", "from_json", "register_coord_codec",
            "to_journal", "from_journal", "JournalNode", "Journal",
-           "to_ir", "from_ir", "FigureIR", "IRNode", "resolve_ir",
+           "to_ir", "from_ir", "FigureIR", "IRNode",
+           "skill",
            "draw", "utils"]
 
 # Single source of truth: pyproject.toml. importlib.metadata reads it at

{plotlet-0.6.0 → plotlet-0.6.4}/src/plotlet/_coord_registry.py

@@ -1,11 +1,16 @@
-"""Coord codec registry — a neutral home for the `class_name → class` map
-that both `serialize.py` and `_journal.py` need for round-tripping coord
-objects like `CircularCoordinate`.
+"""Coord codec registry — the `class_name → class` map behind
+`{"$coord": ...}` envelopes, for coord objects like
+`CircularCoordinate`.
 
-Lives here rather than in either consumer so that removing one of them
-later (e.g. retiring the JSON tree serializer once the journal covers
-the same ground) doesn't leave the registry orphaned. The public API
-`plotlet.register_coord_codec` re-exports from this module directly.
+`record/journal.py` encodes a coord object to its class name;
+`_json_layer._decode` turns the name back into the class via
+`resolve_coord`, which imports the built-in coord module on the first
+miss so cold processes decode without a prior render. The render half
+reads the map too (`render/_validate.py` cross-checks the `container`
+flag, `render/resolved_ir.py` rehydrates coords), so the registry sits
+at the package root, where `record/` and `render/` may both import it.
+The public API `plotlet.register_coord_codec` re-exports from this
+module directly.
 """
 from __future__ import annotations
 
@@ -38,7 +43,7 @@ def resolve_coord(name: str) -> type:
         return _COORD_REGISTRY[name]
     except KeyError:
         pass
-    from .render import coordinates  # noqa: F401 — registers built-ins
+    from .render import _coord_circular  # noqa: F401 — registers built-ins
     try:
         return _COORD_REGISTRY[name]
     except KeyError:

{plotlet-0.6.0 → plotlet-0.6.4}/src/plotlet/_json_layer.py

@@ -1,16 +1,23 @@
-"""JSON layer for Journal.
+"""JSON envelope layer — shared by `record/` and `render/`.
 
 Envelopes Python values that aren't JSON-native (tuple, set, date,
-datetime, dicts with non-string keys, DataFrameLite) so a Journal can
-be dumped through `json.dumps` and rehydrated. Kept out of `_journal.py`
-so the journal core has no coupling — the journal is an event log; JSON
-support is a separate concern.
+datetime, dicts with non-string keys, DataFrameLite) so they can be
+dumped through `json.dumps` and rehydrated. Four consumers: the
+journal's JSON form (`record/journal.py`), the FigureIR wire format
+(`record/figure_ir.py`), value-envelope decoding at render hydration
+(`_decode`, `render/_nodes.py`), and the resolved IR's debug view
+(`render/resolved_ir.py`). It sits at the package root because both
+`record/` and `render/` need it and neither may import the other
+(`tests/test_import_boundary.py`). It also keeps JSON support out of
+`journal.py` itself — the journal stays a plain event log.
 
-DataFrame-shaped and numpy inputs never reach this layer: they're
-normalized to `DataFrameLite` / plain lists at the recorder boundary
-in `chart.py` (via `utils._normalize_data`). So the JSON layer is
-data-library-neutral by construction — it never imports pandas or
-numpy, never grows a branch per data library.
+DataFrame-shaped inputs never reach this layer: they're normalized to
+`DataFrameLite` / plain lists at the recorder boundary in
+`record/chart.py` (via `utils._normalize_data`), so it never imports
+pandas or grows a branch per data library. numpy is the one exception:
+a matrix artist's data rides through record as a 2-D ndarray (numpy is
+a guaranteed dependency, via scipy), and `json_safe` lowers it to
+nested lists — the JSON wire format itself carries no array types.
 
 Envelope keys used here:
     $dataframe    utils.DataFrameLite (canonical DataFrame form)
@@ -23,15 +30,17 @@ Envelope keys used here:
     $dict_pairs   dict whose keys aren't all JSON-native strings
 
 `_decode` at the bottom handles the other envelope family — the
-*reference* envelopes ($node / $coord / $sectors) that journals and IRs
-carry whether or not they ever touch JSON. It lives here because both
-halves need it (the render tree's hydrator and the front half's facet
-expansion) and it resolves only against shared vocabulary.
+*reference* envelopes ($node / $coord / $sectors / $data) that journals
+and IRs carry whether or not they ever touch JSON. It lives here because
+both halves need it (the render tree's hydrator and the front half's
+facet expansion) and it resolves only against shared vocabulary.
 """
 from __future__ import annotations
 from typing import Any
 
-from .utils import DataFrameLite
+import numpy as np
+
+from .utils import DataFrameLite, all_primitive
 
 
 def json_safe(value: Any) -> Any:
@@ -63,6 +72,12 @@ def json_safe(value: Any) -> Any:
         # values that never passed through the journal emitter, e.g. a
         # resolved-IR state dict.
         return {"$sectors": json_safe(value._to_dict())}
+    if isinstance(value, np.ndarray):
+        # A matrix artist's data section entry. The wire format stays
+        # plain nested lists — identical JSON whether the matrix came
+        # in as an array or as lists. Recursing catches the rare
+        # object-dtype cell.
+        return json_safe(value.tolist())
     if isinstance(value, tuple):
         return {"$tuple": [json_safe(v) for v in value]}
     if isinstance(value, (set, frozenset)):
@@ -78,6 +93,11 @@ def json_safe(value: Any) -> Any:
         return {"$dict_pairs": [[json_safe(k), json_safe(v)]
                                 for k, v in value.items()]}
     if isinstance(value, list):
+        # Bulk numeric rows are already JSON-native — one flat scan
+        # instead of per-cell recursion (same bail-out in json_hydrate,
+        # _decode, and the journal/IR walkers).
+        if all_primitive(value):
+            return list(value)
         return [json_safe(v) for v in value]
     return value
 
@@ -110,35 +130,50 @@ def json_hydrate(value: Any) -> Any:
                     for k, v in value["$dict_pairs"]}
         return {k: json_hydrate(v) for k, v in value.items()}
     if isinstance(value, list):
+        if all_primitive(value):
+            return list(value)
         return [json_hydrate(v) for v in value]
     return value
 
 
-def _decode(value: Any, nid_to_node: dict) -> Any:
+def _decode(value: Any, nid_to_node: dict, data_table: dict) -> Any:
     """Resolve plotlet's *reference* envelopes back to live objects —
     `{"$node"}` via `nid_to_node`, `{"$coord"}` via the coord registry,
-    `{"$sectors"}` via `Sectors`. Containers recurse; everything else
-    passes through.
+    `{"$sectors"}` via `Sectors`, `{"$data"}` via `data_table` (the
+    Journal's / FigureIR's data section). Containers recurse; everything
+    else passes through.
 
     Distinct from `json_hydrate` above: that undoes the JSON-native
-    envelopes at the JSON boundary, while these three envelopes live in
-    journals and IRs whether or not they ever touch JSON, and decode at
-    hydration time. Shared vocabulary — used by the render tree's
+    envelopes at the JSON boundary, while these reference envelopes live
+    in journals and IRs whether or not they ever touch JSON, and decode
+    at hydration time. Shared vocabulary — used by the render tree's
     hydrator (`render.hydrate`) and by the facet expansion in
-    `_ir.py`."""
+    `record/figure_ir.py`."""
     if isinstance(value, dict):
         if "$node" in value and len(value) == 1:
             return nid_to_node[value["$node"]]
+        if "$data" in value and len(value) == 1:
+            return data_table[value["$data"]]
         if "$coord" in value:
             from ._coord_registry import resolve_coord
             cls = resolve_coord(value["$coord"])
-            return cls._from_dict(_decode(value.get("kwargs", {}), nid_to_node))
+            return cls._from_dict(
+                _decode(value.get("kwargs", {}), nid_to_node, data_table))
         if "$sectors" in value:
             from .sectors import Sectors
-            return Sectors._from_dict(_decode(value["$sectors"], nid_to_node))
-        return {k: _decode(v, nid_to_node) for k, v in value.items()}
+            return Sectors._from_dict(
+                _decode(value["$sectors"], nid_to_node, data_table))
+        if "$aes" in value and len(value) == 1:
+            from .utils import Aes
+            return Aes(value["$aes"])
+        return {k: _decode(v, nid_to_node, data_table)
+                for k, v in value.items()}
     if isinstance(value, list):
-        return [_decode(v, nid_to_node) for v in value]
+        if all_primitive(value):
+            return list(value)
+        return [_decode(v, nid_to_node, data_table) for v in value]
     if isinstance(value, tuple):
-        return tuple(_decode(v, nid_to_node) for v in value)
+        if all_primitive(value):
+            return value
+        return tuple(_decode(v, nid_to_node, data_table) for v in value)
     return value

{plotlet-0.6.0 → plotlet-0.6.4}/src/plotlet/_regions.py

@@ -15,7 +15,9 @@ The mechanism enforces this:
     When set, the primitive records its bbox under that name. When
     unset (the default), nothing is recorded — so artist `draw()`
     bodies, which never pass `tag=`, produce no regions for free.
-  * Central code (`core.py`, `legend.py`) passes `tag="title"` /
+  * Central code (`render/_chrome_emit.py`, `render/emit.py`,
+    `render/_legend.py`)
+    passes `tag="title"` /
     `"spine"` / `"tick-x"` / `"legend-text"` etc. at the chrome
     emission sites. The tag is right there in the call, grep-able,
     no contextvar magic.
@@ -85,7 +87,9 @@ _CURRENT: contextvars.ContextVar = contextvars.ContextVar(
 def record(kind: str, bbox, *, name: str, **meta) -> None:
     """Record a region into the active sink, if any. Called by
     `draw.*` primitives when they receive a `tag=` kwarg, and by
-    central code (`core.py`, `legend.py`) for chrome that has no
+    central code (`render/_chrome_emit.py`, `render/emit.py`,
+    `render/_legend.py`)
+    for chrome that has no
     primitive call to wrap (panel boundary, canonical legend swatch).
     No-op when no sink is active — the common render path."""
     sink = _CURRENT.get()

{plotlet-0.6.0 → plotlet-0.6.4}/src/plotlet/_tree.py

@@ -3,7 +3,7 @@
 Both halves walk the same tree shape — the recording side at
 validation time (over `Chart` / `Layout`), the render side when
 deriving field state and building share classes (over the render
-nodes in `_render_nodes.py`). The protocol is structural:
+nodes in `render/_nodes.py`). The protocol is structural:
 `_is_parent`, `_children`, `_effective_children()`, `_layout_kind`,
 `_grid_rows` / `_grid_cols`, `_leaf_kind`, and the `_attached_*`
 lists. Nothing here imports either half.

{plotlet-0.6.0 → plotlet-0.6.4}/src/plotlet/artists/__init__.py

@@ -5,10 +5,11 @@ group mirror pairs or shared-machinery siblings — consolidation only
 where the related artists share enough structure to earn it.
 
 Single-artist files (one plot type each):
-  scatter, line, bar, hist, imshow, heatmap, dendrogram, errorbar
+  scatter, line, bar, hist, image_cmap, image_rgba, heatmap, dendrogram, errorbar
   boxplot, violin, swarm, strip
   pointplot, ecdf, rug, density_1d, regression, kde_2d, hexbin, hist2d
-  freqpoly, contour, ridge, qq
+  freqpoly, contour, ridge, qq, numeric_bar, annotation_strip
+  chord_links, chord_ribbon
 
 Category files (closely-related artists grouped):
   references — axhline, axvline, axhspan, axvspan, hlines, vlines
@@ -25,7 +26,8 @@ from . import scatter      # noqa: F401
 from . import line         # noqa: F401
 from . import bar          # noqa: F401
 from . import hist         # noqa: F401
-from . import imshow       # noqa: F401
+from . import image_cmap   # noqa: F401
+from . import image_rgba   # noqa: F401
 from . import heatmap      # noqa: F401
 from . import dendrogram   # noqa: F401
 from . import errorbar     # noqa: F401
@@ -45,6 +47,10 @@ from . import freqpoly     # noqa: F401
 from . import contour      # noqa: F401
 from . import ridge        # noqa: F401
 from . import qq           # noqa: F401
+from . import numeric_bar      # noqa: F401
+from . import annotation_strip # noqa: F401
+from . import chord_links      # noqa: F401
+from . import chord_ribbon     # noqa: F401
 
 # Category files
 from . import references   # noqa: F401

{plotlet-0.6.0 → plotlet-0.6.4}/src/plotlet/artists/_shared.py

@@ -3,13 +3,158 @@
 Each built-in artist registers one of the `*_legend_entries` functions so
 the legend dispatch in `_render_inner` can stay generic — no type-string matching.
 Paint logic is a nested closure; there are no shared swatch helpers.
+
+The `pool_*` / `rgb_buffer` helpers back the PNG-embedded raster paths of
+image_cmap / image_rgba and heatmap: a grid denser than the display can show is box-pooled
+down before encoding. All pooling rules are deterministic (fixed bin
+edges, fixed iteration order, first-seen tie-breaks), so the
+byte-identical-SVG guarantee holds.
 """
-from .._spec import _LEGSPEC
+import math
+
+import numpy as np
+
+from .._spec import _LEGSPEC, _D
 from ..draw import marker, segment, rect
 from ..draw import TAB10
 from ..utils import to_list, resolve_aes, palette_color
 
 
+def pool_target(n_cells, px):
+    """Output-pixel count along one raster axis: full data resolution
+    until cells outnumber `raster_oversample` per display pixel, then
+    capped at that. The oversample headroom keeps hi-dpi rendering and
+    moderate zoom sharp; past it the viewer can't show the extra cells
+    anyway, and its nearest-neighbour downscale would *subsample* them
+    (drop cells) where pooling summarizes them."""
+    cap = max(1, math.ceil(px * _D["raster_oversample"]))
+    return n_cells if n_cells <= cap else cap
+
+
+def pool_mean(values):
+    """NaN/None-ignoring mean of one pooling bin; an all-absent bin → NaN
+    (renders as the artist's absent color, like a NaN cell)."""
+    fin = [v for v in values if v is not None and v == v]
+    if not fin:
+        return float("nan")
+    return sum(fin) / len(fin)
+
+
+def pool_mode(values):
+    """Most frequent value in one pooling bin, for categorical cells
+    (a mean of category labels is meaningless). NaN folds into None —
+    both render as absent. Ties break to the first-seen value."""
+    counts = {}
+    for v in values:
+        if isinstance(v, float) and v != v:
+            v = None
+        counts[v] = counts.get(v, 0) + 1
+    return max(counts.items(), key=lambda kv: kv[1])[0]
+
+
+def pool_grid(matrix, out_h, out_w, pool):
+    """Box-pool a `[row][col]` grid down to `out_h × out_w`. Bin edges by
+    integer rounding; every bin is non-empty because `out_* <= n_*`."""
+    nrows = len(matrix)
+    ncols = len(matrix[0])
+    re = [nrows * i // out_h for i in range(out_h + 1)]
+    ce = [ncols * j // out_w for j in range(out_w + 1)]
+    return [[pool([matrix[r][c]
+                   for r in range(re[i], re[i + 1])
+                   for c in range(ce[j], ce[j + 1])])
+             for j in range(out_w)]
+            for i in range(out_h)]
+
+
+def rgb_buffer(grid, rgb_of):
+    """Flatten a `[row][col]` value grid into a packed RGB byte buffer
+    via `rgb_of(value) -> (r, g, b)` — the input `image_png` expects."""
+    buf = bytearray()
+    for row in grid:
+        for v in row:
+            r, g, b = rgb_of(v)
+            buf.append(r); buf.append(g); buf.append(b)
+    return buf
+
+
+def minmax_grid(d, lo, hi):
+    """NaN/None-ignoring min/max over a 2-D cell grid, for autoscale.
+    Fills only the unset bounds; returns `(lo, hi, found)` where `found`
+    says whether any finite cell existed (callers keep their empty-grid
+    defaults). Vectorized — min/max are comparisons, not arithmetic, so
+    the result is exact; a ±0.0 tie canonicalizes to +0.0 (`x + 0.0`)
+    so it can't depend on scan order. Non-numeric cells fall back to
+    the scalar scan."""
+    try:
+        a = np.asarray(d, dtype=np.float64)     # None cells → NaN
+    except (TypeError, ValueError):
+        flat = [v for row in d for v in row if v is not None and v == v]
+        if flat:
+            if lo is None: lo = min(flat)
+            if hi is None: hi = max(flat)
+        return lo, hi, bool(flat)
+    if bool(np.isnan(a).all()):
+        return lo, hi, False
+    if lo is None: lo = float(np.nanmin(a)) + 0.0
+    if hi is None: hi = float(np.nanmax(a)) + 0.0
+    return lo, hi, True
+
+
+def _pool_mean_np(a, out_h, out_w):
+    """`pool_grid(..., pool_mean)` vectorized: box-pool a 2-D float
+    array to `out_h × out_w` by NaN-ignoring mean.
+
+    Bit-identical to the scalar path by construction: cells are added
+    in the same row-major order (vectorized *across* bins, sequential
+    *within* each bin via the offset loop), NaN adds 0.0 — exact, since
+    `x + 0.0 == x` — and one final division mirrors `sum(fin)/len(fin)`.
+    Only elementwise ops: `np.sum`/`np.mean` pairwise summation is a
+    numpy implementation detail that may change across versions, which
+    would break byte-identical SVG across machines."""
+    nrows, ncols = a.shape
+    re = np.array([nrows * i // out_h for i in range(out_h + 1)])
+    ce = np.array([ncols * j // out_w for j in range(out_w + 1)])
+    r0, rl = re[:-1], np.diff(re)
+    c0, cl = ce[:-1], np.diff(ce)
+    valid = ~np.isnan(a)
+    vals = np.where(valid, a, 0.0)
+    acc = np.zeros((out_h, out_w))
+    cnt = np.zeros((out_h, out_w), dtype=np.int64)
+    for dr in range(int(rl.max())):
+        ri = np.nonzero(dr < rl)[0]
+        row_v = vals[r0[ri] + dr]       # gather rows once per offset
+        row_m = valid[r0[ri] + dr]
+        for dc in range(int(cl.max())):
+            ci = np.nonzero(dc < cl)[0]
+            dst = np.ix_(ri, ci)
+            acc[dst] += row_v[:, c0[ci] + dc]
+            cnt[dst] += row_m[:, c0[ci] + dc]
+    return np.divide(acc, cnt, out=np.full((out_h, out_w), np.nan),
+                     where=cnt > 0)
+
+
+def png_value_cells(rows, out_h, out_w, norm, lut, absent_rgb):
+    """Vectorized pool + colormap for a numeric cell grid → `(rgb_bytes,
+    downsampled)`, or None when the norm only has a scalar form (log) —
+    the caller then falls back to `pool_grid` + `rgb_buffer`. `rows` is
+    a nested list (None/NaN cells → absent color) or a 2-D ndarray."""
+    if norm.kind == "log":
+        return None
+    a = np.asarray(rows, dtype=np.float64)      # None cells → NaN
+    downsampled = (out_h, out_w) != a.shape
+    if downsampled:
+        a = _pool_mean_np(a, out_h, out_w)
+    u = norm.to_unit_array(a)
+    nan_mask = np.isnan(u)
+    # Same rounding as the scalar `int(u * 255 + 0.5)`: values are
+    # >= 0 after clipping, so trunc-toward-zero == floor.
+    idx = (np.where(nan_mask, 0.0, u) * 255.0 + 0.5).astype(np.int64)
+    rgb = np.frombuffer(bytes(lut), dtype=np.uint8).reshape(256, 3)[idx]
+    if nan_mask.any():
+        rgb[nan_mask] = absent_rgb
+    return rgb.tobytes(), downsampled
+
+
 # Used by long-form expansion for `linestyle=` and `alpha=` column splits.
 LINESTYLE_CYCLE = (None, "--", ":", "-.")
 DEFAULT_ALPHA_RANGE = (0.3, 1.0)
@@ -104,6 +249,11 @@ def expand_xy_long_form(kind, data, x_col, y_col,
         elif alpha_value is not None:
             opts["alpha"] = alpha_value
         records.append({"type": kind, "xs": xs_g, "ys": ys_g, "opts": opts})
+    # The raster/simplify thresholds gate on the artist call's total mark
+    # count, not each fan-out slice — ten 10k-point groups strain the
+    # renderer exactly like one 100k-point series.
+    for rec in records:
+        rec["opts"]["_fanout_n"] = n
     return records