@@ -169,8 +169,8 @@ validator, so both pay the same cost:
 - **Row/col order mismatch**: graph edges connect the wrong cells (hard to detect visually).
 - **Negative weights, asymmetry, directionality, or self-edges**: rejected
   instead of transformed.
-- **Sparse stored zeros or duplicate coordinates**: rejected instead of
-  coalesced or discarded.
+- **Duplicate sparse coordinates**: rejected instead of coalesced.
+- **Sparse stored zeros**: not edges; dropped, as if they were not stored.
 - **Very dense graphs**: huge `nnz` → export time and output size explode.
 - **Disconnected or empty graphs**: valid when the exact matrix contract holds.
 
 
@@ -220,8 +220,9 @@ Three aligned arrays of equal length:
   Float64 weight
 - the source graph must already be finite, non-negative, exactly symmetric in
   topology and weight, and exactly zero on the diagonal
-- sparse inputs must contain neither stored zeros nor duplicate coordinates;
-  producers reject rather than reinterpret them
+- sparse inputs must not contain duplicate coordinates, which producers
+  reject rather than coalesce; a stored zero is not an edge, and producers and
+  the web app's AnnData reader drop it
 
 ---
 
 
@@ -24,8 +24,8 @@ In the Cellucid ecosystem, this is typically a KNN/SNN graph derived from:
 - topology and weights must be exactly symmetric
 - every diagonal value must be exactly `0`
 - the `Matrix` package must be installed when the input is sparse
-- sparse matrices must not contain stored zero entries or duplicate
-  coordinates
+- sparse matrices must not contain duplicate coordinates; a stored zero is
+  not an edge and is dropped
 
 ```{note}
 If you do not need connectivity features, skip this entirely. Exports load fine without it.
@@ -141,8 +141,6 @@ A dense `(n_cells, n_cells)` matrix becomes huge quickly. Prefer sparse matrices
   install `Matrix`, or pass a dense base R matrix.
 - `Connectivity matrix shape must exactly match the cell axis: expected (…), got
   (…).` → you have an ordering or subset mismatch.
-- `Sparse connectivity storage must omit zero-weight coordinates.` → drop
-  explicit zeros with `Matrix::drop0(conn)`.
 - `Connectivity values must be real numeric or logical values.` → the sparse
   matrix is not a real (`dMatrix`), logical (`lMatrix`), or pattern (`nMatrix`)
   `Matrix`; convert it first.
 
@@ -358,7 +358,7 @@ Neighbouring messages cover the rest of the graph contract:
 `Connectivity contains duplicate sparse coordinates at (…)`.
 
 Fix:
-- symmetrize the graph and drop stored zeros before the call
+- symmetrize the graph before the call
 
 Docs:
 - {doc}`../c_data_preparation_api/07_connectivities_knn_graph`
 
@@ -213,8 +213,12 @@ Behavior:
 - A catalog then behaves like `local-demo` (loads `datasets.json` +
   `dataset_identity.json`). A file is opened by the AnnData reader worker with
   HTTP range requests (`HttpRangeSource`: synchronous single-range XHR in the
-  worker, 1 MiB pages, read-ahead that grows on forward passes) and served
-  through `h5ad://` / `zarr://` like a local file.
+  worker, 256 KiB pages, read-ahead that grows on forward passes to 16 MiB)
+  and served through `h5ad://` / `zarr://` like a local file. A cell-major
+  (CSR) matrix is indexed by gene when the first gene is shown, not when the
+  file opens, because that index reads the matrix's whole index array: over
+  the network, opening downloads only what the first view draws. A local file
+  starts the index at once, in the background.
 - Requests carry only a single `Range: bytes=a-b` header, which needs no CORS
   preflight. File sizes come from `HEAD` or the provider, because many hosts
   do not expose `Content-Range`.
 
@@ -105,19 +105,13 @@ def _validate_numeric_dtype(dtype: np.dtype[Any]) -> None:
         raise ValueError("Connectivity values must be numeric or boolean.")
 
 
