@@ -2,6 +2,6 @@ A chunk edge length is now always at least 1, while an array extent may be 0. Ev
 
 `FixedDimension(size=0, ...)` now raises a `ValueError`. `ArrayV2Metadata(chunks=(0,))` is still accepted and written as given; an array built from such metadata (with `create_hierarchy`, for example) reads the chunk size as a stored chunk size of 0 is read (below). `create_hierarchy` now builds every array and group before it deletes or stores anything, so a node that cannot be built fails with the store untouched. The regular chunk grid metadata class reads a `bool` chunk edge length as the `int` it equals, and rejects a string or a mapping as a chunk shape as a whole. `RectilinearChunkGridMetadata`, which is experimental, now reads a `bool` edge length as the `int` it equals and rejects a NumPy integer or a float edge length such as `4.0` with a `TypeError`; it used to keep them as given, so that it could not store a NumPy integer, could not read back a `bool`, and stored a float as a JSON float, which the Zarr specification does not allow.
 
-Stored metadata with a regular chunk size of 0 or JSON `false` (Zarr format 2 `chunks`, Zarr format 3 `regular` `chunk_shape`) is now read as one chunk spanning the axis (a multiple of the inner chunk size for sharded arrays, which previously failed to open). zarr-python wrote such sizes for arrays created with a zero-length axis until 3.4, and, from 2.18.7 to 3.2.1, for an explicit chunk size of 0 or `False` on an axis of any length, as in `chunks=(0,)` (those arrays could store no data). On a zero-length axis this opens silently, as before; appending to such an axis then stores chunks of size 1. On an axis of positive length it opens with a `ZarrUserWarning`, which says that the axis holds only the fill value and how to store valid metadata: `array.update_attributes({})`, then `zarr.consolidate_metadata` if the metadata is consolidated. JSON `true`, as zarr-python 3.0 and 3.2 wrote for a chunk size of `True`, is read as 1, silently, in the chunk grid (regular, and the explicit edges and run-length encoded sizes of a rectilinear one) and in the inner chunk shape of every sharding codec, nested or not. A stored rectilinear chunk grid whose edge lengths are integral JSON floats (`[[4.0, 2]]`), as zarr-python 3.2 wrote for float edges, is read with those edges as integers, silently; a float anywhere no release wrote one (a regular chunk shape, the inner chunk shape of a sharding codec, a run-length repeat count, an edge below 1) is rejected.
+Stored metadata with a regular chunk size of 0 or JSON `false` (Zarr format 2 `chunks`, Zarr format 3 `regular` `chunk_shape`) is now read as chunk size 1 (the inner chunk size for sharded arrays, which previously failed to open), however long the axis is: that is the chunk size `chunks=-1` gives on a zero-length axis, and it does not depend on how far the axis has grown since. zarr-python wrote such sizes for arrays created with a zero-length axis until 3.4, and, from 2.18.7 to 3.2.1, for an explicit chunk size of 0 or `False` on an axis of any length, as in `chunks=(0,)` (those arrays could store no data). On a zero-length axis this opens silently, as before, and appending to it stores chunks of size 1. On an axis of positive length it opens with a `ZarrUserWarning`, which says that the axis holds only the fill value and how to store valid metadata: `array.update_attributes({})`, then `zarr.consolidate_metadata` if the metadata is consolidated. JSON `true`, as zarr-python 3.0 and 3.2 wrote for a chunk size of `True`, is read as 1, silently, in the chunk grid (regular, and the explicit edges and run-length encoded sizes of a rectilinear one) and in the inner chunk shape of every sharding codec, nested or not. A stored rectilinear chunk grid whose edge lengths are integral JSON floats (`[[4.0, 2]]`), as zarr-python 3.2 wrote for float edges, is read with those edges as integers, silently; a float anywhere no release wrote one (a regular chunk shape, the inner chunk shape of a sharding codec, a run-length repeat count, an edge below 1) is rejected.
 
