@@ -334,9 +334,7 @@ def _is_rectilinear_chunks(chunks: Any) -> TypeGuard[Sequence[Sequence[int]]]:
         return False
 
 
-def is_regular_1d(
-    dim_chunks: Sequence[int] | np.ndarray[tuple[int], np.dtype[np.int64]],
-) -> bool:
+def is_regular_1d(dim_chunks: Sequence[int]) -> bool:
     """Check if a single dimension's chunk sizes represent a regular grid.
 
     A regular dimension has either all chunks the same size, or all
@@ -346,19 +344,14 @@ def is_regular_1d(
     if len(dim_chunks) <= 1:
         return True
     first = dim_chunks[0]
-    if isinstance(dim_chunks, np.ndarray):
-        # Vectorized comparison avoids per-element Python iteration over int64 arrays.
-        return bool((dim_chunks[1:-1] == first).all() and dim_chunks[-1] <= first)
     for c in dim_chunks[1:-1]:
         if c != first:
             return False
     # Last chunk must be the same size or a smaller boundary chunk
     return dim_chunks[-1] <= first
 
 
-def is_regular_nd(
-    chunks: Iterable[Sequence[int] | np.ndarray[tuple[int], np.dtype[np.int64]]],
-) -> bool:
+def is_regular_nd(chunks: Iterable[Sequence[int]]) -> bool:
     """Check if an N-dimensional chunk specification represents a regular grid."""
     return all(is_regular_1d(d) for d in chunks)
 
 
@@ -5,7 +5,6 @@
 import json
 from typing import TYPE_CHECKING
 
-import numpy as np
 import pytest
 
 from tests.conftest import Expect, ExpectFail
@@ -110,9 +109,6 @@ def test_parse_codecs_unknown_raises(monkeypatch: pytest.MonkeyPatch) -> None:
 # Chunk-grid regularity helpers
 # ---------------------------------------------------------------------------
 
-# Cases used for both list/tuple (Python-sequence path) and ndarray (vectorized
-# path) of `is_regular_1d`. Parametrizing the input form ensures both branches
-# are exercised by the same suite of edge cases.
 _REGULAR_1D_CASES: list[Expect[list[int], bool]] = [
     Expect(input=[], output=True, id="empty"),
     Expect(input=[10], output=True, id="single-chunk"),
@@ -129,19 +125,11 @@ def test_parse_codecs_unknown_raises(monkeypatch: pytest.MonkeyPatch) -> None:
 
 @pytest.mark.parametrize("case", _REGULAR_1D_CASES, ids=lambda c: c.id)
 def test_is_regular_1d_sequence(case: Expect[list[int], bool]) -> None:
-    """`is_regular_1d` accepts plain Python sequences and uses the iterative path."""
-    # list and tuple both go through the non-ndarray branch.
+    """`is_regular_1d` accepts plain Python sequences."""
     assert is_regular_1d(case.input) is case.output
     assert is_regular_1d(tuple(case.input)) is case.output
 
 
-@pytest.mark.parametrize("case", _REGULAR_1D_CASES, ids=lambda c: c.id)
-def test_is_regular_1d_ndarray(case: Expect[list[int], bool]) -> None:
-    """`is_regular_1d` accepts int64 ndarrays and uses the vectorized path."""
-    arr = np.asarray(case.input, dtype=np.int64)
-    assert is_regular_1d(arr) is case.output
-
-
 @pytest.mark.parametrize(
     "case",
     [
@@ -156,8 +144,6 @@ def test_is_regular_1d_ndarray(case: Expect[list[int], bool]) -> None:
 def test_is_regular_nd_sequence(case: Expect[list[list[int]], bool]) -> None:
     """`is_regular_nd` returns True iff every per-dim spec is regular."""
     assert is_regular_nd(case.input) is case.output
-    # Same result via ndarray inputs.
-    assert is_regular_nd([np.asarray(d, dtype=np.int64) for d in case.input]) is case.output
 
 
 # ---------------------------------------------------------------------------