@@ -1 +1 @@
-Define an explicit source token contract: hash supported plain NumPy arrays field by field without structured padding, delegate source hooks and propagate their errors, and reject unsupported sources without converting or serializing them. Object fields, dtype metadata, and non-string field titles require a source hook. Remove optional-Dask and per-call UUID fallbacks. Document hashing costs, mutation limits, and `name=False` for Dask wrapping opaque sources.
+Delegate LazyArray source tokenization to Dask, honoring its registered normalizers, source hooks, and deterministic-token requirements. Remove local content-hashing and UUID fallbacks. Dask remains optional for indexing and reading.
@@ -225,8 +225,8 @@ example that materializes the selected data.
       (`numpy.add(view, 1)` does so; `numpy.shape(view)` and `numpy.ndim(view)`
       can use metadata without reading values)
 
-    Dask tokenization hashes plain NumPy data or delegates to a source hook.
-    Other sources require [an explicit hook or Dask naming opt-out](integrations.md#dask-tokenization-and-source-mutation).
+    Dask tokenization may also inspect values, depending on the wrapped source
+    and tokenization path.
 
     Python arithmetic such as `view + 1` raises `TypeError` instead: this
     wrapper defers indexing, not a general compute graph.
 
@@ -244,39 +244,13 @@ that implementation or reproduce its full worker/GPU lifecycle.
 **API:** [API reference](../api/index.md)
 </nav>
 
-## Dask tokenization and source mutation
-
-`LazyArray.__dask_tokenize__()` combines the serialized transform with a source
-value token. Supported plain NumPy arrays are hashed in full on every call,
-including large arrays. Structured fields are hashed separately, excluding
-padding; overlapping fields are each visited. Time scales with the bytes
-visited, and temporary memory with the largest field buffer. Equal dtype
-representations, shapes, field bytes in C order, and serialized transforms have
-equal tokens. This is byte equality within fields, so signed zeros and distinct
-NaN bit patterns can produce different tokens despite numerical equivalence.
-
-Other sources must define an explicit `__dask_tokenize__` hook. This includes
-object arrays (also structured object fields), array subclasses, memory-mapped
-arrays, and remote arrays. Dtype metadata and non-string field titles also
-require a source hook, including in nested field and subarray dtypes: they can
-contain arbitrary Python objects with no guaranteed value-based representation.
-Known `numpy.memmap` and `mmap.mmap` backing is
-rejected through ndarray base and memoryview object chains. Arbitrary buffer
-provenance cannot be inferred from a plain ndarray. The wrapper does not
-convert or serialize unsupported sources to discover their values. Unsupported sources raise `TypeError`, and
-exceptions from explicit hooks propagate. Installing Dask does not change this
-policy. A hook must describe the source's values or immutable version, and owns
-its determinism and any I/O it performs.
-
-For an opaque source such as a Zarr array, use
-`dask.array.from_array(view, chunks=..., name=False)` to request a fresh graph
-name without content tokenization. This opts out of content-based task sharing.
-See Dask's [from_array documentation](https://docs.dask.org/en/stable/generated/dask.array.from_array.html)
-and [tokenization contract](https://docs.dask.org/en/stable/custom-collections.html#implementing-deterministic-hashing).
-
-Tokens describe values at tokenization time, not a snapshot. Mutating a source
-after building a graph does not update existing Dask keys or invalidate cached
-results. Concurrent mutation during hashing is unsupported. Applications must
-manage source lifetimes and versions; these tokens are not persistent cache
-identities. Readers and partitioning are omitted because they must preserve
-values.
+## Dask tokenization
+
+`LazyArray.__dask_tokenize__()` combines Dask's token for the wrapped source
+with the serialized view transform. Dask owns source hashing, registered
+normalizers, custom source hooks, and deterministic-token requirements.
+Tokenization may read or hash source values. Dask is optional for indexing
+and reading, but required when requesting a Dask token.
+
+The reader and partitioning are omitted because they must preserve values.
+Changing a source after graph construction does not update existing Dask keys.
@@ -28,9 +28,8 @@ you want its values:
 ```
 
 Composing these selections does not read source values; the example reads them
-at `result()`. Construction inspects source metadata. Dask tokenization hashes
-plain NumPy data or delegates to an explicit source hook; other sources need
-[a naming opt-out or source hook](guide/integrations.md#dask-tokenization-and-source-mutation). [Lazy views compose](guide/index.md#lazy-views-compose) shows how
+at `result()`. Construction inspects source metadata, and Dask tokenization can
+inspect source values. [Lazy views compose](guide/index.md#lazy-views-compose) shows how
 the chain stays one description, and where the materialization boundary is.
 
 ## Learn more
 
@@ -7,11 +7,11 @@ ways of deferring an indexing operation.
 The example shows how to:
 
 - Pass a `LazyArray` — over a Zarr array or over a view of one — to
-  `dask.array.from_array` with `name=False` to bypass source tokenization
+  `dask.array.from_array`
 - Build one Dask task per partition from `parts()`, compute them in parallel, and
   place each result with the partition's `out_selection`
 - Read `is_complete` to inspect coverage of a partition cell
-- Inspect `__dask_tokenize__` for equal NumPy source/selection pairs;
+- Inspect `__dask_tokenize__` for the example's equal source/selection pairs;
   token equality can support task deduplication but does not promise persistent caching
 - Measure what a task graph costs for indexing-only work, against composing the
   same selections into one transform
 
@@ -41,14 +41,13 @@ def test_from_array(source: zarr.Array) -> None:
 
     # `from_array` needs `shape`, `dtype`, and `__getitem__`, which the wrapper
     # provides. Each Dask block reads its own region through the wrapper.
-    # Zarr has no source token hook: request a fresh Dask graph name.
-    array = da.from_array(lazy, chunks=(10, 10), name=False)
+    array = da.from_array(lazy, chunks=(10, 10))
     print(array)
     assert np.array_equal(array.compute(scheduler="threads"), source[:])
 
     # A view works the same way, and its shape is the shape of the selection.
     view = LazyArray(source).lazy[5:35, 3:27]
-    array = da.from_array(view, chunks=(10, 10), name=False)
+    array = da.from_array(view, chunks=(10, 10))
     assert array.shape == (30, 24)
     assert np.array_equal(array.compute(scheduler="threads"), source[5:35, 3:27])
 
@@ -83,9 +82,8 @@ def read(part: object) -> np.ndarray:
     print(f"{len(complete)} of {len(parts)} parts cover their chunk completely")
 
 
-def test_tokenize() -> None:
+def test_tokenize(source: zarr.Array) -> None:
     """Check token equality for these unchanged source and selection pairs."""
-    source = np.arange(40 * 30).reshape(40, 30)
     lazy = LazyArray(source)
 
     # These wrappers have equal tokens despite being different Python objects.
 
@@ -12,8 +12,8 @@
 ```
 
 Selection construction does not read source values: `result()`, `__array__`,
-and eager `__getitem__` perform reads. Tokenization hashes plain NumPy source
-data or delegates to an explicit source hook. `.lazy` operations inspect
+and eager `__getitem__` perform reads. Source tokenization is delegated to
+Dask and may inspect source values. `.lazy` operations inspect
 selection metadata and may copy or process supplied index arrays. Composition
 does not accumulate wrapper layers: a view of a view is still a single transform
 and retains its reader.
@@ -137,7 +137,6 @@
 import hashlib
 import json
 import math
-import mmap
 import operator
 from collections.abc import Sequence
 from dataclasses import dataclass, field
@@ -521,66 +520,6 @@ def _validate_prepared_parts(parts: Sequence[Partition], out_shape: tuple[int, .
         raise ValueError("prepared parts do not tile the view exactly")
 
 
-# --------------------------------------------------------------------------- #
-# Tokenization
-# --------------------------------------------------------------------------- #
-
-
-def _validate_token_dtype(dtype: np.dtype[Any]) -> None:
-    """Require dtype attributes with a deterministic, value-based representation."""
-    if dtype.metadata is not None:
-        raise TypeError("Dtype metadata requires an explicit source __dask_tokenize__ hook.")
-    if dtype.subdtype is not None:
-        _validate_token_dtype(dtype.subdtype[0])
-    if dtype.fields is not None:
-        for field in dtype.fields.values():
-            if len(field) == 3 and type(field[2]) is not str:
-                raise TypeError(
-                    "Non-string field titles require an explicit source __dask_tokenize__ hook."
-                )
-            _validate_token_dtype(field[0])
-
-
-def _numpy_values_token(array: np.ndarray[Any, Any]) -> Any:
-    """Hash field values in C order, excluding structured padding bytes."""
-    if array.dtype.fields is not None:
-        return tuple(_numpy_values_token(array[name]) for name in array.dtype.names or ())
-    return hashlib.sha256(array.tobytes(order="C")).hexdigest()
-
-
-def _wrapped_token(array: Any) -> Any:
-    """Identify supported source contents without converting foreign arrays.
-
-    Explicit hooks own their versioning, determinism, and I/O contract.
-    Supported plain NumPy arrays are hashed field by field on every call. Other
-    sources must provide a hook; neither serialization nor identity is a safe
-    substitute for a source's value/version contract.
-    """
-    hook = getattr(array, "__dask_tokenize__", None)
-    if hook is not None:
-        return hook()
-    if type(array) is not np.ndarray or array.dtype.hasobject:
-        msg = (
-            "Tokenization requires a source __dask_tokenize__ hook or a plain "
-            "NumPy ndarray without object fields. For Dask from_array, use "
-            "name=False to bypass content tokenization."
-        )
-        raise TypeError(msg)
-    base: Any = array.base
-    while isinstance(base, (np.ndarray, memoryview, mmap.mmap)):
-        if isinstance(base, (np.memmap, mmap.mmap)):
-            msg = "Memory-mapped sources require an explicit __dask_tokenize__ hook."
-            raise TypeError(msg)
-        base = base.obj if isinstance(base, memoryview) else base.base
-    _validate_token_dtype(array.dtype)
-    return (
-        "numpy.ndarray",
-        array.shape,
-        repr(array.dtype),
-        _numpy_values_token(array),
-    )
-
-
 # --------------------------------------------------------------------------- #
 # The wrapper
 # --------------------------------------------------------------------------- #
@@ -1245,27 +1184,18 @@ def __dask_tokenize__(self) -> Any:
         tokens produce equal tokens; arbitrary semantically equivalent mappings
         are not guaranteed to serialize identically.
 
-        Supported plain NumPy arrays are hashed in full on each call. Structured
-        fields are hashed separately, excluding padding; overlapping fields
-        are each visited. Time scales with the bytes visited, and temporary
-        memory with the largest field buffer. Dtype metadata and non-string
-        field titles require an explicit source hook, including in nested dtypes.
-        Known NumPy/mmap backing is rejected through ndarray base and
-        memoryview object chains; arbitrary buffer provenance is not inferred.
-        Array subclasses, object arrays, and foreign sources require a source `__dask_tokenize__` hook; unsupported sources
-        raise `TypeError`. Hooks own determinism, versioning, and any I/O, and
-        hook exceptions propagate. Installing Dask does not change this policy.
-
-        The reader and partitioning are omitted under the contract that they
-        preserve values. A token describes the source at tokenization time;
-        mutation after graph construction does not invalidate existing Dask
-        keys. Concurrent mutation during hashing is unsupported. This method
-        does not provide a persistent cache identity or a source snapshot.
+        Dask tokenizes the wrapped source using its normal dispatch and
+        determinism policy. This may read or hash source values. Dask is
+        imported only when this method is called and is otherwise optional.
+        The reader and partitioning are omitted because they must preserve
+        values. Mutating a source does not update keys in existing Dask graphs.
         """
+        from dask.base import tokenize  # pyright: ignore[reportMissingImports]
+
         canonical = json.dumps(self._transform.to_json(), sort_keys=True)
         return (
             type(self).__qualname__,
-            _wrapped_token(self._array),
+            tokenize(self._array),
             hashlib.sha256(canonical.encode()).hexdigest(),
         )
Original file line number	Diff line number	Diff line change
`@@ -1 +1 @@`
`1`		-Define an explicit source token contract: hash supported plain NumPy arrays field by field without structured padding, delegate source hooks and propagate their errors, and reject unsupported sources without converting or serializing them. Object fields, dtype metadata, and non-string field titles require a source hook. Remove optional-Dask and per-call UUID fallbacks. Document hashing costs, mutation limits, and `name=False` for Dask wrapping opaque sources.
	`1`	`+Delegate LazyArray source tokenization to Dask, honoring its registered normalizers, source hooks, and deterministic-token requirements. Remove local content-hashing and UUID fallbacks. Dask remains optional for indexing and reading.`