fix(zarr-metadata): the store reader checks that it read bytes

`load_store_json` takes a mapping of store keys to `bytes` and never
checked the values: `json.loads` decoded a `str` as if it were bytes,
and raised `TypeError` for `None` or a `memoryview`, which its
docstring promised would never leak. A value that is not `bytes` is now
an `invalid_type` problem at its key.

Assisted-by: ClaudeCode:claude-opus-5-5

Author: d-v-b

packages/zarr-metadata/changes/4428.bugfix.md

@@ -0,0 +1,4 @@
+`from_key_value` checks that each store value it reads is `bytes`, as its
+signature says: a `str` was decoded as a JSON document, and `None` or a
+`memoryview` raised `TypeError`. Each is now a `MetadataValidationError`
+with an `invalid_type` problem at the store key.

packages/zarr-metadata/src/zarr_metadata/model/_validation.py

@@ -904,8 +904,9 @@ def load_store_json(mapping: Mapping[StoreKey, bytes], key: str) -> object:
     the floats they spell, as zarr-python writes attributes; where one may
     be is the document's validator's to say. Every ingestion failure here
     surfaces as `MetadataValidationError`: a missing store key is a
-    `missing_key` problem and undecodable bytes are an `invalid_json`
-    problem, rather than leaking `KeyError` / `json.JSONDecodeError` to
+    `missing_key` problem, a value that is not `bytes` an `invalid_type`
+    problem, and undecodable bytes an `invalid_json` problem, rather than
+    leaking `KeyError`, `TypeError` or `json.JSONDecodeError` to
     callers.
     """
     # Read by a `str` key whatever narrower key type the mapping declares:
@@ -915,8 +916,15 @@ def load_store_json(mapping: Mapping[StoreKey, bytes], key: str) -> object:
         raise MetadataValidationError(
             [ValidationProblem((key,), "missing store key", "missing_key")]
         )
+    # The runtime half of the annotation: `json.loads` decodes a `str` and
+    # raises `TypeError` on most else.
+    raw = cast("object", stored[key])
+    if not isinstance(raw, bytes):
+        raise MetadataValidationError(
+            [ValidationProblem((key,), f"expected bytes, got {type(raw).__name__}", "invalid_type")]
+        )
     try:
-        return json.loads(stored[key])
+        return json.loads(raw)
     except (UnicodeDecodeError, ValueError) as exc:
         raise MetadataValidationError(
             [ValidationProblem((key,), f"invalid JSON: {exc}", "invalid_json")]

packages/zarr-metadata/tests/model/test_group.py

@@ -400,6 +400,25 @@ def test_consolidated_v2_metadata_values_must_be_json() -> None:
     ]
 
 
+@pytest.mark.parametrize(
+    "stored",
+    [
+        '{"zarr_format": 2}',
+        None,
+        memoryview(b'{"zarr_format": 2}'),
+        bytearray(b'{"zarr_format": 2}'),
+    ],
+    ids=["str", "none", "memoryview", "bytearray"],
+)
+def test_error_a_store_value_that_is_not_bytes_is_refused(stored: object) -> None:
+    """A store maps keys to bytes, and a reader checks that it read bytes."""
+    with pytest.raises(MetadataValidationError) as exc_info:
+        ZarrV2GroupMetadata.from_key_value({".zgroup": stored})  # pyright: ignore[reportArgumentType]
+    assert [(problem.loc, problem.kind) for problem in exc_info.value.problems] == [
+        ((".zgroup",), "invalid_type")
+    ]
+
+
 def test_group_v2_from_key_value_scalar_root_raises_metadata_error() -> None:
     """A scalar .zgroup document fails through the unified metadata error channel."""
     with pytest.raises(MetadataValidationError) as exc_info: