Phase 13.46.DF FIX1: scatter range= removes out-of-range points.

v1.0 set the view window (set_xlim/set_ylim) — out-of-range points stayed
in the collection. Architect 2026-05-28: scatter range must DROP the
points, consistent with hist/profile range= excluding points from binning.
Filter x_data/y_data/df_filtered by one mask before stats+plotting; all
parallel arrays (color/size/marker/error) derive from df_filtered and stay
aligned. Non-facet keeps an exact tight view; faceted cells filter and the
shared axes autoscale to the union (no last-cell-wins). F.71 locks the
point-removal invariant. Gate 1022 -> 1023.

Predecessor: PHASE_13_46_DF v1.0 @ 1d77702.

Author: miranov25

UTILS/dfextensions/dfdraw/docs/CAPABILITY_MATRIX.md

@@ -1,6 +1,6 @@
 # Capability Matrix — dfdraw
 
-**Generated:** 2026-05-28 10:51 UTC
+**Generated:** 2026-05-28 13:04 UTC
 **Phase:** 13.15.DF
 **Generator:** `scripts/generate_capability_matrix.py`
 **Sources:** `tests/feature_taxonomy.py` + `tests/test_layer_classification.py`
@@ -9,13 +9,13 @@
 
 | Status | Count | % |
 |--------|------:|--:|
-| ✅ Verified | 55 | 49% |
+| ✅ Verified | 56 | 49% |
 | ☑️ Smoke-only | 57 | 50% |
 | 🧨 Broken | 0 | 0% |
 | 📋 Planned | 1 | 1% |
-| **Total features** | **113** | |
-| **Total proof tests** | **577** | |
-| **Invariance tests** | **348** | |
+| **Total features** | **114** | |
+| **Total proof tests** | **578** | |
+| **Invariance tests** | **349** | |
 
 **Status key:**
 - ✅ Verified — has at least one invariance test (A ≡ B check)
@@ -179,6 +179,7 @@
 | ✅ | **API.kwarg_typo_guard** — Kwarg-typo guard (difflib did-you-mean at draw() entry) | 1 | 0 |
 | | **RANGE** | | |
 | ✅ | **RANGE.scatter** — range= on scatter via shared 2D resolver | 4 | 0 |
+| ✅ | **RANGE.scatter_filter** — range= on scatter removes out-of-range points (FIX1 semantic) | 1 | 0 |
 | | **TITLE** | | |
 | ✅ | **TITLE.get_suptitle** — _get_suptitle public-API helper (mpl >= 3.8 + fallback) | 1 | 0 |
 

UTILS/dfextensions/dfdraw/plots/scatter.py

@@ -196,6 +196,36 @@ def draw_scatter(
                 pd.to_datetime(_x_arr, unit='s').to_pydatetime()
             )
 
+    # Phase 13.46.DF FIX1 — range= REMOVES out-of-range points (point filter),
+    # consistent with how hist/profile range= excludes points from binning. The
+    # previous v1.0 set_xlim/set_ylim only clipped the VIEW (out-of-range points
+    # stayed in the collection, off-screen) — architect 2026-05-28: scatter
+    # range must drop the points. Done here (before stats + plotting) so the
+    # filtered count is reflected in stats and every parallel array (color,
+    # size, marker, error bars) — all derived from df_filtered — stays aligned.
+    _range_xr = _range_yr = None
+    _range_strategy = None
+    if range is not None:
+        from ._autorange import resolve_range_2d
+        (_range_xr, _range_yr), _range_strategy = resolve_range_2d(
+            range, x_data, y_data,
+            style_strategy=get_style_value("autorange.strategy", "hybrid"),
+            style_k_robust=get_style_value("autorange.k_robust", 4.0),
+            style_k_outlier=get_style_value("autorange.k_outlier", 1.5),
+            style_percentile=get_style_value("autorange.percentile", (1.0, 99.0)),
+        )
+        _rmask = np.ones(len(x_data), dtype=bool)
+        if np.all(np.isfinite(_range_xr)) and _range_xr[0] < _range_xr[1]:
+            _rmask &= (x_data >= _range_xr[0]) & (x_data <= _range_xr[1])
+        if np.all(np.isfinite(_range_yr)) and _range_yr[0] < _range_yr[1]:
+            _rmask &= (y_data >= _range_yr[0]) & (y_data <= _range_yr[1])
+        # Filter x/y and df_filtered by the SAME mask so downstream color/size/
+        # marker/error helpers (which derive from df_filtered) stay aligned.
+        x_data = x_data[_rmask]
+        y_data = y_data[_rmask]
+        if len(df_filtered) == len(_rmask):
+            df_filtered = df_filtered[_rmask]
+
     # Statistics
     stats_dict = _compute_scatter_stats(x_data, y_data)
     # Phase 13.28.DF: Sanitize counters (AD-71)