-Writing data to an array read from such metadata (other than an empty selection) first stores the upgrade of the metadata the store then holds, unless another writer has stored valid metadata since, so that other readers find the chunks written; in a `ZipStore` this adds a second entry for the metadata document, as every metadata update does. If the metadata the store then holds lays out chunks differently (another writer resized the array keeping the chunk size of 0, say), the write raises a `ValueError` asking to reopen the array, and stores nothing. Apart from the array's own metadata writes (`update_attributes`, `resize`), which store the upgrade as before, this is the only operation that stores it: a group's consolidated metadata keeps such an array's metadata as it was stored (`zarr.consolidate_metadata` copies it as the array's own document holds it) until the array stores its upgrade through the group's handle, and changing a group reads and writes no metadata of its members.
+Writing data to an array read from such metadata (other than an empty selection) first stores the upgrade of the metadata the store then holds, unless another writer has stored valid metadata since, so that other readers find the chunks written; in a `ZipStore` this adds a second entry for the metadata document, as every metadata update does. If the metadata the store then holds lays out chunks differently (another writer stored a different chunk size since, say), the write raises a `ValueError` asking to reopen the array, and stores nothing. Apart from the array's own metadata writes (`update_attributes`, `resize`), which store the upgrade as before, this is the only operation that stores it: a group's consolidated metadata keeps such an array's metadata as it was stored (`zarr.consolidate_metadata` copies it as the array's own document holds it) until the array stores its upgrade through the group's handle, and changing a group reads and writes no metadata of its members.
@@ -26,7 +26,6 @@
 from typing import TYPE_CHECKING, Final, TypeGuard, cast
 
 from zarr.core._json import json_equal
-from zarr.core.chunk_grids import full_span_chunk_size
 from zarr.errors import ZarrUserWarning
 
 if TYPE_CHECKING:
