@@ -0,0 +1,3 @@
+Fixed `TypeError: unhashable type: 'writeable void-scalar'` when writing to sharded arrays whose fill value is a `np.void` scalar, e.g. arrays with a structured dtype.
+
+`ArraySpec` equality and hashing now compare the fill value by its byte representation rather than numeric equality. As a result, two specs with a `NaN` (or `NaT`) fill value now compare equal, while fill values of `-0.0` and `0.0` now compare unequal. This also restores the sharding codec's per-chunk spec cache, which had been disabled because of this bug.
@@ -734,6 +734,29 @@ async def test_delete_empty_shards(store: Store) -> None:
     assert len(chunk_bytes) == 16 * 2 + 8 * 8 * 2 + 4
 
 
+def test_structured_dtype_fill_value() -> None:
+    """Sharded arrays with a structured dtype are writable and readable even though
+    the fill value is an (unhashable) ``np.void`` scalar: the sharding codec's
+    chunk-spec caches key on ``ArraySpec``, whose hash must handle void fills
+    (see https://github.com/zarr-developers/zarr-python/issues/3054)."""
+    dtype = np.dtype([("a", "i4"), ("b", "f4")])
+    arr = zarr.create_array(
+        MemoryStore(),
+        shape=(8,),
+        chunks=(2,),
+        shards=(4,),
+        dtype=dtype,
+        fill_value=(1, 2.0),
+    )
+    data = np.array([(i, i / 2) for i in range(8)], dtype=dtype)
+    arr[:4] = data[:4]
+
+    expected = np.zeros(8, dtype=dtype)
+    expected[:4] = data[:4]
+    expected[4:] = (1, 2.0)  # untouched shard reads back as the fill value
+    assert np.array_equal(arr[:], expected)
+
+
 def test_pickle() -> None:
     """ShardingCodec round-trips through pickle, including the non-serialized
     ``subchunk_write_order`` (which ``to_dict`` omits and which must not silently
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	+Fixed `TypeError: unhashable type: 'writeable void-scalar'` when writing to sharded arrays whose fill value is a `np.void` scalar, e.g. arrays with a structured dtype.
	`2`	`+`
	`3`	+`ArraySpec` equality and hashing now compare the fill value by its byte representation rather than numeric equality. As a result, two specs with a `NaN` (or `NaT`) fill value now compare equal, while fill values of `-0.0` and `0.0` now compare unequal. This also restores the sharding codec's per-chunk spec cache, which had been disabled because of this bug.