uxarray-mcp 0.3.0__tar.gz → 0.3.1__tar.gz

{uxarray_mcp-0.3.0 → uxarray_mcp-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: uxarray-mcp
-Version: 0.3.0
+Version: 0.3.1
 Summary: MCP server for analyzing unstructured meshes with UXarray
 Keywords: uxarray,mcp,unstructured grids,scientific computing,globus compute
 Author: Rajeev Jain, Dayan Abdulla
@@ -222,7 +222,7 @@ Requires-Dist: mcp>=1.24,<3
 Requires-Dist: holoviews>=1.19.0
 Requires-Dist: matplotlib>=3.9.0
 Requires-Dist: pyyaml>=6.0
-Requires-Dist: uxarray>=2026.8.0
+Requires-Dist: uxarray>=2026.8.1
 Requires-Dist: sphinx>=7.0 ; extra == 'docs'
 Requires-Dist: sphinx-book-theme>=1.1.0 ; extra == 'docs'
 Requires-Dist: myst-parser>=3.0 ; extra == 'docs'

{uxarray_mcp-0.3.0 → uxarray_mcp-0.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uxarray-mcp"
-version = "0.3.0"
+version = "0.3.1"
 description = "MCP server for analyzing unstructured meshes with UXarray"
 readme = "README.md"
 keywords = [
@@ -29,7 +29,7 @@ dependencies = [
     "holoviews>=1.19.0",
     "matplotlib>=3.9.0",
     "pyyaml>=6.0",
-    "uxarray>=2026.8.0",
+    "uxarray>=2026.8.1",
 ]
 
 [[project.authors]]
@@ -65,7 +65,9 @@ Tracker = "https://github.com/UXARRAY/uxarray-mcp-server/issues"
 
 [dependency-groups]
 dev = [
+    "jsonschema>=4.20.0",
     "mypy>=1.10.0",
+    "packaging>=23.0",
     "pre-commit>=4.3.0",
     "pytest>=9.0.2",
     "pytest-asyncio>=1.0.0",

{uxarray_mcp-0.3.0 → uxarray_mcp-0.3.1}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "uxarray-mcp"
-version = "0.3.0"
+version = "0.3.1"
 description = "MCP server for analyzing unstructured meshes with UXarray"
 readme = "README.md"
 keywords = ["uxarray", "mcp", "unstructured grids", "scientific computing", "globus compute"]
@@ -49,7 +49,7 @@ dependencies = [
     "holoviews>=1.19.0",
     "matplotlib>=3.9.0",
     "pyyaml>=6.0",
-    "uxarray>=2026.8.0",
+    "uxarray>=2026.8.1",
 ]
 
 [project.optional-dependencies]
@@ -76,7 +76,16 @@ Tracker = "https://github.com/UXARRAY/uxarray-mcp-server/issues"
 
 [dependency-groups]
 dev = [
+    # Declared so the outputSchema conformance tests cannot silently skip.
+    # jsonschema arrives transitively today, which means a resolver change
+    # would turn the checks that hold every result to its published envelope
+    # into a green no-op.
+    "jsonschema>=4.20.0",
     "mypy>=1.10.0",
+    # Same reason as jsonschema: the suite-integrity check reads the declared
+    # uxarray floor out of the packaging metadata so it cannot drift from this
+    # file, and it needs a specifier parser to do that.
+    "packaging>=23.0",
     "pre-commit>=4.3.0",
     "pytest>=9.0.2",
     "pytest-asyncio>=1.0.0",

{uxarray_mcp-0.3.0 → uxarray_mcp-0.3.1}/src/uxarray_mcp/__init__.py

@@ -3,4 +3,4 @@
 from uxarray_mcp.tools import inspect_mesh
 
 __all__ = ["inspect_mesh"]
-__version__ = "0.3.0"
+__version__ = "0.3.1"

{uxarray_mcp-0.3.0 → uxarray_mcp-0.3.1}/src/uxarray_mcp/domain/__init__.py

@@ -6,7 +6,15 @@ Functions here contain the pure domain logic used by both local tools
 
 from .area import compute_area_stats
 from .mesh import is_healpix_spec, load_dataset, load_grid, parse_healpix_zoom
-from .remap_coverage import compute_target_coverage, method_is_conservative
+from .profile_coverage import (
+    compute_profile_coverage,
+    profile_coverage_warning_codes,
+)
+from .remap_coverage import (
+    compute_scattered_coverage,
+    compute_target_coverage,
+    method_is_conservative,
+)
 from .variable import compute_variable_info
 from .vector_calc import (
     compute_azimuthal_mean,
@@ -22,7 +30,10 @@ __all__ = [
     "is_healpix_spec",
     "parse_healpix_zoom",
     "compute_area_stats",
+    "compute_profile_coverage",
+    "profile_coverage_warning_codes",
     "compute_target_coverage",
+    "compute_scattered_coverage",
     "method_is_conservative",
     "compute_variable_info",
     "compute_zonal_mean_stats",

uxarray_mcp-0.3.1/src/uxarray_mcp/domain/profile_coverage.py

@@ -0,0 +1,90 @@
+"""How much of a binned profile the mesh actually filled.
+
+``calculate_zonal_mean`` and ``azimuthal_mean`` both reduce a field onto bins
+the caller chooses -- latitude bands, or rings of great-circle distance from a
+centre. Nothing forces those bins to intersect the mesh. A regional mesh asked
+for southern-hemisphere bands, or a radial profile centred a hundred degrees
+away, returns a profile of the requested length made entirely of NaN, and a
+profile of the right shape is indistinguishable from one carrying an answer
+unless somebody counts.
+
+The count here is deliberately indirect. Re-deriving which faces land in which
+bin would duplicate UXarray's own binning and could disagree with it, so this
+measures the profile that came back instead. An empty bin is NaN -- but so is a
+bin whose faces all held missing data, and the two mean different things. The
+source field is therefore checked as well: when it is entirely finite, a NaN
+bin is unambiguously an empty one; when it is not, the cause is reported as
+ambiguous rather than guessed at.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Sequence
+
+import numpy as np
+
+
+def compute_profile_coverage(
+    values: Sequence[float],
+    *,
+    source: Any = None,
+) -> dict[str, Any]:
+    """Report how many bins of a profile carry a value.
+
+    Parameters
+    ----------
+    values
+        The profile as returned by the operation, one entry per bin.
+    source
+        The field the profile was reduced from, if available. Used only to
+        decide whether an empty bin can be attributed to the bins missing the
+        mesh, or whether missing data in the field could explain it too.
+
+    Returns
+    -------
+    dict
+        ``n_bins``, ``n_bins_filled``, ``source_has_missing`` (``None`` when
+        the field was not supplied) and ``cause``, which is
+        ``"bins_miss_mesh"`` only when the source is known to be complete.
+        No fraction: two integers carry it, and this block rides on every
+        profile result under a byte budget.
+    """
+    profile = np.asarray(values, dtype=float)
+    n_bins = int(profile.size)
+    n_filled = int(np.isfinite(profile).sum())
+
+    source_has_missing: bool | None = None
+    if source is not None:
+        source_values = np.asarray(getattr(source, "values", source), dtype=float)
+        source_has_missing = bool(source_values.size) and bool(
+            (~np.isfinite(source_values)).any()
+        )
+
+    if n_filled == n_bins:
+        cause = "none"
+    elif source_has_missing is False:
+        cause = "bins_miss_mesh"
+    else:
+        # Either the field carries missing data or nobody looked, so an empty
+        # bin has two possible explanations and this does not pick one.
+        cause = "ambiguous"
+
+    return {
+        "n_bins": n_bins,
+        "n_bins_filled": n_filled,
+        "source_has_missing": source_has_missing,
+        "cause": cause,
+    }
+
+
+def profile_coverage_warning_codes(coverage: dict[str, Any]) -> list[str]:
+    """Stable codes for a partly or wholly unfilled profile."""
+    n_bins = coverage.get("n_bins", 0)
+    if not n_bins:
+        return []
+    filled = coverage.get("n_bins_filled", 0)
+    if filled == 0:
+        return ["PROFILE_COVERAGE_ZERO"]
+    if filled < n_bins:
+        return ["PROFILE_COVERAGE_PARTIAL"]
+    return []

{uxarray_mcp-0.3.0 → uxarray_mcp-0.3.1}/src/uxarray_mcp/domain/remap_coverage.py

@@ -67,7 +67,9 @@ def compute_target_coverage(
         Source mesh the data lives on.
     target_lon, target_lat : sequence of float
         1-D target coordinate arrays in degrees; the target is their
-        cartesian product, as for a rectilinear grid.
+        cartesian product, as for a rectilinear grid. For a target that is
+        itself an unstructured mesh, whose coordinates pair off rather than
+        multiply out, use :func:`compute_scattered_coverage`.
     method : str, optional
         Remap method name, used only to report its conservation property.
 
@@ -81,7 +83,47 @@ def compute_target_coverage(
     lon = _wrap_lon(np.asarray(list(target_lon), dtype=float))
     lat = np.asarray(list(target_lat), dtype=float)
     mesh_lon, mesh_lat = np.meshgrid(lon, lat)
-    points = np.column_stack([mesh_lon.ravel(), mesh_lat.ravel()])
+    return _coverage_of_points(
+        grid, mesh_lon.ravel(), mesh_lat.ravel(), method=method, wrap=False
+    )
+
+
+def compute_scattered_coverage(
+    grid: Any,
+    target_lon: Sequence[float],
+    target_lat: Sequence[float],
+    *,
+    method: str | None = None,
+) -> dict[str, Any]:
+    """Coverage for a target whose coordinates are paired, not a product.
+
+    An unstructured target grid supplies one longitude and one latitude per
+    point, so taking their cartesian product would invent points the target
+    does not have and report coverage for a mesh nobody asked about. Same
+    measurement, same keys as :func:`compute_target_coverage`.
+    """
+    return _coverage_of_points(grid, target_lon, target_lat, method=method)
+
+
+def _coverage_of_points(
+    grid: Any,
+    target_lon: Sequence[float],
+    target_lat: Sequence[float],
+    *,
+    method: str | None = None,
+    wrap: bool = True,
+) -> dict[str, Any]:
+    """Count how many of the given points lie inside the source mesh."""
+    lon = np.asarray(list(target_lon), dtype=float)
+    if wrap:
+        lon = _wrap_lon(lon)
+    lat = np.asarray(list(target_lat), dtype=float)
+    if lon.shape != lat.shape:
+        raise ValueError(
+            "target_lon and target_lat must have the same shape when the "
+            f"points are paired; got {lon.shape} and {lat.shape}."
+        )
+    points = np.column_stack([lon, lat])
     n_points = int(points.shape[0])
 
     bbox = source_bbox(grid)

{uxarray_mcp-0.3.0 → uxarray_mcp-0.3.1}/src/uxarray_mcp/domain/vector_calc.py

@@ -6,6 +6,7 @@ import warnings as _warnings_module
 from typing import Any, Callable, TypeVar
 
 from uxarray_mcp.domain.dims import face_slice_selection
+from uxarray_mcp.domain.profile_coverage import compute_profile_coverage
 from uxarray_mcp.domain.zonal import extract_profile
 
 _T = TypeVar("_T")
@@ -271,6 +272,14 @@ def compute_gradient(
         result,
         warnings=uxarray_warnings,
         warning_codes=["SPHERE_RADIUS_UNAVAILABLE"] if uxarray_warnings else [],
+        extra={
+            # Requested and applied are different facts, and only the second
+            # one decides whether the derivative is per metre or per radian.
+            # ``curl``/``divergence`` already report both; reporting them here
+            # too is what lets the front door gate all three the same way.
+            "physical_scaling_requested": bool(scale_by_radius),
+            "physical_scaling_applied": bool(scale_by_radius and not uxarray_warnings),
+        },
     )
 
 
@@ -586,4 +595,7 @@ def compute_azimuthal_mean(
         "azimuthal_mean_values": values,
         "reduced_dims": reduced_dims,
         "n_face": int(uxds.uxgrid.n_face),
+        # A centre the mesh does not reach still produces a profile of the
+        # requested length, every ring of it NaN.
+        "profile_coverage": compute_profile_coverage(values, source=var),
     }

{uxarray_mcp-0.3.0 → uxarray_mcp-0.3.1}/src/uxarray_mcp/domain/zonal.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from typing import Any, Optional
 
 from uxarray_mcp.domain.dims import face_slice_selection
+from uxarray_mcp.domain.profile_coverage import compute_profile_coverage
 
 
 def compute_zonal_mean_stats(
@@ -72,6 +73,10 @@ def compute_zonal_mean_stats(
         "conservative": conservative,
         "reduced_dims": reduced_dims,
         "grid_info": grid_info,
+        # Bands the caller asked for need not touch the mesh. A regional mesh
+        # asked for bands it does not span returns a profile of the right
+        # length made of NaN, which reads as an answer unless it is counted.
+        "profile_coverage": compute_profile_coverage(zonal_mean_values, source=var),
     }
 
 

{uxarray_mcp-0.3.0 → uxarray_mcp-0.3.1}/src/uxarray_mcp/preconditions.py

@@ -17,7 +17,7 @@ request (MRTR) flow. ``InputRequiredResult`` lets a server answer a
 ``request_state`` the client echoes back on retry. We mirror that shape
 in the tool result:
 
-- ``result_type`` is ``"input_required"`` rather than ``"complete"``
+- ``outcome`` is ``"input_required"`` rather than ``"complete"``
 - ``input_requests`` carries an ``elicitation/create`` form request
   describing the acknowledgment we need
 - ``request_state`` is an opaque token the caller passes back verbatim
@@ -30,6 +30,15 @@ than reaching the transport as an elicitation. Building the payload in
 the spec's shape now means the day the adapter grows MRTR support this
 becomes a passthrough rather than a redesign.
 
+The mirrored field is named ``outcome`` and not ``result_type``, which
+is what it was called first. The SDK stamps its own ``resultType`` onto
+every JSON-RPC result object, always ``"complete"`` because from the
+protocol's point of view the call did return. A refusal therefore put
+two fields with the same name and contradicting values on one wire,
+separated only by camelCase. ``outcome`` is ours and says which of the
+two payload shapes this is; ``resultType`` is the protocol's and says
+the call completed. Both are true at once now.
+
 Note that ``not_evaluated`` (#84) and a failed precondition are
 different states and stay distinct: one is "we did not check," the other
 is "we checked and it fails."
@@ -47,8 +56,8 @@ from typing import Any
 OVERRIDE_TOKEN = "i-understand-this-result-may-not-be-physical"
 
 #: Marks a result the caller must act on before the computation will run.
-RESULT_TYPE_INPUT_REQUIRED = "input_required"
-RESULT_TYPE_COMPLETE = "complete"
+OUTCOME_INPUT_REQUIRED = "input_required"
+OUTCOME_COMPLETE = "complete"
 
 
 class PreconditionRefusal(Exception):
@@ -85,22 +94,40 @@ def evaluate_vector_preconditions(
     v_variable: str,
     evidence: dict[str, Any],
     scale_by_radius: bool | None,
+    scaling_applied: bool | None = None,
 ) -> list[dict[str, Any]]:
-    """Declare what must hold for ``curl``/``divergence`` to be physical.
+    """Declare what must hold for a vector-calculus result to be physical.
 
-    Three conditions, each independently checkable from metadata the
-    server already reads:
+    Three conditions apply to the two-component operations, each
+    independently checkable from metadata the server already reads:
 
     1. The two components are distinct fields.
     2. Both carry velocity-like units.
     3. Their direction identity (eastward/northward) is resolvable from
        ``standard_name`` or ``long_name``.
 
-    ``curl`` additionally requires radius scaling, without which the
-    result is a unit-sphere quantity rather than a vorticity in s^-1.
+    Every differential operator additionally requires radius scaling,
+    without which the result is a unit-sphere quantity -- a vorticity per
+    radian rather than in s^-1, a gradient per radian rather than per
+    metre.
+
+    ``scaling_applied`` is what that last check actually reads. Asking
+    only whether scaling was *requested* let the gate pass on any grid
+    without a ``sphere_radius`` attribute: UXarray honours the request as
+    far as it can, warns that the result is left on the unit sphere, and
+    returns it. The number came back marked uninterpretable but came back
+    all the same, which is the warning-beside-a-number state #86 exists to
+    end. Pass ``None`` when the caller cannot tell applied from requested
+    and the requested flag is used as before.
     """
     u_ev = evidence.get("u", {}) or {}
     v_ev = evidence.get("v", {}) or {}
+    if operation == "gradient":
+        # A gradient is taken of one field, so the component checks below --
+        # distinctness, velocity units, eastward/northward identity -- have
+        # nothing to read. Radius scaling is the one condition that carries
+        # over, and it is the one that decides the units of the answer.
+        return [_radius_scaling_check(scale_by_radius, scaling_applied)]
     checks = [
         _check(
             # Unnamed components cannot be compared, so this check abstains
@@ -133,18 +160,48 @@ def evaluate_vector_preconditions(
         ),
     ]
     if operation in {"curl", "divergence"}:
-        checks.append(
-            _check(
-                "radius_scaling",
-                bool(scale_by_radius),
-                f"scale_by_radius={bool(scale_by_radius)}.",
-                "Set scale_by_radius=True so the result carries physical "
-                "units instead of unit-sphere units.",
-            )
-        )
+        checks.append(_radius_scaling_check(scale_by_radius, scaling_applied))
     return checks
 
 
+def _radius_scaling_check(
+    scale_by_radius: bool | None,
+    scaling_applied: bool | None,
+) -> dict[str, Any]:
+    """The condition that decides whether a derivative has physical units."""
+    requested = bool(scale_by_radius)
+    if not requested:
+        return _check(
+            "radius_scaling",
+            False,
+            "scale_by_radius=False.",
+            "Set scale_by_radius=True so the result carries physical units "
+            "instead of unit-sphere units.",
+        )
+    if scaling_applied is False:
+        # Requested and refused by the data, not by the caller. Naming the
+        # missing attribute is the repair; telling them to set the flag they
+        # already set would send them in a circle.
+        return _check(
+            "radius_scaling",
+            False,
+            "scale_by_radius=True was requested but the grid carries no "
+            "'sphere_radius' attribute, so UXarray left the result on the "
+            "unit sphere.",
+            "Set uxgrid.sphere_radius on the source grid (6371000.0 m for "
+            "Earth) so the scaling can be applied, or pass "
+            "scale_by_radius=False and read the result as a per-radian "
+            "quantity.",
+        )
+    return _check(
+        "radius_scaling",
+        True,
+        f"scale_by_radius={requested}, applied={scaling_applied}.",
+        "Set scale_by_radius=True so the result carries physical units "
+        "instead of unit-sphere units.",
+    )
+
+
 def evaluate_validation_preconditions(result: dict[str, Any]) -> list[dict[str, Any]]:
     """Declare that a dataset must validate before it is analyzed further.
 
@@ -165,7 +222,10 @@ def evaluate_validation_preconditions(result: dict[str, Any]) -> list[dict[str,
     ]
 
 
-def evaluate_remap_preconditions(coverage: dict[str, Any]) -> list[dict[str, Any]]:
+def evaluate_remap_preconditions(
+    coverage: dict[str, Any],
+    operation: str = "remap_to_rectilinear",
+) -> list[dict[str, Any]]:
     """Declare that a remap target must overlap its source mesh.
 
     #85 shipped ``REMAP_COVERAGE_ZERO`` as a warning printed beside the
@@ -188,15 +248,198 @@ def evaluate_remap_preconditions(coverage: dict[str, Any]) -> list[dict[str, Any
         )
     else:
         extent = "unknown (source bounding box not reported)"
+    # A repair has to name something the caller can actually change. The
+    # rectilinear operation is handed coordinate ranges; the other two are
+    # handed a target grid file, and telling their caller to adjust
+    # target_lon/target_lat would name arguments they never passed.
+    if operation == "remap_to_rectilinear":
+        repair = (
+            "Choose target_lon/target_lat ranges that overlap the source "
+            "mesh extent reported above, so at least some target points "
+            "are interpolated rather than extrapolated."
+        )
+    else:
+        repair = (
+            "Pass a target_grid_path whose mesh overlaps the source extent "
+            "reported above, so at least some target points are interpolated "
+            "rather than extrapolated. If the two grids are meant to overlap, "
+            "check that both use the same longitude convention "
+            "(-180..180 against 0..360)."
+        )
     return [
         _check(
             "remap_coverage_nonzero",
             "REMAP_COVERAGE_ZERO" not in codes,
             f"{n_in} of {n_total} target points fall inside the source mesh; "
             f"the source covers {extent}.",
-            "Choose target_lon/target_lat ranges that overlap the source "
-            "mesh extent reported above, so at least some target points "
-            "are interpolated rather than extrapolated.",
+            repair,
+        )
+    ]
+
+
+#: Spellings of the same unit that CF-conforming files disagree about. Only
+#: pairs that are exactly interchangeable belong here -- this table decides
+#: whether two fields may be subtracted, so a wrong entry produces a wrong
+#: number rather than a refusal.
+_UNIT_SYNONYMS = {
+    "kelvin": "k",
+    "degrees_kelvin": "k",
+    "degk": "k",
+    "celsius": "degc",
+    "degrees_celsius": "degc",
+    "degree_celsius": "degc",
+    "c": "degc",
+    "m/s": "m s-1",
+    "m s^-1": "m s-1",
+    "meter/second": "m s-1",
+    "metre/second": "m s-1",
+    "percent": "%",
+    "1": "",
+    "dimensionless": "",
+    "none": "",
+    "unitless": "",
+}
+
+
+def normalize_units(units: str | None) -> str | None:
+    """Fold a units string to a comparable form, or ``None`` if undeclared.
+
+    Deliberately shallow: it collapses whitespace and case and resolves a
+    fixed synonym table. It does not parse unit algebra, so it will call
+    ``mm day-1`` and ``kg m-2 s-1`` different even though they measure the
+    same thing. That direction of error costs a caller one explicit
+    acknowledgement; the other direction silently subtracts incompatible
+    fields.
+    """
+    if units is None:
+        return None
+    folded = " ".join(str(units).strip().lower().split())
+    if not folded:
+        return None
+    return _UNIT_SYNONYMS.get(folded, folded)
+
+
+def evaluate_comparison_preconditions(
+    variable_name: str,
+    units_a: str | None,
+    units_b: str | None,
+) -> list[dict[str, Any]]:
+    """Declare that two fields must be in the same units to be differenced.
+
+    ``bias``, ``rmse`` and the difference field are all built from ``a - b``,
+    which is only a physical quantity when both sides measure the same thing
+    in the same scale. Subtracting a field in K from one in degC returns
+    273.15 with no hint that the offset is the unit difference and not the
+    model error -- a number that looks like an answer and is not one.
+
+    An undeclared unit is a gap in the metadata rather than a contradiction,
+    so it does not refuse here; ``compare_fields`` reports it through
+    ``scientific_status`` instead. Only a declared, unresolvable disagreement
+    is refusable.
+    """
+    left, right = normalize_units(units_a), normalize_units(units_b)
+    both_declared = left is not None and right is not None
+    return [
+        _check(
+            "units_comparable",
+            not both_declared or left == right,
+            f"{variable_name}: units_a={units_a or 'unset'!r}, "
+            f"units_b={units_b or 'unset'!r}.",
+            "Convert one field so both carry the same units before "
+            "differencing them. If the units are already equivalent and only "
+            "spelled differently, the server does not parse unit algebra -- "
+            "align the strings or acknowledge to proceed.",
+        )
+    ]
+
+
+def evaluate_ensemble_preconditions(
+    operation: str,
+    variable_name: str,
+    evidence: dict[str, Any],
+) -> list[dict[str, Any]]:
+    """Conditions an ensemble statistic needs across its members.
+
+    Averaging members is the same arithmetic as differencing two fields and
+    fails the same way: a member in K averaged with one in degC returns a
+    number that is in neither scale and looks exactly like a valid mean.
+    Undeclared units stay a warning for the reason they do in comparisons --
+    a gap in metadata is not a contradiction.
+
+    The mesh check is separate and weaker on purpose. Members are opened as
+    plain datasets, so identity rests on whatever coordinates the files
+    carry. When they carry none, matching dimension lengths is all there is,
+    and two unrelated meshes with the same face count would satisfy that --
+    so the result says the mesh is unverified rather than claiming it agrees.
+    """
+    units = evidence.get("member_units") or []
+    spelled = ", ".join(repr(u) if u else "unset" for u in units)
+    checks = [
+        _check(
+            "ensemble_units_consistent",
+            evidence.get("units_consistent") is not False,
+            f"{variable_name}: member units are {spelled}.",
+            "Convert the members onto one scale before combining them. The "
+            "server does not parse unit algebra, so equivalent units spelled "
+            "differently also have to be aligned -- or acknowledge to proceed.",
+        )
+    ]
+    if evidence.get("grids_consistent") is False:
+        checks.append(
+            _check(
+                "ensemble_grids_consistent",
+                False,
+                f"{operation}: the members carry coordinates that do not "
+                "match, so their values are not on a common mesh.",
+                "Supply members written on the same mesh, or remap them onto "
+                "a common grid first. Combining values cell-by-cell across "
+                "different meshes averages unrelated locations.",
+            )
+        )
+    return checks
+
+
+def evaluate_profile_preconditions(
+    operation: str,
+    coverage: dict[str, Any],
+) -> list[dict[str, Any]]:
+    """Declare that a binned profile must have at least one filled bin.
+
+    A profile whose bins all miss the mesh comes back the requested length
+    and entirely NaN, which is shaped exactly like an answer. That is the
+    same state ``remap_coverage_nonzero`` refuses over and for the same
+    reason: nothing in the returned array was measured.
+
+    Partly filled stays a warning. A regional mesh averaged over global
+    bands legitimately fills only the bands it spans, and refusing there
+    would make ordinary regional profiles unusable.
+    """
+    n_bins = coverage.get("n_bins", 0)
+    filled = coverage.get("n_bins_filled", 0)
+    if operation == "azimuthal_mean":
+        repair = (
+            "Move center_lon/center_lat onto the mesh, or widen outer_radius "
+            "so the rings reach it. Check the longitude convention too "
+            "(-180..180 against 0..360)."
+        )
+    else:
+        repair = (
+            "Choose lat_spec bands that fall within the latitudes the mesh "
+            "spans, so at least one band contains faces."
+        )
+    if coverage.get("cause") == "ambiguous":
+        # The field itself carries missing data, so an empty bin has two
+        # explanations and the repair should not assert only one of them.
+        repair += (
+            " The field also contains missing values, so empty bins may come "
+            "from the data rather than from the bins missing the mesh."
+        )
+    return [
+        _check(
+            "profile_coverage_nonzero",
+            filled > 0,
+            f"{operation}: {filled} of {n_bins} bins contain a value.",
+            repair,
         )
     ]
 
@@ -288,7 +531,7 @@ def enforce(
             )
         raise PreconditionRefusal(
             {
-                "result_type": RESULT_TYPE_INPUT_REQUIRED,
+                "outcome": OUTCOME_INPUT_REQUIRED,
                 "operation": operation,
                 "refusal": {
                     "summary": (