@@ -207,6 +237,11 @@ def draw_scatter(
         if len(x_data) > 0 else ((0.0, 1.0), (0.0, 1.0))
     )
     stats_dict["autorange_strategy"] = "minmax"
+    # Honest stats when range= was applied: record the resolved strategy +
+    # window actually used to filter (overrides the default above).
+    if _range_strategy is not None:
+        stats_dict["autorange_used"] = (_range_xr, _range_yr)
+        stats_dict["autorange_strategy"] = _range_strategy
 
     # Apply jitter
     if jitter:
@@ -408,36 +443,15 @@ def draw_scatter(
             ax.xaxis.set_major_formatter(mdates.DateFormatter(time_format))
         fig.autofmt_xdate()
 
-    # Phase 13.46.DF C-9: range= support via the SHARED 2D resolver (AD-74
-    # per-axis), identical handling to hist/profile/2D — only the application
-    # differs (set_xlim/set_ylim vs binning, because scatter has no bins).
-    # Applied AFTER plotting so ax.scatter()'s autoscale cannot override it.
-    if range is not None:
-        from ._autorange import resolve_range_2d
-        (_xr, _yr), _strategy = resolve_range_2d(
-            range, x_data, y_data,
-            style_strategy=get_style_value("autorange.strategy", "hybrid"),
-            style_k_robust=get_style_value("autorange.k_robust", 4.0),
-            style_k_outlier=get_style_value("autorange.k_outlier", 1.5),
-            style_percentile=get_style_value("autorange.percentile", (1.0, 99.0)),
-        )
-        # Per-cell limit application is suppressed in facet mode: faceted axes
-        # are SHARED (sharex/sharey), so a per-cell set_xlim would propagate
-        # and the last cell would clobber all others (silently wrong). In a
-        # facet grid the shared axes autoscale to the global data extent
-        # instead. Per-cell strategy tightening under faceting (non-minmax)
-        # is a Phase 13.46.DF FIX1 item — see CRR §2.
-        if not _facet_mode:
-            # Degenerate/empty guard (single point, all-filtered, min==max,
-            # non-finite): skip set_*lim and let matplotlib autoscale.
-            if np.all(np.isfinite(_xr)) and _xr[0] < _xr[1]:
-                ax.set_xlim(_xr)
-            if np.all(np.isfinite(_yr)) and _yr[0] < _yr[1]:
-                ax.set_ylim(_yr)
-        # Honest stats: record the strategy actually resolved (not the
-        # unconditional "minmax" the default path records above).
-        stats_dict["autorange_used"] = (_xr, _yr)
-        stats_dict["autorange_strategy"] = _strategy
+    # Phase 13.46.DF FIX1 — points are already filtered to the resolved range
+    # above. Here we only tighten the VIEW to the exact resolved window in the
+    # non-faceted case (faceted axes are SHARED, so a per-cell set_xlim would
+    # clobber siblings — those autoscale to the union of filtered data instead).
+    if _range_strategy is not None and not _facet_mode:
+        if _range_xr is not None and np.all(np.isfinite(_range_xr)) and _range_xr[0] < _range_xr[1]:
+            ax.set_xlim(_range_xr)
+        if _range_yr is not None and np.all(np.isfinite(_range_yr)) and _range_yr[0] < _range_yr[1]:
+            ax.set_ylim(_range_yr)
 
     return fig, ax, stats_dict
 

UTILS/dfextensions/dfdraw/tests/feature_taxonomy.py

@@ -1501,6 +1501,14 @@
             "test_phase_13_46_df_audit_fixes.py::TestPhase1346AuditFixes::test_f69b_profile_hist_range_minmax_no_unpack_error",
         ],
     },