@@ -74,24 +73,28 @@ def _read_chunk_size(size: JSON, span: int | None, unit: int) -> tuple[int, str
     Returns the edge length and, where the user must act on how it was read, how it was
     read; `None` if the entry cannot be read, which leaves it for the metadata
     constructors to check. A JSON int >= 1 is kept, JSON `true` is read as 1, and 0 or
-    JSON `false` is read as one chunk spanning the axis of length `span`, a multiple of
-    `unit` (the inner chunk size of a shard): on an axis of positive length no chunk
-    can have been stored under it, so the array holds only its fill value. `span` is
-    `None` where no stored 0 is known, as in the inner chunk shape of a sharding codec:
-    0 is then left as stored.
+    JSON `false` is read as `unit`, the smallest chunk edge length the axis can have (1,
+    or the inner chunk size of a shard), whatever the length `span` of the axis. That is
+    what `chunks=-1` gives on an axis of length 0, where these sizes were written, and it
+    does not depend on how far the axis has grown since. On an axis of positive length no
+    chunk can have been stored under a chunk size of 0, so the array holds only its fill
+    value. `span` is `None` where no stored 0 is known, as in the inner chunk shape of a
+    sharding codec: 0 is then left as stored.
     """
     match size:
         case True:
             return 1, None
         case int() if size >= 1:
             return size, None
         case int() if size == 0 and span is not None:
-            edge = full_span_chunk_size(span, unit)
             if span == 0:
-                return edge, None
-            return edge, (
-                f"one chunk spanning the dimension ({edge}), and as no chunk can be stored "
-                "under a chunk size of 0, the array holds only its fill value"
+                return unit, None
+            return unit, (
+                "1, as no chunk can be stored under a chunk size of 0, so the array "
+                "holds only its fill value"
+                if unit == 1
+                else f"{unit}, the inner chunk size, as no chunk can be stored under a "
+                "chunk size of 0, so the array holds only its fill value"
             )
     return None
 
 
@@ -123,32 +123,32 @@ def _nested_sharded_doc(inner: list[Any], nested: list[Any]) -> dict[str, JSON]:
         (_v3_doc([5, 4], [True, 4]), ((1, 4),), True, None),
         (
             _v2_doc([3], [0]),
-            ((3,),),
+            ((1,),),
             True,
             (
-                r"^The stored chunk shape \[0\] is invalid: .* read as \[3\], reading 0 in "
-                r"dimension 0 as one chunk spanning the dimension \(3\), and .* holds only "
-                r"its fill value\.$"
+                r"^The stored chunk shape \[0\] is invalid: .* read as \[1\], reading 0 in "
+                r"dimension 0 as 1, as no chunk can be stored under a chunk size of 0, so the "
+                r"array holds only its fill value\.$"
             ),
         ),
         (
             _v3_doc([4, 3], [4, 0]),
-            ((4, 3),),
+            ((4, 1),),
             True,
             r"reading 0 in dimension 1 as .* holds only its fill value\.$",
         ),
         (
             _v2_doc([0, 3], [0, 0]),
-            ((1, 3),),
+            ((1, 1),),
             True,
-            r"read as \[1, 3\], reading 0 in dimension 1 as .* holds only its fill value\.$",
+            r"read as \[1, 1\], reading 0 in dimension 1 as .* holds only its fill value\.$",
         ),
         (_v3_doc([0], [0], inner=[4]), ((4,), (4,)), True, None),
         (
             _v3_doc([10], [0], inner=[4]),
-            ((12,), (4,)),
+            ((4,), (4,)),
             True,
-            r"spanning the dimension \(12\), and .* holds only its fill value",
+            r"as 4, the inner chunk size, as no chunk .* holds only its fill value",
         ),
         (_v3_doc([0, 3], [0, 3], inner=[2, 3]), ((2, 3), (2, 3)), True, None),
         (_v3_doc([5], [True], inner=[True]), ((1,), (1,)), True, None),
@@ -177,8 +177,8 @@ def _nested_sharded_doc(inner: list[Any], nested: list[Any]) -> dict[str, JSON]:
 def test_upgrade_array_document(
     doc: dict[str, JSON], expected: tuple[Any, ...], upgraded: bool, warning: str | None
 ) -> None:
-    """Valid documents pass unchanged. A stored chunk size of 0 or `false` is read as one
-    chunk spanning the axis (a multiple of the inner chunk when sharded) and `true` as 1,
+    """Valid documents pass unchanged. A stored chunk size of 0 or `false` is read as 1
+    (the inner chunk size when sharded), however long the axis, and `true` as 1,
     in the chunk shape and in the inner chunk shape of every sharding codec, nested or
     not. `from_dict` marks the metadata of an upgraded document; it warns once, naming
     the array, only where a chunk size of 0 was stored for a non-empty axis (which then
@@ -554,7 +554,7 @@ def _rewrite_doc(path: Path, zarr_format: Literal[2, 3], edit: Any) -> None:
     [
         (2, (0, 4), [0, 4], None, (1, 4), False),
         (3, (5,), [True], None, (1,), False),
-        (3, (10,), [0], (4,), (12,), True),
+        (3, (10,), [0], (4,), (4,), True),
     ],
     ids=["v2-empty-2d", "v3-true", "v3-sharded-grown"],
 )
@@ -612,7 +612,7 @@ def store_legacy(doc: dict[str, Any]) -> None:
 
 @pytest.mark.parametrize(
     ("zarr_format", "shape", "inner", "expected"),
-    [(2, (3,), None, (3,)), (3, (3,), None, (3,)), (3, (10,), (4,), (12,))],
+    [(2, (3,), None, (1,)), (3, (3,), None, (1,)), (3, (10,), (4,), (4,))],
     ids=["v2", "v3", "v3-sharded"],
 )
 @pytest.mark.parametrize("api", ["sync", "async", "async-concurrent"])
@@ -720,12 +720,12 @@ def test_stale_handle_write_keeps_valid_document_as_written(
     with pytest.warns(ZarrUserWarning, match="is read as"):
         stale = zarr.open_array(store=path, mode="r+")
     # Valid metadata for the same array, as another writer might store it: chunk size
-    # 3, without the optional members zarr writes, as compact JSON.
+    # 1, without the optional members zarr writes, as compact JSON.
     doc_path = path / (".zarray" if zarr_format == 2 else "zarr.json")
     doc = json.loads(doc_path.read_text())
     for optional in ("dimension_separator", "attributes", "storage_transformers"):
         doc.pop(optional, None)
-    _stored_chunks(doc)[0] = 3
+    _stored_chunks(doc)[0] = 1
     doc_path.write_text(json.dumps(doc, separators=(",", ":")))
     written = doc_path.read_bytes()
 
@@ -743,14 +743,22 @@ def _resize_to_10(doc: dict[str, Any]) -> None:
     doc["shape"] = [10]
 
 
+def _store_chunk_size_3(doc: dict[str, Any]) -> None:
+    _stored_chunks(doc)[0] = 3
+
+
 def _halve_inner_chunk_shape(doc: dict[str, Any]) -> None:
     doc["codecs"][0]["configuration"]["chunk_shape"] = [2]
 
 
 @pytest.mark.parametrize(
     ("zarr_format", "sharded", "change"),
-    [(2, False, _resize_to_10), (3, False, _resize_to_10), (3, True, _halve_inner_chunk_shape)],
-    ids=["v2-resized", "v3-resized", "v3-sharded-inner-chunk-shape"],
+    [
+        (2, False, _store_chunk_size_3),
+        (3, False, _store_chunk_size_3),
+        (3, True, _halve_inner_chunk_shape),
+    ],
+    ids=["v2-chunk-size", "v3-chunk-size", "v3-sharded-inner-chunk-shape"],
 )
 def test_stale_handle_write_after_chunk_grid_change_raises(
     tmp_path: Path,
@@ -759,10 +767,9 @@ def test_stale_handle_write_after_chunk_grid_change_raises(
     change: Callable[[dict[str, Any]], None],
 ) -> None:
     """If the document the store holds when a handle read from an upgraded document
-    first writes chunks lays out chunks differently from the handle's metadata (the
-    array was resized by software that kept the stored chunk size of 0, which now reads
-    as a larger chunk, or its inner chunk shape changed), the handle's chunks would not
-    be found under it: the write raises and stores nothing."""
+    first writes chunks lays out chunks differently from the handle's metadata (another
+    writer stored a different chunk size, or changed the inner chunk shape), the handle's
+    chunks would not be found under it: the write raises and stores nothing."""
     path = tmp_path / "legacy.zarr"
     if sharded:
         zarr.create_array(store=path, shape=(3,), chunks=(4,), shards=(4,), dtype="int16")
