From fe85932c6b58b88161466c4648fb125413ca21dd Mon Sep 17 00:00:00 2001 From: Nathaniel Ramm Date: Wed, 19 Aug 2026 15:16:34 +1000 Subject: [PATCH 1/6] test(item108): RED cross-backend asof strategy cases + NW/IB divergence facts --- .../core/capabilities/divergences.py | 84 +++++++ .../cross_backend/test_rel_join_results.py | 237 +++++++++++++++++- 2 files changed, 317 insertions(+), 4 deletions(-) diff --git a/src/mountainash/core/capabilities/divergences.py b/src/mountainash/core/capabilities/divergences.py index b2cd4053..90310420 100644 --- a/src/mountainash/core/capabilities/divergences.py +++ b/src/mountainash/core/capabilities/divergences.py @@ -680,6 +680,90 @@ def _all() -> tuple[DivergenceFact, ...]: upstream_ref="IB-REL-13", since="2026-08-18", ), + DivergenceFact( + id="NW-REL-03", + kind=DivergenceKind.ENGINE_LENIENCY, + operation_keys=(), # relation op join_asof tolerance param + # "pandas" is listed literally because a raw pd.DataFrame's runtime + # identity resolves to family=NARWHALS, dialect="narwhals-pandas" + # (identify_backend's fallback wraps unrecognized frames via + # narwhals). The existing tolerance CapabilityFact + # (capabilities/narwhals.py:31, backend=NARWHALS, no dialect) is + # family-wide, so it fires on every narwhals-routed dialect + # including "narwhals-lazy". + backends=("narwhals-polars", "narwhals-pandas", "narwhals-lazy", "pandas"), + summary="narwhals join_asof(tolerance=...) is GATE-UNSUPPORTED family-wide (capabilities/narwhals.py); a raw pandas.DataFrame is routed through the same narwhals identity at runtime", + impact="Relation.join_asof(tolerance=...) raises BackendCapabilityError on all narwhals-family dialects, including the 'pandas' test backend", + workaround="Drop tolerance= or use the polars/ibis backends", + upstream_ref=None, + since="2026-08-18", + ), + DivergenceFact( + id="NW-REL-04", + kind=DivergenceKind.ENGINE_LENIENCY, + operation_keys=(), # relation op join_asof null keys + backends=("narwhals-pandas", "pandas"), + summary="pandas merge_asof raises ValueError on null as-of keys (left or right side); narwhals-polars/narwhals-lazy compute no-match rows like Polars", + impact="Relation.join_asof() with null keys raises on narwhals-pandas and the 'pandas' test backend; polars/narwhals-polars/narwhals-lazy/ibis compute no-match rows", + workaround="Use a polars, narwhals-polars, narwhals-lazy, or ibis backend for asof joins over null keys", + upstream_ref=None, + since="2026-08-18", + ), + DivergenceFact( + id="NW-REL-05", + kind=DivergenceKind.ENGINE_LENIENCY, + operation_keys=(), # relation op join_asof nearest duplicate-key ties + backends=("narwhals-pandas", "pandas"), + summary="narwhals-pandas nearest may pick a different duplicate right row than Polars on a duplicate-right-key tie (Polars keeps the last of a tied group; the portable forward-wins fix inherits pandas merge_asof's own first-of-duplicates convention within each of its two internal legs) — the genuine cross-side tie (forward candidate vs a DIFFERENT-valued backward candidate) is unaffected and matches Polars", + impact="Relation.join_asof(strategy='nearest') on narwhals-pandas/'pandas' may select a different (but still equally-near) right row than Polars when the right frame has duplicate keys at the winning distance", + workaround="Use polars, narwhals-polars, narwhals-lazy, or an ibis backend for exact duplicate-tie parity under nearest", + upstream_ref=None, + since="2026-08-19", + ), + DivergenceFact( + id="IB-REL-14", + kind=DivergenceKind.ENGINE_LENIENCY, + operation_keys=(), # relation op join_asof temporal nearest/tolerance + backends=("ibis-sqlite",), + summary="ibis-sqlite has no TimestampDelta translation (OperationNotDefinedError, probe-confirmed on ibis 12.0.0); the asof emulation cannot compute a temporal distance there", + impact="Relation.join_asof(strategy='nearest') or tolerance=... over a temporal `on` column raises BackendCapabilityError on ibis-sqlite; forward/backward over temporal keys (no distance needed) work fine there", + workaround="Use ibis-duckdb, polars, or narwhals for temporal nearest/tolerance asof joins", + upstream_ref=None, + since="2026-08-18", + ), + DivergenceFact( + id="IB-REL-15", + kind=DivergenceKind.ENGINE_LENIENCY, + operation_keys=(), # relation op join_asof strategy param + backends=("ibis-polars",), + summary="ibis-polars rejects the emulation's non-equality candidate join (TypeError: Only equality join predicates supported with pandas, probe-confirmed); forward/nearest strategies are permanently capability-gated there", + impact="Relation.join_asof(strategy='forward'|'nearest') raises BackendCapabilityError on ibis-polars; backward is native and unaffected", + workaround="Use ibis-duckdb, ibis-sqlite, polars, or narwhals for forward/nearest asof joins", + upstream_ref=None, + since="2026-08-18", + ), + DivergenceFact( + id="IB-REL-16", + kind=DivergenceKind.ENGINE_LENIENCY, + operation_keys=(), # relation op join_asof backward duplicate-key ties + backends=("ibis-duckdb",), + summary="ibis-duckdb's native asof_join picks the FIRST equal-key right row on a duplicate-right-key tie under backward; Polars picks the LAST (probe-confirmed on ibis 12.0.0). ibis-polars native (delegating to real Polars) and the Ibis emulation used everywhere else both already match Polars on this", + impact="Relation.join_asof(strategy='backward') on ibis-duckdb may select a different (but still equally-valid, at-or-before) right row than Polars when the right frame has duplicate keys at the matched value", + workaround="Use ibis-sqlite, ibis-polars, polars, or narwhals for exact duplicate-tie parity under backward", + upstream_ref=None, + since="2026-08-19", + ), + DivergenceFact( + id="IB-REL-17", + kind=DivergenceKind.ENGINE_LENIENCY, + operation_keys=(), # relation op join_asof by-grouped row order + backends=("ibis-duckdb", "ibis-sqlite"), + summary="Ibis's SQL-backend asof paths (native duckdb backward, and the emulation used for forward/nearest and all sqlite strategies) order output by [by, on] for determinism, which groups rows contiguously by `by` value; Polars (and narwhals/pandas natively, and ibis-polars natively) instead preserve the left input's own row order, which differs whenever `by` groups are interleaved in that input", + impact="Relation.join_asof(by=...) on ibis-duckdb/ibis-sqlite returns rows grouped by `by` value rather than in left input order when groups interleave; matched values are always correct, only row position differs", + workaround="Use ibis-polars, polars, or narwhals if exact left-input row order must be preserved for interleaved by-groups", + upstream_ref=None, + since="2026-08-19", + ), DivergenceFact( id="IB-REL-12", kind=DivergenceKind.ENGINE_LENIENCY, diff --git a/tests/relations/cross_backend/test_rel_join_results.py b/tests/relations/cross_backend/test_rel_join_results.py index b2b670a9..534fc180 100644 --- a/tests/relations/cross_backend/test_rel_join_results.py +++ b/tests/relations/cross_backend/test_rel_join_results.py @@ -6,6 +6,7 @@ """ from __future__ import annotations +import polars as pl import pytest import mountainash as ma @@ -42,6 +43,55 @@ def sorted_dicts(dicts: list[dict], by: str | list[str]) -> list[dict]: pytest.param(b, marks=xfail_divergence("IB-REL-13", backend=b)) for b in ALL_BACKENDS ] +_ASOF_DIRECTIONAL = [ + pytest.param( + b, + marks=(xfail_divergence("IB-REL-13", backend=b), xfail_divergence("IB-REL-15", backend=b)), + ) + for b in ALL_BACKENDS +] +_ASOF_TEMPORAL_NEAREST = [ + pytest.param( + b, + marks=( + xfail_divergence("IB-REL-13", backend=b), + xfail_divergence("IB-REL-15", backend=b), + xfail_divergence("IB-REL-14", backend=b), + ), + ) + for b in ALL_BACKENDS +] +_ASOF_TOLERANCE = [ + pytest.param(b, marks=xfail_divergence("NW-REL-03", backend=b)) for b in ALL_BACKENDS +] +_ASOF_TEMPORAL_TOLERANCE = [ + pytest.param( + b, + marks=(xfail_divergence("NW-REL-03", backend=b), xfail_divergence("IB-REL-14", backend=b)), + ) + for b in ALL_BACKENDS +] +_ASOF_NULL = [ + pytest.param(b, marks=xfail_divergence("NW-REL-04", backend=b)) for b in ALL_BACKENDS +] +_ASOF_DUP_RIGHT_BACKWARD = [ + pytest.param(b, marks=xfail_divergence("IB-REL-16", backend=b)) for b in ALL_BACKENDS +] +_ASOF_NEAREST_DUP = [ + pytest.param( + b, + marks=( + xfail_divergence("IB-REL-13", backend=b), + xfail_divergence("IB-REL-15", backend=b), + xfail_divergence("NW-REL-05", backend=b), + ), + ) + for b in ALL_BACKENDS +] +_ASOF_BY_GROUPING = [ + pytest.param(b, marks=xfail_divergence("IB-REL-17", backend=b)) for b in ALL_BACKENDS +] + @pytest.mark.cross_backend @pytest.mark.parametrize("backend_name", ALL_BACKENDS) class TestJoinInner: @@ -280,10 +330,6 @@ def test_asof_backward_strategy(self, backend_name, backend_factory): join_asof matches each left row with the nearest right row where right.on <= left.on (backward strategy). - - Note: The `by` parameter is silently dropped by the Relation API - (JoinRelNode has no `by` field, visitor hardcodes by=None). - This is a known mountainash bug — we test without `by` here. """ left, right = backend_factory.create_pair( {"t": [1, 3, 5, 7], "val": ["a", "b", "c", "d"]}, @@ -306,3 +352,186 @@ def test_asof_backward_strategy(self, backend_name, backend_factory): assert result[2]["score"] == 40 assert result[3]["val"] == "d" assert result[3]["score"] == 60 + + def test_asof_duplicate_left_rows(self, backend_name, backend_factory): + """Duplicate LEFT rows (not duplicate right keys — see + test_asof_duplicate_right_keys for that, which DOES diverge on + ibis-duckdb). This case has no ambiguity in which right row matches + each left row, only in output ORDER among the two left rows sharing a + key — which Task 3's determinism fix pins deterministically and + correctly everywhere.""" + left_data = {"t": [5, 5], "val": ["r1", "r2"]} + right_data = {"t": [4, 6], "score": [40, 60]} + oracle = pl.DataFrame(left_data).join_asof( + pl.DataFrame(right_data), on="t", strategy="backward" + ).to_dicts() + left, right = backend_factory.create_pair(left_data, right_data, backend_name) + result = ma.relation(left).join_asof(right, on="t", strategy="backward").to_dicts() + assert result == oracle + + def test_asof_temporal_keys(self, backend_name, backend_factory): + """Temporal on-column, backward strategy (no distance computation needed — + works everywhere unlike nearest/tolerance, see the gated-cell tests below).""" + from datetime import datetime, timedelta + base = datetime(2026, 1, 1) + left_data = {"t": [base, base + timedelta(minutes=3)], "val": ["a", "b"]} + right_data = {"t": [base + timedelta(minutes=1), base + timedelta(minutes=4)], + "score": [10, 40]} + oracle = pl.DataFrame(left_data).join_asof( + pl.DataFrame(right_data), on="t", strategy="backward" + ).to_dicts() + left, right = backend_factory.create_pair(left_data, right_data, backend_name) + result = ma.relation(left).join_asof(right, on="t", strategy="backward").to_dicts() + assert result == oracle + + +@pytest.mark.cross_backend +class TestJoinAsofGatedCells: + def _oracle(self, left_data, right_data, **kwargs): + return pl.DataFrame(left_data).join_asof(pl.DataFrame(right_data), **kwargs).to_dicts() + + @pytest.mark.parametrize("backend_name", _ASOF_DUP_RIGHT_BACKWARD) + def test_asof_duplicate_right_keys(self, backend_name, backend_factory): + """Backward keeps the LAST equal-key right row (Polars-probed). + ibis-duckdb's NATIVE asof_join picks the FIRST — declared as + IB-REL-16 rather than fixed, since the emulation (used everywhere + else) and ibis-polars native (delegating to real Polars) both + already match Polars on this.""" + left_data = {"t": [5], "val": ["x"]} + right_data = {"t": [4, 4, 6], "score": [41, 42, 60]} + oracle = self._oracle(left_data, right_data, on="t", strategy="backward") + left, right = backend_factory.create_pair(left_data, right_data, backend_name) + result = ma.relation(left).join_asof(right, on="t", strategy="backward").to_dicts() + assert result == oracle + + @pytest.mark.parametrize("backend_name", _ASOF_BY_GROUPING) + def test_asof_by_grouping(self, backend_name, backend_factory): + """`by` groups are INTERLEAVED in the input (spec §7.1(5)) but `t` is + globally ascending — pandas merge_asof requires global sortedness of + `on` even with `by` set. IB-REL-17 declares that Ibis's SQL-backend + paths group output by `by` value rather than preserving this + interleaved order; every backend's matched VALUES are correct.""" + left_data = {"g": ["a", "b", "a", "b"], "t": [1, 2, 3, 4], + "val": ["a1", "b2", "a3", "b4"]} + right_data = {"g": ["a", "b", "a", "b"], "t": [1, 2, 3, 5], + "score": [10, 20, 30, 50]} + oracle = self._oracle(left_data, right_data, on="t", by="g", strategy="backward") + left, right = backend_factory.create_pair(left_data, right_data, backend_name) + result = ma.relation(left).join_asof( + right, on="t", by="g", strategy="backward" + ).to_dicts() + assert result == oracle + + @pytest.mark.parametrize("backend_name", _ASOF_DIRECTIONAL) + def test_asof_forward_strategy(self, backend_name, backend_factory): + left_data = {"t": [1, 3, 5, 7], "val": ["a", "b", "c", "d"]} + right_data = {"t": [2, 4, 6], "score": [20, 40, 60]} + oracle = self._oracle(left_data, right_data, on="t", strategy="forward") + left, right = backend_factory.create_pair(left_data, right_data, backend_name) + result = ma.relation(left).join_asof(right, on="t", strategy="forward").to_dicts() + assert result == oracle + + @pytest.mark.parametrize("backend_name", _ASOF_DIRECTIONAL) + def test_asof_nearest_strategy(self, backend_name, backend_factory): + left_data = {"t": [1, 3, 5, 7], "val": ["a", "b", "c", "d"]} + right_data = {"t": [2, 4, 6], "score": [20, 40, 60]} + oracle = self._oracle(left_data, right_data, on="t", strategy="nearest") + left, right = backend_factory.create_pair(left_data, right_data, backend_name) + result = ma.relation(left).join_asof(right, on="t", strategy="nearest").to_dicts() + assert result == oracle + + @pytest.mark.parametrize("backend_name", _ASOF_DIRECTIONAL) + def test_asof_nearest_forward_tie(self, backend_name, backend_factory): + """A GENUINE cross-side equidistant tie (right holds 4 and 6, left is + 5 — two DIFFERENT-valued candidates at equal distance). This is the + core `nearest` correctness fix (Task 4) and has no declared + divergence anywhere — forward-wins here on every backend.""" + left_data = {"t": [5], "val": ["x"]} + right_data = {"t": [4, 6], "score": [40, 60]} + oracle = self._oracle(left_data, right_data, on="t", strategy="nearest") + left, right = backend_factory.create_pair(left_data, right_data, backend_name) + result = ma.relation(left).join_asof(right, on="t", strategy="nearest").to_dicts() + assert result == oracle # forward-wins -> score 60 + + @pytest.mark.parametrize("backend_name", _ASOF_NEAREST_DUP) + def test_asof_nearest_duplicate_right_keys(self, backend_name, backend_factory): + """An EXACT-match tie (right holds a duplicate exactly at the left + key) — a duplicate-tie-winner question, not a cross-side-tie + question. Declared via NW-REL-05 on narwhals-pandas/pandas rather + than fixed.""" + left_data = {"t": [5], "val": ["x"]} + right_data = {"t": [5, 5, 7], "score": [51, 52, 70]} + oracle = self._oracle(left_data, right_data, on="t", strategy="nearest") + left, right = backend_factory.create_pair(left_data, right_data, backend_name) + result = ma.relation(left).join_asof(right, on="t", strategy="nearest").to_dicts() + assert result == oracle # score 52, the LAST t=5 duplicate + + @pytest.mark.parametrize("backend_name", _ASOF_DIRECTIONAL) + def test_asof_nearest_colliding_payload_names(self, backend_name, backend_factory): + """Left and right share a non-key column name (`val`) — Polars-parity + schema suffixes the right one `val_right`, matching plain `join_asof` + on every backend. This is a genuine crash fix (narwhals nearest + previously raised `DuplicateError`), not a tie-break question — no + divergence needed once fixed.""" + left_data = {"t": [1, 5], "val": ["L1", "L5"]} + right_data = {"t": [3, 4], "val": ["R3", "R4"]} + oracle = self._oracle(left_data, right_data, on="t", strategy="nearest") + left, right = backend_factory.create_pair(left_data, right_data, backend_name) + result = ma.relation(left).join_asof(right, on="t", strategy="nearest").to_dicts() + assert result == oracle + + @pytest.mark.parametrize("backend_name", _ASOF_TEMPORAL_NEAREST) + def test_asof_temporal_nearest_strategy(self, backend_name, backend_factory): + from datetime import datetime, timedelta + base = datetime(2026, 1, 1) + left_data = {"t": [base, base + timedelta(minutes=3)], "val": ["a", "b"]} + right_data = {"t": [base + timedelta(minutes=1), base + timedelta(minutes=4)], + "score": [10, 40]} + oracle = self._oracle(left_data, right_data, on="t", strategy="nearest") + left, right = backend_factory.create_pair(left_data, right_data, backend_name) + result = ma.relation(left).join_asof(right, on="t", strategy="nearest").to_dicts() + assert result == oracle + + @pytest.mark.parametrize("backend_name", _ASOF_TEMPORAL_TOLERANCE) + def test_asof_temporal_tolerance(self, backend_name, backend_factory): + """Natural/Polars-idiomatic calling convention: `tolerance` is a + `datetime.timedelta` for a temporal `on` column. `strategy="backward"` + here, so ibis-polars is NOT gated (only forward/nearest are) — the + native path computes this with full Polars parity.""" + from datetime import datetime, timedelta + base = datetime(2026, 1, 1) + left_data = {"t": [base, base + timedelta(minutes=3)], "val": ["a", "b"]} + right_data = {"t": [base + timedelta(minutes=1), base + timedelta(minutes=4)], + "score": [10, 40]} + tol = timedelta(minutes=2) + oracle = self._oracle(left_data, right_data, on="t", strategy="backward", tolerance=tol) + left, right = backend_factory.create_pair(left_data, right_data, backend_name) + result = ma.relation(left).join_asof( + right, on="t", strategy="backward", tolerance=tol + ).to_dicts() + assert result == oracle + + @pytest.mark.parametrize("backend_name", _ASOF_TOLERANCE) + def test_asof_tolerance(self, backend_name, backend_factory): + left_data = {"t": [10, 20, 30], "val": ["a", "b", "c"]} + right_data = {"t": [5, 27], "score": [50, 270]} + oracle = self._oracle(left_data, right_data, on="t", strategy="backward", tolerance=2) + left, right = backend_factory.create_pair(left_data, right_data, backend_name) + result = ma.relation(left).join_asof( + right, on="t", strategy="backward", tolerance=2 + ).to_dicts() + assert result == oracle # distances 5 and 3 both exceed tolerance 2 -> no matches + + @pytest.mark.parametrize("backend_name", _ASOF_NULL) + def test_asof_null_keys(self, backend_name, backend_factory): + """Order-insensitive comparison (`sorted_dicts` by the never-null `val` + column): DuckDB defaults to NULLS LAST on ASC, SQLite to NULLS FIRST — + a pre-existing, orthogonal engine divergence in null-sort defaults. + Values must still match exactly; only row position for the + null-containing row is exempted.""" + left_data = {"t": [None, 3], "val": ["n", "b"]} + right_data = {"t": [None, 2], "score": [99, 20]} + oracle = self._oracle(left_data, right_data, on="t", strategy="backward") + left, right = backend_factory.create_pair(left_data, right_data, backend_name) + result = ma.relation(left).join_asof(right, on="t", strategy="backward").to_dicts() + assert sorted_dicts(result, "val") == sorted_dicts(oracle, "val") From 8546b365643a1a2e8837a512e8c57b21344fb085 Mon Sep 17 00:00:00 2001 From: Nathaniel Ramm Date: Wed, 19 Aug 2026 15:18:25 +1000 Subject: [PATCH 2/6] feat(item108): gate ibis-polars forward/nearest join_asof via strategy param --- .../relations/backends/capabilities/ibis.py | 18 ++++++++ .../relation_mapping/definitions.py | 2 +- tests/core/test_capability_predicate_probe.py | 44 ++++++++++++++++--- tests/core/test_capability_registry.py | 20 ++++++--- .../test_rel_extension_ops_results.py | 28 ++++++++++++ 5 files changed, 101 insertions(+), 11 deletions(-) diff --git a/src/mountainash/relations/backends/capabilities/ibis.py b/src/mountainash/relations/backends/capabilities/ibis.py index 699dcea5..1a8970e6 100644 --- a/src/mountainash/relations/backends/capabilities/ibis.py +++ b/src/mountainash/relations/backends/capabilities/ibis.py @@ -11,6 +11,7 @@ CapabilityLevel, Enforcement, ) +from mountainash.core.capabilities.schema import Clause, ClauseOp, Predicate from mountainash.core.constants import CONST_BACKEND from mountainash.relations.core.relation_system.relation_keys.enums import ( RKEY_MOUNTAINASH_REL, @@ -42,6 +43,23 @@ enforcement=Enforcement.ROUTER_METADATA, probe_exempt="router, not gate — fallback handles it; behaviour covered by relations resource tests", ), + CapabilityFact( + operation_key=RKEY_MOUNTAINASH_REL.JOIN_ASOF, + param="strategy", + level=CapabilityLevel.UNSUPPORTED, + backend=CONST_BACKEND.IBIS, + dialect="ibis-polars", + message="join_asof forward/nearest lowers to a non-equality candidate join; the " + "ibis Polars backend rejects non-equality join predicates " + "(TypeError: Only equality join predicates supported with pandas).", + workaround="Use ibis-duckdb/ibis-sqlite, or polars/narwhals backends.", + upstream_ref="IB-REL-15", + since="2026-08-18", + predicate=Predicate(clauses=( + Clause(path="strategy", op=ClauseOp.IN, + operand=frozenset({"forward", "nearest"})), + )), + ), ) diff --git a/src/mountainash/relations/core/relation_system/relation_mapping/definitions.py b/src/mountainash/relations/core/relation_system/relation_mapping/definitions.py index 541c092b..4d5e261c 100644 --- a/src/mountainash/relations/core/relation_system/relation_mapping/definitions.py +++ b/src/mountainash/relations/core/relation_system/relation_mapping/definitions.py @@ -232,7 +232,7 @@ def _ext(key, method): extension_uri=MountainashRelExtension.UTIL, protocol_method=ExtProto.join_asof, handler=handlers.visit_join_asof, - gate_params=("tolerance",), + gate_params=("tolerance", "strategy"), wraps_native_call=True, ), RelationOperationDef( diff --git a/tests/core/test_capability_predicate_probe.py b/tests/core/test_capability_predicate_probe.py index 0a8e829e..50dbf072 100644 --- a/tests/core/test_capability_predicate_probe.py +++ b/tests/core/test_capability_predicate_probe.py @@ -1,6 +1,8 @@ """Consumer audit for predicate facts (backlog 66b).""" from __future__ import annotations +import pytest + from mountainash.core.capabilities import CapabilityRegistry from mountainash.core.capabilities.schema import ( CapabilityFact, CapabilityLevel, Clause, ClauseOp, Predicate, @@ -8,14 +10,46 @@ from mountainash.core.constants import CONST_BACKEND -def test_no_production_predicate_facts_yet(): - """Invariant: the mechanism ships with zero predicate facts (spec §7 — - no consumer has arrived). If one lands, it MUST be accompanied by the §6 - compound-cell probe (see plan Task 5 deferred note).""" +def test_first_predicate_fact_is_the_join_asof_strategy_gate(): + """Invariant flip (item 108): the mechanism now ships with exactly one + production predicate fact — the ibis-polars join_asof strategy gate.""" from mountainash.core.capabilities.bootstrap import load_all_capability_declarations + from mountainash.relations.core.relation_system.relation_keys.enums import ( + RKEY_MOUNTAINASH_REL, + ) load_all_capability_declarations() facts = [f for f in CapabilityRegistry.facts() if f.predicate is not None] - assert facts == [] + assert len(facts) == 1 + assert facts[0].operation_key == RKEY_MOUNTAINASH_REL.JOIN_ASOF + assert facts[0].param == "strategy" + assert facts[0].dialect == "ibis-polars" + + +def test_first_predicate_fact_is_compound_cell_safe(): + """The §6 compound-cell probe: gate_params=("tolerance", "strategy") binds + BOTH params conjunctively into the BoundCall, but the predicate clause only + inspects `strategy`. A call that also sets `tolerance` must not spuriously + trigger or suppress the gate — the two gate_params are independent axes.""" + import polars as pl + from mountainash.core.constants import CONST_BACKEND + import mountainash as ma + from mountainash.core.types import BackendCapabilityError + + left = pl.DataFrame({"t": [1, 3]}) + right = pl.DataFrame({"t": [2, 4]}) + + # backward + tolerance on ibis-polars: NOT gated (predicate only checks strategy). + import ibis + con = ibis.polars.connect() + L = con.create_table("cp_l", left, overwrite=True) + R = con.create_table("cp_r", right, overwrite=True) + ma.relation(L).join_asof(R, on="t", strategy="backward", tolerance=1).to_polars() + + # forward + tolerance on ibis-polars: IS gated (strategy predicate fires + # regardless of the co-bound tolerance value). + with pytest.raises(BackendCapabilityError) as ei: + ma.relation(L).join_asof(R, on="t", strategy="forward", tolerance=1).to_polars() + assert ei.value.limitation.predicate is not None def test_fact_sort_key_is_total_over_predicate_facts(): diff --git a/tests/core/test_capability_registry.py b/tests/core/test_capability_registry.py index 9b9228f0..f0b9dff1 100644 --- a/tests/core/test_capability_registry.py +++ b/tests/core/test_capability_registry.py @@ -128,11 +128,9 @@ def test_serialize_family_namespace_disjoint(self): finally: CapabilityRegistry._kinds.pop("substrait", None) - def test_ungateable_relation_param_rejected(self): + def test_non_protocol_param_rejected(self): # JOIN_ASOF is handler-routed; a param outside gate_params can never - # gate. (Passes trivially before Task 10 adds gate_params — 'nonsense' - # is also not a protocol param, so either error is acceptable; assert - # ValueError only.) + # gate. 'nonsense' is not a protocol param and not in gate_params. from mountainash.relations.core.relation_system.relation_keys.enums import ( RKEY_MOUNTAINASH_REL, ) @@ -141,9 +139,21 @@ def test_ungateable_relation_param_rejected(self): CONST_BACKEND.NARWHALS, [_fact(backend=CONST_BACKEND.NARWHALS, operation_key=RKEY_MOUNTAINASH_REL.JOIN_ASOF, - param="strategy", level=CapabilityLevel.UNSUPPORTED)], + param="nonsense", level=CapabilityLevel.UNSUPPORTED)], ) + def test_strategy_param_now_gateable(self): + # Task 2: strategy joined gate_params, so a strategy-scoped fact registers. + from mountainash.relations.core.relation_system.relation_keys.enums import ( + RKEY_MOUNTAINASH_REL, + ) + CapabilityRegistry.register_backend( + CONST_BACKEND.NARWHALS, + [_fact(backend=CONST_BACKEND.NARWHALS, + operation_key=RKEY_MOUNTAINASH_REL.JOIN_ASOF, + param="strategy", level=CapabilityLevel.UNSUPPORTED)], + ) + class TestResolutionOrder: def test_dialect_exact_beats_family(self): diff --git a/tests/relations/cross_backend/test_rel_extension_ops_results.py b/tests/relations/cross_backend/test_rel_extension_ops_results.py index 7688b313..5e1c9338 100644 --- a/tests/relations/cross_backend/test_rel_extension_ops_results.py +++ b/tests/relations/cross_backend/test_rel_extension_ops_results.py @@ -376,3 +376,31 @@ def test_fraction_one_returns_all_rows(self, backend_name, backend_factory, requ assert sorted_dicts(result, "a") == sorted_dicts( ma.relation(df).to_dicts(), "a" ) + + +@pytest.mark.cross_backend +class TestJoinAsofStrategyGate: + def test_ibis_polars_forward_nearest_gated(self): + import ibis + import polars as pl + from mountainash.core.types import BackendCapabilityError + + con = ibis.polars.connect() + left = con.create_table("gate_l", pl.DataFrame({"t": [1, 3], "val": ["a", "b"]}), overwrite=True) + right = con.create_table("gate_r", pl.DataFrame({"t": [2, 4], "score": [20, 40]}), overwrite=True) + + for strategy in ("forward", "nearest"): + with pytest.raises(BackendCapabilityError) as ei: + ma.relation(left).join_asof(right, on="t", strategy=strategy).to_polars() + assert ei.value.limitation.predicate is not None + assert ei.value.function_key == RKEY_MOUNTAINASH_REL.JOIN_ASOF + + def test_ibis_polars_backward_not_gated(self): + import ibis + import polars as pl + + con = ibis.polars.connect() + left = con.create_table("gate_l2", pl.DataFrame({"t": [1, 3], "val": ["a", "b"]}), overwrite=True) + right = con.create_table("gate_r2", pl.DataFrame({"t": [2, 4], "score": [20, 40]}), overwrite=True) + result = ma.relation(left).join_asof(right, on="t", strategy="backward").to_polars() + assert result.height == 2 From 0f926f01a57ecb59eb30400ec4755480caddde21 Mon Sep 17 00:00:00 2001 From: Nathaniel Ramm Date: Wed, 19 Aug 2026 15:21:22 +1000 Subject: [PATCH 3/6] feat(item108): Ibis asof strategy dispatch, native(duckdb/polars backward)+emulation, retire IB-REL-13 Probe evidence (polars 1.43.2 | ibis 12.0.0): ALL PASS (scripts/probes/probe_asof_emulation.py) --- scripts/probes/probe_asof_emulation.py | 158 +++++++++++++++ .../core/capabilities/divergences.py | 11 -- .../relsys_ib_ext_ma_util.py | 183 ++++++++++++++++-- .../cross_backend/test_rel_join_results.py | 18 +- 4 files changed, 331 insertions(+), 39 deletions(-) create mode 100644 scripts/probes/probe_asof_emulation.py diff --git a/scripts/probes/probe_asof_emulation.py b/scripts/probes/probe_asof_emulation.py new file mode 100644 index 00000000..e2a66e4d --- /dev/null +++ b/scripts/probes/probe_asof_emulation.py @@ -0,0 +1,158 @@ +"""Version-stamped probe for the item-108 Ibis asof dispatch (spec §9.3). +Run: hatch run test:python scripts/probes/probe_asof_emulation.py +""" +from __future__ import annotations +from datetime import datetime, timedelta + +import ibis +import polars as pl + +print(f"polars {pl.__version__} | ibis {ibis.__version__}") + + +def native_asof(left, right, *, on, by, tolerance, dialect): + """backward-only, duckdb+polars.""" + by_cols = list(by) if by else [] + if dialect == "ibis-duckdb": + # Determinism fix (IB-REL-11 class): duckdb's ASOF JOIN has no stable + # tiebreak for duplicate (by, on) left rows without an explicit + # secondary sort key (probe-confirmed: order varied across 20 fresh- + # connection reps without this). Row order for INTERLEAVED by-groups + # still diverges from Polars even with this fix (declared: IB-REL-17) + # -- this fixes nondeterminism, not full order parity. + left_id = left.mutate(_ma_left_id=ibis.row_number()) + predicates = [left_id[c] == right[c] for c in by_cols] + result = left_id.asof_join(right, on=on, predicates=predicates, tolerance=tolerance) + on_right = f"{on}_right" + drop = [c for c in ([on_right] + [f"{c}_right" for c in by_cols]) if c in result.columns] + if drop: + result = result.drop(*drop) + return result.order_by([*by_cols, on, "_ma_left_id"]).drop("_ma_left_id") + # ibis-polars: delegates directly to real Polars' own join_asof, which + # already preserves left input order natively and stably (probe- + # confirmed: 20/20 identical reps, including for interleaved by-groups) -- + # no order_by needed or wanted here. + predicates = [left[c] == right[c] for c in by_cols] + result = left.asof_join(right, on=on, predicates=predicates, tolerance=tolerance) + on_right = f"{on}_right" + drop = [c for c in ([on_right] + [f"{c}_right" for c in by_cols]) if c in result.columns] + if drop: + result = result.drop(*drop) + return result + + +def emulate_asof(left, right, *, on, by, strategy, tolerance): + left_cols = list(left.columns) + right_cols = list(right.columns) + by_cols = list(by) if by else [] + + is_temporal = left[on].type().is_temporal() + if is_temporal and isinstance(tolerance, timedelta): + tolerance = tolerance.total_seconds() + + def _distance(a, b): + return a.delta(b, unit="second").abs() if is_temporal else (a - b).abs() + + left_sorted = left.order_by([*by_cols, on]) + right_sorted = right.order_by([*by_cols, on]) + left_id = left_sorted.mutate(_ma_left_id=ibis.row_number()) + right_id = right_sorted.mutate(_ma_right_id=ibis.row_number()) + + if strategy == "forward": + pred = right_id[on] >= left_id[on] + elif strategy == "backward": + pred = right_id[on] <= left_id[on] + else: + pred = ibis.literal(True) + for col in by_cols: + pred = pred & (right_id[col] == left_id[col]) + if tolerance is not None: + pred = pred & (_distance(right_id[on], left_id[on]) <= tolerance) + + cand = left_id.join(right_id, pred) + on_right = f"{on}_right" if on in left_cols else on + if strategy == "forward": + rank_order = [cand[on_right], cand["_ma_right_id"]] + elif strategy == "backward": + rank_order = [ibis.desc(cand[on_right]), ibis.desc(cand["_ma_right_id"])] + else: + rank_order = [_distance(cand[on_right], cand[on]), ibis.desc(cand["_ma_right_id"])] + + ranked = cand.mutate( + _ma_rank=ibis.row_number().over(ibis.window(group_by="_ma_left_id", order_by=rank_order)) + ) + right_out_cols = [c if c not in left_cols else f"{c}_right" for c in right_cols] + best = ranked.filter(ranked["_ma_rank"] == 0).select("_ma_left_id", *right_out_cols) + + result = left_id.left_join(best, "_ma_left_id") + drop_cols = {"_ma_left_id_right", on_right} | {f"{c}_right" for c in by_cols} + result = result.drop(*[c for c in drop_cols if c in result.columns]) + result = result.order_by([*by_cols, on, "_ma_left_id"]) + return result.select(*[c for c in result.columns if c != "_ma_left_id"]) + + +base = datetime(2026, 1, 1) +EMULATION_CASES = [ + ("forward", {"t": [1, 3, 5, 7], "val": ["a", "b", "c", "d"]}, + {"t": [2, 4, 6], "score": [20, 40, 60]}, "t", None, "forward", None), + ("nearest", {"t": [1, 3, 5, 7], "val": ["a", "b", "c", "d"]}, + {"t": [2, 4, 6], "score": [20, 40, 60]}, "t", None, "nearest", None), + ("nearest_tie", {"t": [5], "val": ["x"]}, {"t": [4, 6], "score": [40, 60]}, "t", None, "nearest", None), + ("by_grouping_contiguous", {"g": ["a", "a", "b", "b"], "t": [1, 3, 5, 7], "val": ["a1", "a3", "b5", "b7"]}, + {"g": ["a", "a", "b", "b"], "t": [2, 4, 6, 8], "score": [20, 40, 60, 80]}, "t", ["g"], "backward", None), + ("tolerance", {"t": [10, 20, 30], "val": ["a", "b", "c"]}, {"t": [5, 27], "score": [50, 270]}, "t", None, "backward", 2), + ("dup_left", {"t": [5, 5], "val": ["r1", "r2"]}, {"t": [4, 6], "score": [40, 60]}, "t", None, "backward", None), + ("null_keys", {"t": [None, 3], "val": ["n", "b"]}, {"t": [None, 2], "score": [99, 20]}, "t", None, "backward", None), + ("temporal_nearest", {"t": [base, base + timedelta(minutes=3)], "val": ["a", "b"]}, + {"t": [base + timedelta(minutes=1), base + timedelta(minutes=4)], "score": [10, 40]}, "t", None, "nearest", None), +] + +failures = 0 +for name, left_d, right_d, on, by, strategy, tolerance in EMULATION_CASES: + left_pl, right_pl = pl.DataFrame(left_d), pl.DataFrame(right_d) + oracle = left_pl.join_asof(right_pl, on=on, by=by, strategy=strategy, tolerance=tolerance).sort([*(by or []), on]).to_dicts() + for dialect, con in (("duckdb", ibis.duckdb.connect()), ("sqlite", ibis.sqlite.connect())): + L = con.create_table(f"L_{name}", left_pl.to_arrow(), overwrite=True) + R = con.create_table(f"R_{name}", right_pl.to_arrow(), overwrite=True) + # IB-REL-14: ibis-sqlite has no TimestampDelta translation; a temporal + # `on` column combined with nearest (distance needed) cannot compile + # there. Confirm the expected upstream error instead of crashing -- + # this is exactly the gap the production `_emulate_asof` raises + # BackendCapabilityError for. + is_temporal_nearest = name == "temporal_nearest" and dialect == "sqlite" + if is_temporal_nearest: + try: + emulate_asof(L, R, on=on, by=by, strategy=strategy, tolerance=tolerance).to_polars() + except ibis.common.exceptions.OperationNotDefinedError as e: + print(f"{name} [{dialect}] OK (confirms IB-REL-14: {type(e).__name__})") + else: + failures += 1 + print(f"{name} [{dialect}] MISMATCH: expected OperationNotDefinedError (IB-REL-14), got no error") + continue + got = emulate_asof(L, R, on=on, by=by, strategy=strategy, tolerance=tolerance).to_polars().sort([*(by or []), on]).to_dicts() + ok = got == oracle + failures += 0 if ok else 1 + print(f"{name} [{dialect}] {'OK' if ok else 'MISMATCH: got=' + str(got) + ' oracle=' + str(oracle)}") + +# native path: determinism + Polars-parity outside the declared IB-REL-16/17 cells +for name, left_d, right_d, by, dialect in ( + ("native_dup_left", {"t": [5, 5], "val": ["r1", "r2"]}, {"t": [4, 6], "score": [40, 60]}, None, "ibis-duckdb"), + ("native_temporal_tol", {"t": [base, base + timedelta(minutes=3)], "val": ["a", "b"]}, + {"t": [base + timedelta(minutes=1), base + timedelta(minutes=4)], "score": [10, 40]}, None, "ibis-duckdb"), +): + left_pl, right_pl = pl.DataFrame(left_d), pl.DataFrame(right_d) + tol = timedelta(minutes=2) if "tol" in name else None + oracle = left_pl.join_asof(right_pl, on="t", by=by, strategy="backward", tolerance=tol).to_dicts() + orders = set() + for i in range(10): + con = ibis.duckdb.connect() + L = con.create_table(f"n_{name}_{i}", left_pl, overwrite=True) + R = con.create_table(f"n_{name}_{i}r", right_pl, overwrite=True) + got = native_asof(L, R, on="t", by=by, tolerance=tol, dialect=dialect).to_polars().to_dicts() + orders.add(tuple(str(d) for d in got)) + ok = len(orders) == 1 and list(orders)[0] == tuple(str(d) for d in oracle) + failures += 0 if ok else 1 + print(f"{name} [{dialect}] determinism+parity: {'OK' if ok else 'FAIL: ' + str(orders) + ' vs oracle ' + str(oracle)}") + +print("ALL PASS" if failures == 0 else f"{failures} FAILURES") +assert failures == 0 diff --git a/src/mountainash/core/capabilities/divergences.py b/src/mountainash/core/capabilities/divergences.py index 90310420..2c7e8802 100644 --- a/src/mountainash/core/capabilities/divergences.py +++ b/src/mountainash/core/capabilities/divergences.py @@ -669,17 +669,6 @@ def _all() -> tuple[DivergenceFact, ...]: upstream_ref=None, since="2026-08-06", ), - DivergenceFact( - id="IB-REL-13", - kind=DivergenceKind.ENGINE_LENIENCY, - operation_keys=(), # relation op join_asof - backends=("ibis-sqlite",), - summary="ibis-sqlite: asof join raises UnsupportedOperationError — no ASOF JOIN translation", - impact="Relation.join_asof() raises on ibis-sqlite; polars/narwhals and ibis-duckdb compute it correctly", - workaround="Use a polars or narwhals backend for asof joins", - upstream_ref="IB-REL-13", - since="2026-08-18", - ), DivergenceFact( id="NW-REL-03", kind=DivergenceKind.ENGINE_LENIENCY, diff --git a/src/mountainash/relations/backends/relation_systems/ibis/extensions_mountainash/relsys_ib_ext_ma_util.py b/src/mountainash/relations/backends/relation_systems/ibis/extensions_mountainash/relsys_ib_ext_ma_util.py index 2f0a8e1d..321aaa75 100644 --- a/src/mountainash/relations/backends/relation_systems/ibis/extensions_mountainash/relsys_ib_ext_ma_util.py +++ b/src/mountainash/relations/backends/relation_systems/ibis/extensions_mountainash/relsys_ib_ext_ma_util.py @@ -197,17 +197,174 @@ def join_asof( strategy: str, tolerance: Any, ) -> ir.Table: - kwargs: dict[str, Any] = {"on": on} - if by is not None: - kwargs["by"] = by + # backward has a native ASOF JOIN translation on duckdb and polars; + # sqlite has none, and forward/nearest have no native direction + # control anywhere -- those route through the emulation. + if strategy == "backward" and self.dialect in ("ibis-duckdb", "ibis-polars"): + return self._native_asof(left, right, on=on, by=by, tolerance=tolerance) + return self._emulate_asof( + left, right, on=on, by=by, strategy=strategy, tolerance=tolerance + ) + + def _native_asof( + self, + left: ir.Table, + right: ir.Table, + *, + on: str, + by: Optional[list[str]], + tolerance: Any, + ) -> ir.Table: + """Native asof_join for `backward` on ibis-duckdb/ibis-polars, with `by` + translated to predicates (ibis 12 has no `by` parameter) and + Polars-parity schema (the `{on}_right` column ibis 12.0.0's asof_join + always emits is dropped -- a pre-existing leak in the current + codebase, only caught because this plan's tests do full-row Polars- + oracle equality). + + Two DECLARED (not fixed) divergences from Polars on ibis-duckdb: + IB-REL-16 (duplicate-right-key ties under backward pick the FIRST row, + not the LAST) and IB-REL-17 (row order for interleaved `by` groups is + grouped-by-value, not left-input-preserving). Neither is a value- + correctness defect -- every matched row is a valid at-or-before match, + just not necessarily THE SAME one Polars happens to pick among equals. + + One genuine bug IS fixed here, not declared: without an explicit + secondary sort key, duplicate-LEFT-row order on ibis-duckdb is + NONDETERMINISTIC (probe-confirmed: varied across 20 fresh-connection + reps) -- the `_ma_left_id` tiebreak pins this deterministically (and, + as a side effect, correctly, since duplicate-left-row cases have no + by-group-interleaving ambiguity). `ibis.row_number()` has no + translation on ibis-polars (IB-REL-01), and isn't needed there: it + delegates directly to real Polars' own `join_asof`, which already + preserves left input order natively and stably with no `order_by` at + all (probe-confirmed: 20/20 identical reps, including interleaved + groups) -- adding one there would only break that. + """ + by_cols = list(by) if by else [] + if self.dialect == "ibis-duckdb": + left_id = left.mutate(_ma_left_id=ibis.row_number()) + predicates = [left_id[c] == right[c] for c in by_cols] + result = left_id.asof_join(right, on=on, predicates=predicates, tolerance=tolerance) + on_right = f"{on}_right" + drop = [c for c in ([on_right] + [f"{c}_right" for c in by_cols]) if c in result.columns] + if drop: + result = result.drop(*drop) + return result.order_by([*by_cols, on, "_ma_left_id"]).drop("_ma_left_id") + + predicates = [left[c] == right[c] for c in by_cols] + result = left.asof_join(right, on=on, predicates=predicates, tolerance=tolerance) + on_right = f"{on}_right" + drop = [c for c in ([on_right] + [f"{c}_right" for c in by_cols]) if c in result.columns] + if drop: + result = result.drop(*drop) + return result + + def _emulate_asof( + self, + left: ir.Table, + right: ir.Table, + *, + on: str, + by: Optional[list[str]], + strategy: str, + tolerance: Any, + ) -> ir.Table: + """Emulate an asof join as an Ibis relational expression (spec §5.2) + for forward/nearest (any SQL dialect) and every strategy on + ibis-sqlite. Probe-verified (scripts/probes/probe_asof_emulation.py) + against the Polars oracle for VALUE correctness on every case. + + Composition: presort both inputs by `[by, on]`, assign a row_number + identity to each, inner-join on the strategy's directional predicate + (none for `nearest`, ranked purely by distance), rank per left row + (forward: smallest qualifying key, ties broken by smallest id; + backward: largest qualifying key, ties broken by largest id; nearest: + distance then right id descending -- reproduces both "forward wins a + genuine cross-side tie" and "last wins a same-value duplicate tie"), + filter rank 0 (0-based), left-keep join, drop internal/collision + columns. + + DECLARED (not fixed): IB-REL-17 -- the final `order_by([by, on, id])` + groups rows by `by` value, diverging from Polars' left-input-order + preservation when groups interleave. Values are always correct. + + Temporal keys: a `datetime.timedelta` tolerance is converted to + seconds before comparison. Raises BackendCapabilityError for temporal + on-columns combined with nearest/tolerance on ibis-sqlite (IB-REL-14): + `IntervalColumn` has no `.abs()`, and `.delta(unit="second")` has no + sqlite translation (OperationNotDefinedError). Plain forward/backward + over temporal keys need no distance and work fine on both dialects. + """ + from datetime import timedelta + + from mountainash.core.types import BackendCapabilityError + from mountainash.relations.core.relation_system.relation_keys.enums import ( + RKEY_MOUNTAINASH_REL, + ) + + left_cols = list(left.columns) + right_cols = list(right.columns) + by_cols = list(by) if by else [] + + is_temporal = left[on].type().is_temporal() + if self.dialect == "ibis-sqlite" and is_temporal and ( + strategy == "nearest" or tolerance is not None + ): + raise BackendCapabilityError( + "ibis-sqlite has no TimestampDelta translation " + "(OperationNotDefinedError); temporal join_asof nearest/tolerance " + "distance cannot be computed on this dialect. Use ibis-duckdb, " + "polars, or narwhals for temporal nearest/tolerance asof joins.", + backend="ibis", + function_key=RKEY_MOUNTAINASH_REL.JOIN_ASOF, + ) + + if is_temporal and isinstance(tolerance, timedelta): + tolerance = tolerance.total_seconds() + + def _distance(a, b): + if is_temporal: + return a.delta(b, unit="second").abs() + return (a - b).abs() + + left_sorted = left.order_by([*by_cols, on]) + right_sorted = right.order_by([*by_cols, on]) + left_id = left_sorted.mutate(_ma_left_id=ibis.row_number()) + right_id = right_sorted.mutate(_ma_right_id=ibis.row_number()) + + if strategy == "forward": + pred = right_id[on] >= left_id[on] + elif strategy == "backward": + pred = right_id[on] <= left_id[on] + else: # nearest: no directional filter, ranked purely by distance below + pred = ibis.literal(True) + for col in by_cols: + pred = pred & (right_id[col] == left_id[col]) if tolerance is not None: - kwargs["tolerance"] = tolerance - result = left.asof_join(right, **kwargs) - # Ibis's SQL backends (duckdb, sqlite) give no row-order guarantee for - # ASOF JOIN output absent an explicit ORDER BY. An asof join is defined - # over data pre-sorted by `on`, so restoring that order here is the - # correct, deterministic result — it matches polars/narwhals, which - # preserve left input order. Without this, results were flaky rather - # than wrong (see docs/known-divergences.md IB-REL-11, resolved). - order_cols = [*by, on] if by else [on] - return result.order_by(order_cols) + pred = pred & (_distance(right_id[on], left_id[on]) <= tolerance) + + cand = left_id.join(right_id, pred) + on_right = f"{on}_right" if on in left_cols else on + + if strategy == "forward": + rank_order = [cand[on_right], cand["_ma_right_id"]] + elif strategy == "backward": + rank_order = [ibis.desc(cand[on_right]), ibis.desc(cand["_ma_right_id"])] + else: + rank_order = [_distance(cand[on_right], cand[on]), ibis.desc(cand["_ma_right_id"])] + + ranked = cand.mutate( + _ma_rank=ibis.row_number().over( + ibis.window(group_by="_ma_left_id", order_by=rank_order) + ) + ) + right_out_cols = [c if c not in left_cols else f"{c}_right" for c in right_cols] + best = ranked.filter(ranked["_ma_rank"] == 0).select("_ma_left_id", *right_out_cols) + + result = left_id.left_join(best, "_ma_left_id") + drop_cols = {"_ma_left_id_right", on_right} | {f"{c}_right" for c in by_cols} + result = result.drop(*[c for c in drop_cols if c in result.columns]) + result = result.order_by([*by_cols, on, "_ma_left_id"]) + public = [c for c in result.columns if c != "_ma_left_id"] + return result.select(*public) diff --git a/tests/relations/cross_backend/test_rel_join_results.py b/tests/relations/cross_backend/test_rel_join_results.py index 534fc180..4225048e 100644 --- a/tests/relations/cross_backend/test_rel_join_results.py +++ b/tests/relations/cross_backend/test_rel_join_results.py @@ -39,25 +39,14 @@ def sorted_dicts(dicts: list[dict], by: str | list[str]) -> list[dict]: from fixtures.capability_gating import xfail_divergence -_ASOF = [ - pytest.param(b, marks=xfail_divergence("IB-REL-13", backend=b)) for b in ALL_BACKENDS -] - +_ASOF = ALL_BACKENDS _ASOF_DIRECTIONAL = [ - pytest.param( - b, - marks=(xfail_divergence("IB-REL-13", backend=b), xfail_divergence("IB-REL-15", backend=b)), - ) - for b in ALL_BACKENDS + pytest.param(b, marks=xfail_divergence("IB-REL-15", backend=b)) for b in ALL_BACKENDS ] _ASOF_TEMPORAL_NEAREST = [ pytest.param( b, - marks=( - xfail_divergence("IB-REL-13", backend=b), - xfail_divergence("IB-REL-15", backend=b), - xfail_divergence("IB-REL-14", backend=b), - ), + marks=(xfail_divergence("IB-REL-15", backend=b), xfail_divergence("IB-REL-14", backend=b)), ) for b in ALL_BACKENDS ] @@ -81,7 +70,6 @@ def sorted_dicts(dicts: list[dict], by: str | list[str]) -> list[dict]: pytest.param( b, marks=( - xfail_divergence("IB-REL-13", backend=b), xfail_divergence("IB-REL-15", backend=b), xfail_divergence("NW-REL-05", backend=b), ), From 7b034103308f1935cc322cf6e0da171e75234ed1 Mon Sep 17 00:00:00 2001 From: Nathaniel Ramm Date: Wed, 19 Aug 2026 15:22:28 +1000 Subject: [PATCH 4/6] feat(item108): forward-wins nearest tie fix on narwhals-pandas/pandas + colliding-name crash fix --- .../relsys_nw_ext_ma_util.py | 80 +++++++++++++++++++ 1 file changed, 80 insertions(+) diff --git a/src/mountainash/relations/backends/relation_systems/narwhals/extensions_mountainash/relsys_nw_ext_ma_util.py b/src/mountainash/relations/backends/relation_systems/narwhals/extensions_mountainash/relsys_nw_ext_ma_util.py index ee3717cf..c2c463e5 100644 --- a/src/mountainash/relations/backends/relation_systems/narwhals/extensions_mountainash/relsys_nw_ext_ma_util.py +++ b/src/mountainash/relations/backends/relation_systems/narwhals/extensions_mountainash/relsys_nw_ext_ma_util.py @@ -170,9 +170,89 @@ def join_asof( strategy: str, tolerance: Any, ) -> Any: + if strategy == "nearest" and self._is_pandas(left): + return self._nearest_forward_wins(left, right, on=on, by=by) return left.join_asof( right, on=on, by=by if by else None, strategy=strategy, ) + + @staticmethod + def _is_pandas(frame: Any) -> bool: + from narwhals import Implementation + return getattr(frame, "implementation", None) is Implementation.PANDAS + + def _nearest_forward_wins( + self, left: Any, right: Any, *, on: str, by: Optional[list[str]] + ) -> Any: + """Portable fix (spec §5.3) for the genuine defect: pandas merge_asof + picks the BACKWARD candidate on an equidistant nearest tie between two + DIFFERENT-valued candidates, where Polars picks forward. Fixed with a + dual backward/forward join and a distance comparison. + + Colliding payload names: right payload columns sharing a name with a + left column are aliased to `{c}_right` up front (mirroring the ibis + emulation's own convention) -- without this, the `when/then/otherwise` + alias collides with the identically-named left column already in the + select list and narwhals raises `DuplicateError`. This is a genuine + crash fix, kept regardless of the narrower tie-break scope below. + + NOT fixed (declared: NW-REL-05): when the right frame has MULTIPLE + rows at the SAME matched value (a duplicate-key tie, not a cross-side + tie), this inherits pandas merge_asof's own first-of-duplicates + convention on the forward leg and last-of-duplicates on the backward + leg -- so the winning side's OWN duplicate pick may differ from + Polars' uniform last-of-tied-group rule. Reproducing that exactly + needs a within-tie-group row reversal that proved fragile across + interleaved-by-group inputs in earlier drafts of this plan; the + narrower, declared-divergence approach is deliberately preferred. + """ + import narwhals as nw + + by_cols = [by] if isinstance(by, str) else list(by or []) + left_cols = list(left.columns) + right_cols = list(right.columns) + + right_payload_raw = [c for c in right_cols if c not in (by_cols + [on])] + rename_map = {c: (f"{c}_right" if c in left_cols else c) for c in right_payload_raw} + right_aliased = right.rename(rename_map) if rename_map != {c: c for c in right_payload_raw} else right + + left_id = left.with_row_index("_ma_left_id") + # Alias the right `on` column before join_asof: narwhals coalesces the + # shared `on` key into the left's value, so without this the matched + # right-side key is unrecoverable for a distance comparison. + right2 = right_aliased.with_columns(nw.col(on).alias("_ma_right_key")) + + back = left_id.join_asof(right2, on=on, by=by_cols or None, strategy="backward") + fwd = left_id.join_asof(right2, on=on, by=by_cols or None, strategy="forward") + merged = back.join(fwd, on="_ma_left_id", how="left", suffix="_fwd") + + # Forward wins when it matched and is no farther than the backward + # candidate (equidistant -> forward, per the normative tie rule). + fwd_wins = ( + (~merged["_ma_right_key_fwd"].is_null()) + & ( + merged["_ma_right_key"].is_null() + | ( + (merged["_ma_right_key_fwd"] - merged[on]).abs() + <= (merged["_ma_right_key"] - merged[on]).abs() + ) + ) + ) + + right_payload_out = [rename_map[c] for c in right_payload_raw] + left_payload = [c for c in left_cols if c not in (by_cols + [on])] + + keep = [merged[on], merged["_ma_left_id"]] + keep += [merged[c] for c in by_cols] + keep += [merged[c] for c in left_payload] + for c in right_payload_out: + keep.append( + nw.when(fwd_wins).then(merged[f"{c}_fwd"]).otherwise(merged[c]).alias(c) + ) + + result = merged.select(keep) + result = result.sort([*by_cols, on, "_ma_left_id"]) + return result.drop("_ma_left_id") From 78485a418da614e56fe63f401453110bcf1b4b09 Mon Sep 17 00:00:00 2001 From: Nathaniel Ramm Date: Wed, 19 Aug 2026 15:30:36 +1000 Subject: [PATCH 5/6] chore(item108): close IB-REL-13 upstream registry entry, add IB-REL-15 entry, regenerate all generated artifacts Added assert_predicate_capability_gated() to tests/fixtures/capability_gating.py: capability_gate()/assert_capability_gated() only resolve static family/dialect/param facts, never predicate facts (which need actual bound call values to evaluate) - the new helper is the predicate-fact counterpart, keeping the raw pytest.raises form out of migrated test files per test_no_migrated_site_carries_a_raw_capability_form. hatch run mypy:check confirmed pre-existing broken on develop (identical 98 errors, same duplicate-module-name root cause) - zero new errors from this change (diffed). --- docs/known-divergences.md | 46 ++++-- docs/reference/expression-coverage-scoped.md | 8 +- docs/reference/expression-coverage.json | 149 ++++++++++++++++-- docs/reference/expression-coverage.md | 20 ++- registry/upstream-issues.yaml | 44 +++++- .../core/capabilities/divergences.py | 2 +- tests/_spine_expectation_census.md | 20 ++- tests/core/test_capability_predicate_probe.py | 15 +- tests/fixtures/capability_gating.py | 30 ++++ .../test_rel_extension_ops_results.py | 10 +- 10 files changed, 286 insertions(+), 58 deletions(-) diff --git a/docs/known-divergences.md b/docs/known-divergences.md index 85dbecb6..097ba72d 100644 --- a/docs/known-divergences.md +++ b/docs/known-divergences.md @@ -2,11 +2,11 @@ -> Last generated: 2026-08-13 03:40 UTC +> Last generated: 2026-08-19 05:24 UTC ## Overview -Total divergences tracked: **125** +Total divergences tracked: **128** ## Summary @@ -62,6 +62,7 @@ Total divergences tracked: **125** | IB-DT-07 | ibis-sqlite: microsecond() returns seconds instead of microsecond component | ibis-sqlite | upstream_bug | Strict xfail | Investigating | | IB-DT-08 | ibis backends: nanosecond() returns 0 — no sub-microsecond precision from Python datetime | ibis-duckdb, ibis-polars, ibis-sqlite | by_design | Strict xfail | By Design | | IB-DT-09 | Ibis today() upcasts date to timestamp and now() uses query-time UTC SQL | ibis-duckdb, ibis-polars, ibis-sqlite | by_design | Accepted (documented) | By Design | +| IB-DT-19 | SQLite backend memtable registration crashes on null date/timestamp values (NaT binding) | ibis-sqlite | upstream_bug | None | Needs Filing | | NW-DT-01 | Datetime offset ops require literal integers — column expressions rejected (parameter-width) | narwhals-pandas, narwhals-polars | parameter_width | Enhanced error message | Open | | NW-DT-02 | week_of_year not supported on pandas backend | narwhals-pandas | upstream_feature_gap | Strict xfail | Investigating | | NW-DT-03 | dt.time() is not supported on any Narwhals dialect — NotImplementedError | narwhals-pandas, narwhals-polars, narwhals-lazy | upstream_feature_gap | Strict xfail | Investigating | @@ -122,7 +123,8 @@ Total divergences tracked: **125** | IB-REL-10 | ibis-sqlite: drop_nans/unpivot/melt raise OperationNotDefinedError | ibis-sqlite | upstream_feature_gap | Strict xfail | Needs Filing | | IB-REL-11 | RESOLVED: ibis-duckdb asof join returned nondeterministic row order | ibis-duckdb | mountainash_internal | None | Resolved (internal) | | IB-REL-12 | cross_join between two same-named tables from different Ibis connections raises a column-binding error on SQL backends | ibis-duckdb, ibis-sqlite | mountainash_internal | Strict xfail | Investigating | -| IB-REL-13 | ibis-sqlite: asof join raises UnsupportedOperationError | ibis-sqlite | upstream_feature_gap | Strict xfail | Needs Filing | +| IB-REL-13 | RESOLVED: ibis-sqlite asof join raised UnsupportedOperationError | ibis-sqlite | upstream_feature_gap | None | Resolved (internal) | +| IB-REL-15 | ibis-polars rejects non-equality join predicates, blocking the join_asof forward/nearest emulation | ibis-polars | upstream_feature_gap | Enhanced error message | Needs Filing | ### Aggregate Operations @@ -765,6 +767,19 @@ Total divergences tracked: **125** | Workaround | Accepted (documented) | | Last Verified | 2026-07-05 | +### IB-DT-19: SQLite backend memtable registration crashes on null date/timestamp values (NaT binding) + +| Field | Value | +|---|---| +| Project | ibis | +| Category | Datetime Operations | +| Root Cause | upstream_bug | +| Affected Backends | ibis-sqlite | +| Status | Needs Filing | +| Workaround | None | +| Notes | _register_in_memory_table (ibis/backends/sqlite/__init__.py) stages memtables via op.data.to_frame() (a pandas roundtrip). A null date32 or timestamp value becomes pandas NaT, which sqlite3 cannot bind — crashes create_table/insert for any frame containing a null temporal value. Verified empirically 2026-08-18 against ibis 12.0.0 — raw pyarrow.Table sources are incidentally safe for date columns only (PyArrow's Table.to_pandas() defaults date_as_object=True, so a null date32 becomes Python None, not NaT) but not for timestamp columns; polars/pandas DataFrame sources crash for both date and timestamp columns (their own to_pandas() maps Date to datetime64 directly). Discovered downstream in mountainash-data (DEBT-13), not via mountainash's own cross-backend probe suite — mountainash itself does not yet have a CapabilityFact/DivergenceFact exercising this path. | +| Last Verified | 2026-08-18 | + ### NW-DT-01: Datetime offset ops require literal integers — column expressions rejected (parameter-width) | Field | Value | @@ -1264,7 +1279,7 @@ Total divergences tracked: **125** | Notes | ibis-sqlite lacks array/pivot relational translations: Relation.drop_nans()/ unpivot()/melt() raise OperationNotDefinedError; ibis-duckdb/ibis-polars and polars/narwhals compute them. Renamed from a colliding DivergenceFact id (was "IB-REL-07", which already named an unrelated entry above — the ArrayValue.sort() descending-parameter gap) when backlog item 87's id-collision detector caught the reuse; the DivergenceFact and this entry now self-reference via upstream_ref (backlog item 87, 2026-08-13). | | Last Verified | 2026-08-13 | -### IB-REL-11: RESOLVED — ibis-duckdb asof join returned nondeterministic row order +### IB-REL-11: RESOLVED: ibis-duckdb asof join returned nondeterministic row order | Field | Value | |---|---| @@ -1274,7 +1289,7 @@ Total divergences tracked: **125** | Affected Backends | ibis-duckdb | | Status | Resolved (internal) | | Workaround | None | -| Notes | Originally described as "asof join is unreliable on Ibis SQL backends" covering both ibis-duckdb and ibis-sqlite. Root-caused 2026-08-18 (PR #297 CI investigation, repeated single-test process runs flipped xfail/XPASS ~50/50): Relation.join_asof() on the Ibis backend never applied an explicit ORDER BY, and DuckDB gives no row-order guarantee for ASOF JOIN output absent one — the query planner nondeterministically returned rows in original or shuffled order run-to-run. This was not a value divergence: join values were always correct, only the row order backing the test's positional assertions flapped. Fixed by ordering the Ibis join_asof result by the join key(s) (relsys_ib_ext_ma_util.py) to match polars/narwhals' left-order preservation. The distinct ibis-sqlite raise (no ASOF JOIN translation) was split off to IB-REL-13, which remains open. | +| Notes | Originally described as "asof join is unreliable on Ibis SQL backends" covering both ibis-duckdb and ibis-sqlite. Root-caused (2026-08-18, PR #297 CI investigation): Relation.join_asof() on the Ibis backend never applied an explicit ORDER BY, and DuckDB gives no row-order guarantee for ASOF JOIN output absent one — the query planner nondeterministically returned rows in original or shuffled order run-to-run, flipping the strict-xfail test between XFAIL and XPASS(strict) independent of any test-suite change. Not a value divergence — the join values were always correct, only positional-assertion row order flapped. Fixed by ordering the Ibis join_asof result by the join key(s) (relsys_ib_ext_ma_util.py) to match polars/narwhals' left-order preservation. The distinct ibis-sqlite raise (SQLite has no ASOF JOIN translation) was split off to IB-REL-13, which remains a genuine open gap. Renamed from a colliding DivergenceFact id (was "IB-REL-08") 2026-08-13; that history stands, this entry is now closed. | | Last Verified | 2026-08-18 | ### IB-REL-12: cross_join between two same-named tables from different Ibis connections raises a column-binding error on SQL backends @@ -1290,7 +1305,7 @@ Total divergences tracked: **125** | Notes | Verified empirically (backlog item 87, 2026-08-13): Relation.cross_join() raises duckdb BinderException / sqlite OperationalError ("no such column") when the two input tables share a table name but originate from separate Ibis connections (exactly the shape produced by the test suite's BackendDataFrameFactory, which names every table "test_table"); ibis-polars and polars/narwhals are unaffected. Root cause not yet isolated to Ibis vs. mountainash's join visitor — likely a missing table-alias disambiguation when two DatabaseTable operations share a name across connections. Renamed from a colliding DivergenceFact id (was "IB-REL-09", whose yaml entry described a different, no-longer-reproducible "suffixes kwarg" TypeError) when backlog item 87's id-collision detector caught the reuse; the DivergenceFact and this entry now self-reference via upstream_ref. | | Last Verified | 2026-08-13 | -### IB-REL-13: ibis-sqlite: asof join raises UnsupportedOperationError +### IB-REL-13: RESOLVED: ibis-sqlite asof join raised UnsupportedOperationError | Field | Value | |---|---| @@ -1298,10 +1313,23 @@ Total divergences tracked: **125** | Category | Relational Operations | | Root Cause | upstream_feature_gap | | Affected Backends | ibis-sqlite | +| Status | Resolved (internal) | +| Workaround | None | +| Notes | Split from IB-REL-11 (2026-08-18) after the ibis-duckdb portion (a nondeterministic row-order bug, not a value divergence) was fixed in mountainash by ordering the join_asof result deterministically. This entry tracked the remaining genuine upstream gap: Ibis has no ASOF JOIN translation for the SQLite backend. Resolved (2026-08-19, item 108): every strategy on ibis-sqlite now routes through an Ibis-relational-expression emulation (inner candidate join + windowed rank + left-keep join) instead of native asof_join, matching Polars on every value (scripts/probes/ probe_asof_emulation.py). Two narrower row-order/tie-winner divergences from the emulation and the ibis-duckdb native path are tracked separately as IB-REL-16/IB-REL-17. The DivergenceFact was removed from divergences.py in the same change (Task 3); this entry stays as the historical record, per the IB-REL-11 precedent above. | +| Last Verified | 2026-08-19 | + +### IB-REL-15: ibis-polars rejects non-equality join predicates, blocking the join_asof forward/nearest emulation + +| Field | Value | +|---|---| +| Project | ibis | +| Category | Relational Operations | +| Root Cause | upstream_feature_gap | +| Affected Backends | ibis-polars | | Status | Needs Filing | -| Workaround | Strict xfail | -| Notes | Split from IB-REL-11 (2026-08-18) after the ibis-duckdb portion (a nondeterministic row-order bug, not a value divergence) was fixed in mountainash by ordering the join_asof result deterministically. This entry tracks the remaining genuine upstream gap: Ibis has no ASOF JOIN translation for the SQLite backend, so Table.asof_join() raises UnsupportedOperationError on ibis-sqlite. Use a polars or narwhals backend for asof joins on that data. | -| Last Verified | 2026-08-18 | +| Workaround | Enhanced error message | +| Notes | item 108: Relation.join_asof(strategy="forward"|"nearest") lowers to an Ibis-relational-expression emulation (inner candidate join on a non-equality directional predicate, e.g. right.on >= left.on). The Ibis Polars backend raises TypeError("Only equality join predicates supported with pandas") for any non-equality join, so the emulation cannot run there (probe- confirmed on ibis 12.0.0/polars 1.43.2). A CapabilityFact (relations/backends/capabilities/ibis.py) gates this permanently via a predicate on the `strategy` param, raising a clear BackendCapabilityError before the raw TypeError would surface. `backward` is unaffected (native asof_join, no candidate join needed). | +| Last Verified | 2026-08-19 | ## Aggregate Operations diff --git a/docs/reference/expression-coverage-scoped.md b/docs/reference/expression-coverage-scoped.md index 46ccf6fb..e8cb6f20 100644 --- a/docs/reference/expression-coverage-scoped.md +++ b/docs/reference/expression-coverage-scoped.md @@ -5,7 +5,7 @@ Scoped deviations — dialect, parameter, option, value-class; function-level coverage and matrices live in [`expression-coverage.md`](expression-coverage.md). -Declarations: 43 · Facts: 1466 · Registered operations: 326 · Implementation records: 978 +Declarations: 43 · Facts: 1467 · Registered operations: 326 · Implementation records: 978 Legend — scoped deviations: @@ -1984,6 +1984,12 @@ Legend — scoped deviations: | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | | * | tolerance | — | — | unsupported | gate | build | tolerance is not None | join_asof(tolerance=...) is not supported by the Narwhals backend | Drop tolerance= or use the Polars backend. | — | 2026-07-05 | — | — | +### `JOIN_ASOF` × ibis (RKEY_MOUNTAINASH_REL) + +| Dialect | Param | Option values | Value class | Level | Enforcement | Boundary | Condition | Message | Workaround | Upstream | Since | Native errors | Probe-exempt | +| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | +| ibis-polars | strategy | — | — | unsupported | gate | build | — | join_asof forward/nearest lowers to a non-equality candidate join; the ibis Polars backend rejects non-equality join predicates (TypeError: Only equality join predicates supported with pandas). | Use ibis-duckdb/ibis-sqlite, or polars/narwhals backends. | IB-REL-15 | 2026-08-18 | — | — | + ### `READ_RESOURCE` × polars (RKEY_MOUNTAINASH_REL) | Dialect | Param | Option values | Value class | Level | Enforcement | Boundary | Condition | Message | Workaround | Upstream | Since | Native errors | Probe-exempt | diff --git a/docs/reference/expression-coverage.json b/docs/reference/expression-coverage.json index 281b8b79..6769ec01 100644 --- a/docs/reference/expression-coverage.json +++ b/docs/reference/expression-coverage.json @@ -1,7 +1,7 @@ { "stamp": { "declarations": 43, - "facts": 1466, + "facts": 1467, "operations": 326, "implementation_records": 978 }, @@ -39,8 +39,8 @@ "unknown": 0 }, "default_capable": 138, - "audited_clean": 111, - "constrained": 77, + "audited_clean": 110, + "constrained": 78, "audited_unknown": 0 } }, @@ -50,19 +50,19 @@ "expr_capable": 149, "literal_only": 65, "polymorphic": 9, - "unsupported": 1243 + "unsupported": 1244 }, "facts_by_enforcement": { - "gate": 1459, + "gate": 1460, "router_metadata": 3, "materialize_residue": 4 }, "facts_by_backend": { "polars": 265, "narwhals": 586, - "ibis": 615 + "ibis": 616 }, - "facts_total": 1466 + "facts_total": 1467 }, "families": [ { @@ -42942,15 +42942,32 @@ "impl_protocol": "MountainashIbisExtensionRelationSystem", "audited": true, "whole_op": null, - "constrained": false, + "constrained": true, "contradiction": false, "selector_counts": { - "params": 0, + "params": 1, "option_selectors": 0, "value_classes": 0, - "dialects": 0 + "dialects": 1 }, - "constraints": [], + "constraints": [ + { + "dialect": "ibis-polars", + "param": "strategy", + "option_value": null, + "value_class": null, + "level": "unsupported", + "enforcement": "gate", + "boundary": "build", + "condition": null, + "message": "join_asof forward/nearest lowers to a non-equality candidate join; the ibis Polars backend rejects non-equality join predicates (TypeError: Only equality join predicates supported with pandas).", + "workaround": "Use ibis-duckdb/ibis-sqlite, or polars/narwhals backends.", + "upstream_ref": "IB-REL-15", + "since": "2026-08-18", + "native_errors": [], + "probe_exempt": null + } + ], "residue": [], "routed": [], "refinements": [] @@ -46506,6 +46523,22 @@ "since": "2026-08-01", "native_errors": [], "probe_exempt": "relation op-level gap; covered by relation with_row_index cross-backend tests" + }, + { + "dialect": "ibis-polars", + "param": "strategy", + "option_value": null, + "value_class": null, + "level": "unsupported", + "enforcement": "gate", + "boundary": "build", + "condition": null, + "message": "join_asof forward/nearest lowers to a non-equality candidate join; the ibis Polars backend rejects non-equality join predicates (TypeError: Only equality join predicates supported with pandas).", + "workaround": "Use ibis-duckdb/ibis-sqlite, or polars/narwhals backends.", + "upstream_ref": "IB-REL-15", + "since": "2026-08-18", + "native_errors": [], + "probe_exempt": null } ] }, @@ -70069,18 +70102,58 @@ "since": "2026-08-06" }, { - "id": "IB-REL-13", + "id": "IB-REL-14", "kind": "engine_leniency", "operation_keys": [], "backends": [ "ibis-sqlite" ], - "summary": "ibis-sqlite: asof join raises UnsupportedOperationError — no ASOF JOIN translation", - "impact": "Relation.join_asof() raises on ibis-sqlite; polars/narwhals and ibis-duckdb compute it correctly", - "workaround": "Use a polars or narwhals backend for asof joins", - "upstream_ref": "IB-REL-13", + "summary": "ibis-sqlite has no TimestampDelta translation (OperationNotDefinedError, probe-confirmed on ibis 12.0.0); the asof emulation cannot compute a temporal distance there", + "impact": "Relation.join_asof(strategy='nearest') or tolerance=... over a temporal `on` column raises BackendCapabilityError on ibis-sqlite; forward/backward over temporal keys (no distance needed) work fine there", + "workaround": "Use ibis-duckdb, polars, or narwhals for temporal nearest/tolerance asof joins", + "upstream_ref": null, "since": "2026-08-18" }, + { + "id": "IB-REL-15", + "kind": "engine_leniency", + "operation_keys": [], + "backends": [ + "ibis-polars" + ], + "summary": "ibis-polars rejects the emulation's non-equality candidate join (TypeError: Only equality join predicates supported with pandas, probe-confirmed); forward/nearest strategies are permanently capability-gated there", + "impact": "Relation.join_asof(strategy='forward'|'nearest') raises BackendCapabilityError on ibis-polars; backward is native and unaffected", + "workaround": "Use ibis-duckdb, ibis-sqlite, polars, or narwhals for forward/nearest asof joins", + "upstream_ref": "IB-REL-15", + "since": "2026-08-18" + }, + { + "id": "IB-REL-16", + "kind": "engine_leniency", + "operation_keys": [], + "backends": [ + "ibis-duckdb" + ], + "summary": "ibis-duckdb's native asof_join picks the FIRST equal-key right row on a duplicate-right-key tie under backward; Polars picks the LAST (probe-confirmed on ibis 12.0.0). ibis-polars native (delegating to real Polars) and the Ibis emulation used everywhere else both already match Polars on this", + "impact": "Relation.join_asof(strategy='backward') on ibis-duckdb may select a different (but still equally-valid, at-or-before) right row than Polars when the right frame has duplicate keys at the matched value", + "workaround": "Use ibis-sqlite, ibis-polars, polars, or narwhals for exact duplicate-tie parity under backward", + "upstream_ref": null, + "since": "2026-08-19" + }, + { + "id": "IB-REL-17", + "kind": "engine_leniency", + "operation_keys": [], + "backends": [ + "ibis-duckdb", + "ibis-sqlite" + ], + "summary": "Ibis's SQL-backend asof paths (native duckdb backward, and the emulation used for forward/nearest and all sqlite strategies) order output by [by, on] for determinism, which groups rows contiguously by `by` value; Polars (and narwhals/pandas natively, and ibis-polars natively) instead preserve the left input's own row order, which differs whenever `by` groups are interleaved in that input", + "impact": "Relation.join_asof(by=...) on ibis-duckdb/ibis-sqlite returns rows grouped by `by` value rather than in left input order when groups interleave; matched values are always correct, only row position differs", + "workaround": "Use ibis-polars, polars, or narwhals if exact left-input row order must be preserved for interleaved by-groups", + "upstream_ref": null, + "since": "2026-08-19" + }, { "id": "IB-STR-11", "kind": "engine_leniency", @@ -70990,6 +71063,50 @@ "upstream_ref": null, "since": "2026-08-06" }, + { + "id": "NW-REL-03", + "kind": "engine_leniency", + "operation_keys": [], + "backends": [ + "narwhals-polars", + "narwhals-pandas", + "narwhals-lazy", + "pandas" + ], + "summary": "narwhals join_asof(tolerance=...) is GATE-UNSUPPORTED family-wide (capabilities/narwhals.py); a raw pandas.DataFrame is routed through the same narwhals identity at runtime", + "impact": "Relation.join_asof(tolerance=...) raises BackendCapabilityError on all narwhals-family dialects, including the 'pandas' test backend", + "workaround": "Drop tolerance= or use the polars/ibis backends", + "upstream_ref": null, + "since": "2026-08-18" + }, + { + "id": "NW-REL-04", + "kind": "engine_leniency", + "operation_keys": [], + "backends": [ + "narwhals-pandas", + "pandas" + ], + "summary": "pandas merge_asof raises ValueError on null as-of keys (left or right side); narwhals-polars/narwhals-lazy compute no-match rows like Polars", + "impact": "Relation.join_asof() with null keys raises on narwhals-pandas and the 'pandas' test backend; polars/narwhals-polars/narwhals-lazy/ibis compute no-match rows", + "workaround": "Use a polars, narwhals-polars, narwhals-lazy, or ibis backend for asof joins over null keys", + "upstream_ref": null, + "since": "2026-08-18" + }, + { + "id": "NW-REL-05", + "kind": "engine_leniency", + "operation_keys": [], + "backends": [ + "narwhals-pandas", + "pandas" + ], + "summary": "narwhals-pandas nearest may pick a different duplicate right row than Polars on a duplicate-right-key tie (Polars keeps the last of a tied group; the portable forward-wins fix inherits pandas merge_asof's own first-of-duplicates convention within each of its two internal legs) — the genuine cross-side tie (forward candidate vs a DIFFERENT-valued backward candidate) is unaffected and matches Polars", + "impact": "Relation.join_asof(strategy='nearest') on narwhals-pandas/'pandas' may select a different (but still equally-near) right row than Polars when the right frame has duplicate keys at the winning distance", + "workaround": "Use polars, narwhals-polars, narwhals-lazy, or an ibis backend for exact duplicate-tie parity under nearest", + "upstream_ref": null, + "since": "2026-08-19" + }, { "id": "NW-STR-14", "kind": "semantics", diff --git a/docs/reference/expression-coverage.md b/docs/reference/expression-coverage.md index 66592ad3..e89fb39d 100644 --- a/docs/reference/expression-coverage.md +++ b/docs/reference/expression-coverage.md @@ -3,7 +3,7 @@ -Declarations: 43 · Facts: 1466 · Registered operations: 326 · Implementation records: 978 +Declarations: 43 · Facts: 1467 · Registered operations: 326 · Implementation records: 978 Scoped deviations (dialect/param/option/value-class) live in [`expression-coverage-scoped.md`](expression-coverage-scoped.md). @@ -52,7 +52,7 @@ Legend — cell states (by exception): | --- | --- | --- | --- | --- | --- | --- | | polars | 191 | 83 | 52 | 0 | 0 | 326 | | narwhals | 97 | 151 | 78 | 0 | 0 | 326 | -| ibis | 138 | 111 | 77 | 0 | 0 | 326 | +| ibis | 138 | 110 | 78 | 0 | 0 | 326 | contradictions: 0 audited_unknown: 0 @@ -61,9 +61,9 @@ audited_unknown: 0 | Axis | Breakdown | | --- | --- | -| Level | expr_capable 149, literal_only 65, polymorphic 9, unsupported 1243 | -| Enforcement | gate 1459, router_metadata 3, materialize_residue 4 | -| Backend | polars 265, narwhals 586, ibis 615 | +| Level | expr_capable 149, literal_only 65, polymorphic 9, unsupported 1244 | +| Enforcement | gate 1460, router_metadata 3, materialize_residue 4 | +| Backend | polars 265, narwhals 586, ibis 616 | `pandas` / `pyarrow` are routed input types (they execute via the narwhals path) and are not independent coverage columns. @@ -388,7 +388,7 @@ audited_unknown: 0 | `EMPTY_FRAME` | ✓ audited | ✓ audited | ✓ audited | | `EXPLODE` | ✓ audited | ✓ audited | ✓ audited | | `FETCH_FROM_END` | ✓ audited | ✓ audited | ✓ audited | -| `JOIN_ASOF` | ✓ audited | ◐ partial (1 params, 0 option-selectors, 0 value-classes, 0 dialects) | ✓ audited | +| `JOIN_ASOF` | ✓ audited | ◐ partial (1 params, 0 option-selectors, 0 value-classes, 0 dialects) | ◐ partial (1 params, 0 option-selectors, 0 value-classes, 1 dialects) | | `PIVOT` | ✓ audited | ✓ audited | ✓ audited | | `READ_RESOURCE` | ✓ audited ↻ routed | ✓ audited ↻ routed | ✓ audited ↻ routed | | `REF` | ✓ᴴ audited | ✓ᴴ audited | ✓ᴴ audited | @@ -539,7 +539,10 @@ Cells whose facts are all scoped (dialect / parameter / option / value-class) ha | IB-REL-06 | engine_leniency | ibis-duckdb | — | DuckDB rejects tables containing untyped all-NULL columns | Projections whose column is entirely null raise a type resolution error | cast the null column to an explicit type first | IB-REL-06 | 2026-07-05 | | IB-REL-10 | engine_leniency | ibis-sqlite | — | ibis-sqlite lacks array/pivot relational translations: drop_nans, unpivot/melt raise OperationNotDefinedError | Relation.drop_nans()/unpivot()/melt() raise on ibis-sqlite; other backends compute them | Use ibis-duckdb or a polars/narwhals backend for these relational ops | IB-REL-10 | 2026-08-06 | | IB-REL-12 | engine_leniency | ibis-duckdb, ibis-sqlite | — | cross_join between two same-named tables from different Ibis connections raises a column-binding error on ibis SQL backends (ibis-duckdb BinderException, ibis-sqlite OperationalError) | Relation.cross_join() raises on ibis-duckdb/ibis-sqlite; polars/narwhals and ibis-polars compute it | Use a polars/narwhals backend or ibis-polars for cross joins | IB-REL-12 | 2026-08-06 | -| IB-REL-13 | engine_leniency | ibis-sqlite | — | ibis-sqlite: asof join raises UnsupportedOperationError — no ASOF JOIN translation | Relation.join_asof() raises on ibis-sqlite; polars/narwhals and ibis-duckdb compute it correctly | Use a polars or narwhals backend for asof joins | IB-REL-13 | 2026-08-18 | +| IB-REL-14 | engine_leniency | ibis-sqlite | — | ibis-sqlite has no TimestampDelta translation (OperationNotDefinedError, probe-confirmed on ibis 12.0.0); the asof emulation cannot compute a temporal distance there | Relation.join_asof(strategy='nearest') or tolerance=... over a temporal `on` column raises BackendCapabilityError on ibis-sqlite; forward/backward over temporal keys (no distance needed) work fine there | Use ibis-duckdb, polars, or narwhals for temporal nearest/tolerance asof joins | — | 2026-08-18 | +| IB-REL-15 | engine_leniency | ibis-polars | — | ibis-polars rejects the emulation's non-equality candidate join (TypeError: Only equality join predicates supported with pandas, probe-confirmed); forward/nearest strategies are permanently capability-gated there | Relation.join_asof(strategy='forward'\|'nearest') raises BackendCapabilityError on ibis-polars; backward is native and unaffected | Use ibis-duckdb, ibis-sqlite, polars, or narwhals for forward/nearest asof joins | IB-REL-15 | 2026-08-18 | +| IB-REL-16 | engine_leniency | ibis-duckdb | — | ibis-duckdb's native asof_join picks the FIRST equal-key right row on a duplicate-right-key tie under backward; Polars picks the LAST (probe-confirmed on ibis 12.0.0). ibis-polars native (delegating to real Polars) and the Ibis emulation used everywhere else both already match Polars on this | Relation.join_asof(strategy='backward') on ibis-duckdb may select a different (but still equally-valid, at-or-before) right row than Polars when the right frame has duplicate keys at the matched value | Use ibis-sqlite, ibis-polars, polars, or narwhals for exact duplicate-tie parity under backward | — | 2026-08-19 | +| IB-REL-17 | engine_leniency | ibis-duckdb, ibis-sqlite | — | Ibis's SQL-backend asof paths (native duckdb backward, and the emulation used for forward/nearest and all sqlite strategies) order output by [by, on] for determinism, which groups rows contiguously by `by` value; Polars (and narwhals/pandas natively, and ibis-polars natively) instead preserve the left input's own row order, which differs whenever `by` groups are interleaved in that input | Relation.join_asof(by=...) on ibis-duckdb/ibis-sqlite returns rows grouped by `by` value rather than in left input order when groups interleave; matched values are always correct, only row position differs | Use ibis-polars, polars, or narwhals if exact left-input row order must be preserved for interleaved by-groups | — | 2026-08-19 | | IB-STR-11 | engine_leniency | ibis-polars | `CONTAINS`, `STARTS_WITH`, `ENDS_WITH` | ibis-polars rejects case-insensitive string matching (contains/starts_with/ends_with with case_sensitive=False) — UnsupportedArgumentError | case-insensitive contains/starts_with/ends_with raise on ibis-polars; other backends compute them | Use ibis-duckdb/ibis-sqlite or a polars/narwhals backend for case-insensitive matching | IB-STR-11 | 2026-08-06 | | IB-TYPE-02 | semantics | ibis-duckdb, ibis-sqlite | `IS_NAN`, `FILL_NAN` | SQL engines treat NaN as NULL; NaN == NaN yields NULL not False | is_nan/fill_nan/NaN comparisons diverge on SQL engines | Use is_null/fill_null on SQL backends | IB-TYPE-02 | 2026-07-05 | | IB-TYPE-04 | type_inference | ibis-duckdb, ibis-polars, ibis-sqlite | — | Ibis defers type resolution to its backend, unlike eager Polars | Type-sensitive operations and result comparisons can differ despite matching values | — | IB-TYPE-04 | 2026-07-05 | @@ -579,6 +582,9 @@ Cells whose facts are all scoped (dialect / parameter / option / value-class) ha | NW-MATH-10 | engine_leniency | pandas, narwhals | `SIN`, `COS`, `TAN`, `ASIN`, `ACOS`, `ATAN`, `ATAN2`, `RADIANS`, `DEGREES`, `SINH`, `COSH`, `TANH`, `ASINH`, `ACOSH`, `ATANH` | pandas and narwhals lack native trigonometric, angular-conversion, and hyperbolic math functions; these ops raise NotImplementedError | trig (sin/cos/tan/asin/acos/atan/atan2), angular (radians/degrees), and hyperbolic (sinh/cosh/tanh/asinh/acosh/atanh) raise on pandas and all narwhals backends; polars and ibis (polars/duckdb) compute them | Use a polars or ibis-polars/ibis-duckdb backend for these math functions | NW-MATH-10 | 2026-08-06 | | NW-REL-01 | engine_leniency | narwhals-lazy | — | narwhals-lazy with_row_index() requires an explicit order_by= (row order over a LazyFrame is undefined); calling it without one raises TypeError | Relation.with_row_index() raises on narwhals-lazy; eager narwhals/polars and ibis-duckdb/ibis-sqlite assign a 0..N-1 index | Use an eager backend, or pass an explicit order before the lazy row index | — | 2026-08-06 | | NW-REL-02 | engine_leniency | narwhals | — | Narwhals does not support unnest of a struct column | Relation.unnest() raises on narwhals backends; polars and ibis compute it | Use a polars or ibis backend for unnest | — | 2026-08-06 | +| NW-REL-03 | engine_leniency | narwhals-polars, narwhals-pandas, narwhals-lazy, pandas | — | narwhals join_asof(tolerance=...) is GATE-UNSUPPORTED family-wide (capabilities/narwhals.py); a raw pandas.DataFrame is routed through the same narwhals identity at runtime | Relation.join_asof(tolerance=...) raises BackendCapabilityError on all narwhals-family dialects, including the 'pandas' test backend | Drop tolerance= or use the polars/ibis backends | — | 2026-08-18 | +| NW-REL-04 | engine_leniency | narwhals-pandas, pandas | — | pandas merge_asof raises ValueError on null as-of keys (left or right side); narwhals-polars/narwhals-lazy compute no-match rows like Polars | Relation.join_asof() with null keys raises on narwhals-pandas and the 'pandas' test backend; polars/narwhals-polars/narwhals-lazy/ibis compute no-match rows | Use a polars, narwhals-polars, narwhals-lazy, or ibis backend for asof joins over null keys | — | 2026-08-18 | +| NW-REL-05 | engine_leniency | narwhals-pandas, pandas | — | narwhals-pandas nearest may pick a different duplicate right row than Polars on a duplicate-right-key tie (Polars keeps the last of a tied group; the portable forward-wins fix inherits pandas merge_asof's own first-of-duplicates convention within each of its two internal legs) — the genuine cross-side tie (forward candidate vs a DIFFERENT-valued backward candidate) is unaffected and matches Polars | Relation.join_asof(strategy='nearest') on narwhals-pandas/'pandas' may select a different (but still equally-near) right row than Polars when the right frame has duplicate keys at the winning distance | Use polars, narwhals-polars, narwhals-lazy, or an ibis backend for exact duplicate-tie parity under nearest | — | 2026-08-19 | | NW-STR-14 | semantics | narwhals-pandas | `TITLE`, `INITCAP` | narwhals-pandas title/initcap route to pandas str.title(); its Unicode titlecasing of sharp-S/ligatures differs from polars to_titlecase (e.g. 'ße' -> 'ẞe' vs 'SSe') | title()/initcap() on narwhals-pandas may differ from polars/narwhals-polars on non-ASCII inputs (sharp-S, ligatures); ASCII is identical | Use polars or narwhals-polars where exact polars titlecasing of non-ASCII is required | — | 2026-07-29 | | NW-STR-15 | semantics | pandas, narwhals | `LTRIM`, `RTRIM` | pandas and narwhals lack directional trimming: ltrim/rtrim and strip_chars_start/end strip BOTH sides (only strip_chars is native), so leading/trailing-only requests over-strip | ltrim/rtrim and str.strip_chars_start()/strip_chars_end() strip both sides on pandas/narwhals; polars and ibis strip only the requested side | Use a polars or ibis backend for directional trimming | — | 2026-08-06 | | NW-STR-17 | engine_leniency | pandas, narwhals | `REPEAT` | str.repeat(n) is unsupported on pandas and narwhals (BackendCapabilityError); no repeat translation is wired for these backends | ma.col(x).str.repeat(n) raises on pandas and all narwhals backends; polars and ibis compute it | Use a polars or ibis backend for str.repeat() | — | 2026-08-06 | diff --git a/registry/upstream-issues.yaml b/registry/upstream-issues.yaml index e933b6ba..69e4c6ab 100644 --- a/registry/upstream-issues.yaml +++ b/registry/upstream-issues.yaml @@ -629,21 +629,51 @@ issues: - id: IB-REL-13 project: ibis category: relation-ops - summary: 'ibis-sqlite: asof join raises UnsupportedOperationError' + summary: 'RESOLVED: ibis-sqlite asof join raised UnsupportedOperationError' root_cause: upstream_feature_gap affected_backends: - ibis-sqlite upstream_issue: null upstream_issue_filed_by: null - status: needs_filing - our_workaround: xfail_strict + status: resolved_in_mountainash + our_workaround: none notes: 'Split from IB-REL-11 (2026-08-18) after the ibis-duckdb portion (a nondeterministic row-order bug, not a value divergence) was fixed in mountainash by ordering the join_asof result deterministically. This entry - tracks the remaining genuine upstream gap: Ibis has no ASOF JOIN translation - for the SQLite backend, so Table.asof_join() raises UnsupportedOperationError - on ibis-sqlite. Use a polars or narwhals backend for asof joins on that data.' - last_verified: '2026-08-18' + tracked the remaining genuine upstream gap: Ibis has no ASOF JOIN + translation for the SQLite backend. Resolved (2026-08-19, item 108): every + strategy on ibis-sqlite now routes through an Ibis-relational-expression + emulation (inner candidate join + windowed rank + left-keep join) instead + of native asof_join, matching Polars on every value (scripts/probes/ + probe_asof_emulation.py). Two narrower row-order/tie-winner divergences + from the emulation and the ibis-duckdb native path are tracked separately + as IB-REL-16/IB-REL-17. The DivergenceFact was removed from divergences.py + in the same change (Task 3); this entry stays as the historical record, + per the IB-REL-11 precedent above.' + last_verified: '2026-08-19' +- id: IB-REL-15 + project: ibis + category: relation-ops + summary: ibis-polars rejects non-equality join predicates, blocking the join_asof + forward/nearest emulation + root_cause: upstream_feature_gap + affected_backends: + - ibis-polars + upstream_issue: null + upstream_issue_filed_by: null + status: needs_filing + our_workaround: error_enrichment + notes: 'item 108: Relation.join_asof(strategy="forward"|"nearest") lowers to an + Ibis-relational-expression emulation (inner candidate join on a non-equality + directional predicate, e.g. right.on >= left.on). The Ibis Polars backend + raises TypeError("Only equality join predicates supported with pandas") + for any non-equality join, so the emulation cannot run there (probe- + confirmed on ibis 12.0.0/polars 1.43.2). A CapabilityFact + (relations/backends/capabilities/ibis.py) gates this permanently via a + predicate on the `strategy` param, raising a clear BackendCapabilityError + before the raw TypeError would surface. `backward` is unaffected (native + asof_join, no candidate join needed).' + last_verified: '2026-08-19' - id: IB-REL-12 project: ibis category: relation-ops diff --git a/src/mountainash/core/capabilities/divergences.py b/src/mountainash/core/capabilities/divergences.py index 2c7e8802..b1af85e7 100644 --- a/src/mountainash/core/capabilities/divergences.py +++ b/src/mountainash/core/capabilities/divergences.py @@ -728,7 +728,7 @@ def _all() -> tuple[DivergenceFact, ...]: summary="ibis-polars rejects the emulation's non-equality candidate join (TypeError: Only equality join predicates supported with pandas, probe-confirmed); forward/nearest strategies are permanently capability-gated there", impact="Relation.join_asof(strategy='forward'|'nearest') raises BackendCapabilityError on ibis-polars; backward is native and unaffected", workaround="Use ibis-duckdb, ibis-sqlite, polars, or narwhals for forward/nearest asof joins", - upstream_ref=None, + upstream_ref="IB-REL-15", since="2026-08-18", ), DivergenceFact( diff --git a/tests/_spine_expectation_census.md b/tests/_spine_expectation_census.md index 0a9445a8..1ed6bf51 100644 --- a/tests/_spine_expectation_census.md +++ b/tests/_spine_expectation_census.md @@ -143,11 +143,21 @@ Buckets: `migrated` (derivable from the spine today), `retained` (a LITERAL_ONLY | tests/expressions/cross_backend/test_window_results.py:32 | static-marker | UNRESOLVED | UNRESOLVED | UNRESOLVED | None | spine-derived id-keyed divergence mark via xfail_divergence('UNRESOLVED') — migrated | | tests/relations/cross_backend/test_rel_edge_cases_results.py:41 | static-marker | UNRESOLVED | UNRESOLVED | UNRESOLVED | None | spine-derived id-keyed divergence mark via xfail_divergence('IB-REL-06') — migrated | | tests/relations/cross_backend/test_rel_expression_integration.py:42 | static-marker | UNRESOLVED | UNRESOLVED | UNRESOLVED | None | spine-derived id-keyed divergence mark via xfail_divergence('MA-REL-02') — migrated | -| tests/relations/cross_backend/test_rel_extension_ops_results.py:38 | static-marker | UNRESOLVED | UNRESOLVED | UNRESOLVED | None | spine-derived id-keyed divergence mark via xfail_divergence('IB-REL-10') — migrated | -| tests/relations/cross_backend/test_rel_extension_ops_results.py:39 | static-marker | UNRESOLVED | UNRESOLVED | UNRESOLVED | None | spine-derived id-keyed divergence mark via xfail_divergence('NW-REL-01') — migrated | -| tests/relations/cross_backend/test_rel_extension_ops_results.py:40 | static-marker | UNRESOLVED | UNRESOLVED | UNRESOLVED | None | spine-derived id-keyed divergence mark via xfail_divergence('NW-REL-02') — migrated | -| tests/relations/cross_backend/test_rel_extension_ops_results.py:41 | static-marker | UNRESOLVED | UNRESOLVED | UNRESOLVED | None | spine-derived id-keyed divergence mark via xfail_divergence('MA-REL-01') — migrated | -| tests/relations/cross_backend/test_rel_join_results.py:42 | static-marker | UNRESOLVED | UNRESOLVED | UNRESOLVED | None | spine-derived id-keyed divergence mark via xfail_divergence('IB-REL-13') — migrated | +| tests/relations/cross_backend/test_rel_extension_ops_results.py:39 | static-marker | UNRESOLVED | UNRESOLVED | UNRESOLVED | None | spine-derived id-keyed divergence mark via xfail_divergence('IB-REL-10') — migrated | +| tests/relations/cross_backend/test_rel_extension_ops_results.py:40 | static-marker | UNRESOLVED | UNRESOLVED | UNRESOLVED | None | spine-derived id-keyed divergence mark via xfail_divergence('NW-REL-01') — migrated | +| tests/relations/cross_backend/test_rel_extension_ops_results.py:41 | static-marker | UNRESOLVED | UNRESOLVED | UNRESOLVED | None | spine-derived id-keyed divergence mark via xfail_divergence('NW-REL-02') — migrated | +| tests/relations/cross_backend/test_rel_extension_ops_results.py:42 | static-marker | UNRESOLVED | UNRESOLVED | UNRESOLVED | None | spine-derived id-keyed divergence mark via xfail_divergence('MA-REL-01') — migrated | +| tests/relations/cross_backend/test_rel_join_results.py:44 | static-marker | UNRESOLVED | UNRESOLVED | UNRESOLVED | None | spine-derived id-keyed divergence mark via xfail_divergence('IB-REL-15') — migrated | +| tests/relations/cross_backend/test_rel_join_results.py:49 | static-marker | UNRESOLVED | UNRESOLVED | UNRESOLVED | None | spine-derived id-keyed divergence mark via xfail_divergence('IB-REL-15') — migrated | +| tests/relations/cross_backend/test_rel_join_results.py:49 | static-marker | UNRESOLVED | UNRESOLVED | UNRESOLVED | None | spine-derived id-keyed divergence mark via xfail_divergence('IB-REL-14') — migrated | +| tests/relations/cross_backend/test_rel_join_results.py:54 | static-marker | UNRESOLVED | UNRESOLVED | UNRESOLVED | None | spine-derived id-keyed divergence mark via xfail_divergence('NW-REL-03') — migrated | +| tests/relations/cross_backend/test_rel_join_results.py:59 | static-marker | UNRESOLVED | UNRESOLVED | UNRESOLVED | None | spine-derived id-keyed divergence mark via xfail_divergence('NW-REL-03') — migrated | +| tests/relations/cross_backend/test_rel_join_results.py:59 | static-marker | UNRESOLVED | UNRESOLVED | UNRESOLVED | None | spine-derived id-keyed divergence mark via xfail_divergence('IB-REL-14') — migrated | +| tests/relations/cross_backend/test_rel_join_results.py:64 | static-marker | UNRESOLVED | UNRESOLVED | UNRESOLVED | None | spine-derived id-keyed divergence mark via xfail_divergence('NW-REL-04') — migrated | +| tests/relations/cross_backend/test_rel_join_results.py:67 | static-marker | UNRESOLVED | UNRESOLVED | UNRESOLVED | None | spine-derived id-keyed divergence mark via xfail_divergence('IB-REL-16') — migrated | +| tests/relations/cross_backend/test_rel_join_results.py:73 | static-marker | UNRESOLVED | UNRESOLVED | UNRESOLVED | None | spine-derived id-keyed divergence mark via xfail_divergence('IB-REL-15') — migrated | +| tests/relations/cross_backend/test_rel_join_results.py:74 | static-marker | UNRESOLVED | UNRESOLVED | UNRESOLVED | None | spine-derived id-keyed divergence mark via xfail_divergence('NW-REL-05') — migrated | +| tests/relations/cross_backend/test_rel_join_results.py:80 | static-marker | UNRESOLVED | UNRESOLVED | UNRESOLVED | None | spine-derived id-keyed divergence mark via xfail_divergence('IB-REL-17') — migrated | | tests/relations/cross_backend/test_terminal_scalar_aggregates.py:13 | static-marker | UNRESOLVED | UNRESOLVED | UNRESOLVED | None | spine-derived id-keyed divergence mark via xfail_divergence('IB-AGG-05') — migrated | | tests/relations/cross_backend/test_terminal_scalar_aggregates.py:14 | static-marker | UNRESOLVED | UNRESOLVED | UNRESOLVED | None | spine-derived id-keyed divergence mark via xfail_divergence('NW-AGG-03') — migrated | | tests/relations/test_relation_aliases.py:23 | static-marker | UNRESOLVED | UNRESOLVED | UNRESOLVED | None | spine-derived id-keyed divergence mark via xfail_divergence('IB-REL-10') — migrated | diff --git a/tests/core/test_capability_predicate_probe.py b/tests/core/test_capability_predicate_probe.py index 50dbf072..8d9ccf93 100644 --- a/tests/core/test_capability_predicate_probe.py +++ b/tests/core/test_capability_predicate_probe.py @@ -1,8 +1,6 @@ """Consumer audit for predicate facts (backlog 66b).""" from __future__ import annotations -import pytest - from mountainash.core.capabilities import CapabilityRegistry from mountainash.core.capabilities.schema import ( CapabilityFact, CapabilityLevel, Clause, ClauseOp, Predicate, @@ -31,9 +29,11 @@ def test_first_predicate_fact_is_compound_cell_safe(): inspects `strategy`. A call that also sets `tolerance` must not spuriously trigger or suppress the gate — the two gate_params are independent axes.""" import polars as pl - from mountainash.core.constants import CONST_BACKEND import mountainash as ma - from mountainash.core.types import BackendCapabilityError + from fixtures.capability_gating import assert_predicate_capability_gated + from mountainash.relations.core.relation_system.relation_keys.enums import ( + RKEY_MOUNTAINASH_REL, + ) left = pl.DataFrame({"t": [1, 3]}) right = pl.DataFrame({"t": [2, 4]}) @@ -47,9 +47,10 @@ def test_first_predicate_fact_is_compound_cell_safe(): # forward + tolerance on ibis-polars: IS gated (strategy predicate fires # regardless of the co-bound tolerance value). - with pytest.raises(BackendCapabilityError) as ei: - ma.relation(L).join_asof(R, on="t", strategy="forward", tolerance=1).to_polars() - assert ei.value.limitation.predicate is not None + err = assert_predicate_capability_gated( + lambda: ma.relation(L).join_asof(R, on="t", strategy="forward", tolerance=1).to_polars() + ) + assert err.function_key == RKEY_MOUNTAINASH_REL.JOIN_ASOF def test_fact_sort_key_is_total_over_predicate_facts(): diff --git a/tests/fixtures/capability_gating.py b/tests/fixtures/capability_gating.py index 57c3d586..21914d51 100644 --- a/tests/fixtures/capability_gating.py +++ b/tests/fixtures/capability_gating.py @@ -132,6 +132,36 @@ def assert_capability_gated(operation_key, family, *, dialect=None, build, return None +def assert_predicate_capability_gated(build) -> BackendCapabilityError: + """Assert ``build()`` raises ``BackendCapabilityError`` from a + predicate-gated ``CapabilityFact`` (item 108: the ibis-polars + join_asof ``strategy`` gate). + + Not a case ``assert_capability_gated`` can express: ``capability_gate()`` + resolves a fact via ``CapabilityRegistry.capability_for``, which reads only + ``_facts``/``_value_class_facts`` — never ``_predicate_facts``. A predicate + fact's applicability depends on the ACTUAL bound call values (e.g. + ``strategy="forward"`` vs ``"backward"``), which only exist once ``build()`` + actually runs through the real dispatch and its predicate is evaluated — + there is no static ``(operation_key, family, dialect, param)`` tuple to + pre-declare. This helper is the predicate-fact counterpart: + ``pytest.raises`` plus the ``.limitation.predicate is not None`` check + lives here, once, so no call site needs its own hand-coded reconstruction + (the pattern ``test_no_migrated_site_carries_a_raw_capability_form`` polices + out of migrated test files). + + Returns the raised error so the caller can assert further fields + (e.g. ``.function_key``). + """ + with pytest.raises(BackendCapabilityError) as ei: + build() + assert ei.value.limitation.predicate is not None, ( + f"expected a predicate-gated BackendCapabilityError, got " + f"limitation={ei.value.limitation!r}" + ) + return ei.value + + def xfail_divergence(divergence_id, *, backend, strict=True) -> pytest.MarkDecorator: """Mark a test xfail when a known DivergenceFact applies to ``backend``. diff --git a/tests/relations/cross_backend/test_rel_extension_ops_results.py b/tests/relations/cross_backend/test_rel_extension_ops_results.py index 5e1c9338..94493caf 100644 --- a/tests/relations/cross_backend/test_rel_extension_ops_results.py +++ b/tests/relations/cross_backend/test_rel_extension_ops_results.py @@ -14,6 +14,7 @@ ) from fixtures.capability_gating import ( assert_capability_gated, + assert_predicate_capability_gated, gate_dialect, gate_family, xfail_divergence, @@ -383,17 +384,16 @@ class TestJoinAsofStrategyGate: def test_ibis_polars_forward_nearest_gated(self): import ibis import polars as pl - from mountainash.core.types import BackendCapabilityError con = ibis.polars.connect() left = con.create_table("gate_l", pl.DataFrame({"t": [1, 3], "val": ["a", "b"]}), overwrite=True) right = con.create_table("gate_r", pl.DataFrame({"t": [2, 4], "score": [20, 40]}), overwrite=True) for strategy in ("forward", "nearest"): - with pytest.raises(BackendCapabilityError) as ei: - ma.relation(left).join_asof(right, on="t", strategy=strategy).to_polars() - assert ei.value.limitation.predicate is not None - assert ei.value.function_key == RKEY_MOUNTAINASH_REL.JOIN_ASOF + def _build(strategy=strategy): + return ma.relation(left).join_asof(right, on="t", strategy=strategy).to_polars() + err = assert_predicate_capability_gated(_build) + assert err.function_key == RKEY_MOUNTAINASH_REL.JOIN_ASOF def test_ibis_polars_backward_not_gated(self): import ibis From 69ca307ef6fc7b604fa69c9b75acbb450f9bc4bb Mon Sep 17 00:00:00 2001 From: Nathaniel Ramm Date: Wed, 19 Aug 2026 15:38:02 +1000 Subject: [PATCH 6/6] fix(item108): serialize predicate clauses into expression-coverage.json test_json_completeness caught a real gap: _fact_dict (render_markdown.py) never serialized CapabilityFact.predicate at all, so test_json_completeness's own JSON-vs-live-model fact-multiset comparison hardcoded () for every fact's predicate term (previously harmless - no production predicate fact existed to expose it). Item 108's IB-REL-15 predicate fact is the first one, and tripped the drift the hardcoded () was silently hiding. Added a kind-tagged JSON encoding (_operand_json/_clause_dict) mirroring schema._operand_key's own tagging, plus the test-side inverse (_operand_key_from_json/_clause_key_from_json) so the identity round-trips exactly through the wire format. Full tests/relations + tests/core sweep (8141 passed) confirms no other predicate-fact-shaped gaps remain. --- docs/reference/expression-coverage.json | 8826 +++++++++++------ .../core/capabilities/render_markdown.py | 27 +- tests/core/test_expression_coverage_doc.py | 22 +- 3 files changed, 5939 insertions(+), 2936 deletions(-) diff --git a/docs/reference/expression-coverage.json b/docs/reference/expression-coverage.json index 6769ec01..77e346d2 100644 --- a/docs/reference/expression-coverage.json +++ b/docs/reference/expression-coverage.json @@ -946,7 +946,8 @@ "upstream_ref": "NW-DT-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -982,7 +983,8 @@ "upstream_ref": "IB-DT-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -1045,7 +1047,8 @@ "upstream_ref": "NW-DT-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -1081,7 +1084,8 @@ "upstream_ref": "IB-DT-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -1144,7 +1148,8 @@ "upstream_ref": "NW-DT-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -1180,7 +1185,8 @@ "upstream_ref": "IB-DT-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -1243,7 +1249,8 @@ "upstream_ref": "NW-DT-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -1279,7 +1286,8 @@ "upstream_ref": "IB-DT-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -1342,7 +1350,8 @@ "upstream_ref": "NW-DT-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -1378,7 +1387,8 @@ "upstream_ref": "IB-DT-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -1441,7 +1451,8 @@ "upstream_ref": "NW-DT-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -1477,7 +1488,8 @@ "upstream_ref": "IB-DT-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -1540,7 +1552,8 @@ "upstream_ref": "NW-DT-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -1576,7 +1589,8 @@ "upstream_ref": "IB-DT-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -1639,7 +1653,8 @@ "upstream_ref": "NW-DT-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -1675,7 +1690,8 @@ "upstream_ref": "IB-DT-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -1738,7 +1754,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -1754,7 +1771,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -1770,7 +1788,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -1786,7 +1805,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -1822,7 +1842,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-polars", @@ -1838,7 +1859,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-polars", @@ -1854,7 +1876,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-polars", @@ -1870,7 +1893,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-polars", @@ -1886,7 +1910,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-polars", @@ -1902,7 +1927,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -1918,7 +1944,8 @@ "upstream_ref": null, "since": "2026-08-18", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -1934,7 +1961,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -1950,7 +1978,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -1966,7 +1995,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -1982,7 +2012,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -1998,7 +2029,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -2014,7 +2046,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -2030,7 +2063,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -2046,7 +2080,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -2062,7 +2097,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -2078,7 +2114,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -2094,7 +2131,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -2110,7 +2148,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -3798,7 +3837,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -3814,7 +3854,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -3830,7 +3871,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -3846,7 +3888,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -3882,7 +3925,8 @@ "upstream_ref": null, "since": "2026-08-18", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -3898,7 +3942,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -3914,7 +3959,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -3930,7 +3976,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -3946,7 +3993,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -3962,7 +4010,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -3978,7 +4027,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -3994,7 +4044,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -4010,7 +4061,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -4026,7 +4078,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -4042,7 +4095,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -4058,7 +4112,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -4074,7 +4129,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -4156,7 +4212,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -4172,7 +4229,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -4560,7 +4618,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -4576,7 +4635,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -4592,7 +4652,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -4608,7 +4669,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -4644,7 +4706,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-polars", @@ -4660,7 +4723,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-polars", @@ -4676,7 +4740,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-polars", @@ -4692,7 +4757,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-polars", @@ -4708,7 +4774,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-polars", @@ -4724,7 +4791,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -4740,7 +4808,8 @@ "upstream_ref": null, "since": "2026-08-18", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -4756,7 +4825,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -4772,7 +4842,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -4788,7 +4859,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -4804,7 +4876,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -4820,7 +4893,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -4836,7 +4910,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -4852,7 +4927,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -4868,7 +4944,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -4884,7 +4961,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -4900,7 +4978,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -4916,7 +4995,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -4932,7 +5012,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -5599,7 +5680,8 @@ "upstream_ref": null, "since": "2026-07-29", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -5615,7 +5697,8 @@ "upstream_ref": null, "since": "2026-07-29", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -5678,7 +5761,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -5694,7 +5778,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -5710,7 +5795,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -5726,7 +5812,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -5762,7 +5849,8 @@ "upstream_ref": null, "since": "2026-08-18", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -5778,7 +5866,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -5794,7 +5883,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -5810,7 +5900,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -5826,7 +5917,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -5842,7 +5934,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -5858,7 +5951,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -5874,7 +5968,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -5890,7 +5985,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -5906,7 +6002,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -5922,7 +6019,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -5938,7 +6036,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -5954,7 +6053,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -6414,7 +6514,8 @@ "upstream_ref": "NW-LIST-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [ @@ -6434,7 +6535,8 @@ "native_errors": [ "TypeError" ], - "probe_exempt": "whole-op materialize-time storage residue (narwhals-pandas PyArrow-list requirement); enriched after the visitor, not an arg-type gate" + "probe_exempt": "whole-op materialize-time storage residue (narwhals-pandas PyArrow-list requirement); enriched after the visitor, not an arg-type gate", + "predicate": null } ], "routed": [], @@ -6973,7 +7075,8 @@ "native_errors": [ "ValueError" ], - "probe_exempt": "value-conditioned (negative index) — not a structural param gate" + "probe_exempt": "value-conditioned (negative index) — not a structural param gate", + "predicate": null } ], "routed": [], @@ -8549,7 +8652,8 @@ "upstream_ref": "NW-LIST-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [ @@ -8569,7 +8673,8 @@ "native_errors": [ "TypeError" ], - "probe_exempt": "whole-op materialize-time storage residue (narwhals-pandas PyArrow-list requirement); enriched after the visitor, not an arg-type gate" + "probe_exempt": "whole-op materialize-time storage residue (narwhals-pandas PyArrow-list requirement); enriched after the visitor, not an arg-type gate", + "predicate": null } ], "routed": [], @@ -8768,7 +8873,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": "polymorphic — both paths supported by design" + "probe_exempt": "polymorphic — both paths supported by design", + "predicate": null } ], "residue": [], @@ -8804,7 +8910,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": "polymorphic — both paths supported by design" + "probe_exempt": "polymorphic — both paths supported by design", + "predicate": null } ], "residue": [], @@ -8840,7 +8947,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": "polymorphic — both paths supported by design" + "probe_exempt": "polymorphic — both paths supported by design", + "predicate": null } ], "residue": [], @@ -8884,7 +8992,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": "polymorphic — both paths supported by design" + "probe_exempt": "polymorphic — both paths supported by design", + "predicate": null } ], "residue": [], @@ -8920,7 +9029,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": "polymorphic — both paths supported by design" + "probe_exempt": "polymorphic — both paths supported by design", + "predicate": null } ], "residue": [], @@ -8956,7 +9066,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": "polymorphic — both paths supported by design" + "probe_exempt": "polymorphic — both paths supported by design", + "predicate": null } ], "residue": [], @@ -9866,7 +9977,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": "polymorphic — both paths supported by design" + "probe_exempt": "polymorphic — both paths supported by design", + "predicate": null } ], "residue": [], @@ -9902,7 +10014,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": "polymorphic — both paths supported by design" + "probe_exempt": "polymorphic — both paths supported by design", + "predicate": null } ], "residue": [], @@ -9938,7 +10051,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": "polymorphic — both paths supported by design" + "probe_exempt": "polymorphic — both paths supported by design", + "predicate": null } ], "residue": [], @@ -13137,7 +13251,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -13153,7 +13268,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -13173,7 +13289,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -13206,7 +13323,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -13222,7 +13340,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -13238,7 +13357,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -13254,7 +13374,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -13274,7 +13395,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -13290,7 +13412,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -13323,7 +13446,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -13339,7 +13463,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -13355,7 +13480,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -13371,7 +13497,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -13387,7 +13514,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -13407,7 +13535,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The DuckDB omission path raises the exact exception required by the requested ERROR semantics, so the explicit option is equivalent" + "probe_exempt": "The DuckDB omission path raises the exact exception required by the requested ERROR semantics, so the explicit option is equivalent", + "predicate": null } ] } @@ -13448,7 +13577,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -13464,7 +13594,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -13480,7 +13611,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -13496,7 +13628,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -13512,7 +13645,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -13528,7 +13662,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -13548,7 +13683,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate" + "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate", + "predicate": null } ] }, @@ -13581,7 +13717,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -13597,7 +13734,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -13613,7 +13751,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -13629,7 +13768,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -13645,7 +13785,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -13661,7 +13802,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -13677,7 +13819,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -13693,7 +13836,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -13709,7 +13853,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -13725,7 +13870,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -13741,7 +13887,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -13757,7 +13904,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -13773,7 +13921,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -13789,7 +13938,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -13825,7 +13975,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -13841,7 +13992,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -13857,7 +14009,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -13873,7 +14026,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -13889,7 +14043,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -13905,7 +14060,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -13921,7 +14077,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -13937,7 +14094,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -13953,7 +14111,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -13969,7 +14128,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -13985,7 +14145,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -14001,7 +14162,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -14017,7 +14179,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -14037,7 +14200,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The DuckDB omission path raises the exact exception required by the requested ERROR semantics, so the explicit option is equivalent" + "probe_exempt": "The DuckDB omission path raises the exact exception required by the requested ERROR semantics, so the explicit option is equivalent", + "predicate": null } ] } @@ -14078,7 +14242,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -14094,7 +14259,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -14110,7 +14276,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -14126,7 +14293,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -14142,7 +14310,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -14158,7 +14327,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -14178,7 +14348,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate" + "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate", + "predicate": null } ] }, @@ -14211,7 +14382,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -14227,7 +14399,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -14243,7 +14416,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -14259,7 +14433,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -14275,7 +14450,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -14291,7 +14467,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -14307,7 +14484,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -14323,7 +14501,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -14339,7 +14518,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -14355,7 +14535,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -14371,7 +14552,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -14387,7 +14569,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -14403,7 +14586,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -14419,7 +14603,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -14455,7 +14640,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -14471,7 +14657,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -14487,7 +14674,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -14503,7 +14691,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -14519,7 +14708,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -14535,7 +14725,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -14551,7 +14742,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -14567,7 +14759,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -14583,7 +14776,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -14599,7 +14793,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -14615,7 +14810,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -14631,7 +14827,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -14647,7 +14844,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -14663,7 +14861,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -14707,7 +14906,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -14723,7 +14923,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -14739,7 +14940,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -14755,7 +14957,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -14771,7 +14974,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -14787,7 +14991,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -14803,7 +15008,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -14823,7 +15029,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -14856,7 +15063,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -14872,7 +15080,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -14888,7 +15097,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -14904,7 +15114,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -14920,7 +15131,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -14936,7 +15148,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -14952,7 +15165,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -14968,7 +15182,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -14984,7 +15199,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -15000,7 +15216,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -15016,7 +15233,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -15032,7 +15250,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -15048,7 +15267,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -15064,7 +15284,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -15084,7 +15305,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -15100,7 +15322,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -15133,7 +15356,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -15149,7 +15373,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -15165,7 +15390,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -15181,7 +15407,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -15197,7 +15424,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -15213,7 +15441,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -15229,7 +15458,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -15245,7 +15475,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -15261,7 +15492,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -15277,7 +15509,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -15293,7 +15526,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -15309,7 +15543,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -15325,7 +15560,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -15341,7 +15577,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -15357,7 +15594,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -15377,7 +15615,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The DuckDB omission path raises the exact exception required by the requested ERROR semantics, so the explicit option is equivalent" + "probe_exempt": "The DuckDB omission path raises the exact exception required by the requested ERROR semantics, so the explicit option is equivalent", + "predicate": null } ] } @@ -15418,7 +15657,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -15434,7 +15674,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -15450,7 +15691,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -15466,7 +15708,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -15482,7 +15725,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -15498,7 +15742,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -15518,7 +15763,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate" + "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate", + "predicate": null } ] }, @@ -15551,7 +15797,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -15567,7 +15814,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -15583,7 +15831,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -15599,7 +15848,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -15615,7 +15865,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -15631,7 +15882,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -15647,7 +15899,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -15663,7 +15916,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -15679,7 +15933,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -15695,7 +15950,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -15711,7 +15967,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -15727,7 +15984,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -15743,7 +16001,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -15759,7 +16018,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -15795,7 +16055,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -15811,7 +16072,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -15827,7 +16089,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -15843,7 +16106,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -15859,7 +16123,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -15875,7 +16140,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -15891,7 +16157,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -15907,7 +16174,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -15923,7 +16191,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -15939,7 +16208,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -15955,7 +16225,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -15971,7 +16242,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -15987,7 +16259,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -16007,7 +16280,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The DuckDB omission path raises the exact exception required by the requested ERROR semantics, so the explicit option is equivalent" + "probe_exempt": "The DuckDB omission path raises the exact exception required by the requested ERROR semantics, so the explicit option is equivalent", + "predicate": null } ] } @@ -16048,7 +16322,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -16064,7 +16339,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -16080,7 +16356,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -16096,7 +16373,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -16112,7 +16390,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -16148,7 +16427,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -16164,7 +16444,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -16180,7 +16461,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -16196,7 +16478,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -16212,7 +16495,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -16228,7 +16512,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -16244,7 +16529,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -16260,7 +16546,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -16276,7 +16563,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -16292,7 +16580,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -16328,7 +16617,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -16344,7 +16634,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -16360,7 +16651,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -16376,7 +16668,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -16392,7 +16685,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -16408,7 +16702,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -16424,7 +16719,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -16440,7 +16736,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -16456,7 +16753,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -16472,7 +16770,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -16516,7 +16815,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -16532,7 +16832,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -16548,7 +16849,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -16564,7 +16866,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -16580,7 +16883,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -16616,7 +16920,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -16632,7 +16937,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -16648,7 +16954,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -16664,7 +16971,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -16680,7 +16988,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -16696,7 +17005,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -16712,7 +17022,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -16728,7 +17039,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -16744,7 +17056,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -16760,7 +17073,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -16796,7 +17110,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -16812,7 +17127,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -16828,7 +17144,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -16844,7 +17161,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -16860,7 +17178,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -16876,7 +17195,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -16892,7 +17212,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -16908,7 +17229,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -16924,7 +17246,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -16940,7 +17263,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -16984,7 +17308,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -17000,7 +17325,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -17016,7 +17342,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -17032,7 +17359,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -17048,7 +17376,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -17064,7 +17393,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -17084,7 +17414,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate" + "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate", + "predicate": null } ] }, @@ -17117,7 +17448,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -17133,7 +17465,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -17149,7 +17482,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -17165,7 +17499,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -17181,7 +17516,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -17197,7 +17533,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -17213,7 +17550,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -17229,7 +17567,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -17245,7 +17584,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -17261,7 +17601,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -17277,7 +17618,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -17293,7 +17635,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -17309,7 +17652,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -17325,7 +17669,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -17361,7 +17706,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -17377,7 +17723,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -17393,7 +17740,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -17409,7 +17757,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -17425,7 +17774,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -17441,7 +17791,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -17457,7 +17808,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -17473,7 +17825,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -17489,7 +17842,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -17505,7 +17859,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -17521,7 +17876,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -17537,7 +17893,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -17553,7 +17910,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -17569,7 +17927,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -17613,7 +17972,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -17629,7 +17989,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -17645,7 +18006,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -17661,7 +18023,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -17677,7 +18040,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -17693,7 +18057,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -17713,7 +18078,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate" + "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate", + "predicate": null } ] }, @@ -17746,7 +18112,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -17762,7 +18129,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -17778,7 +18146,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -17794,7 +18163,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -17810,7 +18180,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -17826,7 +18197,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -17842,7 +18214,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -17858,7 +18231,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -17874,7 +18248,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -17890,7 +18265,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -17906,7 +18282,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -17922,7 +18299,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -17938,7 +18316,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -17954,7 +18333,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -17990,7 +18370,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -18006,7 +18387,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -18022,7 +18404,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -18038,7 +18421,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -18054,7 +18438,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -18070,7 +18455,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -18086,7 +18472,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -18102,7 +18489,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -18118,7 +18506,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -18134,7 +18523,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -18150,7 +18540,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -18166,7 +18557,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -18182,7 +18574,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -18198,7 +18591,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -18502,7 +18896,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -18518,7 +18913,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -18534,7 +18930,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -18550,7 +18947,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -18566,7 +18964,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -18602,7 +19001,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -18618,7 +19018,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -18634,7 +19035,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -18650,7 +19052,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -18666,7 +19069,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -18682,7 +19086,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -18698,7 +19103,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -18714,7 +19120,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -18730,7 +19137,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -18746,7 +19154,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -18782,7 +19191,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -18798,7 +19208,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -18814,7 +19225,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -18830,7 +19242,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -18846,7 +19259,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -18862,7 +19276,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -18878,7 +19293,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -18894,7 +19310,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -18910,7 +19327,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -18926,7 +19344,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -18970,7 +19389,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -18986,7 +19406,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -19002,7 +19423,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -19018,7 +19440,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -19034,7 +19457,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -19070,7 +19494,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -19086,7 +19511,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -19102,7 +19528,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -19118,7 +19545,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -19134,7 +19562,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -19150,7 +19579,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -19166,7 +19596,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -19182,7 +19613,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -19198,7 +19630,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -19214,7 +19647,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -19250,7 +19684,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -19266,7 +19701,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -19282,7 +19718,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -19298,7 +19735,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -19314,7 +19752,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -19330,7 +19769,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -19346,7 +19786,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -19362,7 +19803,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -19378,7 +19820,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -19394,7 +19837,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -19438,7 +19882,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -19454,7 +19899,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -19470,7 +19916,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -19486,7 +19933,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -19502,7 +19950,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -19538,7 +19987,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -19554,7 +20004,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -19570,7 +20021,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -19586,7 +20038,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -19602,7 +20055,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -19618,7 +20072,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -19634,7 +20089,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -19650,7 +20106,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -19666,7 +20123,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -19682,7 +20140,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -19718,7 +20177,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -19734,7 +20194,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -19750,7 +20211,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -19766,7 +20228,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -19782,7 +20245,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -19798,7 +20262,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -19814,7 +20279,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -19830,7 +20296,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -19846,7 +20313,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -19862,7 +20330,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -19906,7 +20375,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -19922,7 +20392,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -19938,7 +20409,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -19954,7 +20426,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -19970,7 +20443,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -19986,7 +20460,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -20002,7 +20477,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -20018,7 +20494,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -20034,7 +20511,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -20050,7 +20528,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -20066,7 +20545,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -20082,7 +20562,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -20098,7 +20579,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -20118,7 +20600,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate" + "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -20134,7 +20617,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate" + "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate", + "predicate": null } ] }, @@ -20167,7 +20651,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -20183,7 +20668,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -20199,7 +20685,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -20215,7 +20702,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -20231,7 +20719,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -20247,7 +20736,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -20263,7 +20753,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -20279,7 +20770,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -20295,7 +20787,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -20311,7 +20804,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -20327,7 +20821,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -20343,7 +20838,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -20359,7 +20855,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -20375,7 +20872,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -20391,7 +20889,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -20407,7 +20906,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -20423,7 +20923,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -20439,7 +20940,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -20455,7 +20957,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -20471,7 +20974,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -20487,7 +20991,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -20503,7 +21008,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -20519,7 +21025,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -20535,7 +21042,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -20551,7 +21059,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -20567,7 +21076,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -20587,7 +21097,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate" + "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -20603,7 +21114,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate" + "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -20619,7 +21131,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate" + "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -20635,7 +21148,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate" + "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate", + "predicate": null } ] }, @@ -20668,7 +21182,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -20684,7 +21199,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -20700,7 +21216,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -20716,7 +21233,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -20732,7 +21250,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -20748,7 +21267,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -20764,7 +21284,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -20780,7 +21301,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -20796,7 +21318,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -20812,7 +21335,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -20828,7 +21352,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -20844,7 +21369,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -20860,7 +21386,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -20876,7 +21403,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -20892,7 +21420,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -20908,7 +21437,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -20924,7 +21454,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -20940,7 +21471,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -20956,7 +21488,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -20972,7 +21505,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -20988,7 +21522,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -21004,7 +21539,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -21020,7 +21556,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -21036,7 +21573,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -21052,7 +21590,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -21068,7 +21607,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -21084,7 +21624,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -21100,7 +21641,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -21116,7 +21658,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -21132,7 +21675,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -21176,7 +21720,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -21192,7 +21737,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -21208,7 +21754,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -21224,7 +21771,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -21240,7 +21788,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -21276,7 +21825,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -21292,7 +21842,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -21308,7 +21859,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -21324,7 +21876,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -21340,7 +21893,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -21356,7 +21910,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -21372,7 +21927,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -21388,7 +21944,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -21404,7 +21961,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -21420,7 +21978,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -21456,7 +22015,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -21472,7 +22032,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -21488,7 +22049,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -21504,7 +22066,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -21520,7 +22083,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -21536,7 +22100,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -21552,7 +22117,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -21568,7 +22134,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -21584,7 +22151,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -21600,7 +22168,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -21644,7 +22213,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -21660,7 +22230,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -21676,7 +22247,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -21692,7 +22264,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -21712,7 +22285,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate" + "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -21728,7 +22302,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate" + "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -21744,7 +22319,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -21777,7 +22353,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -21793,7 +22370,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -21809,7 +22387,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -21825,7 +22404,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -21841,7 +22421,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -21857,7 +22438,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -21873,7 +22455,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -21889,7 +22472,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -21909,7 +22493,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate" + "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -21925,7 +22510,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate" + "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -21941,7 +22527,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -21957,7 +22544,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate" + "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -21973,7 +22561,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate" + "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -21989,7 +22578,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -22022,7 +22612,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -22038,7 +22629,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -22054,7 +22646,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -22070,7 +22663,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -22086,7 +22680,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -22102,7 +22697,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -22118,7 +22714,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -22134,7 +22731,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -22150,7 +22748,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -22166,7 +22765,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -22182,7 +22782,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -22198,7 +22799,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -22214,7 +22816,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -22234,7 +22837,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The DuckDB omission path raises the exact exception required by the requested ERROR semantics, so the explicit option is equivalent" + "probe_exempt": "The DuckDB omission path raises the exact exception required by the requested ERROR semantics, so the explicit option is equivalent", + "predicate": null } ] } @@ -22275,7 +22879,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -22291,7 +22896,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -22307,7 +22913,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -22323,7 +22930,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -22339,7 +22947,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -22355,7 +22964,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -22371,7 +22981,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -22391,7 +23002,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -22424,7 +23036,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -22440,7 +23053,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -22456,7 +23070,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -22472,7 +23087,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -22488,7 +23104,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -22504,7 +23121,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -22520,7 +23138,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -22536,7 +23155,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -22552,7 +23172,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -22568,7 +23189,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -22584,7 +23206,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -22600,7 +23223,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -22616,7 +23240,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -22632,7 +23257,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -22652,7 +23278,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -22668,7 +23295,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -22701,7 +23329,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -22717,7 +23346,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -22733,7 +23363,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -22749,7 +23380,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -22765,7 +23397,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -22781,7 +23414,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -22797,7 +23431,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -22813,7 +23448,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -22829,7 +23465,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -22845,7 +23482,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -22861,7 +23499,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -22877,7 +23516,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -22893,7 +23533,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -22909,7 +23550,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -22925,7 +23567,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -22945,7 +23588,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The DuckDB omission path raises the exact exception required by the requested ERROR semantics, so the explicit option is equivalent" + "probe_exempt": "The DuckDB omission path raises the exact exception required by the requested ERROR semantics, so the explicit option is equivalent", + "predicate": null } ] } @@ -22986,7 +23630,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -23002,7 +23647,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -23022,7 +23668,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -23055,7 +23702,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -23071,7 +23719,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -23087,7 +23736,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -23103,7 +23753,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -23123,7 +23774,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -23139,7 +23791,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -23172,7 +23825,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -23188,7 +23842,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -23204,7 +23859,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -23220,7 +23876,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -23236,7 +23893,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -23256,7 +23914,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The DuckDB omission path raises the exact exception required by the requested ERROR semantics, so the explicit option is equivalent" + "probe_exempt": "The DuckDB omission path raises the exact exception required by the requested ERROR semantics, so the explicit option is equivalent", + "predicate": null } ] } @@ -23297,7 +23956,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -23313,7 +23973,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -23333,7 +23994,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -23366,7 +24028,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -23382,7 +24045,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -23398,7 +24062,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -23414,7 +24079,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -23434,7 +24100,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -23450,7 +24117,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -23483,7 +24151,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -23499,7 +24168,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -23515,7 +24185,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -23531,7 +24202,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -23547,7 +24219,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -23563,7 +24236,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -23607,7 +24281,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -23623,7 +24298,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -23639,7 +24315,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -23655,7 +24332,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -23671,7 +24349,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -23707,7 +24386,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -23723,7 +24403,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -23739,7 +24420,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -23755,7 +24437,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -23771,7 +24454,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -23787,7 +24471,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -23803,7 +24488,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -23819,7 +24505,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -23835,7 +24522,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -23851,7 +24539,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -23887,7 +24576,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -23903,7 +24593,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -23919,7 +24610,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -23935,7 +24627,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -23951,7 +24644,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -23967,7 +24661,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -23983,7 +24678,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -23999,7 +24695,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -24015,7 +24712,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -24031,7 +24729,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -24335,7 +25034,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -24351,7 +25051,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -24367,7 +25068,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -24383,7 +25085,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -24399,7 +25102,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -24435,7 +25139,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -24451,7 +25156,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -24467,7 +25173,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -24483,7 +25190,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -24499,7 +25207,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -24515,7 +25224,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -24531,7 +25241,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -24547,7 +25258,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -24563,7 +25275,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -24579,7 +25292,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -24615,7 +25329,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -24631,7 +25346,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -24647,7 +25363,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -24663,7 +25380,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -24679,7 +25397,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -24695,7 +25414,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -24711,7 +25431,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -24727,7 +25448,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -24743,7 +25465,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -24759,7 +25482,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -24803,7 +25527,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -24819,7 +25544,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -24835,7 +25561,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -24851,7 +25578,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -24867,7 +25595,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -24903,7 +25632,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -24919,7 +25649,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -24935,7 +25666,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -24951,7 +25683,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -24967,7 +25700,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -24983,7 +25717,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -24999,7 +25734,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -25015,7 +25751,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -25031,7 +25768,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -25047,7 +25785,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -25083,7 +25822,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -25099,7 +25839,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -25115,7 +25856,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -25131,7 +25873,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -25147,7 +25890,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -25163,7 +25907,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -25179,7 +25924,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -25195,7 +25941,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -25211,7 +25958,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -25227,7 +25975,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -25271,7 +26020,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -25287,7 +26037,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -25303,7 +26054,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -25319,7 +26071,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -25335,7 +26088,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -25351,7 +26105,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -25371,7 +26126,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate" + "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate", + "predicate": null } ] }, @@ -25404,7 +26160,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -25420,7 +26177,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -25436,7 +26194,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -25452,7 +26211,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -25468,7 +26228,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -25484,7 +26245,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -25500,7 +26262,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -25516,7 +26279,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -25532,7 +26296,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -25548,7 +26313,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -25564,7 +26330,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -25580,7 +26347,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -25596,7 +26364,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -25616,7 +26385,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate" + "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate", + "predicate": null } ] }, @@ -25649,7 +26419,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -25665,7 +26436,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -25681,7 +26453,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -25697,7 +26470,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -25713,7 +26487,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -25729,7 +26504,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -25745,7 +26521,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -25761,7 +26538,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -25777,7 +26555,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -25793,7 +26572,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -25809,7 +26589,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -25825,7 +26606,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -25841,7 +26623,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -25861,7 +26644,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The DuckDB omission path raises the exact exception required by the requested ERROR semantics, so the explicit option is equivalent" + "probe_exempt": "The DuckDB omission path raises the exact exception required by the requested ERROR semantics, so the explicit option is equivalent", + "predicate": null } ] } @@ -25902,7 +26686,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -25918,7 +26703,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -25934,7 +26720,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -25950,7 +26737,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -25966,7 +26754,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -25982,7 +26771,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -25998,7 +26788,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -26018,7 +26809,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -26051,7 +26843,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -26067,7 +26860,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -26083,7 +26877,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -26099,7 +26894,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -26115,7 +26911,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -26131,7 +26928,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -26147,7 +26945,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -26163,7 +26962,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -26179,7 +26979,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -26195,7 +26996,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -26211,7 +27013,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -26227,7 +27030,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -26243,7 +27047,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -26259,7 +27064,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -26279,7 +27085,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -26295,7 +27102,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -26328,7 +27136,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -26344,7 +27153,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -26360,7 +27170,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -26376,7 +27187,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -26392,7 +27204,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -26408,7 +27221,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -26424,7 +27238,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -26440,7 +27255,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -26456,7 +27272,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -26472,7 +27289,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -26488,7 +27306,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -26504,7 +27323,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -26520,7 +27340,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -26536,7 +27357,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -26552,7 +27374,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -26572,7 +27395,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The DuckDB omission path raises the exact exception required by the requested ERROR semantics, so the explicit option is equivalent" + "probe_exempt": "The DuckDB omission path raises the exact exception required by the requested ERROR semantics, so the explicit option is equivalent", + "predicate": null } ] } @@ -26613,7 +27437,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -26629,7 +27454,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -26645,7 +27471,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -26661,7 +27488,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -26677,7 +27505,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -26713,7 +27542,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -26729,7 +27559,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -26745,7 +27576,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -26761,7 +27593,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -26777,7 +27610,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -26793,7 +27627,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -26809,7 +27644,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -26825,7 +27661,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -26841,7 +27678,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -26857,7 +27695,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -26893,7 +27732,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -26909,7 +27749,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -26925,7 +27766,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -26941,7 +27783,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -26957,7 +27800,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -26973,7 +27817,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -26989,7 +27834,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -27005,7 +27851,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -27021,7 +27868,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -27037,7 +27885,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -27081,7 +27930,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -27097,7 +27947,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -27113,7 +27964,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -27129,7 +27981,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -27145,7 +27998,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -27181,7 +28035,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -27197,7 +28052,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -27213,7 +28069,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -27229,7 +28086,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -27245,7 +28103,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -27261,7 +28120,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -27277,7 +28137,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -27293,7 +28154,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -27309,7 +28171,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -27325,7 +28188,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -27361,7 +28225,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -27377,7 +28242,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -27393,7 +28259,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -27409,7 +28276,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -27425,7 +28293,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -27441,7 +28310,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -27457,7 +28327,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -27473,7 +28344,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -27489,7 +28361,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -27505,7 +28378,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -29409,7 +30283,8 @@ "upstream_ref": null, "since": "2026-07-25", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -29425,7 +30300,8 @@ "upstream_ref": null, "since": "2026-07-25", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -29461,7 +30337,8 @@ "upstream_ref": null, "since": "2026-07-25", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -29477,7 +30354,8 @@ "upstream_ref": null, "since": "2026-07-25", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -29521,7 +30399,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -29537,7 +30416,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -29553,7 +30433,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -29569,7 +30450,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -29585,7 +30467,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -29601,7 +30484,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -29637,7 +30521,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -29653,7 +30538,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -29669,7 +30555,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -29685,7 +30572,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -29701,7 +30589,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -29717,7 +30606,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -29733,7 +30623,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -29749,7 +30640,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -29765,7 +30657,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -29781,7 +30674,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -29797,7 +30691,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -29813,7 +30708,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -29829,7 +30725,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -29845,7 +30742,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -29861,7 +30759,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -29877,7 +30776,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -29893,7 +30793,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -29909,7 +30810,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -29945,7 +30847,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -29961,7 +30864,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -29977,7 +30881,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -29993,7 +30898,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -30009,7 +30915,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -30025,7 +30932,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -30041,7 +30949,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -30057,7 +30966,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -30073,7 +30983,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -30089,7 +31000,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -30105,7 +31017,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -30121,7 +31034,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -30137,7 +31051,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -30153,7 +31068,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -30169,7 +31085,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -30185,7 +31102,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -30229,7 +31147,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -30265,7 +31184,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -30281,7 +31201,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -30317,7 +31238,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -30333,7 +31255,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -30349,7 +31272,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -30365,7 +31289,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -30447,7 +31372,8 @@ "upstream_ref": null, "since": "2026-07-29", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -30463,7 +31389,8 @@ "upstream_ref": null, "since": "2026-07-29", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -30545,7 +31472,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-polars", @@ -30561,7 +31489,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -30577,7 +31506,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -30593,7 +31523,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -30609,7 +31540,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -30625,7 +31557,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -30641,7 +31574,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -30657,7 +31591,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -30739,7 +31674,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -30755,7 +31691,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -30771,7 +31708,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -30787,7 +31725,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -30803,7 +31742,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -30819,7 +31759,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -30947,7 +31888,8 @@ "upstream_ref": null, "since": "2026-07-30", "native_errors": [], - "probe_exempt": "whole-op gate on a WILDCARD_PARAM fact; cannot be keyed on an OpSpec param (OpSpecs are indexed by concrete argument name) — verified by the dedicated cross-backend gate tests in test_datetime_strptime_format.py" + "probe_exempt": "whole-op gate on a WILDCARD_PARAM fact; cannot be keyed on an OpSpec param (OpSpecs are indexed by concrete argument name) — verified by the dedicated cross-backend gate tests in test_datetime_strptime_format.py", + "predicate": null } ], "residue": [], @@ -30983,7 +31925,8 @@ "upstream_ref": null, "since": "2026-07-30", "native_errors": [], - "probe_exempt": "whole-op gate on a WILDCARD_PARAM fact; cannot be keyed on an OpSpec param (OpSpecs are indexed by concrete argument name) — verified by the dedicated cross-backend gate tests in test_datetime_strptime_format.py" + "probe_exempt": "whole-op gate on a WILDCARD_PARAM fact; cannot be keyed on an OpSpec param (OpSpecs are indexed by concrete argument name) — verified by the dedicated cross-backend gate tests in test_datetime_strptime_format.py", + "predicate": null } ], "residue": [], @@ -31065,7 +32008,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -31081,7 +32025,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -31097,7 +32042,8 @@ "upstream_ref": null, "since": "2026-07-30", "native_errors": [], - "probe_exempt": "whole-op gate on a WILDCARD_PARAM fact; cannot be keyed on an OpSpec param (OpSpecs are indexed by concrete argument name) — verified by the dedicated cross-backend gate tests in test_datetime_strptime_format.py" + "probe_exempt": "whole-op gate on a WILDCARD_PARAM fact; cannot be keyed on an OpSpec param (OpSpecs are indexed by concrete argument name) — verified by the dedicated cross-backend gate tests in test_datetime_strptime_format.py", + "predicate": null } ], "residue": [], @@ -31819,7 +32765,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -31839,7 +32786,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -31872,7 +32820,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "whole-op gate; verified by the dedicated op-level probe suite (test_op_level_gate_probes.py), which cannot be keyed on an OpSpec param" + "probe_exempt": "whole-op gate; verified by the dedicated op-level probe suite (test_op_level_gate_probes.py), which cannot be keyed on an OpSpec param", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -31888,7 +32837,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -31904,7 +32854,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -31920,7 +32871,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -31936,7 +32888,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -31972,7 +32925,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -31988,7 +32942,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -32008,7 +32963,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] } @@ -32049,7 +33005,8 @@ "upstream_ref": "PL-STR-03", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -32065,7 +33022,8 @@ "upstream_ref": "PL-STR-03", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -32081,7 +33039,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -32101,7 +33060,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "RIGHT is the builder default, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "RIGHT is the builder default, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -32134,7 +33094,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "whole-op gate; verified by the dedicated op-level probe suite (test_op_level_gate_probes.py), which cannot be keyed on an OpSpec param" + "probe_exempt": "whole-op gate; verified by the dedicated op-level probe suite (test_op_level_gate_probes.py), which cannot be keyed on an OpSpec param", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -32150,7 +33111,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -32166,7 +33128,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -32182,7 +33145,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -32198,7 +33162,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -32234,7 +33199,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": "dynamic arg silently miscompiles: str(Expr) bakes the unresolved expression's Python repr into the output as a literal string rather than raising — cannot be confirmed by an exception-based probe" + "probe_exempt": "dynamic arg silently miscompiles: str(Expr) bakes the unresolved expression's Python repr into the output as a literal string rather than raising — cannot be confirmed by an exception-based probe", + "predicate": null }, { "dialect": null, @@ -32250,7 +33216,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -32266,7 +33233,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -32282,7 +33250,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -32302,7 +33271,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "RIGHT is the builder default, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "RIGHT is the builder default, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] } @@ -32541,7 +33511,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -32574,7 +33545,8 @@ "upstream_ref": "NW-STR-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -32594,7 +33566,8 @@ "upstream_ref": "NW-STR-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -32610,7 +33583,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -32626,7 +33600,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -32642,7 +33617,8 @@ "upstream_ref": "NW-STR-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ] }, @@ -32675,7 +33651,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -32691,7 +33668,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -32711,7 +33689,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] } @@ -32752,7 +33731,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -32768,7 +33748,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -32788,7 +33769,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -32821,7 +33803,8 @@ "upstream_ref": "NW-STR-03", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -32837,7 +33820,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -32853,7 +33837,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -32869,7 +33854,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -32885,7 +33871,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -32905,7 +33892,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -32921,7 +33909,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -32954,7 +33943,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -32970,7 +33960,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -32986,7 +33977,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -33002,7 +33994,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-polars", @@ -33018,7 +34011,8 @@ "upstream_ref": "PL-STR-01", "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -33038,7 +34032,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] } @@ -33082,7 +34077,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -33115,7 +34111,8 @@ "upstream_ref": "NW-STR-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -33135,7 +34132,8 @@ "upstream_ref": "NW-STR-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -33151,7 +34149,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -33167,7 +34166,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -33183,7 +34183,8 @@ "upstream_ref": "NW-STR-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ] }, @@ -33216,7 +34217,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -33232,7 +34234,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -33252,7 +34255,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] } @@ -33293,7 +34297,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -33313,7 +34318,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -33346,7 +34352,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -33362,7 +34369,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -33382,7 +34390,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -33398,7 +34407,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -33431,7 +34441,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "whole-op gate; verified by the dedicated op-level probe suite (test_op_level_gate_probes.py), which cannot be keyed on an OpSpec param" + "probe_exempt": "whole-op gate; verified by the dedicated op-level probe suite (test_op_level_gate_probes.py), which cannot be keyed on an OpSpec param", + "predicate": null }, { "dialect": null, @@ -33447,7 +34458,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -33463,7 +34475,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -33479,7 +34492,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -33495,7 +34509,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -33558,7 +34573,8 @@ "upstream_ref": "NW-STR-06", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -33621,7 +34637,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": "dynamic arg silently miscompiles: the SQL-LIKE→regex conversion runs on str(Expr), producing a pattern that matches nothing rather than raising — cannot be confirmed by an exception-based probe" + "probe_exempt": "dynamic arg silently miscompiles: the SQL-LIKE→regex conversion runs on str(Expr), producing a pattern that matches nothing rather than raising — cannot be confirmed by an exception-based probe", + "predicate": null }, { "dialect": "polars", @@ -33637,7 +34654,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -33653,7 +34671,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -33673,7 +34692,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -33706,7 +34726,8 @@ "upstream_ref": "NW-STR-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -33722,7 +34743,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -33738,7 +34760,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -33754,7 +34777,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -33770,7 +34794,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -33790,7 +34815,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -33806,7 +34832,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -33839,7 +34866,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -33855,7 +34883,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -33871,7 +34900,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -33887,7 +34917,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-polars", @@ -33903,7 +34934,8 @@ "upstream_ref": "IB-STR-06", "since": "2026-08-12", "native_errors": [], - "probe_exempt": "whole-op gate on a dialect-scoped WILDCARD_PARAM fact; cannot be keyed on an OpSpec param — verified by the dedicated cross-backend gate test in test_pattern.py (TestLikeIbisPolarsGate) and the native-bypass self-healing probe in test_op_level_gate_probes.py (test_like_ibis_polars_native_still_broken)" + "probe_exempt": "whole-op gate on a dialect-scoped WILDCARD_PARAM fact; cannot be keyed on an OpSpec param — verified by the dedicated cross-backend gate test in test_pattern.py (TestLikeIbisPolarsGate) and the native-bypass self-healing probe in test_op_level_gate_probes.py (test_like_ibis_polars_native_still_broken)", + "predicate": null } ], "residue": [], @@ -33923,7 +34955,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] } @@ -33964,7 +34997,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -33984,7 +35018,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -34017,7 +35052,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -34033,7 +35069,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -34053,7 +35090,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -34069,7 +35107,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -34102,7 +35141,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -34118,7 +35158,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -34138,7 +35179,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] } @@ -34179,7 +35221,8 @@ "upstream_ref": "PL-STR-03", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -34215,7 +35258,8 @@ "upstream_ref": "NW-STR-06", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -34231,7 +35275,8 @@ "upstream_ref": "NW-STR-06", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -34313,7 +35358,8 @@ "upstream_ref": "NW-STR-07", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -34349,7 +35395,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": "dynamic arg silently miscompiles via str(Expr) into a no-op char-class, returning the input unchanged rather than raising — cannot be confirmed by an exception-based probe" + "probe_exempt": "dynamic arg silently miscompiles via str(Expr) into a no-op char-class, returning the input unchanged rather than raising — cannot be confirmed by an exception-based probe", + "predicate": null } ], "residue": [], @@ -34458,7 +35505,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -34474,7 +35522,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -34490,7 +35539,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -34506,7 +35556,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -34522,7 +35573,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "polars", @@ -34538,7 +35590,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -34558,7 +35611,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -34574,7 +35628,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -34590,7 +35645,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -34623,7 +35679,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -34639,7 +35696,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -34655,7 +35713,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -34671,7 +35730,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -34687,7 +35747,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -34703,7 +35764,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -34719,7 +35781,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -34735,7 +35798,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -34751,7 +35815,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -34767,7 +35832,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -34783,7 +35849,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -34799,7 +35866,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -34815,7 +35883,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -34831,7 +35900,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -34847,7 +35917,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -34863,7 +35934,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -34879,7 +35951,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "narwhals-polars", @@ -34895,7 +35968,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -34931,7 +36005,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -34947,7 +36022,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -34963,7 +36039,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -34979,7 +36056,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -34995,7 +36073,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -35011,7 +36090,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -35027,7 +36107,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -35043,7 +36124,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": null, @@ -35059,7 +36141,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -35075,7 +36158,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -35091,7 +36175,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -35107,7 +36192,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -35123,7 +36209,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -35139,7 +36226,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -35155,7 +36243,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -35171,7 +36260,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -35187,7 +36277,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -35203,7 +36294,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -35247,7 +36339,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -35263,7 +36356,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -35279,7 +36373,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -35295,7 +36390,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -35311,7 +36407,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "polars", @@ -35327,7 +36424,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -35343,7 +36441,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "polars", @@ -35359,7 +36458,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -35379,7 +36479,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -35395,7 +36496,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -35411,7 +36513,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -35444,7 +36547,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -35460,7 +36564,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -35476,7 +36581,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -35492,7 +36598,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -35508,7 +36615,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -35524,7 +36632,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -35540,7 +36649,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -35556,7 +36666,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -35572,7 +36683,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -35588,7 +36700,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -35604,7 +36717,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -35620,7 +36734,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -35636,7 +36751,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -35652,7 +36768,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "narwhals-polars", @@ -35668,7 +36785,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -35684,7 +36802,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -35700,7 +36819,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "narwhals-polars", @@ -35716,7 +36836,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -35732,7 +36853,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "narwhals-polars", @@ -35748,7 +36870,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -35768,7 +36891,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -35784,7 +36908,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -35800,7 +36925,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -35816,7 +36942,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -35832,7 +36959,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -35848,7 +36976,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -35881,7 +37010,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -35897,7 +37027,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -35913,7 +37044,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -35929,7 +37061,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -35945,7 +37078,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": null, @@ -35961,7 +37095,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -35977,7 +37112,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": null, @@ -35993,7 +37129,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -36009,7 +37146,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -36025,7 +37163,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -36041,7 +37180,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -36057,7 +37197,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -36073,7 +37214,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -36089,7 +37231,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -36105,7 +37248,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -36121,7 +37265,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-polars", @@ -36137,7 +37282,8 @@ "upstream_ref": "IB-STR-09", "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -36157,7 +37303,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -36173,7 +37320,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -36189,7 +37337,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] } @@ -36230,7 +37379,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -36246,7 +37396,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -36262,7 +37413,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -36278,7 +37430,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "polars", @@ -36294,7 +37447,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -36310,7 +37464,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -36326,7 +37481,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "polars", @@ -36342,7 +37498,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -36362,7 +37519,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -36378,7 +37536,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -36394,7 +37553,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -36427,7 +37587,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -36443,7 +37604,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -36459,7 +37621,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -36475,7 +37638,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -36491,7 +37655,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -36507,7 +37672,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -36523,7 +37689,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -36539,7 +37706,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -36555,7 +37723,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -36571,7 +37740,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -36587,7 +37757,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -36603,7 +37774,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -36619,7 +37791,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -36635,7 +37808,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -36651,7 +37825,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -36667,7 +37842,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -36683,7 +37859,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "narwhals-polars", @@ -36699,7 +37876,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -36715,7 +37893,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -36731,7 +37910,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -36747,7 +37927,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "narwhals-polars", @@ -36763,7 +37944,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -36799,7 +37981,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -36815,7 +37998,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -36831,7 +38015,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -36847,7 +38032,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -36863,7 +38049,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -36879,7 +38066,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": null, @@ -36895,7 +38083,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -36911,7 +38100,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -36927,7 +38117,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -36943,7 +38134,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": null, @@ -36959,7 +38151,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -36975,7 +38168,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -36991,7 +38185,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -37007,7 +38202,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -37023,7 +38219,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -37039,7 +38236,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -37055,7 +38253,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -37071,7 +38270,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -37087,7 +38287,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -37103,7 +38304,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -37119,7 +38321,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -37135,7 +38338,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -37179,7 +38383,8 @@ "upstream_ref": "PL-STR-02", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -37195,7 +38400,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -37211,7 +38417,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -37227,7 +38434,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -37243,7 +38451,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -37259,7 +38468,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "polars", @@ -37275,7 +38485,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -37295,7 +38506,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -37311,7 +38523,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -37327,7 +38540,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -37360,7 +38574,8 @@ "upstream_ref": "NW-STR-05", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -37376,7 +38591,8 @@ "upstream_ref": "NW-STR-05", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -37392,7 +38608,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -37408,7 +38625,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -37424,7 +38642,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -37440,7 +38659,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -37456,7 +38676,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -37472,7 +38693,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -37488,7 +38710,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -37504,7 +38727,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -37520,7 +38744,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -37536,7 +38761,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -37552,7 +38778,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -37568,7 +38795,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -37584,7 +38812,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "narwhals-polars", @@ -37600,7 +38829,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -37616,7 +38846,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "narwhals-polars", @@ -37632,7 +38863,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -37652,7 +38884,8 @@ "upstream_ref": "NW-STR-05", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -37668,7 +38901,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -37684,7 +38918,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -37700,7 +38935,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -37716,7 +38952,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -37732,7 +38969,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -37748,7 +38986,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -37764,7 +39003,8 @@ "upstream_ref": "NW-STR-05", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ] }, @@ -37797,7 +39037,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -37813,7 +39054,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -37829,7 +39071,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -37845,7 +39088,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -37861,7 +39105,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": null, @@ -37877,7 +39122,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -37893,7 +39139,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": null, @@ -37909,7 +39156,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -37925,7 +39173,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -37941,7 +39190,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -37957,7 +39207,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -37973,7 +39224,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -37989,7 +39241,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -38005,7 +39258,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -38021,7 +39275,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -38037,7 +39292,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-polars", @@ -38053,7 +39309,8 @@ "upstream_ref": "PL-STR-02", "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -38073,7 +39330,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -38089,7 +39347,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -38105,7 +39364,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] } @@ -38146,7 +39406,8 @@ "upstream_ref": "PL-STR-04", "since": "2026-08-13", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -38162,7 +39423,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -38178,7 +39440,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -38194,7 +39457,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -38210,7 +39474,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -38230,7 +39495,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -38246,7 +39512,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -38262,7 +39529,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -38295,7 +39563,8 @@ "upstream_ref": "NW-STR-20", "since": "2026-08-13", "native_errors": [], - "probe_exempt": "whole-op gate on a family-wide WILDCARD_PARAM fact; no OpSpec exists since narwhals genuinely has no candidate method to probe -- verified by a dedicated native-API-surface self-healing probe (not a re-invocation of the mountainash wrapper's own hard-coded raise)" + "probe_exempt": "whole-op gate on a family-wide WILDCARD_PARAM fact; no OpSpec exists since narwhals genuinely has no candidate method to probe -- verified by a dedicated native-API-surface self-healing probe (not a re-invocation of the mountainash wrapper's own hard-coded raise)", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -38311,7 +39580,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -38327,7 +39597,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -38343,7 +39614,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -38359,7 +39631,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -38375,7 +39648,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -38391,7 +39665,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -38407,7 +39682,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -38423,7 +39699,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -38439,7 +39716,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -38455,7 +39733,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -38471,7 +39750,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -38487,7 +39767,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -38503,7 +39784,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -38519,7 +39801,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -38555,7 +39838,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -38571,7 +39855,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -38587,7 +39872,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -38603,7 +39889,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -38619,7 +39906,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -38635,7 +39923,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -38651,7 +39940,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -38667,7 +39957,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-polars", @@ -38683,7 +39974,8 @@ "upstream_ref": "IB-STR-13", "since": "2026-08-13", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -38699,7 +39991,8 @@ "upstream_ref": "IB-STR-12", "since": "2026-08-13", "native_errors": [], - "probe_exempt": "whole-op gate on a dialect-scoped WILDCARD_PARAM fact; cannot be keyed on an OpSpec param -- verified by a dedicated cross-backend gate test plus the native-bypass self-healing probe in test_op_level_gate_probes.py, mirroring item 83's TestLikeIbisPolarsGate / test_like_ibis_polars_native_still_broken" + "probe_exempt": "whole-op gate on a dialect-scoped WILDCARD_PARAM fact; cannot be keyed on an OpSpec param -- verified by a dedicated cross-backend gate test plus the native-bypass self-healing probe in test_op_level_gate_probes.py, mirroring item 83's TestLikeIbisPolarsGate / test_like_ibis_polars_native_still_broken", + "predicate": null } ], "residue": [], @@ -38719,7 +40012,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -38735,7 +40029,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -38751,7 +40046,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] } @@ -38792,7 +40088,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -38808,7 +40105,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -38824,7 +40122,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -38840,7 +40139,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -38856,7 +40156,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "polars", @@ -38872,7 +40173,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -38888,7 +40190,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "polars", @@ -38904,7 +40207,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -38924,7 +40228,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -38940,7 +40245,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -38956,7 +40262,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -38989,7 +40296,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -39005,7 +40313,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -39021,7 +40330,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -39037,7 +40347,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -39053,7 +40364,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -39069,7 +40381,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -39085,7 +40398,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -39101,7 +40415,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -39117,7 +40432,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -39133,7 +40449,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -39149,7 +40466,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -39165,7 +40483,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -39181,7 +40500,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -39197,7 +40517,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -39213,7 +40534,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -39229,7 +40551,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -39245,7 +40568,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -39261,7 +40585,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -39277,7 +40602,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "narwhals-polars", @@ -39293,7 +40619,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -39309,7 +40636,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "narwhals-polars", @@ -39325,7 +40653,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -39361,7 +40690,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -39377,7 +40707,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -39393,7 +40724,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -39409,7 +40741,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -39425,7 +40758,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -39441,7 +40775,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -39457,7 +40792,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -39473,7 +40809,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": null, @@ -39489,7 +40826,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -39505,7 +40843,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": null, @@ -39521,7 +40860,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -39537,7 +40877,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -39553,7 +40894,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -39569,7 +40911,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -39585,7 +40928,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -39601,7 +40945,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -39617,7 +40962,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -39633,7 +40979,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -39649,7 +40996,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -39665,7 +41013,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -39681,7 +41030,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -39697,7 +41047,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -39741,7 +41092,8 @@ "upstream_ref": "PL-STR-03", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -39823,7 +41175,8 @@ "upstream_ref": "PL-STR-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -39839,7 +41192,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -39855,7 +41209,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -39875,7 +41230,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -39908,7 +41264,8 @@ "upstream_ref": "NW-STR-03", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -39924,7 +41281,8 @@ "upstream_ref": "NW-STR-03", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -39940,7 +41298,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -39956,7 +41315,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -39972,7 +41332,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -39988,7 +41349,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -40008,7 +41370,8 @@ "upstream_ref": "NW-STR-03", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -40024,7 +41387,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -40040,7 +41404,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -40056,7 +41421,8 @@ "upstream_ref": "NW-STR-03", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ] }, @@ -40089,7 +41455,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -40105,7 +41472,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -40121,7 +41489,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -40137,7 +41506,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-polars", @@ -40153,7 +41523,8 @@ "upstream_ref": "PL-STR-02", "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -40173,7 +41544,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] } @@ -40214,7 +41586,8 @@ "upstream_ref": "PL-STR-03", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -40230,7 +41603,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": "dynamic arg silently miscompiles: str(Expr) bakes the unresolved expression's Python repr into the output as a literal string rather than raising — cannot be confirmed by an exception-based probe" + "probe_exempt": "dynamic arg silently miscompiles: str(Expr) bakes the unresolved expression's Python repr into the output as a literal string rather than raising — cannot be confirmed by an exception-based probe", + "predicate": null }, { "dialect": null, @@ -40246,7 +41620,8 @@ "upstream_ref": "PL-STR-03", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -40301,7 +41676,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -40317,7 +41693,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": "dynamic arg silently miscompiles: str(Expr) bakes the unresolved expression's Python repr into the output as a literal string rather than raising — cannot be confirmed by an exception-based probe" + "probe_exempt": "dynamic arg silently miscompiles: str(Expr) bakes the unresolved expression's Python repr into the output as a literal string rather than raising — cannot be confirmed by an exception-based probe", + "predicate": null }, { "dialect": null, @@ -40333,7 +41710,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -40461,7 +41839,8 @@ "upstream_ref": "NW-STR-06", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -40524,7 +41903,8 @@ "upstream_ref": "PL-STR-03", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -40560,7 +41940,8 @@ "upstream_ref": "NW-STR-06", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -40576,7 +41957,8 @@ "upstream_ref": "NW-STR-06", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -40658,7 +42040,8 @@ "upstream_ref": "NW-STR-07", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -40694,7 +42077,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": "dynamic arg silently miscompiles via str(Expr) into a no-op char-class, returning the input unchanged rather than raising — cannot be confirmed by an exception-based probe" + "probe_exempt": "dynamic arg silently miscompiles via str(Expr) into a no-op char-class, returning the input unchanged rather than raising — cannot be confirmed by an exception-based probe", + "predicate": null } ], "residue": [], @@ -40757,7 +42141,8 @@ "upstream_ref": "NW-STR-21", "since": "2026-08-13", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [ @@ -40777,7 +42162,8 @@ "native_errors": [ "TypeError" ], - "probe_exempt": "whole-op materialize-time storage residue (narwhals-pandas pyarrow-backed-series requirement) -- storage-dependent, not an intrinsic dialect-wide gap: a pyarrow-backed pandas DataFrame genuinely works, so this cannot be a build-time GATE (mirrors NW-LIST-01's identical pyarrow-storage-dependent CONTAINS/T_CONTAINS pattern)" + "probe_exempt": "whole-op materialize-time storage residue (narwhals-pandas pyarrow-backed-series requirement) -- storage-dependent, not an intrinsic dialect-wide gap: a pyarrow-backed pandas DataFrame genuinely works, so this cannot be a build-time GATE (mirrors NW-LIST-01's identical pyarrow-storage-dependent CONTAINS/T_CONTAINS pattern)", + "predicate": null } ], "routed": [], @@ -40812,7 +42198,8 @@ "upstream_ref": "IB-STR-10", "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -40859,7 +42246,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -40892,7 +42280,8 @@ "upstream_ref": "NW-STR-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -40912,7 +42301,8 @@ "upstream_ref": "NW-STR-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -40928,7 +42318,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -40944,7 +42335,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -40960,7 +42352,8 @@ "upstream_ref": "NW-STR-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ] }, @@ -40993,7 +42386,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -41009,7 +42403,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -41029,7 +42424,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] } @@ -41070,7 +42466,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -41086,7 +42483,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -41106,7 +42504,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -41139,7 +42538,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -41155,7 +42555,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -41171,7 +42572,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -41187,7 +42589,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -41207,7 +42610,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -41223,7 +42627,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -41256,7 +42661,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -41272,7 +42678,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -41288,7 +42695,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -41304,7 +42712,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -41324,7 +42733,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] } @@ -41365,7 +42775,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -41381,7 +42792,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -41401,7 +42813,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits WRAP_FROM_END, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits WRAP_FROM_END, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -41434,7 +42847,8 @@ "upstream_ref": "NW-STR-06", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -41450,7 +42864,8 @@ "upstream_ref": "NW-STR-06", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -41466,7 +42881,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -41482,7 +42898,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -41498,7 +42915,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -41514,7 +42932,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -41534,7 +42953,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits WRAP_FROM_END, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits WRAP_FROM_END, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -41550,7 +42970,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits WRAP_FROM_END, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits WRAP_FROM_END, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -41583,7 +43004,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -41599,7 +43021,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -41615,7 +43038,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -41631,7 +43055,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -41651,7 +43076,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits WRAP_FROM_END, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits WRAP_FROM_END, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] } @@ -41692,7 +43118,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -41712,7 +43139,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -41745,7 +43173,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "whole-op gate; verified by the dedicated op-level probe suite (test_op_level_gate_probes.py), which cannot be keyed on an OpSpec param" + "probe_exempt": "whole-op gate; verified by the dedicated op-level probe suite (test_op_level_gate_probes.py), which cannot be keyed on an OpSpec param", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -41761,7 +43190,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -41777,7 +43207,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -41793,7 +43224,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -41809,7 +43241,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -41845,7 +43278,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "whole-op gate; verified by the dedicated op-level probe suite (test_op_level_gate_probes.py), which cannot be keyed on an OpSpec param" + "probe_exempt": "whole-op gate; verified by the dedicated op-level probe suite (test_op_level_gate_probes.py), which cannot be keyed on an OpSpec param", + "predicate": null }, { "dialect": null, @@ -41861,7 +43295,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -41877,7 +43312,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -41893,7 +43329,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -41909,7 +43346,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -41953,7 +43391,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -41973,7 +43412,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -42006,7 +43446,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -42022,7 +43463,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -42042,7 +43484,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -42058,7 +43501,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -42091,7 +43535,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "whole-op gate; verified by the dedicated op-level probe suite (test_op_level_gate_probes.py), which cannot be keyed on an OpSpec param" + "probe_exempt": "whole-op gate; verified by the dedicated op-level probe suite (test_op_level_gate_probes.py), which cannot be keyed on an OpSpec param", + "predicate": null }, { "dialect": null, @@ -42107,7 +43552,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -42123,7 +43569,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -42139,7 +43586,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -42155,7 +43603,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -42218,7 +43667,8 @@ "upstream_ref": "NW-STR-07", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -42254,7 +43704,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": "dynamic arg silently miscompiles via str(Expr) into a no-op char-class, returning the input unchanged rather than raising — cannot be confirmed by an exception-based probe" + "probe_exempt": "dynamic arg silently miscompiles via str(Expr) into a no-op char-class, returning the input unchanged rather than raising — cannot be confirmed by an exception-based probe", + "predicate": null } ], "residue": [], @@ -42298,7 +43749,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -42318,7 +43770,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -42351,7 +43804,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -42367,7 +43821,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -42387,7 +43842,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -42403,7 +43859,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] }, @@ -42436,7 +43893,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -42452,7 +43910,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -42472,7 +43931,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null } ] } @@ -42929,7 +44389,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -42965,7 +44426,20 @@ "upstream_ref": "IB-REL-15", "since": "2026-08-18", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": [ + { + "path": "strategy", + "op": "IN", + "operand": { + "kind": 1, + "value": [ + "forward", + "nearest" + ] + } + } + ] } ], "residue": [], @@ -43076,7 +44550,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": "router, not gate — fallback handles it; behaviour covered by relations resource tests" + "probe_exempt": "router, not gate — fallback handles it; behaviour covered by relations resource tests", + "predicate": null } ], "refinements": [] @@ -43112,7 +44587,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": "router, not gate — fallback handles it; behaviour covered by relations resource tests" + "probe_exempt": "router, not gate — fallback handles it; behaviour covered by relations resource tests", + "predicate": null } ], "refinements": [] @@ -43148,7 +44624,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": "router, not gate — fallback handles it; behaviour covered by relations resource tests" + "probe_exempt": "router, not gate — fallback handles it; behaviour covered by relations resource tests", + "predicate": null } ], "refinements": [] @@ -43469,7 +44946,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ], "residue": [], @@ -43635,7 +45113,8 @@ "upstream_ref": "IB-REL-01", "since": "2026-08-01", "native_errors": [], - "probe_exempt": "relation op-level gap; covered by relation with_row_index cross-backend tests" + "probe_exempt": "relation op-level gap; covered by relation with_row_index cross-backend tests", + "predicate": null } ], "residue": [], @@ -45246,7 +46725,8 @@ "upstream_ref": "IB-DT-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -45262,7 +46742,8 @@ "upstream_ref": "IB-DT-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -45278,7 +46759,8 @@ "upstream_ref": "IB-DT-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -45294,7 +46776,8 @@ "upstream_ref": "IB-DT-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -45310,7 +46793,8 @@ "upstream_ref": "IB-DT-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -45326,7 +46810,8 @@ "upstream_ref": "IB-DT-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -45342,7 +46827,8 @@ "upstream_ref": "IB-DT-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -45358,7 +46844,8 @@ "upstream_ref": "IB-DT-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ] }, @@ -45389,7 +46876,8 @@ "upstream_ref": null, "since": "2026-07-29", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -45405,7 +46893,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -45421,7 +46910,8 @@ "upstream_ref": null, "since": "2026-07-29", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -45437,7 +46927,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -45453,7 +46944,8 @@ "upstream_ref": null, "since": "2026-08-18", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -45469,7 +46961,8 @@ "upstream_ref": null, "since": "2026-08-18", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -45485,7 +46978,8 @@ "upstream_ref": null, "since": "2026-08-18", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -45501,7 +46995,8 @@ "upstream_ref": null, "since": "2026-08-18", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ] }, @@ -45534,7 +47029,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-polars", @@ -45550,7 +47046,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-polars", @@ -45566,7 +47063,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-polars", @@ -45582,7 +47080,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-polars", @@ -45598,7 +47097,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-polars", @@ -45614,7 +47114,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-polars", @@ -45630,7 +47131,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-polars", @@ -45646,7 +47148,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-polars", @@ -45662,7 +47165,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-polars", @@ -45678,7 +47182,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-polars", @@ -45694,7 +47199,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-polars", @@ -45710,7 +47216,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -45726,7 +47233,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -45742,7 +47250,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -45758,7 +47267,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -45774,7 +47284,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -45790,7 +47301,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -45806,7 +47318,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -45822,7 +47335,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -45838,7 +47352,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -45854,7 +47369,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -45870,7 +47386,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -45886,7 +47403,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -45902,7 +47420,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -45918,7 +47437,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -45934,7 +47454,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -45950,7 +47471,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -45966,7 +47488,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -45982,7 +47505,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -45998,7 +47522,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -46014,7 +47539,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -46030,7 +47556,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -46046,7 +47573,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -46062,7 +47590,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -46078,7 +47607,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -46094,7 +47624,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -46110,7 +47641,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -46126,7 +47658,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -46142,7 +47675,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -46158,7 +47692,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -46174,7 +47709,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -46190,7 +47726,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -46206,7 +47743,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -46222,7 +47760,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -46238,7 +47777,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -46254,7 +47794,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -46270,7 +47811,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -46286,7 +47828,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -46302,7 +47845,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -46318,7 +47862,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -46334,7 +47879,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -46350,7 +47896,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -46366,7 +47913,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -46382,7 +47930,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -46398,7 +47947,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -46414,7 +47964,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -46430,7 +47981,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -46446,7 +47998,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -46462,7 +48015,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -46478,7 +48032,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ] }, @@ -46506,7 +48061,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": "router, not gate — fallback handles it; behaviour covered by relations resource tests" + "probe_exempt": "router, not gate — fallback handles it; behaviour covered by relations resource tests", + "predicate": null }, { "dialect": "ibis-polars", @@ -46522,7 +48078,8 @@ "upstream_ref": "IB-REL-01", "since": "2026-08-01", "native_errors": [], - "probe_exempt": "relation op-level gap; covered by relation with_row_index cross-backend tests" + "probe_exempt": "relation op-level gap; covered by relation with_row_index cross-backend tests", + "predicate": null }, { "dialect": "ibis-polars", @@ -46538,7 +48095,20 @@ "upstream_ref": "IB-REL-15", "since": "2026-08-18", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": [ + { + "path": "strategy", + "op": "IN", + "operand": { + "kind": 1, + "value": [ + "forward", + "nearest" + ] + } + } + ] } ] }, @@ -46562,7 +48132,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": "polymorphic — both paths supported by design" + "probe_exempt": "polymorphic — both paths supported by design", + "predicate": null }, { "dialect": null, @@ -46578,7 +48149,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": "polymorphic — both paths supported by design" + "probe_exempt": "polymorphic — both paths supported by design", + "predicate": null } ] }, @@ -46602,7 +48174,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": "polymorphic — both paths supported by design" + "probe_exempt": "polymorphic — both paths supported by design", + "predicate": null } ] }, @@ -46635,7 +48208,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -46651,7 +48225,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -46667,7 +48242,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -46683,7 +48259,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -46699,7 +48276,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -46715,7 +48293,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -46731,7 +48310,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -46747,7 +48327,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -46763,7 +48344,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -46779,7 +48361,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -46795,7 +48378,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -46811,7 +48395,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -46827,7 +48412,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -46843,7 +48429,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -46859,7 +48446,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -46875,7 +48463,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -46891,7 +48480,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -46907,7 +48497,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -46923,7 +48514,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -46939,7 +48531,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -46955,7 +48548,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -46971,7 +48565,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -46987,7 +48582,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47003,7 +48599,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47019,7 +48616,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47035,7 +48633,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47051,7 +48650,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47067,7 +48667,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47083,7 +48684,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47099,7 +48701,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47115,7 +48718,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47131,7 +48735,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47147,7 +48752,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47163,7 +48769,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47179,7 +48786,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47195,7 +48803,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47211,7 +48820,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47227,7 +48837,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47243,7 +48854,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47259,7 +48871,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47275,7 +48888,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47291,7 +48905,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47307,7 +48922,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47323,7 +48939,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47339,7 +48956,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47355,7 +48973,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47371,7 +48990,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47387,7 +49007,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47403,7 +49024,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47419,7 +49041,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47435,7 +49058,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47451,7 +49075,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47467,7 +49092,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47483,7 +49109,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47499,7 +49126,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47515,7 +49143,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47531,7 +49160,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47547,7 +49177,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47563,7 +49194,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47579,7 +49211,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47595,7 +49228,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47611,7 +49245,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47627,7 +49262,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47643,7 +49279,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47659,7 +49296,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47675,7 +49313,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47691,7 +49330,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47707,7 +49347,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47723,7 +49364,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47739,7 +49381,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47755,7 +49398,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47771,7 +49415,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47787,7 +49432,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47803,7 +49449,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47819,7 +49466,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47835,7 +49483,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47851,7 +49500,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47867,7 +49517,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47883,7 +49534,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47899,7 +49551,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47915,7 +49568,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47931,7 +49585,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47947,7 +49602,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47963,7 +49619,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47979,7 +49636,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -47995,7 +49653,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48011,7 +49670,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48027,7 +49687,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48043,7 +49704,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48059,7 +49721,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48075,7 +49738,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48091,7 +49755,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48107,7 +49772,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48123,7 +49789,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48139,7 +49806,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48155,7 +49823,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48171,7 +49840,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48187,7 +49857,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48203,7 +49874,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48219,7 +49891,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48235,7 +49908,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48251,7 +49925,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48267,7 +49942,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48283,7 +49959,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48299,7 +49976,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48315,7 +49993,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48331,7 +50010,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48347,7 +50027,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48363,7 +50044,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48379,7 +50061,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48395,7 +50078,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48411,7 +50095,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48427,7 +50112,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48443,7 +50129,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48459,7 +50146,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48475,7 +50163,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48491,7 +50180,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48507,7 +50197,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48523,7 +50214,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48539,7 +50231,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48555,7 +50248,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48571,7 +50265,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48587,7 +50282,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48603,7 +50299,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48619,7 +50316,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48635,7 +50333,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48651,7 +50350,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48667,7 +50367,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48683,7 +50384,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48699,7 +50401,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48715,7 +50418,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48731,7 +50435,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48747,7 +50452,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48763,7 +50469,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48779,7 +50486,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48795,7 +50503,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48811,7 +50520,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48827,7 +50537,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48843,7 +50554,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48859,7 +50571,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48875,7 +50588,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48891,7 +50605,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48907,7 +50622,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48923,7 +50639,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48939,7 +50656,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48955,7 +50673,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48971,7 +50690,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -48987,7 +50707,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -49003,7 +50724,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -49019,7 +50741,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -49035,7 +50758,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -49051,7 +50775,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49067,7 +50792,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49083,7 +50809,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49099,7 +50826,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49115,7 +50843,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49131,7 +50860,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49147,7 +50877,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49163,7 +50894,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The DuckDB omission path raises the exact exception required by the requested ERROR semantics, so the explicit option is equivalent" + "probe_exempt": "The DuckDB omission path raises the exact exception required by the requested ERROR semantics, so the explicit option is equivalent", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49179,7 +50911,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The DuckDB omission path raises the exact exception required by the requested ERROR semantics, so the explicit option is equivalent" + "probe_exempt": "The DuckDB omission path raises the exact exception required by the requested ERROR semantics, so the explicit option is equivalent", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49195,7 +50928,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The DuckDB omission path raises the exact exception required by the requested ERROR semantics, so the explicit option is equivalent" + "probe_exempt": "The DuckDB omission path raises the exact exception required by the requested ERROR semantics, so the explicit option is equivalent", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49211,7 +50945,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49227,7 +50962,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49243,7 +50979,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49259,7 +50996,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49275,7 +51013,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49291,7 +51030,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49307,7 +51047,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49323,7 +51064,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49339,7 +51081,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49355,7 +51098,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49371,7 +51115,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49387,7 +51132,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49403,7 +51149,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49419,7 +51166,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49435,7 +51183,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The DuckDB omission path raises the exact exception required by the requested ERROR semantics, so the explicit option is equivalent" + "probe_exempt": "The DuckDB omission path raises the exact exception required by the requested ERROR semantics, so the explicit option is equivalent", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49451,7 +51200,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The DuckDB omission path raises the exact exception required by the requested ERROR semantics, so the explicit option is equivalent" + "probe_exempt": "The DuckDB omission path raises the exact exception required by the requested ERROR semantics, so the explicit option is equivalent", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49467,7 +51217,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The DuckDB omission path raises the exact exception required by the requested ERROR semantics, so the explicit option is equivalent" + "probe_exempt": "The DuckDB omission path raises the exact exception required by the requested ERROR semantics, so the explicit option is equivalent", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49483,7 +51234,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The DuckDB omission path raises the exact exception required by the requested ERROR semantics, so the explicit option is equivalent" + "probe_exempt": "The DuckDB omission path raises the exact exception required by the requested ERROR semantics, so the explicit option is equivalent", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49499,7 +51251,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The DuckDB omission path raises the exact exception required by the requested ERROR semantics, so the explicit option is equivalent" + "probe_exempt": "The DuckDB omission path raises the exact exception required by the requested ERROR semantics, so the explicit option is equivalent", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49515,7 +51268,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The DuckDB omission path raises the exact exception required by the requested ERROR semantics, so the explicit option is equivalent" + "probe_exempt": "The DuckDB omission path raises the exact exception required by the requested ERROR semantics, so the explicit option is equivalent", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49531,7 +51285,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49547,7 +51302,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49563,7 +51319,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49579,7 +51336,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49595,7 +51353,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49611,7 +51370,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49627,7 +51387,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49643,7 +51404,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49659,7 +51421,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49675,7 +51438,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49691,7 +51455,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49707,7 +51472,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49723,7 +51489,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49739,7 +51506,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49755,7 +51523,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49771,7 +51540,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49787,7 +51557,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49803,7 +51574,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49819,7 +51591,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49835,7 +51608,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49851,7 +51625,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49867,7 +51642,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49883,7 +51659,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49899,7 +51676,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49915,7 +51693,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49931,7 +51710,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49947,7 +51727,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49963,7 +51744,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49979,7 +51761,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -49995,7 +51778,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50011,7 +51795,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50027,7 +51812,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50043,7 +51829,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50059,7 +51846,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50075,7 +51863,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50091,7 +51880,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50107,7 +51897,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50123,7 +51914,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50139,7 +51931,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50155,7 +51948,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50171,7 +51965,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50187,7 +51982,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50203,7 +51999,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50219,7 +52016,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50235,7 +52033,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50251,7 +52050,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50267,7 +52067,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50283,7 +52084,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50299,7 +52101,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50315,7 +52118,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50331,7 +52135,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50347,7 +52152,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50363,7 +52169,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50379,7 +52186,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50395,7 +52203,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50411,7 +52220,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50427,7 +52237,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50443,7 +52254,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50459,7 +52271,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50475,7 +52288,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50491,7 +52305,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50507,7 +52322,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50523,7 +52339,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50539,7 +52356,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50555,7 +52373,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50571,7 +52390,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50587,7 +52407,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50603,7 +52424,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50619,7 +52441,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50635,7 +52458,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50651,7 +52475,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50667,7 +52492,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50683,7 +52509,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50699,7 +52526,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50715,7 +52543,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50731,7 +52560,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50747,7 +52577,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50763,7 +52594,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50779,7 +52611,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50795,7 +52628,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50811,7 +52645,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50827,7 +52662,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50843,7 +52679,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50859,7 +52696,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50875,7 +52713,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50891,7 +52730,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50907,7 +52747,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50923,7 +52764,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50939,7 +52781,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50955,7 +52798,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50971,7 +52815,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -50987,7 +52832,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51003,7 +52849,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51019,7 +52866,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51035,7 +52883,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51051,7 +52900,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51067,7 +52917,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51083,7 +52934,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51099,7 +52951,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51115,7 +52968,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51131,7 +52985,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51147,7 +53002,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51163,7 +53019,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51179,7 +53036,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51195,7 +53053,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51211,7 +53070,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51227,7 +53087,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51243,7 +53104,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51259,7 +53121,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51275,7 +53138,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51291,7 +53155,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51307,7 +53172,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51323,7 +53189,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51339,7 +53206,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51355,7 +53223,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51371,7 +53240,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51387,7 +53257,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51403,7 +53274,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51419,7 +53291,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51435,7 +53308,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51451,7 +53325,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51467,7 +53342,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51483,7 +53359,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ] }, @@ -51516,7 +53393,8 @@ "upstream_ref": null, "since": "2026-07-25", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -51532,7 +53410,8 @@ "upstream_ref": null, "since": "2026-07-29", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -51548,7 +53427,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -51564,7 +53444,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -51580,7 +53461,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51596,7 +53478,8 @@ "upstream_ref": null, "since": "2026-07-25", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51612,7 +53495,8 @@ "upstream_ref": null, "since": "2026-07-29", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51628,7 +53512,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51644,7 +53529,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51660,7 +53546,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ] }, @@ -51704,7 +53591,8 @@ "upstream_ref": null, "since": "2026-07-30", "native_errors": [], - "probe_exempt": "whole-op gate on a WILDCARD_PARAM fact; cannot be keyed on an OpSpec param (OpSpecs are indexed by concrete argument name) — verified by the dedicated cross-backend gate tests in test_datetime_strptime_format.py" + "probe_exempt": "whole-op gate on a WILDCARD_PARAM fact; cannot be keyed on an OpSpec param (OpSpecs are indexed by concrete argument name) — verified by the dedicated cross-backend gate tests in test_datetime_strptime_format.py", + "predicate": null }, { "dialect": "ibis-sqlite", @@ -51720,7 +53608,8 @@ "upstream_ref": null, "since": "2026-07-30", "native_errors": [], - "probe_exempt": "whole-op gate on a WILDCARD_PARAM fact; cannot be keyed on an OpSpec param (OpSpecs are indexed by concrete argument name) — verified by the dedicated cross-backend gate tests in test_datetime_strptime_format.py" + "probe_exempt": "whole-op gate on a WILDCARD_PARAM fact; cannot be keyed on an OpSpec param (OpSpecs are indexed by concrete argument name) — verified by the dedicated cross-backend gate tests in test_datetime_strptime_format.py", + "predicate": null } ] }, @@ -51766,7 +53655,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -51782,7 +53672,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -51798,7 +53689,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -51814,7 +53706,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -51830,7 +53723,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -51846,7 +53740,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -51862,7 +53757,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -51878,7 +53774,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51894,7 +53791,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51910,7 +53808,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51926,7 +53825,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51942,7 +53842,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51958,7 +53859,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51974,7 +53876,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -51990,7 +53893,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -52006,7 +53910,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ] }, @@ -52037,7 +53942,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-polars", @@ -52053,7 +53959,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -52069,7 +53976,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -52085,7 +53993,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -52101,7 +54010,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -52117,7 +54027,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -52133,7 +54044,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -52149,7 +54061,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -52165,7 +54078,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -52181,7 +54095,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -52197,7 +54112,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -52213,7 +54129,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -52229,7 +54146,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -52245,7 +54163,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ] }, @@ -52273,7 +54192,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": "dynamic arg silently miscompiles: str(Expr) bakes the unresolved expression's Python repr into the output as a literal string rather than raising — cannot be confirmed by an exception-based probe" + "probe_exempt": "dynamic arg silently miscompiles: str(Expr) bakes the unresolved expression's Python repr into the output as a literal string rather than raising — cannot be confirmed by an exception-based probe", + "predicate": null }, { "dialect": null, @@ -52289,7 +54209,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": "dynamic arg silently miscompiles via str(Expr) into a no-op char-class, returning the input unchanged rather than raising — cannot be confirmed by an exception-based probe" + "probe_exempt": "dynamic arg silently miscompiles via str(Expr) into a no-op char-class, returning the input unchanged rather than raising — cannot be confirmed by an exception-based probe", + "predicate": null }, { "dialect": null, @@ -52305,7 +54226,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": "dynamic arg silently miscompiles via str(Expr) into a no-op char-class, returning the input unchanged rather than raising — cannot be confirmed by an exception-based probe" + "probe_exempt": "dynamic arg silently miscompiles via str(Expr) into a no-op char-class, returning the input unchanged rather than raising — cannot be confirmed by an exception-based probe", + "predicate": null }, { "dialect": null, @@ -52321,7 +54243,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": "dynamic arg silently miscompiles via str(Expr) into a no-op char-class, returning the input unchanged rather than raising — cannot be confirmed by an exception-based probe" + "probe_exempt": "dynamic arg silently miscompiles via str(Expr) into a no-op char-class, returning the input unchanged rather than raising — cannot be confirmed by an exception-based probe", + "predicate": null }, { "dialect": null, @@ -52337,7 +54260,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -52353,7 +54277,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -52369,7 +54294,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": "dynamic arg silently miscompiles: str(Expr) bakes the unresolved expression's Python repr into the output as a literal string rather than raising — cannot be confirmed by an exception-based probe" + "probe_exempt": "dynamic arg silently miscompiles: str(Expr) bakes the unresolved expression's Python repr into the output as a literal string rather than raising — cannot be confirmed by an exception-based probe", + "predicate": null }, { "dialect": null, @@ -52385,7 +54311,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ] }, @@ -52418,7 +54345,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "whole-op gate; verified by the dedicated op-level probe suite (test_op_level_gate_probes.py), which cannot be keyed on an OpSpec param" + "probe_exempt": "whole-op gate; verified by the dedicated op-level probe suite (test_op_level_gate_probes.py), which cannot be keyed on an OpSpec param", + "predicate": null }, { "dialect": null, @@ -52434,7 +54362,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "whole-op gate; verified by the dedicated op-level probe suite (test_op_level_gate_probes.py), which cannot be keyed on an OpSpec param" + "probe_exempt": "whole-op gate; verified by the dedicated op-level probe suite (test_op_level_gate_probes.py), which cannot be keyed on an OpSpec param", + "predicate": null }, { "dialect": null, @@ -52450,7 +54379,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "whole-op gate; verified by the dedicated op-level probe suite (test_op_level_gate_probes.py), which cannot be keyed on an OpSpec param" + "probe_exempt": "whole-op gate; verified by the dedicated op-level probe suite (test_op_level_gate_probes.py), which cannot be keyed on an OpSpec param", + "predicate": null }, { "dialect": null, @@ -52466,7 +54396,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -52482,7 +54413,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -52498,7 +54430,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -52514,7 +54447,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -52530,7 +54464,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -52546,7 +54481,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -52562,7 +54498,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -52578,7 +54515,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -52594,7 +54532,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -52610,7 +54549,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -52626,7 +54566,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -52642,7 +54583,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -52658,7 +54600,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -52674,7 +54617,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -52690,7 +54634,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -52706,7 +54651,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -52722,7 +54668,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -52738,7 +54685,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -52754,7 +54702,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -52770,7 +54719,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -52786,7 +54736,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -52802,7 +54753,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -52818,7 +54770,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -52834,7 +54787,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -52850,7 +54804,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -52866,7 +54821,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -52882,7 +54838,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -52898,7 +54855,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -52914,7 +54872,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -52930,7 +54889,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -52946,7 +54906,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -52962,7 +54923,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": null, @@ -52978,7 +54940,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -52994,7 +54957,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -53010,7 +54974,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -53026,7 +54991,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -53042,7 +55008,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -53058,7 +55025,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -53074,7 +55042,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -53090,7 +55059,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -53106,7 +55076,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -53122,7 +55093,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -53138,7 +55110,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -53154,7 +55127,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -53170,7 +55144,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": null, @@ -53186,7 +55161,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": null, @@ -53202,7 +55178,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": null, @@ -53218,7 +55195,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -53234,7 +55212,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -53250,7 +55229,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -53266,7 +55246,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -53282,7 +55263,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": null, @@ -53298,7 +55280,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": null, @@ -53314,7 +55297,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": null, @@ -53330,7 +55314,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": null, @@ -53346,7 +55331,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": null, @@ -53362,7 +55348,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -53378,7 +55365,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -53394,7 +55382,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -53410,7 +55399,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -53426,7 +55416,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -53442,7 +55433,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -53458,7 +55450,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -53474,7 +55467,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -53490,7 +55484,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -53506,7 +55501,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -53522,7 +55518,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -53538,7 +55535,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -53554,7 +55552,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -53570,7 +55569,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -53586,7 +55586,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -53602,7 +55603,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -53618,7 +55620,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -53634,7 +55637,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -53650,7 +55654,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -53666,7 +55671,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -53682,7 +55688,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -53698,7 +55705,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -53714,7 +55722,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -53730,7 +55739,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -53746,7 +55756,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -53762,7 +55773,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -53778,7 +55790,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -53794,7 +55807,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -53810,7 +55824,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -53826,7 +55841,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -53842,7 +55858,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -53858,7 +55875,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -53874,7 +55892,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -53890,7 +55909,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -53906,7 +55926,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -53922,7 +55943,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -53938,7 +55960,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -53954,7 +55977,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -53970,7 +55994,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -53986,7 +56011,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54002,7 +56028,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54018,7 +56045,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54034,7 +56062,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54050,7 +56079,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54066,7 +56096,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54082,7 +56113,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54098,7 +56130,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54114,7 +56147,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54130,7 +56164,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54146,7 +56181,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54162,7 +56198,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54178,7 +56215,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54194,7 +56232,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54210,7 +56249,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54226,7 +56266,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54242,7 +56283,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54258,7 +56300,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54274,7 +56317,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54290,7 +56334,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54306,7 +56351,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54322,7 +56368,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54338,7 +56385,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54354,7 +56402,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54370,7 +56419,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54386,7 +56436,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54402,7 +56453,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54418,7 +56470,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54434,7 +56487,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54450,7 +56504,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits WRAP_FROM_END, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits WRAP_FROM_END, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54466,7 +56521,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54482,7 +56538,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54498,7 +56555,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54514,7 +56572,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54530,7 +56589,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54546,7 +56606,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54562,7 +56623,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54578,7 +56640,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "RIGHT is the builder default, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "RIGHT is the builder default, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54594,7 +56657,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54610,7 +56674,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54626,7 +56691,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54642,7 +56708,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54658,7 +56725,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54674,7 +56742,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54690,7 +56759,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54706,7 +56776,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54722,7 +56793,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -54738,7 +56810,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ] }, @@ -54774,7 +56847,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -54790,7 +56864,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -54806,7 +56881,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ] }, @@ -54850,7 +56926,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -54866,7 +56943,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -54882,7 +56960,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -54898,7 +56977,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -54914,7 +56994,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -54930,7 +57011,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -54946,7 +57028,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -54962,7 +57045,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -54978,7 +57062,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -54994,7 +57079,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -55010,7 +57096,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -55026,7 +57113,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -55042,7 +57130,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -55058,7 +57147,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -55074,7 +57164,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -55090,7 +57181,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -55106,7 +57198,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -55122,7 +57215,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -55138,7 +57232,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-duckdb", @@ -55154,7 +57249,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-polars", @@ -55170,7 +57266,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-polars", @@ -55186,7 +57283,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-polars", @@ -55202,7 +57300,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ] }, @@ -55241,7 +57340,8 @@ "upstream_ref": "PL-STR-02", "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-polars", @@ -55257,7 +57357,8 @@ "upstream_ref": "PL-STR-01", "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-polars", @@ -55273,7 +57374,8 @@ "upstream_ref": "PL-STR-02", "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ] }, @@ -55314,7 +57416,8 @@ "upstream_ref": "IB-STR-06", "since": "2026-08-12", "native_errors": [], - "probe_exempt": "whole-op gate on a dialect-scoped WILDCARD_PARAM fact; cannot be keyed on an OpSpec param — verified by the dedicated cross-backend gate test in test_pattern.py (TestLikeIbisPolarsGate) and the native-bypass self-healing probe in test_op_level_gate_probes.py (test_like_ibis_polars_native_still_broken)" + "probe_exempt": "whole-op gate on a dialect-scoped WILDCARD_PARAM fact; cannot be keyed on an OpSpec param — verified by the dedicated cross-backend gate test in test_pattern.py (TestLikeIbisPolarsGate) and the native-bypass self-healing probe in test_op_level_gate_probes.py (test_like_ibis_polars_native_still_broken)", + "predicate": null }, { "dialect": "ibis-polars", @@ -55330,7 +57433,8 @@ "upstream_ref": "IB-STR-09", "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-polars", @@ -55346,7 +57450,8 @@ "upstream_ref": "IB-STR-10", "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ] }, @@ -55393,7 +57498,8 @@ "upstream_ref": "IB-STR-13", "since": "2026-08-13", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "ibis-sqlite", @@ -55409,7 +57515,8 @@ "upstream_ref": "IB-STR-12", "since": "2026-08-13", "native_errors": [], - "probe_exempt": "whole-op gate on a dialect-scoped WILDCARD_PARAM fact; cannot be keyed on an OpSpec param -- verified by a dedicated cross-backend gate test plus the native-bypass self-healing probe in test_op_level_gate_probes.py, mirroring item 83's TestLikeIbisPolarsGate / test_like_ibis_polars_native_still_broken" + "probe_exempt": "whole-op gate on a dialect-scoped WILDCARD_PARAM fact; cannot be keyed on an OpSpec param -- verified by a dedicated cross-backend gate test plus the native-bypass self-healing probe in test_op_level_gate_probes.py, mirroring item 83's TestLikeIbisPolarsGate / test_like_ibis_polars_native_still_broken", + "predicate": null } ] }, @@ -55437,7 +57544,8 @@ "upstream_ref": "NW-DT-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -55453,7 +57561,8 @@ "upstream_ref": "NW-DT-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -55469,7 +57578,8 @@ "upstream_ref": "NW-DT-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -55485,7 +57595,8 @@ "upstream_ref": "NW-DT-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -55501,7 +57612,8 @@ "upstream_ref": "NW-DT-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -55517,7 +57629,8 @@ "upstream_ref": "NW-DT-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -55533,7 +57646,8 @@ "upstream_ref": "NW-DT-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -55549,7 +57663,8 @@ "upstream_ref": "NW-DT-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ] }, @@ -55582,7 +57697,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -55598,7 +57714,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -55614,7 +57731,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -55630,7 +57748,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -55646,7 +57765,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -55662,7 +57782,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -55678,7 +57799,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -55694,7 +57816,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -55710,7 +57833,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -55726,7 +57850,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -55742,7 +57867,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -55758,7 +57884,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -55774,7 +57901,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -55790,7 +57918,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -55806,7 +57935,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -55822,7 +57952,8 @@ "upstream_ref": null, "since": "2026-08-16", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ] }, @@ -55864,7 +57995,8 @@ "upstream_ref": "NW-LIST-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -55880,7 +58012,8 @@ "upstream_ref": "NW-LIST-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -55898,7 +58031,8 @@ "native_errors": [ "TypeError" ], - "probe_exempt": "whole-op materialize-time storage residue (narwhals-pandas PyArrow-list requirement); enriched after the visitor, not an arg-type gate" + "probe_exempt": "whole-op materialize-time storage residue (narwhals-pandas PyArrow-list requirement); enriched after the visitor, not an arg-type gate", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -55916,7 +58050,8 @@ "native_errors": [ "TypeError" ], - "probe_exempt": "whole-op materialize-time storage residue (narwhals-pandas PyArrow-list requirement); enriched after the visitor, not an arg-type gate" + "probe_exempt": "whole-op materialize-time storage residue (narwhals-pandas PyArrow-list requirement); enriched after the visitor, not an arg-type gate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -55934,7 +58069,8 @@ "native_errors": [ "ValueError" ], - "probe_exempt": "value-conditioned (negative index) — not a structural param gate" + "probe_exempt": "value-conditioned (negative index) — not a structural param gate", + "predicate": null } ] }, @@ -55962,7 +58098,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -55978,7 +58115,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": "router, not gate — fallback handles it; behaviour covered by relations resource tests" + "probe_exempt": "router, not gate — fallback handles it; behaviour covered by relations resource tests", + "predicate": null }, { "dialect": null, @@ -55994,7 +58132,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ] }, @@ -56018,7 +58157,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": "polymorphic — both paths supported by design" + "probe_exempt": "polymorphic — both paths supported by design", + "predicate": null }, { "dialect": null, @@ -56034,7 +58174,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": "polymorphic — both paths supported by design" + "probe_exempt": "polymorphic — both paths supported by design", + "predicate": null } ] }, @@ -56058,7 +58199,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": "polymorphic — both paths supported by design" + "probe_exempt": "polymorphic — both paths supported by design", + "predicate": null } ] }, @@ -56091,7 +58233,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate" + "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56107,7 +58250,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56123,7 +58267,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56139,7 +58284,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56155,7 +58301,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56171,7 +58318,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate" + "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56187,7 +58335,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56203,7 +58352,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56219,7 +58369,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56235,7 +58386,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56251,7 +58403,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56267,7 +58420,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56283,7 +58437,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56299,7 +58454,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56315,7 +58471,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56331,7 +58488,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56347,7 +58505,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56363,7 +58522,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56379,7 +58539,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56395,7 +58556,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56411,7 +58573,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56427,7 +58590,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate" + "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56443,7 +58607,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate" + "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56459,7 +58624,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56475,7 +58641,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56491,7 +58658,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56507,7 +58675,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56523,7 +58692,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56539,7 +58709,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56555,7 +58726,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56571,7 +58743,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56587,7 +58760,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56603,7 +58777,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56619,7 +58794,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56635,7 +58811,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56651,7 +58828,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56667,7 +58845,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56683,7 +58862,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56699,7 +58879,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56715,7 +58896,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56731,7 +58913,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56747,7 +58930,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56763,7 +58947,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56779,7 +58964,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56795,7 +58981,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56811,7 +58998,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56827,7 +59015,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56843,7 +59032,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56859,7 +59049,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56875,7 +59066,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56891,7 +59083,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56907,7 +59100,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56923,7 +59117,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56939,7 +59134,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56955,7 +59151,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56971,7 +59168,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -56987,7 +59185,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57003,7 +59202,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57019,7 +59219,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57035,7 +59236,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57051,7 +59253,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57067,7 +59270,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57083,7 +59287,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57099,7 +59304,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57115,7 +59321,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57131,7 +59338,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57147,7 +59355,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57163,7 +59372,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57179,7 +59389,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57195,7 +59406,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57211,7 +59423,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57227,7 +59440,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57243,7 +59457,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57259,7 +59474,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57275,7 +59491,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57291,7 +59508,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57307,7 +59525,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57323,7 +59542,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57339,7 +59559,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57355,7 +59576,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57371,7 +59593,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57387,7 +59610,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57403,7 +59627,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57419,7 +59644,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57435,7 +59661,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57451,7 +59678,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57467,7 +59695,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57483,7 +59712,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57499,7 +59729,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57515,7 +59746,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57531,7 +59763,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57547,7 +59780,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57563,7 +59797,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57579,7 +59814,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57595,7 +59831,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57611,7 +59848,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57627,7 +59865,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57643,7 +59882,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57659,7 +59899,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57675,7 +59916,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57691,7 +59933,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57707,7 +59950,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57723,7 +59967,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57739,7 +59984,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57755,7 +60001,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57771,7 +60018,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57787,7 +60035,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57803,7 +60052,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57819,7 +60069,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57835,7 +60086,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57851,7 +60103,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57867,7 +60120,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57883,7 +60137,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57899,7 +60154,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57915,7 +60171,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57931,7 +60188,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57947,7 +60205,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57963,7 +60222,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57979,7 +60239,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -57995,7 +60256,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -58011,7 +60273,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -58027,7 +60290,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -58043,7 +60307,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -58059,7 +60324,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -58075,7 +60341,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -58091,7 +60358,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -58107,7 +60375,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -58123,7 +60392,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -58139,7 +60409,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -58155,7 +60426,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -58171,7 +60443,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -58187,7 +60460,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -58203,7 +60477,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -58219,7 +60494,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -58235,7 +60511,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -58251,7 +60528,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -58267,7 +60545,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -58283,7 +60562,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -58299,7 +60579,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -58315,7 +60596,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -58331,7 +60613,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -58347,7 +60630,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -58363,7 +60647,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -58379,7 +60664,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -58395,7 +60681,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -58411,7 +60698,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -58427,7 +60715,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -58443,7 +60732,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -58459,7 +60749,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -58475,7 +60766,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -58491,7 +60783,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -58507,7 +60800,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -58523,7 +60817,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate" + "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -58539,7 +60834,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -58555,7 +60851,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -58571,7 +60868,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate" + "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -58587,7 +60885,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -58603,7 +60902,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -58619,7 +60919,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -58635,7 +60936,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -58651,7 +60953,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -58667,7 +60970,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -58683,7 +60987,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -58699,7 +61004,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -58715,7 +61021,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -58731,7 +61038,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -58747,7 +61055,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate" + "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -58763,7 +61072,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate" + "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -58779,7 +61089,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -58795,7 +61106,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -58811,7 +61123,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -58827,7 +61140,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -58843,7 +61157,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -58859,7 +61174,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate" + "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -58875,7 +61191,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -58891,7 +61208,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -58907,7 +61225,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -58923,7 +61242,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -58939,7 +61259,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -58955,7 +61276,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -58971,7 +61293,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -58987,7 +61310,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59003,7 +61327,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59019,7 +61344,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59035,7 +61361,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59051,7 +61378,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59067,7 +61395,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59083,7 +61412,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59099,7 +61429,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59115,7 +61446,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59131,7 +61463,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59147,7 +61480,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -59163,7 +61497,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -59179,7 +61514,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -59195,7 +61531,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -59211,7 +61548,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -59227,7 +61565,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -59243,7 +61582,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -59259,7 +61599,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59275,7 +61616,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59291,7 +61633,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59307,7 +61650,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59323,7 +61667,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59339,7 +61684,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59355,7 +61701,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59371,7 +61718,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59387,7 +61735,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59403,7 +61752,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59419,7 +61769,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59435,7 +61786,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59451,7 +61803,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59467,7 +61820,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59483,7 +61837,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59499,7 +61854,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59515,7 +61871,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59531,7 +61888,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59547,7 +61905,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59563,7 +61922,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59579,7 +61939,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59595,7 +61956,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59611,7 +61973,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59627,7 +61990,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59643,7 +62007,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59659,7 +62024,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59675,7 +62041,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59691,7 +62058,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59707,7 +62075,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59723,7 +62092,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59739,7 +62109,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59755,7 +62126,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59771,7 +62143,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59787,7 +62160,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59803,7 +62177,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59819,7 +62194,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59835,7 +62211,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59851,7 +62228,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59867,7 +62245,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59883,7 +62262,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59899,7 +62279,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59915,7 +62296,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59931,7 +62313,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59947,7 +62330,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59963,7 +62347,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59979,7 +62364,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -59995,7 +62381,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60011,7 +62398,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60027,7 +62415,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60043,7 +62432,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60059,7 +62449,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60075,7 +62466,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60091,7 +62483,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60107,7 +62500,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60123,7 +62517,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60139,7 +62534,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60155,7 +62551,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60171,7 +62568,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60187,7 +62585,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60203,7 +62602,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60219,7 +62619,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60235,7 +62636,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60251,7 +62653,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60267,7 +62670,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60283,7 +62687,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60299,7 +62704,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60315,7 +62721,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60331,7 +62738,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60347,7 +62755,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60363,7 +62772,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60379,7 +62789,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60395,7 +62806,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60411,7 +62823,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60427,7 +62840,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60443,7 +62857,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60459,7 +62874,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60475,7 +62891,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60491,7 +62908,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60507,7 +62925,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60523,7 +62942,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60539,7 +62959,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60555,7 +62976,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60571,7 +62993,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60587,7 +63010,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60603,7 +63027,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60619,7 +63044,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60635,7 +63061,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60651,7 +63078,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60667,7 +63095,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60683,7 +63112,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60699,7 +63129,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60715,7 +63146,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60731,7 +63163,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60747,7 +63180,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60763,7 +63197,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60779,7 +63214,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60795,7 +63231,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60811,7 +63248,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60827,7 +63265,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60843,7 +63282,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60859,7 +63299,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60875,7 +63316,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60891,7 +63333,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60907,7 +63350,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60923,7 +63367,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60939,7 +63384,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ] }, @@ -60972,7 +63418,8 @@ "upstream_ref": null, "since": "2026-07-25", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -60988,7 +63435,8 @@ "upstream_ref": null, "since": "2026-07-25", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ] }, @@ -61032,7 +63480,8 @@ "upstream_ref": null, "since": "2026-07-30", "native_errors": [], - "probe_exempt": "whole-op gate on a WILDCARD_PARAM fact; cannot be keyed on an OpSpec param (OpSpecs are indexed by concrete argument name) — verified by the dedicated cross-backend gate tests in test_datetime_strptime_format.py" + "probe_exempt": "whole-op gate on a WILDCARD_PARAM fact; cannot be keyed on an OpSpec param (OpSpecs are indexed by concrete argument name) — verified by the dedicated cross-backend gate tests in test_datetime_strptime_format.py", + "predicate": null } ] }, @@ -61078,7 +63527,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -61094,7 +63544,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -61110,7 +63561,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -61126,7 +63578,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -61142,7 +63595,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -61158,7 +63612,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -61174,7 +63629,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -61190,7 +63646,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -61206,7 +63663,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -61222,7 +63680,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -61238,7 +63697,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -61254,7 +63714,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -61270,7 +63731,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -61286,7 +63748,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -61302,7 +63765,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -61318,7 +63782,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -61334,7 +63799,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -61350,7 +63816,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -61366,7 +63833,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -61382,7 +63850,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ] }, @@ -61410,7 +63879,8 @@ "upstream_ref": "NW-STR-06", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -61426,7 +63896,8 @@ "upstream_ref": "NW-STR-06", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -61442,7 +63913,8 @@ "upstream_ref": "NW-STR-07", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -61458,7 +63930,8 @@ "upstream_ref": "NW-STR-07", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -61474,7 +63947,8 @@ "upstream_ref": "NW-STR-07", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -61490,7 +63964,8 @@ "upstream_ref": "NW-STR-06", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -61506,7 +63981,8 @@ "upstream_ref": "NW-STR-06", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -61522,7 +63998,8 @@ "upstream_ref": "NW-STR-06", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -61538,7 +64015,8 @@ "upstream_ref": "NW-STR-06", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -61554,7 +64032,8 @@ "upstream_ref": "NW-STR-06", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -61570,7 +64049,8 @@ "upstream_ref": "NW-STR-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -61586,7 +64066,8 @@ "upstream_ref": "NW-STR-05", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -61602,7 +64083,8 @@ "upstream_ref": "NW-STR-03", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -61618,7 +64100,8 @@ "upstream_ref": "NW-STR-05", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -61634,7 +64117,8 @@ "upstream_ref": "NW-STR-06", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -61650,7 +64134,8 @@ "upstream_ref": "NW-STR-03", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -61666,7 +64151,8 @@ "upstream_ref": "NW-STR-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -61682,7 +64168,8 @@ "upstream_ref": "NW-STR-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -61698,7 +64185,8 @@ "upstream_ref": "NW-STR-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -61714,7 +64202,8 @@ "upstream_ref": "NW-STR-03", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ] }, @@ -61747,7 +64236,8 @@ "upstream_ref": "NW-STR-03", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-lazy", @@ -61763,7 +64253,8 @@ "upstream_ref": "NW-STR-05", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-lazy", @@ -61779,7 +64270,8 @@ "upstream_ref": "NW-STR-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-lazy", @@ -61795,7 +64287,8 @@ "upstream_ref": "NW-STR-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-lazy", @@ -61811,7 +64304,8 @@ "upstream_ref": "NW-STR-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -61827,7 +64321,8 @@ "upstream_ref": "NW-STR-03", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -61843,7 +64338,8 @@ "upstream_ref": "NW-STR-05", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -61859,7 +64355,8 @@ "upstream_ref": "NW-STR-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -61875,7 +64372,8 @@ "upstream_ref": "NW-STR-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -61891,7 +64389,8 @@ "upstream_ref": "NW-STR-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ] }, @@ -61924,7 +64423,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "whole-op gate; verified by the dedicated op-level probe suite (test_op_level_gate_probes.py), which cannot be keyed on an OpSpec param" + "probe_exempt": "whole-op gate; verified by the dedicated op-level probe suite (test_op_level_gate_probes.py), which cannot be keyed on an OpSpec param", + "predicate": null }, { "dialect": null, @@ -61940,7 +64440,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "whole-op gate; verified by the dedicated op-level probe suite (test_op_level_gate_probes.py), which cannot be keyed on an OpSpec param" + "probe_exempt": "whole-op gate; verified by the dedicated op-level probe suite (test_op_level_gate_probes.py), which cannot be keyed on an OpSpec param", + "predicate": null }, { "dialect": null, @@ -61956,7 +64457,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "whole-op gate; verified by the dedicated op-level probe suite (test_op_level_gate_probes.py), which cannot be keyed on an OpSpec param" + "probe_exempt": "whole-op gate; verified by the dedicated op-level probe suite (test_op_level_gate_probes.py), which cannot be keyed on an OpSpec param", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -61972,7 +64474,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -61988,7 +64491,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62004,7 +64508,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62020,7 +64525,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62036,7 +64542,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62052,7 +64559,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62068,7 +64576,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62084,7 +64593,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62100,7 +64610,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62116,7 +64627,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62132,7 +64644,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62148,7 +64661,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62164,7 +64678,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62180,7 +64695,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62196,7 +64712,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62212,7 +64729,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62228,7 +64746,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62244,7 +64763,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62260,7 +64780,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62276,7 +64797,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62292,7 +64814,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62308,7 +64831,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62324,7 +64848,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62340,7 +64865,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62356,7 +64882,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62372,7 +64899,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62388,7 +64916,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62404,7 +64933,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62420,7 +64950,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62436,7 +64967,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62452,7 +64984,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62468,7 +65001,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62484,7 +65018,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62500,7 +65035,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62516,7 +65052,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62532,7 +65069,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62548,7 +65086,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62564,7 +65103,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62580,7 +65120,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62596,7 +65137,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62612,7 +65154,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62628,7 +65171,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62644,7 +65188,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62660,7 +65205,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62676,7 +65222,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62692,7 +65239,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62708,7 +65256,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62724,7 +65273,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62740,7 +65290,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62756,7 +65307,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62772,7 +65324,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62788,7 +65341,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62804,7 +65358,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62820,7 +65375,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62836,7 +65392,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62852,7 +65409,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62868,7 +65426,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62884,7 +65443,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62900,7 +65460,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62916,7 +65477,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62932,7 +65494,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62948,7 +65511,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62964,7 +65528,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62980,7 +65545,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -62996,7 +65562,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -63012,7 +65579,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits WRAP_FROM_END, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits WRAP_FROM_END, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -63028,7 +65596,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -63044,7 +65613,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -63060,7 +65630,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -63076,7 +65647,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -63092,7 +65664,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -63108,7 +65681,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -63124,7 +65698,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -63140,7 +65715,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -63156,7 +65732,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -63172,7 +65749,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -63188,7 +65766,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -63204,7 +65783,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -63220,7 +65800,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "narwhals-pandas", @@ -63236,7 +65817,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -63252,7 +65834,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -63268,7 +65851,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -63284,7 +65868,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -63300,7 +65885,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -63316,7 +65902,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -63332,7 +65919,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -63348,7 +65936,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -63364,7 +65953,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -63380,7 +65970,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -63396,7 +65987,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -63412,7 +66004,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -63428,7 +66021,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -63444,7 +66038,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -63460,7 +66055,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -63476,7 +66072,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -63492,7 +66089,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -63508,7 +66106,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -63524,7 +66123,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -63540,7 +66140,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -63556,7 +66157,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -63572,7 +66174,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -63588,7 +66191,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -63604,7 +66208,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -63620,7 +66225,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -63636,7 +66242,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -63652,7 +66259,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -63668,7 +66276,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -63684,7 +66293,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -63700,7 +66310,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -63716,7 +66327,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -63732,7 +66344,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -63748,7 +66361,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -63764,7 +66378,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -63780,7 +66395,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -63796,7 +66412,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -63812,7 +66429,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -63828,7 +66446,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -63844,7 +66463,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -63860,7 +66480,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -63876,7 +66497,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -63892,7 +66514,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -63908,7 +66531,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -63924,7 +66548,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -63940,7 +66565,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -63956,7 +66582,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -63972,7 +66599,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -63988,7 +66616,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -64004,7 +66633,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -64020,7 +66650,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -64036,7 +66667,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -64052,7 +66684,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -64068,7 +66701,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "narwhals-polars", @@ -64084,7 +66718,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "narwhals-polars", @@ -64100,7 +66735,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -64116,7 +66752,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -64132,7 +66769,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -64148,7 +66786,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -64164,7 +66803,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -64180,7 +66820,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -64196,7 +66837,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -64212,7 +66854,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -64228,7 +66871,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -64244,7 +66888,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -64260,7 +66905,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -64276,7 +66922,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -64292,7 +66939,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -64308,7 +66956,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -64324,7 +66973,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -64340,7 +66990,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -64356,7 +67007,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits WRAP_FROM_END, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits WRAP_FROM_END, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "narwhals-polars", @@ -64372,7 +67024,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "narwhals-polars", @@ -64388,7 +67041,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "narwhals-polars", @@ -64404,7 +67058,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "narwhals-polars", @@ -64420,7 +67075,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -64436,7 +67092,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -64452,7 +67109,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -64468,7 +67126,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -64484,7 +67143,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -64500,7 +67160,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "narwhals-polars", @@ -64516,7 +67177,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "narwhals-polars", @@ -64532,7 +67194,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "narwhals-polars", @@ -64548,7 +67211,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "narwhals-polars", @@ -64564,7 +67228,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "narwhals-polars", @@ -64580,7 +67245,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -64596,7 +67262,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -64612,7 +67279,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -64628,7 +67296,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -64644,7 +67313,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ] }, @@ -64688,7 +67358,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -64704,7 +67375,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -64720,7 +67392,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -64736,7 +67409,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -64752,7 +67426,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -64768,7 +67443,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -64784,7 +67460,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -64800,7 +67477,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -64816,7 +67494,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -64832,7 +67511,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -64848,7 +67528,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -64864,7 +67545,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -64880,7 +67562,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -64896,7 +67579,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -64912,7 +67596,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -64928,7 +67613,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -64944,7 +67630,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -64960,7 +67647,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -64976,7 +67664,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-polars", @@ -64992,7 +67681,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ] }, @@ -65039,7 +67729,8 @@ "upstream_ref": "NW-STR-20", "since": "2026-08-13", "native_errors": [], - "probe_exempt": "whole-op gate on a family-wide WILDCARD_PARAM fact; no OpSpec exists since narwhals genuinely has no candidate method to probe -- verified by a dedicated native-API-surface self-healing probe (not a re-invocation of the mountainash wrapper's own hard-coded raise)" + "probe_exempt": "whole-op gate on a family-wide WILDCARD_PARAM fact; no OpSpec exists since narwhals genuinely has no candidate method to probe -- verified by a dedicated native-API-surface self-healing probe (not a re-invocation of the mountainash wrapper's own hard-coded raise)", + "predicate": null }, { "dialect": null, @@ -65055,7 +67746,8 @@ "upstream_ref": "NW-STR-21", "since": "2026-08-13", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "narwhals-pandas", @@ -65073,7 +67765,8 @@ "native_errors": [ "TypeError" ], - "probe_exempt": "whole-op materialize-time storage residue (narwhals-pandas pyarrow-backed-series requirement) -- storage-dependent, not an intrinsic dialect-wide gap: a pyarrow-backed pandas DataFrame genuinely works, so this cannot be a build-time GATE (mirrors NW-LIST-01's identical pyarrow-storage-dependent CONTAINS/T_CONTAINS pattern)" + "probe_exempt": "whole-op materialize-time storage residue (narwhals-pandas pyarrow-backed-series requirement) -- storage-dependent, not an intrinsic dialect-wide gap: a pyarrow-backed pandas DataFrame genuinely works, so this cannot be a build-time GATE (mirrors NW-LIST-01's identical pyarrow-storage-dependent CONTAINS/T_CONTAINS pattern)", + "predicate": null } ] }, @@ -65101,7 +67794,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": "router, not gate — fallback handles it; behaviour covered by relations resource tests" + "probe_exempt": "router, not gate — fallback handles it; behaviour covered by relations resource tests", + "predicate": null } ] }, @@ -65125,7 +67819,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": "polymorphic — both paths supported by design" + "probe_exempt": "polymorphic — both paths supported by design", + "predicate": null }, { "dialect": null, @@ -65141,7 +67836,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": "polymorphic — both paths supported by design" + "probe_exempt": "polymorphic — both paths supported by design", + "predicate": null } ] }, @@ -65165,7 +67861,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": "polymorphic — both paths supported by design" + "probe_exempt": "polymorphic — both paths supported by design", + "predicate": null } ] }, @@ -65198,7 +67895,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate" + "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -65214,7 +67912,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -65230,7 +67929,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -65246,7 +67946,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate" + "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -65262,7 +67963,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -65278,7 +67980,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -65294,7 +67997,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -65310,7 +68014,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -65326,7 +68031,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -65342,7 +68048,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -65358,7 +68065,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -65374,7 +68082,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -65390,7 +68099,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -65406,7 +68116,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -65422,7 +68133,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate" + "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -65438,7 +68150,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate" + "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -65454,7 +68167,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate" + "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -65470,7 +68184,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate" + "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -65486,7 +68201,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate" + "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -65502,7 +68218,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate" + "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -65518,7 +68235,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate" + "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -65534,7 +68252,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate" + "probe_exempt": "The native omission path already has the requested arithmetic semantics, so the explicit option cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -65550,7 +68269,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -65566,7 +68286,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -65582,7 +68303,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -65598,7 +68320,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -65614,7 +68337,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -65630,7 +68354,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -65646,7 +68371,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -65662,7 +68388,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -65678,7 +68405,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -65694,7 +68422,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -65710,7 +68439,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -65726,7 +68456,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -65742,7 +68473,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -65758,7 +68490,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -65774,7 +68507,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -65790,7 +68524,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -65806,7 +68541,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -65822,7 +68558,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -65838,7 +68575,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -65854,7 +68592,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -65870,7 +68609,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -65886,7 +68626,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -65902,7 +68643,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -65918,7 +68660,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The explicit option selects the native backend's existing behavior, so it is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -65934,7 +68677,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -65950,7 +68694,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -65966,7 +68711,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -65982,7 +68728,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -65998,7 +68745,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66014,7 +68762,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66030,7 +68779,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66046,7 +68796,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66062,7 +68813,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66078,7 +68830,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66094,7 +68847,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66110,7 +68864,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66126,7 +68881,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66142,7 +68898,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66158,7 +68915,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66174,7 +68932,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66190,7 +68949,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66206,7 +68966,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66222,7 +68983,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66238,7 +69000,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66254,7 +69017,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66270,7 +69034,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66286,7 +69051,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66302,7 +69068,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66318,7 +69085,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66334,7 +69102,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66350,7 +69119,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66366,7 +69136,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66382,7 +69153,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66398,7 +69170,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66414,7 +69187,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66430,7 +69204,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66446,7 +69221,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66462,7 +69238,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66478,7 +69255,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66494,7 +69272,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66510,7 +69289,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66526,7 +69306,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66542,7 +69323,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66558,7 +69340,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66574,7 +69357,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66590,7 +69374,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66606,7 +69391,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66622,7 +69408,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66638,7 +69425,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66654,7 +69442,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66670,7 +69459,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66686,7 +69476,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66702,7 +69493,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66718,7 +69510,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66734,7 +69527,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66750,7 +69544,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66766,7 +69561,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66782,7 +69578,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66798,7 +69595,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66814,7 +69612,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66830,7 +69629,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66846,7 +69646,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66862,7 +69663,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66878,7 +69680,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66894,7 +69697,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66910,7 +69714,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66926,7 +69731,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66942,7 +69748,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66958,7 +69765,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66974,7 +69782,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -66990,7 +69799,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67006,7 +69816,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67022,7 +69833,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67038,7 +69850,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67054,7 +69867,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67070,7 +69884,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67086,7 +69901,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67102,7 +69918,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67118,7 +69935,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67134,7 +69952,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67150,7 +69969,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67166,7 +69986,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67182,7 +70003,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67198,7 +70020,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67214,7 +70037,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67230,7 +70054,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67246,7 +70071,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67262,7 +70088,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67278,7 +70105,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67294,7 +70122,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67310,7 +70139,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67326,7 +70156,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67342,7 +70173,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67358,7 +70190,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67374,7 +70207,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67390,7 +70224,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67406,7 +70241,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67422,7 +70258,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67438,7 +70275,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67454,7 +70292,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67470,7 +70309,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67486,7 +70326,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67502,7 +70343,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67518,7 +70360,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67534,7 +70377,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67550,7 +70394,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67566,7 +70411,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67582,7 +70428,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67598,7 +70445,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67614,7 +70462,8 @@ "upstream_ref": null, "since": "2026-07-21", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ] }, @@ -67660,7 +70509,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67676,7 +70526,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67692,7 +70543,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67708,7 +70560,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67724,7 +70577,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67740,7 +70594,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67756,7 +70611,8 @@ "upstream_ref": null, "since": "2026-08-15", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ] }, @@ -67786,7 +70642,8 @@ "upstream_ref": "PL-STR-03", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -67802,7 +70659,8 @@ "upstream_ref": "PL-STR-03", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -67818,7 +70676,8 @@ "upstream_ref": "PL-STR-03", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -67834,7 +70693,8 @@ "upstream_ref": "PL-STR-03", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -67850,7 +70710,8 @@ "upstream_ref": "PL-STR-03", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -67866,7 +70727,8 @@ "upstream_ref": "PL-STR-03", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -67882,7 +70744,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": "dynamic arg silently miscompiles: the SQL-LIKE→regex conversion runs on str(Expr), producing a pattern that matches nothing rather than raising — cannot be confirmed by an exception-based probe" + "probe_exempt": "dynamic arg silently miscompiles: the SQL-LIKE→regex conversion runs on str(Expr), producing a pattern that matches nothing rather than raising — cannot be confirmed by an exception-based probe", + "predicate": null }, { "dialect": null, @@ -67898,7 +70761,8 @@ "upstream_ref": "PL-STR-02", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -67914,7 +70778,8 @@ "upstream_ref": null, "since": "2026-07-05", "native_errors": [], - "probe_exempt": "dynamic arg silently miscompiles: str(Expr) bakes the unresolved expression's Python repr into the output as a literal string rather than raising — cannot be confirmed by an exception-based probe" + "probe_exempt": "dynamic arg silently miscompiles: str(Expr) bakes the unresolved expression's Python repr into the output as a literal string rather than raising — cannot be confirmed by an exception-based probe", + "predicate": null }, { "dialect": null, @@ -67930,7 +70795,8 @@ "upstream_ref": "PL-STR-03", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": null, @@ -67946,7 +70812,8 @@ "upstream_ref": "PL-STR-01", "since": "2026-07-05", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ] }, @@ -67979,7 +70846,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -67995,7 +70863,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -68011,7 +70880,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -68027,7 +70897,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -68043,7 +70914,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -68059,7 +70931,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -68075,7 +70948,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -68091,7 +70965,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -68107,7 +70982,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -68123,7 +70999,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -68139,7 +71016,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -68155,7 +71033,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -68171,7 +71050,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -68187,7 +71067,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -68203,7 +71084,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -68219,7 +71101,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -68235,7 +71118,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits CASE_SENSITIVE, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -68251,7 +71135,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -68267,7 +71152,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -68283,7 +71169,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -68299,7 +71186,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -68315,7 +71203,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -68331,7 +71220,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -68347,7 +71237,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -68363,7 +71254,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -68379,7 +71271,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -68395,7 +71288,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -68411,7 +71305,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -68427,7 +71322,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -68443,7 +71339,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -68459,7 +71356,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -68475,7 +71373,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -68491,7 +71390,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -68507,7 +71407,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -68523,7 +71424,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits UTF8, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -68539,7 +71441,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -68555,7 +71458,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -68571,7 +71475,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -68587,7 +71492,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -68603,7 +71509,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -68619,7 +71526,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -68635,7 +71543,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -68651,7 +71560,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -68667,7 +71577,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -68683,7 +71594,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -68699,7 +71611,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -68715,7 +71628,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -68731,7 +71645,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "polars", @@ -68747,7 +71662,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -68763,7 +71679,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -68779,7 +71696,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -68795,7 +71713,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -68811,7 +71730,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -68827,7 +71747,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -68843,7 +71764,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits this regexp flag value, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -68859,7 +71781,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -68875,7 +71798,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -68891,7 +71815,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -68907,7 +71832,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -68923,7 +71849,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -68939,7 +71866,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -68955,7 +71883,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -68971,7 +71900,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -68987,7 +71917,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "The builder default emits WRAP_FROM_END, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "The builder default emits WRAP_FROM_END, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -69003,7 +71934,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "polars", @@ -69019,7 +71951,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "polars", @@ -69035,7 +71968,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -69051,7 +71985,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -69067,7 +72002,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -69083,7 +72019,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "RIGHT is the builder default, so the explicit option is observably equivalent to omission and cannot discriminate" + "probe_exempt": "RIGHT is the builder default, so the explicit option is observably equivalent to omission and cannot discriminate", + "predicate": null }, { "dialect": "polars", @@ -69099,7 +72036,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "polars", @@ -69115,7 +72053,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "polars", @@ -69131,7 +72070,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "polars", @@ -69147,7 +72087,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "polars", @@ -69163,7 +72104,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check" + "probe_exempt": "value-agnostic companion to the representative-value positional fact; the value-scoped disposition probe drives the native-path check", + "predicate": null }, { "dialect": "polars", @@ -69179,7 +72121,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -69195,7 +72138,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -69211,7 +72155,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -69227,7 +72172,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -69243,7 +72189,8 @@ "upstream_ref": null, "since": "2026-07-23", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ] }, @@ -69287,7 +72234,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -69303,7 +72251,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -69319,7 +72268,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -69335,7 +72285,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -69351,7 +72302,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -69367,7 +72319,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -69383,7 +72336,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -69399,7 +72353,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -69415,7 +72370,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null }, { "dialect": "polars", @@ -69431,7 +72387,8 @@ "upstream_ref": null, "since": "2026-08-12", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ] }, @@ -69466,7 +72423,8 @@ "upstream_ref": "PL-STR-04", "since": "2026-08-13", "native_errors": [], - "probe_exempt": null + "probe_exempt": null, + "predicate": null } ] } diff --git a/src/mountainash/core/capabilities/render_markdown.py b/src/mountainash/core/capabilities/render_markdown.py index 520db015..77a1c13c 100644 --- a/src/mountainash/core/capabilities/render_markdown.py +++ b/src/mountainash/core/capabilities/render_markdown.py @@ -8,6 +8,7 @@ import json from datetime import date, timedelta +from enum import Enum from typing import TYPE_CHECKING, Any, Callable from mountainash.core.capabilities.coverage import ( @@ -25,6 +26,7 @@ CapabilityFact, CapabilityLevel, Enforcement, # summary stats + ValueClass, ) if TYPE_CHECKING: @@ -589,13 +591,35 @@ def _op_key(operation_key: Any) -> dict[str, str]: return {"family": type(operation_key).__name__, "op": operation_key.name} +def _operand_json(operand: Any) -> dict[str, Any]: + """JSON-safe tagged encoding of a predicate clause operand, mirroring + schema._operand_key's own kind tagging (0=None, 1=frozenset, 2=ValueClass, + 3=other Enum, 4=scalar) so the committed JSON round-trips the exact same + identity tuple test_json_completeness compares against the live model.""" + if operand is None: + return {"kind": 0, "value": None} + if isinstance(operand, frozenset): + return {"kind": 1, "value": sorted(str(m) for m in operand)} + if isinstance(operand, ValueClass): + return {"kind": 2, "value": operand.value} + if isinstance(operand, Enum): + return {"kind": 3, "type": type(operand).__name__, "value": operand.value} + return {"kind": 4, "value": operand} + + +def _clause_dict(clause: Any) -> dict[str, Any]: + return {"path": clause.path, "op": clause.op.name, "operand": _operand_json(clause.operand)} + + def _fact_dict(f: CapabilityFact) -> dict[str, Any]: """Serialize one CapabilityFact as a dict (spec §4.6 shape). `option_value` is None -> JSON `null`; `native_errors=()` -> JSON `[]`. `value_class` is None -> JSON `null`; the level/enforcement/boundary are serialized by .value. `condition`/`message` are always strings (the - model's default is "" so absent-prose is "" not null here).""" + model's default is "" so absent-prose is "" not null here). `predicate` + is None for the vast majority of facts (no predicate); item 108 adds the + first production predicate fact, so this field is no longer vestigial.""" return { "dialect": f.dialect, "param": f.param, @@ -611,6 +635,7 @@ def _fact_dict(f: CapabilityFact) -> dict[str, Any]: "since": f.since, "native_errors": [e.__name__ for e in f.native_errors], "probe_exempt": f.probe_exempt, + "predicate": [_clause_dict(c) for c in f.predicate.clauses] if f.predicate is not None else None, } diff --git a/tests/core/test_expression_coverage_doc.py b/tests/core/test_expression_coverage_doc.py index 83d07da3..76fafa69 100644 --- a/tests/core/test_expression_coverage_doc.py +++ b/tests/core/test_expression_coverage_doc.py @@ -75,11 +75,31 @@ def test_coverage_doc_is_current(report, rel_path, renderer): # --------------------------------------------------------------------------- +def _operand_key_from_json(d: dict) -> tuple: + """Inverse of render_markdown._operand_json — rebuilds the exact + schema._operand_key tuple shape from the wire (kind-tagged) form.""" + kind = d["kind"] + if kind == 0: + return (0,) + if kind == 1: + return (1, tuple(d["value"])) + if kind == 2: + return (2, d["value"]) + if kind == 3: + return (3, d["type"], d["value"]) + return (4, d["value"]) + + +def _clause_key_from_json(c: dict) -> tuple: + return (c["path"], c["op"], _operand_key_from_json(c["operand"])) + + def _json_fact_identity(f_dict: dict) -> tuple: """The §4.4 fact identity (minus operation_key / backend, which the JSON carries on the cell) rebuilt from a JSON fact dict. Mirrors `fact_sort_key`'s field order so the multiset comparison is total over the same lexicographic key. Strings are kept (not enum-typed) because the JSON form is wire-only.""" + predicate = f_dict.get("predicate") return ( f_dict["dialect"] or "", f_dict["param"], @@ -95,7 +115,7 @@ def _json_fact_identity(f_dict: dict) -> tuple: f_dict["upstream_ref"] or "", tuple(f_dict["native_errors"]), f_dict["probe_exempt"] or "", - (), # predicate term — empty for synthetic facts (none carry a predicate) + tuple(_clause_key_from_json(c) for c in predicate) if predicate else (), )