@@ -21,6 +21,7 @@
     Colormap,
     LinearSegmentedColormap,
     ListedColormap,
+    LogNorm,
     Normalize,
     to_rgba,
 )
@@ -130,60 +131,16 @@ def _resolve_continuous_norm(values: Any, cmap_params: CmapParams) -> Normalize:
             vmin = data_min
         if vmax is None:
             vmax = data_max
+    if vmin == vmax and not isinstance(base, LogNorm):
+        # A constant/degenerate range collapses the colormap onto its floor; fall back to the
+        # unit interval so the single value maps to a stable color. LogNorm is exempt: 0 is
+        # out of its domain.
+        vmin, vmax = 0.0, 1.0
     resolved = copy(base)
     resolved.vmin, resolved.vmax = vmin, vmax
     return resolved
 
 
-def _apply_mask_to_outline_vectors(
-    outline_color_vector: Any,
-    outline_color_source_vector: pd.Series | None,
-    mask: Any,
-) -> tuple[Any, pd.Series | None]:
-    """Apply a boolean ``keep`` mask to outline color vector(s).
-
-    Used to keep outline data aligned with the fill data after a ``groups``
-    or rasterize-based filter is applied to the rendered element.
-    """
-    arr = np.asarray(mask)
-    if outline_color_source_vector is not None:
-        outline_color_source_vector = outline_color_source_vector[arr]
-    return outline_color_vector[arr], outline_color_source_vector
-
-
-def _align_outline_vector_to_length(
-    outline_color_vector: Any,
-    outline_color_source_vector: pd.Series | None,
-    n: int,
-) -> tuple[Any, pd.Series | None]:
-    """Pad or truncate the outline color vector(s) to length ``n``.
-
-    Used when the outline column annotates a different row count than the rendered
-    element (cross-table case, or rasterize-induced label drop). Missing entries
-    are padded with NaN so downstream code maps them to ``na_color``.
-    """
-    if outline_color_vector is None or len(outline_color_vector) == n:
-        return outline_color_vector, outline_color_source_vector
-    if len(outline_color_vector) > n:
-        if outline_color_source_vector is not None:
-            outline_color_source_vector = outline_color_source_vector[:n]
-        return outline_color_vector[:n], outline_color_source_vector
-    pad = n - len(outline_color_vector)
-    if outline_color_source_vector is not None:
-        # Categorical: downstream picks one hex per category from rows that *have* a
-        # category. NaN-padded rows contribute no category, so the per-row hex pad is
-        # immaterial; pad with NaN to skip the allocation.
-        padded_vec = np.concatenate([np.asarray(outline_color_vector), np.full(pad, np.nan, dtype=object)])
-        outline_color_source_vector = pd.Categorical(
-            list(outline_color_source_vector) + [None] * pad,
-            categories=outline_color_source_vector.categories,
-        )
-    else:
-        # Continuous: numeric vector, pad with NaN so cmap maps padded rows to na_color.
-        padded_vec = np.concatenate([np.asarray(outline_color_vector, dtype=float), np.full(pad, np.nan)])
-    return padded_vec, outline_color_source_vector
-
-
 def _color_vector_to_rgba(
     color_vector: Any | None,
     color_source_vector: pd.Series | None,
@@ -742,7 +699,7 @@ def _set_color_source_vec(
 ColorType = Literal["categorical", "continuous", "none"]
 
 
-@dataclass(frozen=True)
+@dataclass(frozen=True, eq=False)
 class ColorSpec:
     """Resolved color for one element layer: the explicit color-state the renderers consume.
 
@@ -793,13 +750,32 @@ def apply_transfunc(self, transfunc: Any) -> ColorSpec:
             return replace(self, color_vector=transfunc(self.color_vector))
         return self
 
-    def with_color_vector(self, color_vector: ArrayLike) -> ColorSpec:
-        """Return a copy with a replaced ``color_vector`` (renderer-specific rewrites: broadcast, compute)."""
-        return replace(self, color_vector=color_vector)
+    def align_to_length(self, n: int, na_color: Color) -> ColorSpec:
+        """Pad or truncate both vectors to ``n`` rows (cross-table / rasterize outline alignment).
+
+        Padded rows render as ``na_color``: a categorical (hex) ``color_vector`` pads with the na_color
+        hex — NaN would crash ``to_rgba_array`` — and ``source_vector`` with an absent category; a
+        continuous vector pads with NaN so the cmap maps it to na_color.
+        """
+        vec = self.color_vector
+        if vec is None or len(vec) == n:
+            return self
+        if len(vec) > n:
+            source = None if self.source_vector is None else self.source_vector[:n]
+            return replace(self, source_vector=source, color_vector=np.asarray(vec)[:n])
+        pad = n - len(vec)
+        if self.source_vector is not None:
+            padded = np.concatenate(
+                [np.asarray(vec, dtype=object), np.full(pad, na_color.get_hex_with_alpha(), dtype=object)]
+            )
+            source = pd.Categorical(list(self.source_vector) + [None] * pad, categories=self.source_vector.categories)
+            return replace(self, source_vector=source, color_vector=padded)
+        padded = np.concatenate([np.asarray(vec, dtype=float), np.full(pad, np.nan)])
+        return replace(self, color_vector=padded)
 
 
 def resolve_color(*args: Any, **kwargs: Any) -> ColorSpec:
-    """Resolve an element's color into a typed :class:`ColorSpec` (the #700 IR's color layer).
+    """Resolve an element's color into a typed :class:`ColorSpec`.
 
     Pass-through wrapper over :func:`_set_color_source_vec` that classifies its result into an
     explicit ``colortype`` so callers stop re-deriving the state from ``source is None``/``categorical``.
 
@@ -33,9 +33,8 @@
 
 from spatialdata_plot._logging import _log_context, logger
 from spatialdata_plot.pl._color import (
+    ColorSpec,
     ColorType,
-    _align_outline_vector_to_length,
-    _apply_mask_to_outline_vectors,
     _color_vector_to_rgba,
     _get_colors_for_categorical_obs,
     _get_linear_colormap,
@@ -646,8 +645,7 @@ def _render_shapes(
 
     col_for_outline_color = render_params.col_for_outline_color
     outline_table_name = render_params.outline_table_name
-    outline_color_source_vector: pd.Series | None = None
-    outline_color_vector: Any = None
+    outline_color_spec: ColorSpec | None = None
     if col_for_outline_color is not None:
         # When the outline column lives in a table that hasn't been joined yet
         # (no fill table, or a different table than fill's), left-join it onto
@@ -675,51 +673,41 @@ def _render_shapes(
             table_layer=table_layer,
             coordinate_system=coordinate_system,
         )
-        outline_color_source_vector, outline_color_vector = (
-            outline_color_spec.source_vector,
-            outline_color_spec.color_vector,
-        )
         # Cross-table case: if fill and outline tables differ and the outline table does
         # not annotate every row of the (fill-joined) element, the vector length will
         # differ from the rendered element row count. Warn + align so per-shape lookup stays
         # well-defined.
         _n_shapes = len(sdata_filt[element])
-        if outline_color_vector is not None and len(outline_color_vector) != _n_shapes:
+        if len(outline_color_spec.color_vector) != _n_shapes:
             logger.warning(
                 f"Outline column '{col_for_outline_color}' does not fully annotate "
                 f"element '{element}' under its fill-joined alignment "
-                f"({len(outline_color_vector)} of {_n_shapes} rows). Missing rows will use na_color."
-            )
-            outline_color_vector, outline_color_source_vector = _align_outline_vector_to_length(
-                outline_color_vector,
-                outline_color_source_vector,
-                _n_shapes,
+                f"({len(outline_color_spec.color_vector)} of {_n_shapes} rows). Missing rows will use na_color."
             )
+            outline_color_spec = outline_color_spec.align_to_length(_n_shapes, render_params.cmap_params.na_color)
 
     _warn_groups(groups, colortype, color_spec.source_vector, col_for_color)
 
     # When groups are specified, filter out non-matching elements by default.
     # Only show non-matching elements if the user explicitly sets na_color.
     _na = render_params.cmap_params.na_color
-    if (
-        groups is not None
-        and color_spec.source_vector is not None
-        and (_na.default_color_set or _na.is_fully_transparent())
-    ):
+    if groups is not None and color_spec.is_categorical and (_na.default_color_set or _na.is_fully_transparent()):
         keep = color_spec.source_vector.isin(groups)
         color_spec = color_spec.filter(keep)
         shapes = shapes[keep].reset_index(drop=True)
         if len(shapes) == 0:
             return
         sdata_filt[element] = shapes
-        if outline_color_vector is not None:
-            outline_color_vector, outline_color_source_vector = _apply_mask_to_outline_vectors(
-                outline_color_vector, outline_color_source_vector, keep
-            )
+        if outline_color_spec is not None:
+            outline_color_spec = outline_color_spec.filter(keep)
 
-    # carrier pipeline done; unpack the final vectors for the read/draw phase below
     color_spec = color_spec.apply_transfunc(render_params.transfunc)
     color_source_vector, color_vector = color_spec.source_vector, color_spec.color_vector
+    outline_color_source_vector, outline_color_vector = (
+        (outline_color_spec.source_vector, outline_color_spec.color_vector)
+        if outline_color_spec is not None
+        else (None, None)
+    )
 
     norm = render_params.cmap_params.fresh_norm()
 
@@ -1454,11 +1442,7 @@ def _render_points(
     # When groups are specified, filter out non-matching elements by default.
     # Only show non-matching elements if the user explicitly sets na_color.
     _na = render_params.cmap_params.na_color
-    if (
-        groups is not None
-        and color_spec.source_vector is not None
-        and (_na.default_color_set or _na.is_fully_transparent())
-    ):
+    if groups is not None and color_spec.is_categorical and (_na.default_color_set or _na.is_fully_transparent()):
         keep = color_spec.source_vector.isin(groups)
         color_spec = color_spec.filter(keep)
         n_points = int(keep.sum())
@@ -1469,7 +1453,6 @@ def _render_points(
         adata = adata[keep]
         _reparse_points(sdata_filt, element, points, transformation_in_cs, coordinate_system, col_for_color)
 
-    # carrier pipeline done; unpack the final vectors for the read/draw phase below
     color_spec = color_spec.apply_transfunc(render_params.transfunc)
     color_source_vector, color_vector = color_spec.source_vector, color_spec.color_vector
 
@@ -2284,8 +2267,7 @@ def _render_labels(
     # to the outline vectors to keep lengths consistent.
     col_for_outline_color = render_params.col_for_outline_color
     outline_table_name = render_params.outline_table_name
-    outline_color_source_vector: pd.Series | None = None
-    outline_color_vector: Any = None
+    outline_color_spec: ColorSpec | None = None
     if col_for_outline_color is not None:
         outline_color_spec = resolve_color(
             sdata=sdata_filt,
@@ -2301,18 +2283,10 @@ def _render_labels(
             render_type="labels",
             coordinate_system=coordinate_system,
         )
-        outline_color_source_vector, outline_color_vector = (
-            outline_color_spec.source_vector,
-            outline_color_spec.color_vector,
-        )
         # Align to instance_id so the rasterize/groups masks (computed against
         # instance_id) can be applied without IndexError when the outline table
         # annotates a subset of the labels.
-        outline_color_vector, outline_color_source_vector = _align_outline_vector_to_length(
-            outline_color_vector,
-            outline_color_source_vector,
-            len(instance_id),
-        )
+        outline_color_spec = outline_color_spec.align_to_length(len(instance_id), render_params.cmap_params.na_color)
 
     # rasterize/downsampling can drop labels from the raster; remove their (now-absent) instance ids
     # so per-instance colors stay aligned and as_points does not emit dots for dropped cells.
@@ -2321,10 +2295,8 @@ def _render_labels(
         instance_id = instance_id[mask]
         if col_for_color is not None:
             color_spec = color_spec.filter(mask)
-        if outline_color_vector is not None:
-            outline_color_vector, outline_color_source_vector = _apply_mask_to_outline_vectors(
-                outline_color_vector, outline_color_source_vector, mask
-            )
+        if outline_color_spec is not None:
+            outline_color_spec = outline_color_spec.filter(mask)
 
     _warn_groups(groups, colortype, color_spec.source_vector, col_for_color)
 
@@ -2344,14 +2316,16 @@ def _render_labels(
         label.values[~keep_mask] = 0
         instance_id = instance_id[keep_vec]
         color_spec = color_spec.filter(keep_vec)
-        if outline_color_vector is not None:
-            outline_color_vector, outline_color_source_vector = _apply_mask_to_outline_vectors(
-                outline_color_vector, outline_color_source_vector, keep_vec
-            )
+        if outline_color_spec is not None:
+            outline_color_spec = outline_color_spec.filter(keep_vec)
 
-    # carrier pipeline done; unpack the final vectors for the read/draw phase below
     color_spec = color_spec.apply_transfunc(render_params.transfunc)
     color_source_vector, color_vector = color_spec.source_vector, color_spec.color_vector
+    outline_color_source_vector, outline_color_vector = (
+        (outline_color_spec.source_vector, outline_color_spec.color_vector)
+        if outline_color_spec is not None
+        else (None, None)
+    )
 
     if render_params.as_points:
         # Fast mode: one dot per label at its centroid. Compute on the *rendered* raster (already
 
@@ -521,6 +521,25 @@ def track(x):
     assert called, "transfunc was not called for continuous labels data"
 
 
+def test_render_labels_all_nan_color_renders_under_rasterize(sdata_blobs: SpatialData):
+    # Regression: an all-NaN color column is the "none" colortype (na-array source, not None).
+    # Under default rasterize the per-instance mask path used to trip an
+    # `assert color_source_vector is None`; it must now just render.
+    labels_name = "blobs_labels"
+    instances = get_element_instances(sdata_blobs[labels_name])
+    n_obs = len(instances)
+    adata = AnnData(np.zeros((n_obs, 1)))
+    adata.obs["instance_id"] = instances.values
+    adata.obs["nanvals"] = np.full(n_obs, np.nan)
+    adata.obs["region"] = labels_name
+    sdata_blobs["label_table"] = TableModel.parse(
+        adata=adata, region_key="region", instance_key="instance_id", region=labels_name
+    )
+    fig, ax = plt.subplots()
+    sdata_blobs.pl.render_labels(labels_name, color="nanvals", table_name="label_table").pl.show(ax=ax)
+    plt.close(fig)
+
+
 @pytest.mark.parametrize("dtype", [np.float16, np.float32, np.float64])
 def test_render_labels_rejects_float_dtype(dtype):
     # Regression test for #606: float-dtype labels must raise a clear
 
@@ -1029,6 +1029,18 @@ def test_render_points_color_by_z_data_column():
         plt.close(fig)
 
 
+def test_render_points_all_nan_color_with_groups_does_not_crash():
+    # Regression: all-NaN color is the "none" colortype; the groups preamble must not call
+    # .isin on the na-array source (same none-state class as the labels/shapes crashes).
+    pts = PointsModel.parse(pd.DataFrame({"x": [1.0, 2.0, 3.0], "y": [1.0, 2.0, 3.0], "nanvals": [np.nan] * 3}))
+    sdata = SpatialData(points={"p": pts})
+    fig, ax = plt.subplots()
+    try:
+        sdata.pl.render_points("p", color="nanvals", groups=["a"]).pl.show(ax=ax)
+    finally:
+        plt.close(fig)
+
+
 def test_render_points_color_by_z_with_extra_columns():
     # regression test for #615
     pts = PointsModel.parse(
 
@@ -1121,6 +1121,15 @@ def test_plot_shapes_as_points_datashader(self, sdata_blobs: SpatialData):
         self._as_points(sdata_blobs, "datashader").pl.show()
 
 
+def test_render_shapes_all_nan_color_with_groups_does_not_crash(sdata_blobs_shapes_annotated: SpatialData):
+    # Regression: all-NaN color is the "none" colortype (na-array source, not categorical); the
+    # groups preamble must not feed it to _warn_missing_groups, which reads `.categories`.
+    sdata_blobs_shapes_annotated["blobs_polygons"]["nanvals"] = [np.nan] * 5
+    fig, ax = plt.subplots()
+    sdata_blobs_shapes_annotated.pl.render_shapes("blobs_polygons", color="nanvals", groups=["a"]).pl.show(ax=ax)
+    plt.close(fig)
+
+
 def test_gene_symbols_auto_detect_table(sdata_blobs: SpatialData):
     """gene_symbols resolves correctly without explicit table_name (#247)."""
     sdata_blobs["table"].obs["region"] = pd.Categorical(["blobs_circles"] * sdata_blobs["table"].n_obs)