fix(testing): pass bare-int rectilinear dims through the chunks= conversion

The stateful hypothesis tests convert generated chunk grid metadata back
into a create_array chunks= argument. Bare-int dimensions — the spec's
step-size shorthand, now produced when a uniform dimension of a mixed
grid collapses — were wrapped as single-element lists, turning "repeat
to cover the axis" into "exactly one chunk" and failing the sum-to-span
check (e.g. chunks=[1] for span 3). Extract the conversion into
chunks_param_from_rectilinear, pass bare ints through unchanged, and
widen ChunksLike to admit mixed int | sequence per-dimension specs,
which the normalizer already accepted.

Assisted-by: ClaudeCode:claude-fable-5

Author: d-v-b

changes/4174.bugfix.md

@@ -4,5 +4,8 @@ size + extent pair (`FixedDimension`) instead of being expanded to one entry
 per chunk, so creating arrays like
 `zarr.create_array(store, shape=(2**62,), chunks=(1,), dtype='int32')` succeeds
 instantly instead of raising `ValueError` or allocating gigabytes of memory.
-The intermediate `ChunksTuple` representation was removed in the process.
+The intermediate `ChunksTuple` representation was removed in the process, and
+`ChunksLike` now admits per-dimension specs that mix a bare int (uniform chunk
+size) with explicit edge-length sequences, matching what the normalizer and
+the rectilinear grid spec already accepted.
 This is the creation-time counterpart of the indexing fix in #4172.

src/zarr/core/common.py

@@ -35,7 +35,9 @@
 
 BytesLike = bytes | bytearray | memoryview
 ShapeLike = Iterable[int | np.integer[Any]] | int | np.integer[Any]
-ChunksLike = ShapeLike | Iterable[Iterable[int]]
+# Per-dimension chunk specs may mix a bare int (uniform chunk size, the
+# rectilinear spec's step-size shorthand) with explicit edge-length sequences.
+ChunksLike = ShapeLike | Iterable[int | Iterable[int]]
 # For backwards compatibility
 ChunkCoords = tuple[int, ...]
 ZarrFormat = Literal[2, 3]

src/zarr/testing/strategies.py

@@ -312,17 +312,14 @@ def arrays(
     # - RegularChunkGridMetadata -> flat tuple of ints
     # - RectilinearChunkGridMetadata -> nested list of ints (triggers rectilinear path)
     # - v2 -> flat tuple of ints
-    chunks_param: tuple[int, ...] | list[list[int]]
+    chunks_param: tuple[int, ...] | list[int | list[int]]
     shard_shape = None
     dim_names = None
     if zarr_format == 3:
         chunk_grid_meta = draw(st.none() | chunk_grids(shape=nparray.shape), label="chunk grid")
         dim_names = draw(dimension_names(ndim=nparray.ndim), label="dimension names")
         if isinstance(chunk_grid_meta, RectilinearChunkGridMetadata):
-            chunks_param = [
-                list(dim) if isinstance(dim, tuple) else [dim]
-                for dim in chunk_grid_meta.chunk_shapes
-            ]
+            chunks_param = chunks_param_from_rectilinear(chunk_grid_meta)
         elif isinstance(chunk_grid_meta, RegularChunkGridMetadata):
             chunks_param = chunk_grid_meta.chunk_shape
         else:
@@ -404,6 +401,19 @@ def simple_arrays(
     )
 
 
+def chunks_param_from_rectilinear(
+    meta: RectilinearChunkGridMetadata,
+) -> list[int | list[int]]:
+    """Convert rectilinear chunk grid metadata into a `chunks=` argument.
+
+    Explicit edge tuples become lists. Bare ints — the spec's step-size
+    shorthand meaning "repeat to cover the axis" — pass through unchanged;
+    wrapping one in a single-element list would instead declare exactly one
+    chunk, which fails normalization whenever the axis needs more than one.
+    """
+    return [list(dim) if isinstance(dim, tuple) else dim for dim in meta.chunk_shapes]
+
+
 @st.composite
 def rectilinear_chunks(draw: st.DrawFn, *, shape: tuple[int, ...]) -> list[list[int]]:
     """Generate valid rectilinear chunk shapes for a given array shape.

tests/test_properties.py

@@ -448,3 +448,29 @@ def test_array_metadata_meets_spec(meta: ArrayV2Metadata | ArrayV3Metadata) -> N
         assert serialized_complex_float_is_valid(asdict_dict["fill_value"])
     elif dtype_native.kind in ("M", "m") and np.isnat(meta.fill_value):
         assert asdict_dict["fill_value"] == -9223372036854775808
+
+
+def test_chunks_param_from_rectilinear_bare_int_roundtrip() -> None:
+    """Bare-int dims in rectilinear metadata (the spec's step-size shorthand,
+    produced when a uniform dimension of a mixed grid is collapsed) must pass
+    through the `chunks=` conversion unchanged. Wrapping one in a
+    single-element list turns "repeat to cover the axis" into "exactly one
+    chunk" and re-creation fails the sum-to-span check."""
+    from zarr.core.metadata.v3 import RectilinearChunkGridMetadata
+    from zarr.storage import MemoryStore
+    from zarr.testing.strategies import chunks_param_from_rectilinear
+
+    with zarr.config.set({"array.rectilinear_chunks": True}):
+        src = zarr.create_array(
+            MemoryStore(), shape=(3, 3), chunks=[[1, 2], [1, 1, 1]], dtype="uint8"
+        )
+        grid = src.metadata.chunk_grid  # type: ignore[union-attr]
+        assert isinstance(grid, RectilinearChunkGridMetadata)
+        assert grid.chunk_shapes == ((1, 2), 1)
+        dst = zarr.create_array(
+            MemoryStore(),
+            shape=src.shape,
+            chunks=chunks_param_from_rectilinear(grid),
+            dtype="uint8",
+        )
+        assert dst.metadata.chunk_grid == grid  # type: ignore[union-attr]