@@ -16,21 +16,21 @@
 from functools import partial
 from typing import TYPE_CHECKING, Any, Final
 
+from hypothesis import reject
 from hypothesis import strategies as st
 
 from zarr_metadata.testing._data_type import FLOAT_WIDTHS, INTEGER_RANGES, finite_floats
-from zarr_metadata.testing._nested import (
+from zarr_metadata.testing._draw import (
     briefly,
     data_type_fields,
     data_types,
     fill_values_of,
-    pipeline_walk,
+    pipelines_for,
     read,
-    takes,
 )
 from zarr_metadata.testing._strategy import CodecStrategy
 from zarr_metadata.v3._definition import Chunk, DataTypeDefinition, storage_of
-from zarr_metadata.v3.codec._arithmetic import COMPLEX, FLOATING_POINT, NOT_NUMBERS, read_name
+from zarr_metadata.v3.codec._arithmetic import FLOATING_POINT, NO_REAL_NUMBERS, read_name
 from zarr_metadata.v3.codec.blosc import BLOSC_CNAME, BLOSC_CODEC, BLOSC_NO_SHUFFLE, BLOSC_SHUFFLE
 from zarr_metadata.v3.codec.bytes import BYTES_CODEC, ENDIANNESS
 from zarr_metadata.v3.codec.cast_value import (
@@ -134,8 +134,8 @@ def _scale_offset(chunk: Chunk, _strategies: Strategies) -> Configurations | Non
     are small non-negative integers, which every listed type holds.
     """
     data_type = chunk.data_type
-    read = data_type is not None and data_type.resolution == "read"
-    definition = data_type.definition if data_type is not None and read else None
+    is_read = data_type is not None and data_type.resolution == "read"
+    definition = data_type.definition if data_type is not None and is_read else None
     if definition is None:
         offset: st.SearchStrategy[JSONValue] = _SMALL_NUMBERS
         scale: st.SearchStrategy[JSONValue] = st.integers(1, 127)
@@ -156,10 +156,6 @@ def _unchunked(configurations: Configurations) -> CodecStrategy:
     return CodecStrategy(configurations=lambda _chunk, _strategies: configurations)
 
 
-_NO_REAL_NUMBERS: Final = NOT_NUMBERS | COMPLEX
-"""The data types `cast_value` takes neither from nor to: none of them models real numbers."""
-
-
 def _source_scalars(chunk: Chunk, strategies: Strategies) -> st.SearchStrategy[JSONValue]:
     """Values of the chunk's data type: its fill values, or small numbers when no scope read it or no strategy draws for it."""
     source = chunk.data_type
@@ -203,9 +199,9 @@ def _cast_value(chunk: Chunk, strategies: Strategies) -> Configurations | None:
     of its direction; `wrap` is drawn only for a type that is not
     floating-point.
     """
-    if read_name(chunk.data_type) in _NO_REAL_NUMBERS:
+    if read_name(chunk.data_type) in NO_REAL_NUMBERS:
         return None
-    targets = [d for d in data_types(strategies) if d.name not in _NO_REAL_NUMBERS]
+    targets = [d for d in data_types(strategies) if d.name not in NO_REAL_NUMBERS]
     if len(targets) == 0:
         return None
     return _cast_value_configuration(targets, _source_scalars(chunk, strategies), strategies)
@@ -244,10 +240,14 @@ def _sharding_configuration(
         "index_codecs": (),
     }
     handed = SHARDING_INDEXED_CODEC.pipelines(sized, {}, chunk)
+    codecs = pipelines_for(handed["codecs"], inner)
+    index_codecs = pipelines_for(handed["index_codecs"], strategies, _STATIC)
+    if codecs is None or index_codecs is None:
+        reject()  # a codec that takes a chunk of the data type, but not of these lengths
     configuration: dict[str, st.SearchStrategy[Any]] = {
         "chunk_shape": st.just(chunk_shape),
-        "codecs": pipeline_walk(handed["codecs"], inner),
-        "index_codecs": pipeline_walk(handed["index_codecs"], strategies, _STATIC),
+        "codecs": codecs,
+        "index_codecs": index_codecs,
     }
     optional = {"index_location": st.sampled_from(SHARDING_INDEX_LOCATION)}
     return draw(st.fixed_dictionaries(configuration, optional=optional))
@@ -273,9 +273,9 @@ def _sharding(chunk: Chunk, strategies: Strategies, *, depth: int) -> Configurat
     not drawn: shards drawn without end would nest without end.
     """
     handed = SHARDING_INDEXED_CODEC.pipelines(_NO_SHAPE, {}, Chunk(None, chunk.data_type))
-    if not takes(Chunk(None, handed["codecs"].data_type), strategies):
+    if pipelines_for(Chunk(None, handed["codecs"].data_type), strategies) is None:
         return None
-    if not takes(Chunk(None, handed["index_codecs"].data_type), strategies, _STATIC):
+    if pipelines_for(Chunk(None, handed["index_codecs"].data_type), strategies, _STATIC) is None:
         return None
     inner = {d: s for d, s in strategies.items() if d is not SHARDING_INDEXED_CODEC}
     if depth > 0:
 
@@ -15,7 +15,7 @@
 
 from hypothesis import strategies as st
 
-from zarr_metadata.testing._nested import (
+from zarr_metadata.testing._draw import (
     briefly,
     data_type_fields,
     data_types,
 
@@ -117,14 +117,15 @@ def scope_of(strategies: Strategies) -> Context:
 
 
 def read(field: object, kind: type[D], strategies: Strategies) -> Resolved[D]:
-    """`field`, drawn from `strategies`, read in their scope; a `ValueError` if it is refused.
+    """`field`, drawn from `strategies` or held by a configuration handed to one, read in their scope; a `ValueError` if it is refused.
 
-    A strategy draws what its definition accepts, so a refused draw is a
-    fault in the strategy, not something to draw again.
+    A strategy draws what its definition accepts, so a refused field is a
+    fault in a strategy or in the configuration it was handed, not
+    something to draw again.
     """
     resolved, problems = resolve(field, kind, scope_of(strategies))
     if len(problems) != 0:
-        msg = f"a strategy drew {field!r}, which is refused: {problems!r}"
+        msg = f"{field!r}, read in the strategies' scope, is refused: {problems!r}"
         raise ValueError(msg)
     return resolved
 
@@ -190,10 +191,11 @@ def data_type_fields(
 def fill_values_of(
     data_type: Resolved[DataTypeDefinition[Any]], strategies: Strategies
 ) -> SearchStrategy[JSONValue]:
-    """Fill values of `data_type`, a data type field read in the strategies' scope."""
+    """Fill values of `data_type`, a data type field read in the strategies' scope; a `LookupError` if no definition in it read the field."""
     definition, configuration = data_type.definition, data_type.configuration
-    assert definition is not None
-    assert configuration is not None
+    if definition is None or configuration is None:
+        msg = f"no strategy draws fill values of {data_type.json!r}, which no definition in `strategies` reads"
+        raise LookupError(msg)
     found = cast("DataTypeStrategy", strategy_for(definition, strategies))
     return found.fill_values(configuration, strategies)
 
@@ -228,12 +230,18 @@ def _holds_pipelines(definition: CodecDefinition[Any]) -> bool:
     return definition.pipelines is not no_pipelines
 
 
-def takes(chunk: Chunk, strategies: Strategies, sizes: frozenset[CodecSize] = EVERY_SIZE) -> bool:
-    """Whether some array -> bytes codec that holds no pipelines takes `chunk` as it is.
+def pipelines_for(
+    chunk: Chunk, strategies: Strategies, sizes: frozenset[CodecSize] = EVERY_SIZE
+) -> SearchStrategy[tuple[ZarrV3MetadataFieldJSON, ...]] | None:
+    """Pipelines handed `chunk`, of codecs of one of `sizes`; None when no array -> bytes codec that holds no pipelines takes the chunk as it is.
 
-    Enough for a pipeline to be drawn for it: one of only that codec.
+    One that does is enough for a pipeline: one of only that codec. One
+    that holds pipelines of its own takes a chunk only if what it holds
+    does, so it settles nothing.
     """
-    return len(_taking(chunk, "array_bytes", sizes, strategies, holding=False)) != 0
+    if len(_taking(chunk, "array_bytes", sizes, strategies, holding=False)) == 0:
+        return None
+    return _walk(chunk, strategies, sizes)
 
 
 @st.composite
@@ -245,19 +253,15 @@ def _codec(
 
 
 @st.composite
-def pipeline_walk(
-    draw: st.DrawFn,
-    chunk: Chunk,
-    strategies: Strategies,
-    sizes: frozenset[CodecSize] = EVERY_SIZE,
+def _walk(
+    draw: st.DrawFn, chunk: Chunk, strategies: Strategies, sizes: frozenset[CodecSize]
 ) -> tuple[ZarrV3MetadataFieldJSON, ...]:
     """Codecs for a pipeline handed `chunk`, each drawn for the chunk the one before it hands on.
 
     Array -> array codecs, then one array -> bytes codec, then bytes ->
     bytes codecs, each of one of `sizes`. What an array -> array codec
     hands on is what its definition's `transition` says of the codec as
     drawn: a `cast_value` hands the next codec the data type it casts to.
-    Draw it only for a chunk `takes` says a pipeline is drawn for.
     """
     codecs: list[ZarrV3MetadataFieldJSON] = []
     handed = chunk
@@ -288,9 +292,8 @@ def pipeline_walk(
     "data_type_fields",
     "data_types",
     "fill_values_of",
-    "pipeline_walk",
+    "pipelines_for",
     "read",
     "scope_of",
     "strategy_for",
-    "takes",
 ]
@@ -50,13 +50,12 @@ def test_my_reader_reads_every_blosc_codec(field):
 from zarr_metadata.testing._chunk_key_encoding import CHUNK_KEY_ENCODING_STRATEGIES
 from zarr_metadata.testing._codec import CODEC_STRATEGIES
 from zarr_metadata.testing._data_type import DATA_TYPE_STRATEGIES
-from zarr_metadata.testing._nested import (
+from zarr_metadata.testing._draw import (
     any_spelling,
     briefly,
-    pipeline_walk,
+    pipelines_for,
     scope_of,
     strategy_for,
-    takes,
 )
 from zarr_metadata.testing._strategy import (
     NOTHING_KNOWN,
@@ -190,9 +189,7 @@ def pipelines(
     defines takes a `string` one.
     """
     strategies = briefly(strategies)
-    if not takes(chunk, strategies):
-        return None
-    return pipeline_walk(chunk, strategies)
+    return pipelines_for(chunk, strategies)
 
 
 def _canonical(
 
@@ -67,11 +67,15 @@
 """
 
 
+NO_REAL_NUMBERS: Final = NOT_NUMBERS | COMPLEX
+"""The data types that model no real number, which `cast_value` takes neither from nor to."""
+
+
 def read_name(data_type: Resolved[Any] | None) -> str | None:
     """The name the definition that read `data_type` is filed under; None when no definition read it."""
     if data_type is None or data_type.resolution != "read" or data_type.definition is None:
         return None
     return data_type.definition.name
 
 
-__all__ = ["COMPLEX", "FLOATING_POINT", "NOT_NUMBERS", "read_name"]
+__all__ = ["COMPLEX", "FLOATING_POINT", "NOT_NUMBERS", "NO_REAL_NUMBERS", "read_name"]
@@ -19,12 +19,7 @@
     fill_value_problems,
     named_configuration,
 )
-from zarr_metadata.v3.codec._arithmetic import (
-    COMPLEX,
-    FLOATING_POINT,
-    NOT_NUMBERS,
-    read_name,
-)
+from zarr_metadata.v3.codec._arithmetic import FLOATING_POINT, NO_REAL_NUMBERS, read_name
 
 CAST_VALUE_CODEC_NAME: Final = "cast_value"
 """The `name` field value of the `cast_value` codec."""
@@ -111,10 +106,6 @@ class CastValueCodecObject(TypedDict, closed=True):
 """
 
 
-_NO_REAL_NUMBERS: Final = NOT_NUMBERS | COMPLEX
-"""The data types the codec takes neither from nor to: none of them models real numbers."""
-
-
 def _scalars(
     configuration: CastValueCodecConfiguration, side: Literal["source", "target"]
 ) -> Iterator[tuple[tuple[str | int, ...], JSONValue]]:
@@ -157,7 +148,7 @@ def _rules(
     if target is None or name is None:
         return
     written, _, _ = named_configuration(target.json)
-    if name in _NO_REAL_NUMBERS:
+    if name in NO_REAL_NUMBERS:
         yield ValidationProblem(
             ("data_type",),
             f"expected a data type that models real numbers, got {written!r}",
@@ -188,7 +179,7 @@ def _chunk_rules(
     name = read_name(source)
     if source is None or name is None:
         return
-    if name in _NO_REAL_NUMBERS:
+    if name in NO_REAL_NUMBERS:
         written, _, _ = named_configuration(source.json)
         yield ValidationProblem(
             (),
 
@@ -39,7 +39,6 @@
 from zarr_metadata.v3._definition import as_kind, kind_of, no_pipelines, storage_of, unchanged
 from zarr_metadata.v3._pipeline import read_pipeline
 from zarr_metadata.v3.chunk_grid.rectilinear import RECTILINEAR_CHUNK_GRID
-from zarr_metadata.v3.codec._arithmetic import COMPLEX, NOT_NUMBERS
 from zarr_metadata.v3.codec.bytes import BYTES_CODEC
 from zarr_metadata.v3.codec.cast_value import CAST_VALUE_CODEC
 from zarr_metadata.v3.codec.gzip import GZIP_CODEC
@@ -276,7 +275,28 @@ def test_a_cast_from_a_data_type_without_a_strategy_draws_numbers() -> None:
     find(configurations, lambda configuration: "scalar_map" in configuration, settings=_REACH)
 
 
-@given(data=st.data(), chunk=_chunks())
+@st.composite
+def _partly_known_chunks(draw: st.DrawFn) -> Chunk:
+    """A chunk some of which nothing says: its lengths along an axis or at all, or its data type, read by nothing in scope."""
+    chunk = draw(_chunks())
+    lengths = draw(
+        st.sampled_from(
+            [
+                chunk.lengths,
+                None,
+                None if chunk.lengths is None else tuple(None for _ in chunk.lengths),
+            ]
+        )
+    )
+    data_type = draw(st.sampled_from([chunk.data_type, None, _UNREAD_DATA_TYPE]))
+    return Chunk(lengths, data_type)
+
+
+_UNREAD_DATA_TYPE = resolve({"name": "an.unread.type"}, DataTypeDefinition, CORE_AND_EXTENSIONS)[0]
+"""A data type field that nothing in scope claims: a chunk of it says nothing of its values."""
+
+
+@given(data=st.data(), chunk=_chunks() | _partly_known_chunks())
 def test_pipelines_read(data: st.DataObject, chunk: Chunk) -> None:
     """A pipeline drawn for a chunk reads as one handed it, through JSON too; none is drawn only for a chunk no codec encodes."""
     drawn = pipelines(chunk)
@@ -419,6 +439,14 @@ def test_a_codec_strategy_refusing_an_unknown_chunk_is_a_value_error() -> None:
         fields(GZIP_CODEC, strategies=DEFAULT_STRATEGIES | {GZIP_CODEC: refusing})
 
 
+def test_fill_values_of_a_field_no_definition_reads_is_a_lookup_error() -> None:
+    """A struct handed a field type that no definition in the strategies reads has no fill values to draw for it."""
+    without_float32 = {d: s for d, s in DEFAULT_STRATEGIES.items() if d is not FLOAT32_DATA_TYPE}
+    configuration: Any = {"fields": ({"name": "a", "data_type": "float32"},)}
+    with pytest.raises(LookupError, match="no definition in `strategies` reads"):
+        fill_values(STRUCT_DATA_TYPE, configuration, strategies=without_float32)
+
+
 def test_a_refused_nested_draw_is_a_value_error() -> None:
     """A field a configuration holds is read as it is drawn, so a strategy that draws a refused one is caught there."""
     refused = DataTypeStrategy(
@@ -429,7 +457,7 @@ def test_a_refused_nested_draw_is_a_value_error() -> None:
         CAST_VALUE_CODEC: DEFAULT_STRATEGIES[CAST_VALUE_CODEC],
         NUMPY_DATETIME64_DATA_TYPE: refused,
     }
-    with pytest.raises(ValueError, match="which is refused"):
+    with pytest.raises(ValueError, match="read in the strategies. scope, is refused"):
         find(fields(CAST_VALUE_CODEC, strategies=strategies), lambda _field: True, settings=_ONCE)
 
 
@@ -560,16 +588,21 @@ def test_pipelines_reach_every_codec(definition: CodecDefinition[Any]) -> None:
     )
 
 
-@pytest.mark.parametrize("member", ["codecs", "index_codecs"])
 @pytest.mark.parametrize(
-    "definition", [d for d in _CODECS if d is not SHARDING_INDEXED_CODEC], ids=_id
+    ("definition", "member"),
+    [
+        (d, member)
+        for d in _CODECS
+        if d is not SHARDING_INDEXED_CODEC
+        for member in ("codecs", "index_codecs")
+        if member == "codecs" or d.size == "static"
+    ],
+    ids=_id,
 )
 def test_shards_hold_every_codec_their_pipeline_takes(
     definition: CodecDefinition[Any], member: str
 ) -> None:
     """A shard's pipelines reach each codec they take: its index codecs, only those of static size."""
-    if member == "index_codecs" and definition.size != "static":
-        return
     find(
         _shards(),
         lambda shard: (definition.name, (member,)) in _codecs_in((shard,)),
@@ -612,8 +645,18 @@ def _read_data_type(field: object) -> Any:  # noqa: ANN401
     return resolved
 
 
-_REAL_NUMBERS = [d for d in _DATA_TYPES if d.name not in NOT_NUMBERS | COMPLEX]
-"""The data types `cast_value` casts to: those that model real numbers."""
+_REAL_NUMBERS = [
+    d
+    for d in _DATA_TYPES
+    if d.name
+    in {
+        *(f"{sign}int{bits}" for sign in ("", "u") for bits in (8, 16, 32, 64)),
+        *(f"float{bits}" for bits in (16, 32, 64)),
+        "numpy.datetime64",
+        "numpy.timedelta64",
+    }
+]
+"""The data types `cast_value` casts to: integers and floats, and the numpy times, which are signed 64-bit integers."""
 
 
 @pytest.mark.parametrize("definition", _REAL_NUMBERS, ids=_id)