🩹 fix(v0.24): validate chart component count; drop dead normalize_vector

Two small robustness fixes surfaced by the v0.24 pre-release audit:

* charts: concrete `AbstractFixedComponentsChart` subclasses carrying an
  `AbstractDimensionalFlag` (e.g. `Abstract3D`, n=3) now assert their component
  count matches the declared dimension at class-creation time, replacing the six
  `# TODO: add a check it's ND` placeholders in d0-d6 with one central check
  (the flag records `_chart_ndim`; `__init_subclass__` compares it to the
  component tuple and raises a clear TypeError). Abstract / variable-n charts
  are unaffected.

* vectors: remove the orphaned `normalize_vector` stub — a
  `@plum.dispatch.abstract` with no concrete registration, no public export,
  no callers and no tests.

(The audit's third item — a 1D@2D QMatrix matmul path — is dropped: #571 removed
the whole `quantity_matrix` module in favor of `unxts.linalg`, so it no longer
belongs in coordinax.)

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: nstarman

src/coordinax/_src/base/charts.py

@@ -364,6 +364,20 @@ def __init_subclass__(cls, **kw: Any) -> None:
                     cls._coord_dimensions = _get_tuple(args[2])
                     break
 
+            # Check the component count matches the declared dimension flag (if
+            # this chart mixes in an `AbstractDimensionalFlag` with a fixed `n`).
+            ndim = getattr(cls, "_chart_ndim", None)
+            if (
+                isinstance(ndim, int)
+                and hasattr(cls, "_components")
+                and len(cls._components) != ndim
+            ):
+                msg = (
+                    f"{cls.__name__} is declared {ndim}D but has "
+                    f"{len(cls._components)} components {cls._components}"
+                )
+                raise TypeError(msg)
+
         super().__init_subclass__(**kw)  # AbstractChart has.
 
     @property
@@ -389,9 +403,15 @@ class AbstractDimensionalFlag:
 
     """
 
+    #: Declared coordinate dimension of the flag (set when ``n`` is given).
+    _chart_ndim: ClassVar[int | L["N"]]
+
     def __init_subclass__(cls, n: int | L["N"] | None = None, **kw: Any) -> None:
         if n is not None:
             DIMENSIONAL_FLAGS[n] = cls
+            # Record the declared dimension so concrete fixed-component charts
+            # can validate their component count against it.
+            cls._chart_ndim = n
 
         # Enforce that this is a subclass of AbstractChart unless it's an
         # abstract base class (name starts with "Abstract")

src/coordinax/_src/charts/d0.py

@@ -31,8 +31,6 @@ class Abstract0D(AbstractDimensionalFlag, n=0):
     A 0D representation has no coordinate component.
     """
 
-    # TODO: add a check it's 0D
-
     @override
     def __init_subclass__(cls, n: int | L["N"] | None = None, **kw: Any) -> None:
         # Enforce that this is a subclass of AbstractChart

src/coordinax/_src/charts/d1.py

@@ -49,8 +49,6 @@ class Abstract1D(AbstractDimensionalFlag, n=1):
     Cartesian $(x)$ or radial $(r)$ coordinates.
     """
 
-    # TODO: add a check it's 1D
-
     @override
     def __init_subclass__(cls, n: int | L["N"] | None = None, **kw: Any) -> None:
         # Enforce that this is a subclass of AbstractChart

src/coordinax/_src/charts/d2.py

@@ -35,8 +35,6 @@ class Abstract2D(AbstractDimensionalFlag, n=2):
     two angular coordinates but represents a curved surface.
     """
 
-    # TODO: add a check it's 2D
-
     @override
     def __init_subclass__(cls, n: int | L["N"] | None = None, **kw: Any) -> None:
         # Enforce that this is a subclass of AbstractChart

src/coordinax/_src/charts/d3.py

@@ -54,8 +54,6 @@ class Abstract3D(AbstractDimensionalFlag, n=3):
     (cylindrical, spherical), or other three-dimensional manifolds.
     """
 
-    # TODO: add a check it's 3D
-
     @override
     def __init_subclass__(cls, n: int | L["N"] | None = None, **kw: Any) -> None:
         # Enforce that this is a subclass of AbstractChart

src/coordinax/_src/charts/d4.py

@@ -17,8 +17,6 @@ class Abstract4D(AbstractDimensionalFlag, n=4):
     example is the Minkowski spacetime chart ``(ct, x, y, z)``.
     """
 
-    # TODO: add a check it's 4D
-
     @override
     def __init_subclass__(cls, n: int | L["N"] | None = None, **kw: Any) -> None:
         # Enforce that this is a subclass of AbstractChart

src/coordinax/_src/charts/d6.py

@@ -28,8 +28,6 @@ class Abstract6D(AbstractDimensionalFlag, n=6):
     Examples include Cartesian representations in arbitrary dimensions.
     """
 
-    # TODO: add a check it's 6D
-
     @override
     def __init_subclass__(cls, n: int | L["N"] | None = None, **kw: Any) -> None:
         # Enforce that this is a subclass of AbstractChart

src/coordinax/vectors/_src/__init__.py

@@ -1,6 +1,5 @@
 """Vectors."""
 
-from .api import *
 from .base import *
 from .bundle import *
 from .constants import *

src/coordinax/vectors/_src/api.py

@@ -181,3 +181,43 @@ def test_flags_must_subclass_chart(self) -> None:
         for _flag_cls in cxc.DIMENSIONAL_FLAGS.values():
             # All registered flags should have chart subclasses
             pass  # Registration enforces this
+
+    def test_component_count_must_match_declared_dimension(self) -> None:
+        """A concrete chart's component count must match its dimension flag."""
+        import dataclasses
+
+        from typing import Literal
+
+        import jax.tree_util as jtu
+
+        from coordinax._src.base import (
+            MT,
+            AbstractFixedComponentsChart,
+            chart_dataclass_decorator,
+        )
+        from coordinax._src.charts.d3 import Abstract3D, Cart3D
+        from coordinax._src.custom_types import Len
+        from coordinax._src.euclidean.manifold import R3
+
+        two_keys = tuple[Literal["a"], Literal["b"]]
+        two_dims = tuple[Len, Len]
+
+        # A 2-component chart declared 3D (via Abstract3D) must be rejected.
+        with pytest.raises(TypeError, match="declared 3D but has 2 components"):
+
+            @jtu.register_static
+            @chart_dataclass_decorator
+            class _Bad3D(
+                AbstractFixedComponentsChart[MT, two_keys, two_dims], Abstract3D
+            ):
+                _: dataclasses.KW_ONLY
+                M: MT = R3
+
+                @property
+                def cartesian(self):
+                    return Cart3D(M=self.M)
+
+    def test_component_count_matches_for_predefined_charts(self) -> None:
+        """Every predefined chart's ndim matches its component count."""
+        assert cxc.cart3d.ndim == len(cxc.cart3d.components) == 3
+        assert cxc.polar2d.ndim == len(cxc.polar2d.components) == 2