-def _validated_float64_weights(
-    values: np.ndarray,
-    *,
-    reject_zero: bool,
-) -> np.ndarray:
+def _validated_float64_weights(values: np.ndarray) -> np.ndarray:
     """Validate weights and return their exact little-endian Float64 form."""
     _validate_numeric_dtype(values.dtype)
     if not np.all(np.isfinite(values)):
         raise ValueError("Connectivity values must all be finite.")
     if np.any(values < 0):
         raise ValueError("Connectivity values must all be non-negative.")
-    if reject_zero and np.any(values == 0):
-        raise ValueError("Sparse connectivity must not contain stored zero entries.")
 
     with np.errstate(over="ignore", invalid="ignore"):
         weights = values.astype(little_endian_payload_dtype(np.float64), copy=False)
@@ -202,10 +196,13 @@ def _sparse_upper_pairs(
 
     rows = np.asarray(coordinates.row, dtype=np.int64)
     columns = np.asarray(coordinates.col, dtype=np.int64)
-    weights = _validated_float64_weights(
-        np.asarray(coordinates.data),
-        reject_zero=True,
-    )
+    weights = _validated_float64_weights(np.asarray(coordinates.data))
+    # A stored zero is not an edge: it is dropped, as if it were not stored.
+    stored = weights != 0
+    if not np.all(stored):
+        rows = rows[stored]
+        columns = columns[stored]
+        weights = weights[stored]
 
     if np.any(rows == columns):
         raise ValueError("Connectivity diagonal values must all be exactly zero.")
@@ -230,8 +227,7 @@ def _dense_upper_pairs(
     if matrix.ndim != 2:
         raise ValueError(f"Connectivity matrix must be two-dimensional; got shape {matrix.shape}.")
     weights_matrix = _validated_float64_weights(
-        matrix,
-        reject_zero=False,
+        matrix
     )
 
     if np.any(np.diag(weights_matrix) != 0):
 
@@ -432,7 +432,8 @@ def _prepare_generation(
         Exact weighted undirected graph, shape ``(n_cells, n_cells)``. Values
         must be finite and non-negative, the topology and weights must be
         exactly symmetric, and the diagonal must be zero. Sparse inputs must
-        not contain duplicate coordinates or stored zero entries.
+        not contain duplicate coordinates; a stored zero is not an edge and is
+        dropped.
     out_dir : Path
         Staging directory that receives the candidate generation. It is always
         supplied by :func:`prepare` and must be absent or empty.
 
@@ -130,16 +130,27 @@ def test_invalid_connectivity_is_rejected_without_reinterpretation(
 
 
 @pytest.mark.parametrize("sparse_format", ["coo", "csr", "csc", "lil", "bsr"])
-def test_sparse_stored_zero_entries_are_rejected(sparse_format: str) -> None:
-    row = np.array([0, 1], dtype=np.int32)
-    column = np.array([1, 0], dtype=np.int32)
+def test_sparse_stored_zero_entries_are_not_edges(sparse_format: str) -> None:
+    # A stored zero is dropped, as if it were not stored: files written by
+    # other tools keep them, and they carry no edge.
+    row = np.array([0, 1, 0, 2], dtype=np.int32)
+    column = np.array([1, 0, 2, 0], dtype=np.int32)
     candidate = sparse.coo_matrix(
-        (np.zeros(2, dtype=np.float64), (row, column)),
-        shape=(2, 2),
+        (np.array([0.5, 0.5, 0.0, 0.0]), (row, column)),
+        shape=(3, 3),
     ).asformat(sparse_format)
 
-    with pytest.raises(ValueError, match="stored zero"):
-        validate_connectivity_edges(candidate, n_cells=2)
+    edges = validate_connectivity_edges(candidate, n_cells=3)
+    assert edges.n_edges == 1
+    assert edges.sources.tolist() == [0]
+    assert edges.destinations.tolist() == [1]
+    assert edges.weights.tolist() == [0.5]
+
+    only_zeros = sparse.coo_matrix(
+        (np.zeros(2), (row[:2], column[:2])),
+        shape=(3, 3),
+    ).asformat(sparse_format)
+    assert validate_connectivity_edges(only_zeros, n_cells=3).n_edges == 0
 
 
 @pytest.mark.parametrize("sparse_format", ["coo", "csr", "csc", "lil", "bsr"])