jarvisplot 2.1.4__tar.gz → 2.1.6__tar.gz

{jarvisplot-2.1.4 → jarvisplot-2.1.6}/JarvisPLOT.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: JarvisPLOT
-Version: 2.1.4
+Version: 2.1.6
 Summary: Jarvis-PLOT: YAML-driven plotting engine
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -161,11 +161,20 @@ The loop `jplot man` prints is:
 5. `jplot <file>` — render, only when the figure itself is needed.
 
 `jplot man --json` is the machine-readable manual: 15 topics, plus a
-live page for every one of the 28 layer methods and 11 transform steps
-(`jplot man scatter`, `jplot man transform.profile`). Method contracts come from
+live pages for every registered layer method and transform step
+(`jplot man scatter`, `jplot man transform.profile`, `jplot man PDF1D`). Method contracts come from
 the same registry `jplot cap methods` reads, so a man page cannot drift from the
 code.
 
+For continuous one-dimensional distributions from raw samples, use `PDF1D`
+(CDF plus PDF) or `CDF1D` in a data transform. `coordinates.x` owns `expr`,
+`lim`, and `grid`; optional `repeat` computes independent batch means and
+standard deviations. See [the contract](docs/specs/PDF_CDF_1D.md) and the
+[runnable example](Example/pdf_cdf_1d.yaml).
+Reconstruction defaults to adaptive true CDF anchors and `monotone_c2`
+interpolation (C2 CDF / C1 PDF). Set `anchors: all` and `interpolation: pchip`
+to reproduce the original all-node reconstruction.
+
 Two things worth knowing before trusting a config:
 
 - `jplot validate` checks shape and contracts and never touches the data;

{jarvisplot-2.1.4 → jarvisplot-2.1.6}/JarvisPLOT.egg-info/SOURCES.txt

@@ -22,6 +22,7 @@ jarvisplot/core.py
 jarvisplot/core_assets.py
 jarvisplot/core_runtime.py
 jarvisplot/data_access.py
+jarvisplot/data_generation_contracts.py
 jarvisplot/data_loader.py
 jarvisplot/data_loader_hdf5.py
 jarvisplot/data_loader_runtime.py
@@ -29,10 +30,12 @@ jarvisplot/data_loader_summary.py
 jarvisplot/dataset_types.py
 jarvisplot/diagnostic_guidance.py
 jarvisplot/diagnostics.py
+jarvisplot/distribution_1d_config.py
 jarvisplot/dryrun_runtime.py
 jarvisplot/expr_names.py
 jarvisplot/fix_apply.py
 jarvisplot/flowchart.py
+jarvisplot/generated_data.py
 jarvisplot/inner_func.py
 jarvisplot/man_catalog.py
 jarvisplot/man_methods.py
@@ -51,6 +54,7 @@ jarvisplot/yaml_io.py
 jarvisplot/Figure/__init__.py
 jarvisplot/Figure/adapters_rect.py
 jarvisplot/Figure/adapters_ternary.py
+jarvisplot/Figure/adaptive_cdf_runtime.py
 jarvisplot/Figure/bin_stat_runtime.py
 jarvisplot/Figure/colorbar_runtime.py
 jarvisplot/Figure/config_runtime.py
@@ -63,6 +67,7 @@ jarvisplot/Figure/data_pipelines.py
 jarvisplot/Figure/debug_config.py
 jarvisplot/Figure/density_cell_runtime.py
 jarvisplot/Figure/design_runtime.py
+jarvisplot/Figure/distribution_1d_runtime.py
 jarvisplot/Figure/dynesty_runtime.py
 jarvisplot/Figure/figure.py
 jarvisplot/Figure/figure_types.py
@@ -121,6 +126,8 @@ jarvisplot/manual_cards/data-columns.yaml
 jarvisplot/manual_cards/debug-overlay.yaml
 jarvisplot/manual_cards/diagnostics.yaml
 jarvisplot/manual_cards/dryrun-viz.yaml
