@@ -10,6 +10,17 @@ regular grid, nested sequences produce a rectilinear grid. Rectilinear grids
 remain gated behind `zarr.config.set({"array.rectilinear_chunks": True})`.
 See #4174 for the accompanying O(1) chunk normalization change.
 
+One consequence for users who never enable rectilinear chunks: because a
+nested sequence now always requests a rectilinear grid, a per-dimension
+sequence of edge lengths that happens to be uniform — for example the
+`((4,), (4,))` or `[[3, 3, 1]]` form that a dask array's `.chunks` attribute
+produces — is no longer quietly accepted as a regular grid when the
+`array.rectilinear_chunks` option is off. Such input raises
+`ValueError: Rectilinear chunk grids are experimental and disabled by default`,
+exactly as it did in 3.2.x; the silent acceptance existed only in 3.3.0. Pass
+one integer per dimension (e.g. `chunks=(4, 4)`, or a dask array's
+`.chunksize`) to request a regular grid.
+
 `zarr.from_array` with the default `chunks="keep"` / `shards="keep"` now
 reproduces the source's stored grid exactly: a rectilinear grid is passed
 through in O(number of dimensions), with uniform dimensions keeping their
@@ -21,7 +32,7 @@ a rectilinear shard grid `Array.info` no longer raises — it reports the shard
 shape as `<variable>` — while `Array.nchunks_initialized` counts the chunks of
 each initialized shard individually instead of raising.
 
-Everything described here concerns rectilinear chunk grids, which remain an
-experimental feature gated behind
-`zarr.config.set({"array.rectilinear_chunks": True})`; arrays with regular
-chunk grids are unaffected.
+Apart from the nested-sequence input form noted above, everything described
+here concerns rectilinear chunk grids, which remain an experimental feature
+gated behind `zarr.config.set({"array.rectilinear_chunks": True})`; arrays
+with regular chunk grids are unaffected.
@@ -1224,9 +1224,12 @@ async def nchunks_initialized(self) -> int:
         Calculate the number of chunks that have been initialized in storage.
 
         This value is calculated as the sum of the number of chunks in every initialized shard
-        (shard sizes can vary when the shard grid is rectilinear). For arrays that do not use
-        sharding, each stored object holds one chunk, so the number of chunks initialized is the
-        same as the number of stored objects associated with an array.
+        (shard sizes can vary when the shard grid is rectilinear). Each initialized shard is
+        counted at its full declared size, so for an edge shard that extends beyond the array
+        extent this includes chunks that lie entirely outside the array, and the result can
+        exceed `nchunks`. For arrays that do not use sharding, each stored object holds one
+        chunk, so the number of chunks initialized is the same as the number of stored objects
+        associated with an array.
 
         Returns
         -------
@@ -2347,9 +2350,13 @@ def nchunks_initialized(self) -> int:
         Calculate the number of chunks that have been initialized in storage.
 
         This value is calculated as the sum of the number of chunks in every initialized shard
-        (shard sizes can vary when the shard grid is rectilinear). For arrays that do not use sharding,
-        each stored object holds one chunk, so the number of chunks initialized is the same as the number
-        of stored objects associated with an array. For a direct count of the number of initialized stored objects, see `nshards_initialized`.
+        (shard sizes can vary when the shard grid is rectilinear). Each initialized shard is
+        counted at its full declared size, so for an edge shard that extends beyond the array
+        extent this includes chunks that lie entirely outside the array, and the result can
+        exceed `nchunks`. For arrays that do not use sharding, each stored object holds one
+        chunk, so the number of chunks initialized is the same as the number of stored objects
+        associated with an array. For a direct count of the number of initialized stored
+        objects, see `nshards_initialized`.
 
         Returns
         -------
@@ -5423,9 +5430,12 @@ async def _nchunks_initialized(
     Calculate the number of chunks that have been initialized in storage.
 
     This value is calculated as the sum of the number of chunks in every initialized shard
-    (shard sizes can vary when the shard grid is rectilinear). For arrays that do not use
-    sharding, each stored object holds one chunk, so the number of chunks initialized is the
-    same as the number of stored objects associated with an array.
+    (shard sizes can vary when the shard grid is rectilinear). Each initialized shard is
+    counted at its full declared size, so for an edge shard that extends beyond the array
+    extent this includes chunks that lie entirely outside the array, and the result can
+    exceed `nchunks`. For arrays that do not use sharding, each stored object holds one
+    chunk, so the number of chunks initialized is the same as the number of stored objects
+    associated with an array.
 
     Parameters
     ----------