@@ -781,6 +788,26 @@ def test_stale_handle_write_after_chunk_grid_change_raises(
     assert {p.name: p.read_bytes() for p in path.iterdir()} == documents
 
 
+@pytest.mark.parametrize("zarr_format", [2, 3])
+def test_stale_handle_write_after_resize_keeping_zero(
+    tmp_path: Path, zarr_format: Literal[2, 3]
+) -> None:
+    """A stored chunk size of 0 is read as 1 however long the axis is, so a resize by
+    software that kept it lays out chunks as the handle does: the handle's first write
+    stores the upgrade of the resized document, then its chunks."""
+    path = tmp_path / "legacy.zarr"
+    _legacy_array(path, zarr_format)
+    with pytest.warns(ZarrUserWarning, match="is read as"):
+        stale = zarr.open_array(store=path, mode="r+")
+    _rewrite_doc(path, zarr_format, _resize_to_10)
+
+    stale[0:3] = [7, 8, 9]
+
+    reopened = _open_strictly(path)
+    assert (reopened.shape, reopened.chunks) == ((10,), (1,))
+    np.testing.assert_array_equal(reopened[...], [7, 8, 9, 0, 0, 0, 0, 0, 0, 0])
+
+
 def _set_attribute(array: AnyArray) -> None:
     array.attrs["x"] = 1
 
@@ -838,7 +865,7 @@ def test_write_without_stored_document(zarr_format: Literal[2, 3]) -> None:
     assert not [key for key in store._store_dict if key.endswith((".zarray", "zarr.json"))]
 
 
-@pytest.mark.parametrize(("shape", "expected"), [((0,), (1,)), ((3,), (3,))])
+@pytest.mark.parametrize(("shape", "expected"), [((0,), (1,)), ((3,), (1,))])
 def test_array_from_metadata_with_chunk_size_zero(shape: tuple[int], expected: tuple[int]) -> None:
     """`ArrayV2Metadata` accepts a chunk size of 0, as a stored document may hold it. An
     array built from such metadata reads it as the upgrades read that document, silently
@@ -1023,7 +1050,7 @@ def test_consolidated_upgraded_member_stored_by_its_first_write(
 
     np.testing.assert_array_equal(_open_strictly(path / "a")[...], [7, 8, 9])
     zarr.consolidate_metadata(path)
-    assert _stored_chunks(_consolidated_member(path, zarr_format, "a")) == [3]
+    assert _stored_chunks(_consolidated_member(path, zarr_format, "a")) == [1]
 
 
 @pytest.mark.filterwarnings("ignore:Consolidated metadata is currently not part:UserWarning")
@@ -1032,14 +1059,14 @@ def test_consolidated_upgraded_member_write_after_chunk_grid_change_raises(
     tmp_path: Path, zarr_format: Literal[2, 3]
 ) -> None:
     """A member read from its consolidated copy, whose own document has since been
-    resized by software that kept the stored chunk size of 0, would write chunks no
-    reader finds: its first write raises and stores nothing."""
+    stored with a different chunk size, would write chunks no reader finds: its first
+    write raises and stores nothing."""
     path = tmp_path / "group.zarr"
     _consolidated_legacy_member(path, zarr_format)
     with pytest.warns(ZarrUserWarning, match="is read as"):
         array = zarr.open_group(path, mode="r+", use_consolidated=True)["a"]
     assert isinstance(array, zarr.Array)
-    _rewrite_doc(path / "a", zarr_format, _resize_to_10)
+    _rewrite_doc(path / "a", zarr_format, _store_chunk_size_3)
     documents = {p: p.read_bytes() for p in path.rglob("*") if p.is_file()}
 
     with pytest.raises(ValueError, match="has changed since this array was opened: reopen"):
@@ -1069,7 +1096,7 @@ def test_consolidated_upgraded_member_attributes_kept_by_group_write(
         warnings.simplefilter("always")
         attributes = dict(zarr.open_group(path, mode="r", use_consolidated=True)["a"].attrs)
     assert attributes == {"x": 1}
-    assert _stored_chunks(_consolidated_member(path, zarr_format, "a")) == [3]
+    assert _stored_chunks(_consolidated_member(path, zarr_format, "a")) == [1]
     assert not [w for w in record if "is read as" in str(w.message)]
 
 
@@ -1159,7 +1186,7 @@ def test_legacy_chunk_size_consolidated(tmp_path: Path, zarr_format: Literal[2,
         ]
     for array in arrays:
         assert isinstance(array, zarr.Array)
-        assert array.chunks == (2,)
+        assert array.chunks == (1,)
         array.update_attributes({})
     zarr.consolidate_metadata(path)
     with warnings.catch_warnings():
@@ -1170,4 +1197,4 @@ def test_legacy_chunk_size_consolidated(tmp_path: Path, zarr_format: Literal[2,
             for name in names:
                 array = reopened[name]
                 assert isinstance(array, zarr.Array)
-                assert array.chunks == (2,)
+                assert array.chunks == (1,)