+    {
+        "id": "RANGE.scatter_filter",
+        "name": "range= on scatter removes out-of-range points (FIX1 semantic)",
+        "category": "RANGE",
+        "tests": [
+            "test_phase_13_46_df_audit_fixes.py::TestPhase1346AuditFixes::test_f71_scatter_range_removes_out_of_range_points",
+        ],
+    },
     {
         "id": "TITLE.get_suptitle",
         "name": "_get_suptitle public-API helper (mpl >= 3.8 + fallback)",

UTILS/dfextensions/dfdraw/tests/test_layer_classification.py

@@ -441,6 +441,7 @@
     "test_phase_13_46_df_audit_fixes.py::TestPhase1346AuditFixes::test_f69a_scatter_range_strategy_parity": "invariance",
     "test_phase_13_46_df_audit_fixes.py::TestPhase1346AuditFixes::test_f69b_profile_hist_range_minmax_no_unpack_error": "invariance",
     "test_phase_13_46_df_audit_fixes.py::TestPhase1346AuditFixes::test_f70_get_suptitle_live_path": "invariance",
+    "test_phase_13_46_df_audit_fixes.py::TestPhase1346AuditFixes::test_f71_scatter_range_removes_out_of_range_points": "invariance",
 
     # Everything else defaults to "smoke"
 }

UTILS/dfextensions/dfdraw/tests/test_phase_13_46_df_audit_fixes.py

@@ -209,3 +209,45 @@ def test_f70_get_suptitle_live_path(self):
         fig2 = plt.figure()
         assert _get_suptitle(fig2) == ""
         plt.close(fig2)
+
+    # -- F.71 — C-9 FIX1: scatter range REMOVES out-of-range points ------
+
+    def test_f71_scatter_range_removes_out_of_range_points(self):
+        """Phase 13.46.DF FIX1: scatter range= must DROP out-of-range points
+        (point filter), not merely clip the view. Consistent with hist/profile
+        range= excluding points from binning.
+
+        With explicit outliers, range='percentile_99' (and an explicit tuple)
+        must reduce the plotted point count; range='minmax' (window == full
+        data) must remove nothing."""
+        rs = np.random.RandomState(0)
+        x = np.concatenate([rs.normal(0, 1, 990),
+                            np.array([100., -100, 200, -200, 300,
+                                      150, -150, 180, -180, 120])])
+        df = pd.DataFrame({'x': x, 'y': rs.normal(0, 1, 1000),
+                           'c': rs.rand(1000)})
+        n_in = len(df)
+
+        # percentile_99 drops outliers
+        fig, ax, st = DFDraw(df).scatter('y:x', range="percentile_99")
+        n_pct = len(ax.collections[0].get_offsets())
+        assert n_pct < n_in, "percentile_99 must remove out-of-range points"
+        plt.close(fig)
+
+        # explicit tuple drops points outside the window
+        fig, ax, st = DFDraw(df).scatter('y:x', range=((-3, 3), (-3, 3)))
+        n_tup = len(ax.collections[0].get_offsets())
+        assert n_tup < n_in, "explicit-tuple range must remove out-of-range points"
+        plt.close(fig)
+
+        # minmax window == full data → nothing removed
+        df_in = df.iloc[:990]  # inliers only, no extreme outliers
+        fig, ax, st = DFDraw(df_in).scatter('y:x', range="minmax")
+        assert len(ax.collections[0].get_offsets()) == len(df_in), \
+            "minmax must not remove any points"
+        plt.close(fig)
+
+        # parallel color array stays aligned through filtering (no length crash)
+        fig, ax, st = DFDraw(df).scatter('y:x', color='c', range="percentile_99")
+        assert len(ax.collections[0].get_offsets()) < n_in
+        plt.close(fig)