+jarvisplot/manual_cards/field-interp.yaml
+jarvisplot/manual_cards/generated-data.yaml
 jarvisplot/manual_cards/layer-method.yaml
 jarvisplot/manual_cards/manifest.yaml
 jarvisplot/manual_cards/method_notes.yaml
@@ -135,7 +142,9 @@ jarvisplot/schema/manifest.json
 jarvisplot/schema/plot-config.json
 jarvisplot/schema/core/common.json
 jarvisplot/schema/core/dataset.json
+jarvisplot/schema/core/distribution-1d.json
 jarvisplot/schema/core/figure.json
+jarvisplot/schema/core/generated-data.json
 jarvisplot/schema/core/layer.json
 jarvisplot/schema/core/transform.json
 jarvisplot/schema/methods/bar.json
@@ -185,6 +194,7 @@ jarvisplot/verbs/man.py
 jarvisplot/verbs/suggest.py
 jarvisplot/verbs/template.py
 jarvisplot/verbs/validate.py
+tests/test_adaptive_cdf.py
 tests/test_agent_digest.py
 tests/test_agent_envelope.py
 tests/test_axis_title.py
@@ -210,6 +220,7 @@ tests/test_debug_yaml_override.py
 tests/test_density_cell_transform.py
 tests/test_design_runtime.py
 tests/test_diagnostic_guidance.py
+tests/test_distribution_1d_transform.py
 tests/test_docs_status_labels.py
 tests/test_doctor_partial.py
 tests/test_explain.py
@@ -217,6 +228,7 @@ tests/test_figure_contracts.py
 tests/test_figure_type_expander.py
 tests/test_fix_application.py
 tests/test_flowchart_renderer.py
+tests/test_generated_data.py
 tests/test_imshow_adapter.py
 tests/test_interp_2d_transform.py
 tests/test_interp_natural_neighbor.py

{jarvisplot-2.1.4 → jarvisplot-2.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: JarvisPLOT
-Version: 2.1.4
+Version: 2.1.6
 Summary: Jarvis-PLOT: YAML-driven plotting engine
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -161,11 +161,20 @@ The loop `jplot man` prints is:
 5. `jplot <file>` — render, only when the figure itself is needed.
 
 `jplot man --json` is the machine-readable manual: 15 topics, plus a
-live page for every one of the 28 layer methods and 11 transform steps
-(`jplot man scatter`, `jplot man transform.profile`). Method contracts come from
+live pages for every registered layer method and transform step
+(`jplot man scatter`, `jplot man transform.profile`, `jplot man PDF1D`). Method contracts come from
 the same registry `jplot cap methods` reads, so a man page cannot drift from the
 code.
 
+For continuous one-dimensional distributions from raw samples, use `PDF1D`
+(CDF plus PDF) or `CDF1D` in a data transform. `coordinates.x` owns `expr`,
+`lim`, and `grid`; optional `repeat` computes independent batch means and
+standard deviations. See [the contract](docs/specs/PDF_CDF_1D.md) and the
+[runnable example](Example/pdf_cdf_1d.yaml).
+Reconstruction defaults to adaptive true CDF anchors and `monotone_c2`
+interpolation (C2 CDF / C1 PDF). Set `anchors: all` and `interpolation: pchip`
+to reproduce the original all-node reconstruction.
+
 Two things worth knowing before trusting a config:
 
 - `jplot validate` checks shape and contracts and never touches the data;

{jarvisplot-2.1.4 → jarvisplot-2.1.6}/README.md

@@ -139,11 +139,20 @@ The loop `jplot man` prints is:
 5. `jplot <file>` — render, only when the figure itself is needed.
 
 `jplot man --json` is the machine-readable manual: 15 topics, plus a
-live page for every one of the 28 layer methods and 11 transform steps
-(`jplot man scatter`, `jplot man transform.profile`). Method contracts come from
+live pages for every registered layer method and transform step
+(`jplot man scatter`, `jplot man transform.profile`, `jplot man PDF1D`). Method contracts come from
 the same registry `jplot cap methods` reads, so a man page cannot drift from the
 code.
 
+For continuous one-dimensional distributions from raw samples, use `PDF1D`
+(CDF plus PDF) or `CDF1D` in a data transform. `coordinates.x` owns `expr`,
+`lim`, and `grid`; optional `repeat` computes independent batch means and
+standard deviations. See [the contract](docs/specs/PDF_CDF_1D.md) and the
+[runnable example](Example/pdf_cdf_1d.yaml).
+Reconstruction defaults to adaptive true CDF anchors and `monotone_c2`
+interpolation (C2 CDF / C1 PDF). Set `anchors: all` and `interpolation: pchip`
+to reproduce the original all-node reconstruction.
+
 Two things worth knowing before trusting a config:
 
 - `jplot validate` checks shape and contracts and never touches the data;

{jarvisplot-2.1.4 → jarvisplot-2.1.6}/jarvisplot/Figure/adapters_rect.py

@@ -12,7 +12,11 @@ from matplotlib.collections import PolyCollection
 #
 from .helper import _auto_clip, _mask_by_extend, voronoi_finite_polygons_2d, _clip_poly_to_rect
 from .profile_runtime import grid_from_metadata, regular_grid_mesh
-from .interp_natural_neighbor import resolve_backend
+from .interp_natural_neighbor import (
+    drawing_backend_options,
+    log_backend_diagnostics,
+    resolve_backend,
+)
 from .posterior_hpd import prepare_hpd_contour_style
 
 DEFAULT_JP_SAMPLE_GRID = 500
@@ -242,8 +246,9 @@ class StdAxesAdapter:
         ny: Optional[int] = None,
         xlim=None,
         ylim=None,
-        nan_policy: str = "strict",
+        nan_policy: str = "ignore",
         backend_options: Optional[dict[str, Any]] = None,
+        logger=None,
     ):
         x = np.asarray(x, dtype=float).reshape(-1)
         y = np.asarray(y, dtype=float).reshape(-1)
@@ -273,8 +278,9 @@ class StdAxesAdapter:
             X,
             Y,
             nan_policy=nan_policy,
-            backend_options=backend_options,
+            backend_options=drawing_backend_options(backend_options),
         )
+        log_backend_diagnostics(logger, getattr(backend, "last_diagnostics", None))
         return X, Y, np.asarray(Z, dtype=float)
 
     def _build_jpcontour_grid(
@@ -322,9 +328,10 @@ class StdAxesAdapter:
         ny: Optional[int] = None,
         xlim=None,
         ylim=None,
-        nan_policy: str = "strict",
+        nan_policy: str = "ignore",
         diagnostics: bool = False,
         backend_options: Optional[dict[str, Any]] = None,
+        logger=None,
     ):
         """Interpolate scattered data on an axes-fraction grid for contour rendering.
 
@@ -361,8 +368,9 @@ class StdAxesAdapter:
             Y,
             nan_policy=nan_policy,
             diagnostics=diagnostics,
-            backend_options=backend_options,
+            backend_options=drawing_backend_options(backend_options),
         )
+        log_backend_diagnostics(logger, getattr(backend, "last_diagnostics", None))
         return X, Y, np.asarray(Z, dtype=float)
 
     # —— Common method forwarding (add as needed) ——
@@ -518,12 +526,18 @@ class StdAxesAdapter:
         ny: Optional[int] = None,
         xlim=None,
         ylim=None,
-        nan_policy: str = "strict",
+        nan_policy: str = "ignore",
         diagnostics: bool = False,
         backend_options: Optional[dict[str, Any]] = None,
         **kwargs,
     ):
-        """Scattered-data contour plot rendered in axes-fraction coordinates."""
+        """Scattered-data contour plot rendered in axes-fraction coordinates.
+
+        ``nan_policy`` defaults to ``ignore`` here: a sample whose z is NaN --
+        an empty profile-likelihood cell, say -- is not a measurement, and
+        letting it propagate would blank the cells around it as well. Pass
+        ``nan_policy="strict"`` to keep those neighbourhoods masked instead.
+        """
         kw = self._merge("contour", kwargs)
         kw.pop("transform", None)
         logger = kw.pop("_logger", None)
@@ -540,6 +554,7 @@ class StdAxesAdapter:
             nan_policy=nan_policy,
             diagnostics=diagnostics,
             backend_options=backend_options,
+            logger=logger,
         )
         kw = prepare_hpd_contour_style(Z, X, Y, kw, logger=logger)
         label_map = kw.pop("_hpd_label_map", None)
@@ -570,7 +585,7 @@ class StdAxesAdapter:
         ny: Optional[int] = None,
         xlim=None,
         ylim=None,
-        nan_policy: str = "strict",
+        nan_policy: str = "ignore",
         diagnostics: bool = False,
         backend_options: Optional[dict[str, Any]] = None,
         **kwargs,
@@ -578,6 +593,7 @@ class StdAxesAdapter:
         """Filled scattered-data contour plot rendered in axes-fraction coordinates."""
         kw = self._merge("contourf", kwargs)
         kw.pop("transform", None)
+        logger = kw.pop("_logger", None)
         X, Y, Z = self._interpolate_jpcontour_grid(
             x,
             y,
@@ -591,6 +607,7 @@ class StdAxesAdapter:
             nan_policy=nan_policy,
             diagnostics=diagnostics,
             backend_options=backend_options,
+            logger=logger,
         )
         artists = self.ax.contourf(
             X,
@@ -614,7 +631,7 @@ class StdAxesAdapter:
         ny: Optional[int] = None,
         xlim=None,
         ylim=None,
-        nan_policy: str = "strict",
+        nan_policy: str = "ignore",
         backend_options: Optional[dict[str, Any]] = None,
         shading: str = "auto",
         **kwargs,
@@ -633,6 +650,7 @@ class StdAxesAdapter:
             kw.pop(k, None)
         kw.pop("shading", None)
         kw.pop("transform", None)
+        logger = kw.pop("_logger", None)
         X, Y, Z = self._interpolate_jpfield_grid(
             x,
             y,
@@ -645,6 +663,7 @@ class StdAxesAdapter:
             ylim=ylim,
             nan_policy=nan_policy,
             backend_options=backend_options,
+            logger=logger,
         )
         X = np.asarray(X, dtype=float)
         Y = np.asarray(Y, dtype=float)

jarvisplot-2.1.6/jarvisplot/Figure/adaptive_cdf_runtime.py

@@ -0,0 +1,131 @@
+"""Adaptive empirical-CDF anchors and a local, monotone C2 quintic interpolant.
+
+No bins, kernels, or nonlinear solver. The quartic PDF is represented in the
+Bernstein basis; nonnegative coefficients certify nonnegativity on each whole
+interval, rather than only at sampled output points.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from heapq import heappop, heappush
+
+import numpy as np
+from scipy.interpolate import BPoly, CubicSpline, PchipInterpolator
+
+from ..distribution_1d_config import AnchorSettings
+
+
+def monotone_c2(x: np.ndarray, y: np.ndarray) -> BPoly:
+    """Exact C2 Hermite quintics with locally limited slopes and curvatures.
+
+    On an interval of width h and secant m, the quartic derivative's Bernstein
+    coefficients are [d0, d0+h*a0/4, 5*m-2*(d0+d1)+h*(a1-a0)/4,
+    d1-h*a1/4, d1]. Limit curvatures first, then shrink each node's (d,a)
+    together so all five coefficients are nonnegative. Each shared node has
+    one value, slope, and curvature: the assembled CDF is C2 and PDF is C1.
+    The support endpoints have zero slope/curvature, allowing constant CDF
+    extension and zero PDF extension without a boundary derivative jump.
+    """
+    x, y = np.asarray(x, dtype=float), np.asarray(y, dtype=float)
+    if x.ndim != 1 or len(x) < 2 or y.shape != x.shape or not np.all(np.isfinite(x)) or not np.all(np.isfinite(y)):
+        raise ValueError("monotone_c2 needs matching finite 1D anchor arrays")
+    h, mass = np.diff(x), np.diff(y)
+    if np.any(h <= 0) or np.any(mass < 0):
+        raise ValueError("monotone_c2 requires strictly increasing x and nondecreasing CDF anchors")
+    # A clamped cubic estimates smooth slopes/curvatures in linear time. Its
+    # unconstrained interpolant is never returned: the quintic limiter below
+    # certifies monotonicity even where the cubic estimate would overshoot.
+    seed = CubicSpline(x, y, bc_type=((1, 0.0), (1, 0.0)))
+    slopes = np.maximum(seed(x, 1), 0.0)
+    slopes[[0, -1]] = 0.0
+    curvature = seed(x, 2)
+    # Adjacent interval constraints for the first/last PDF control coefficients.
+    lower, upper = np.full(len(x), -np.inf), np.full(len(x), np.inf)
+    lower[:-1] = -4 * slopes[:-1] / h
+    upper[1:] = 4 * slopes[1:] / h
+    curvature = np.clip(curvature, lower, upper)
+    curvature[[0, -1]] = 0.0
+    # Both contributions are nonnegative after clipping. Reducing either node
+    # cannot violate another interval's constraint, so one local pass suffices.
+    left = 2 * slopes[:-1] + h * curvature[:-1] / 4
+    right = 2 * slopes[1:] - h * curvature[1:] / 4
+    available = 5 * mass / h
+    total = left + right
+    factors = np.ones(len(h))
+    active = total > available
+    factors[active] = (available[active] / total[active]) * (1 - 32 * np.finfo(float).eps)
+    node_factors = np.ones(len(x))
+    node_factors[:-1] = np.minimum(node_factors[:-1], factors)
+    node_factors[1:] = np.minimum(node_factors[1:], factors)
+    slopes *= node_factors
+    curvature *= node_factors
+    if not np.all(np.isfinite(slopes)) or not np.all(np.isfinite(curvature)):
+        raise ValueError("monotone_c2 cannot resolve this anchor spacing; inspect support and score precision")
+    return BPoly.from_derivatives(x, np.column_stack((y, slopes, curvature)), extrapolate=False)
+
+
+def interpolate_cdf(x: np.ndarray, y: np.ndarray, method: str):
+    if method == "monotone_c2":
+        return monotone_c2(x, y)
+    if method == "pchip":
+        return PchipInterpolator(x, y, extrapolate=False)
+    raise ValueError(f"unknown CDF interpolation {method!r}")
+
+
+@dataclass(frozen=True)
+class AnchorFit:
+    curve: BPoly | PchipInterpolator
+    indices: np.ndarray
+    max_error: float
+    stop_reason: str
+
+
+def fit_anchors(x: np.ndarray, y: np.ndarray, config: AnchorSettings, interpolation: str) -> AnchorFit:
+    """Select only real empirical nodes plus the supplied support endpoints.
+
+    A bounded set of probability seeds starts the fit. Each pass evaluates
+    residuals against all empirical knots once, then scans disjoint intervals
+    and refines up to eight worst intervals. min_mass is the required observed
+    cumulative mass on EACH side of a proposed new node; it stops the selector
+    from chasing individual sample jumps. No output grid participates.
+    """
+    if config.method == "all":
+        curve = interpolate_cdf(x, y, interpolation)
+        return AnchorFit(curve, np.arange(len(x)), 0.0, "all")
+    # Retain the first empirical value and the first empirical value reaching
+    # probability one, so the fit preserves the observed onset and upper tail.
+    last = min(int(np.searchsorted(y, 1.0)), len(x) - 1)
+    selected = {0, min(1, len(x) - 1), last, len(x) - 1}
+    seed_count = min(9, config.max_points - len(selected) + 1)
+    for target in np.linspace(0, 1, seed_count)[1:-1]:
+        index = min(int(np.searchsorted(y, target)), len(x) - 1)
+        ordered = sorted(selected)
+        slot = int(np.searchsorted(ordered, index))
+        if index in selected or slot == 0 or slot == len(ordered):
+            continue
+        if min(y[index] - y[ordered[slot - 1]], y[ordered[slot]] - y[index]) >= config.min_mass:
+            selected.add(index)
+    while True:
+        indices = np.array(sorted(selected), dtype=int)
+        curve = interpolate_cdf(x[indices], y[indices], interpolation)
+        residual = np.abs(curve(x) - y)
+        error = float(np.max(residual))
+        if error <= config.tolerance:
+            return AnchorFit(curve, indices, error, "tolerance")
+        if len(selected) >= config.max_points:
+            return AnchorFit(curve, indices, error, "max_points")
+        queue = []
+        for lo, hi in zip(indices[:-1], indices[1:]):
+            # Search only nodes with enough probability mass on both sides.
+            start = max(lo + 1, int(np.searchsorted(y, y[lo] + config.min_mass, side="left")))
+            end = min(hi, int(np.searchsorted(y, y[hi] - config.min_mass, side="right")))
+            if start >= end:
+                continue
+            index = start + int(np.argmax(residual[start:end]))
+            if residual[index] > config.tolerance:
+                heappush(queue, (-float(residual[index]), index))
+        if not queue:
+            return AnchorFit(curve, indices, error, "min_mass")
+        for _ in range(min(8, config.max_points - len(selected), len(queue))):
+            _, index = heappop(queue)
+            selected.add(index)

{jarvisplot-2.1.4 → jarvisplot-2.1.6}/jarvisplot/Figure/design_runtime.py

@@ -129,8 +129,12 @@ def _preview_colorbar(fig, name, cfg):
 
     from .colorbar_runtime import axc_color_config, axc_is_horizontal
 
-    cmap = axc_color_config(fig.frame, name).get("cmap") or cfg["fallback_cmap"]
-    is_h = axc_is_horizontal(fig.frame, name)
+    # Lightweight wrappers used by design tooling may expose only ``fig`` and
+    # ``axes``. An absent frame means there is no colorbar override, not that
+    # the rest of the debug overlay should be abandoned halfway through.
+    frame = getattr(fig, "frame", {})
+    cmap = axc_color_config(frame, name).get("cmap") or cfg["fallback_cmap"]
+    is_h = axc_is_horizontal(frame, name)
     ramp = np.linspace(0.0, 1.0, int(cfg["samples"])).reshape(-1, 1)
     if is_h:
         ramp = ramp.reshape(1, -1)

jarvisplot-2.1.6/jarvisplot/Figure/distribution_1d_runtime.py

@@ -0,0 +1,165 @@
+"""Raw weighted samples -> continuous CDF, optionally its analytic derivative.
+
+PDF1D and CDF1D share the reconstruction. No histogram or sample-grid
+renormalisation participates in fitting: the grid only evaluates the interpolant.
+"""
+from __future__ import annotations
+
+from typing import Any, Mapping
+
+import numpy as np
+import pandas as pd
+from scipy.interpolate import PchipInterpolator
+
+from ..distribution_1d_config import KINDS, settings
+from ..memtrace import memtrace_checkpoint, memtrace_object_inventory
+from ..utils.expression import eval_dataframe_expression
+from .adaptive_cdf_runtime import fit_anchors
+
+ALGORITHM_REVISION = "weighted-ecdf-adaptive-bernstein-c2-v3"
+
+
+def _values(df: pd.DataFrame, expr: Any, logger=None) -> np.ndarray:
+    values = np.asarray(eval_dataframe_expression(df, expr, logger=logger), dtype=float)
+    if values.ndim == 0:
+        return np.full(len(df), float(values))
+    if values.shape != (len(df),):
+        raise ValueError(f"expression {expr!r} must return one value per input row, got {values.shape}")
+    return values
+
+
+def _infer_limits(x: np.ndarray, scale: str) -> tuple[float, float]:
+    unique = np.unique(x)
+    if len(unique) < 2:
+        raise ValueError("one unique sample cannot define a continuous support; set coordinates.x.lim")
+    lo = unique[0] - 0.5 * (unique[1] - unique[0])
+    hi = unique[-1] + 0.5 * (unique[-1] - unique[-2])
+    if scale == "log":
+        if unique[0] <= 0:
+            raise ValueError("coordinates.x.scale: log requires positive samples")
+        lo = max(lo, unique[0] * 0.5)
+    if not np.isfinite(lo) or not np.isfinite(hi) or not lo < hi:
+        raise ValueError("cannot infer finite support; set coordinates.x.lim")
+    return float(lo), float(hi)
+
+
+def empirical_knots(x: np.ndarray, weights: np.ndarray, limits: tuple[float, float]):
+    """Inclusive empirical nodes plus support endpoints; return largest atom too."""
+    lo, hi = limits
+    order = np.argsort(x, kind="stable")
+    x, weights = x[order], weights[order]
+    unique, first = np.unique(x, return_index=True)
+    # Rescaling before summation avoids overflow without changing probability.
+    scaled = weights / weights.max()
+    mass = np.add.reduceat(scaled, first)
+    mass /= mass.sum()
+    cumulative = np.minimum(np.cumsum(mass), 1.0)
+    cumulative[-1] = 1.0
+    interior = (unique > lo) & (unique < hi)
+    knots = np.r_[lo, unique[interior], hi]
+    probabilities = np.r_[0.0, cumulative[interior], 1.0]
+    return knots, probabilities, float(mass.max())
+
+
+def build_cdf(x: np.ndarray, weights: np.ndarray, limits: tuple[float, float]) -> PchipInterpolator:
+    """Original all-anchor PCHIP path, useful for exact empirical-node comparisons.
+
+    A sample exactly at lo cannot retain its jump with F(lo)=0; its mass is
+    carried into the first interval. Other empirical nodes retain their CDF.
+    Production reconstruction uses fit_anchors with the selected settings.
+    """
+    knots, probabilities, _ = empirical_knots(x, weights, limits)
+    return PchipInterpolator(knots, probabilities, extrapolate=False)
+
+
+def distribution_1d(df: pd.DataFrame, cfg: Mapping[str, Any], kind: str, logger=None) -> pd.DataFrame:
+    if kind not in KINDS:
+        raise ValueError(f"unknown distribution transform {kind!r}")
+    if not isinstance(df, pd.DataFrame) or df.empty:
+        raise ValueError(f"{kind} needs a nonempty pandas sample table")
+    opts = settings(cfg)
+    memtrace_checkpoint(logger, f"pipeline.{kind}.before", df)
+    x = _values(df, opts.x["expr"], logger)
+    weights = _values(df, opts.weight["expr"], logger) if opts.weight else np.ones(len(df))
+    if not np.all(np.isfinite(x)) or not np.all(np.isfinite(weights)):
+        raise ValueError(f"{kind} needs finite samples and weights; filter invalid rows first")
+    if np.any(weights < 0):
+        raise ValueError(f"{kind} needs nonnegative probability weights; signed event weights are not a CDF")
+    work = pd.DataFrame({"x": x, "weight": weights})
+    if opts.repeat is not None:
+        if opts.repeat not in df.columns:
+            raise KeyError(f"{kind} missing repeat column {opts.repeat!r}")
+        if df[opts.repeat].isna().any():
+            raise ValueError(f"{kind} repeat identifiers must not be missing")
+        work["repeat"] = df[opts.repeat].to_numpy()
+    positive = weights > 0
+    if not positive.any():
+        raise ValueError(f"{kind} weights sum to zero")
+    limits = opts.limits or _infer_limits(x[positive], opts.scale)
+    lo, hi = limits
+    if np.any((x[positive] < lo) | (x[positive] > hi)):
+        raise ValueError(f"{kind} coordinates.x.lim must contain all positive-weight samples; filter first to truncate")
+    grid = np.geomspace(lo, hi, opts.grid) if opts.scale == "log" else np.linspace(lo, hi, opts.grid)
+    memtrace_object_inventory(logger, f"pipeline.{kind}.samples", {"samples": work})
+    curves = ("cdf", "pdf") if kind == "PDF1D" else ("cdf",)
+    mean = {key: np.zeros(opts.grid) for key in curves}
+    m2 = {key: np.zeros(opts.grid) for key in curves}
+    groups = work.groupby("repeat", sort=False, observed=True) if opts.repeat else [(None, work)]
+    n = 0
+    boundary_mass = False
+    diagnostics = []
+    for label, block in groups:
+        block = block.loc[block.weight > 0]
+        if block.empty:
+            raise ValueError(f"{kind} repeat {label!r} weights sum to zero")
+        bx, bw = block.x.to_numpy(), block.weight.to_numpy()
+        boundary_mass |= bool(np.any(bx == lo))
+        knots, probabilities, largest_jump = empirical_knots(bx, bw, limits)
+        fit = fit_anchors(knots, probabilities, opts.anchors, opts.interpolation)
+        cdf = fit.curve
+        diagnostics.append({
+            "repeat": label.item() if isinstance(label, np.generic) else label,
+            "n_anchors": len(fit.indices), "n_candidates": len(knots),
+            "max_cdf_error": fit.max_error, "stop_reason": fit.stop_reason,
+            "largest_empirical_jump": largest_jump,
+        })
+        if logger is not None:
+            logger.debug(f"{kind} repeat={label!r}: anchors={len(fit.indices)}/{len(knots)}, "
+                         f"max CDF node error={fit.max_error:.6g}, stopped={fit.stop_reason}")
+            if opts.anchors.method == "adaptive" and fit.max_error > opts.anchors.tolerance:
+                logger.warning(f"{kind} repeat={label!r}: CDF error {fit.max_error:.6g} exceeds "
+                               f"tolerance {opts.anchors.tolerance:g}; stopped at {fit.stop_reason}. "
+                               "Adjust anchors settings if finer CDF reconstruction is needed.")
+            if opts.anchors.method == "adaptive" and largest_jump > max(2 * opts.anchors.tolerance, opts.anchors.min_mass):
+                logger.warning(f"{kind} repeat={label!r}: empirical probability jump {largest_jump:.6g}; "
+                               "a continuous density spreads this discrete mass over an interval")
+        values = {"cdf": cdf(grid)}
+        if kind == "PDF1D":
+            pdf = cdf.derivative()(grid)
+            tolerance = 128 * np.finfo(float).eps * max(1.0, float(np.max(np.abs(pdf))))
+            if np.min(pdf) < -tolerance:
+                raise ValueError(f"{kind} produced a negative density beyond floating-point tolerance")
+            values["pdf"] = np.maximum(pdf, 0.0)
+        n += 1
+        for key in curves:
+            if not np.all(np.isfinite(values[key])):
+                raise ValueError(f"{kind} produced nonfinite {key}; inspect sample spacing/support")
+            delta = values[key] - mean[key]
+            mean[key] += delta / n
+            m2[key] += delta * (values[key] - mean[key])
+    out = {opts.name: grid}
+    for key in curves:
+        out[key] = mean[key]
+        out[f"{key}_std"] = np.sqrt(np.maximum(m2[key], 0.0) / (n - 1)) if n > 1 else np.full(opts.grid, np.nan)
+    out["n_repeats"] = n
+    table = pd.DataFrame(out)
+    table.attrs["distribution_1d"] = {
+        "algorithm": ALGORITHM_REVISION, "interpolation": opts.interpolation,
+        "anchor_method": opts.anchors.method, "support": limits, "repeats": diagnostics,
+    }
+    if logger is not None:
+        if boundary_mass:
+            logger.warning(f"{kind}: mass at the lower support boundary is spread over the first CDF interval")
+        logger.debug(f"{kind}: {len(df)} samples -> {opts.grid} points, {n} repeats, support={limits}, std ddof=1")
+    memtrace_checkpoint(logger, f"pipeline.{kind}.after", table)
+    return table