wasm, format: listing a group asks for all its missing blocks per pass

Listing a group read every child's object header and stopped at the
first that was not fetched yet, and so did the traversals of the group's
index (v1 B-tree and symbol table nodes, the local heap's names, v2
B-tree nodes and fractal heap objects). Over openUrl's restartable
reader each block cost its own pass and round trip: 184 serial requests
to list 3000 datasets at 1 MiB blocks, 536 at 64 KiB.

- core::Reader::list reads every child's header before returning the
  first error (the same error, in listing order, Group::groups/datasets
  return), classifying them as those do.
- clawhdf5-format: after the first sibling that fails, the B-tree v1
  and v2 collectors, the symbol table node loop and the dense-link loop
  go on reading (not using) the remaining siblings, then return that
  first error: results and errors are unchanged, only failing
  traversals read more, and in memory that is free (storage::touch).
  A v1 group's local heap segment (names) is read at once, up to 1 MiB.
- LazyStorage no longer fills a one-block hole that is already cached
  (it was fetched again: 215 MB fetched from a 198 MB file).

Measured with tests/lazy.rs listing_cost_of_a_given_file on the
reviewer's file (h5py, 3000 datasets of 64 KiB, 198 MB), list('/'):
  libver earliest, 1 MiB blocks: 185 passes/184 requests -> 6/73
  libver earliest, 64 KiB:       537/536 -> 8/531 (6 in flight)
  libver latest,   1 MiB:        189/188 -> 9/98
  libver latest,   64 KiB:       453/452 -> 11/452
Bytes fetched are unchanged (the headers are spread through the file).
New test listing_a_large_group_takes_a_few_passes (512-byte blocks):
FileBuilder 600 children 102 -> 5 passes; h5py earliest/latest 2000
children 8 and 11 passes. Conformance 600 of 697 (baseline 600);
check-32bit-casts, check-nostd and h5rs-fuzz over the CVE corpus clean.

Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>

crates/clawhdf5-wasm/tests/lazy.rs

@@ -473,3 +473,106 @@ fn corpus_files_read_the_same_lazily() {
         files.len()
     );
 }
+
+/// Passes and requests `list(path)` takes on a file opened lazily at
+/// `block`-byte blocks (the open not counted), checking the listing against
+/// the in-memory one.
+fn listing_cost(data: &[u8], path: &str, block: u64) -> (u64, u64) {
+    let want = Reader::open(data.to_vec()).unwrap().list(path).unwrap();
+    let lazy = Lazy::open(
+        data.to_vec(),
+        LazyConfig {
+            block_size: block,
+            ..LazyConfig::default()
+        },
+    )
+    .unwrap();
+    let before = lazy.storage.stats();
+    assert_eq!(lazy.call(|r| r.list(path)).unwrap(), want);
+    let after = lazy.storage.stats();
+    (
+        after.passes - before.passes,
+        after.requests - before.requests,
+    )
+}
+
+/// Listing a group reads every child's object header, and its index (B-tree
+/// and symbol table nodes, or B-tree v2 and heap blocks) before that. Each
+/// pass asks for every node of a level it is missing, not the first one
+/// only, so the passes (network round trips) grow with the depth of the
+/// index, not with the number of children: 2000 children with headers
+/// scattered over 512-byte blocks list in a handful of passes, where each
+/// header block used to cost its own.
+#[test]
+fn listing_a_large_group_takes_a_few_passes() {
+    let mut b = FileBuilder::new();
+    let mut g = b.create_group("many");
+    for i in 0..600 {
+        g.create_dataset(&format!("d{i}")).with_i32_data(&[i; 64]);
+    }
+    b.add_group(g.finish());
+    let data = b.finish().unwrap();
+    let (passes, requests) = listing_cost(&data, "/many", 512);
+    eprintln!("FileBuilder, 600 children: {passes} passes, {requests} requests");
+    assert!(passes <= 6, "{passes} passes");
+
+    if !python_available() {
+        return;
+    }
+    let dir = tempfile::tempdir().unwrap();
+    for libver in ["earliest", "latest"] {
+        let path = dir.path().join(format!("{libver}.h5"));
+        let script = format!(
+            "import h5py, numpy as np\n\
+             with h5py.File({:?}, 'w', libver='{libver}') as f:\n\
+             \x20   for i in range(2000):\n\
+             \x20       f.create_dataset('d%d' % i, data=np.full(256, i, np.float32))\n",
+            path.display().to_string()
+        );
+        let out = Command::new(python())
+            .args(["-c", &script])
+            .output()
+            .unwrap();
+        assert!(
+            out.status.success(),
+            "{}",
+            String::from_utf8_lossy(&out.stderr)
+        );
+        let data = std::fs::read(&path).unwrap();
+        let (passes, requests) = listing_cost(&data, "/", 512);
+        eprintln!("h5py libver={libver}, 2000 children: {passes} passes, {requests} requests");
+        assert!(passes <= 12, "{libver}: {passes} passes");
+    }
+}
+
+/// `CLAWHDF5_WASM_LIST_FILE=file.h5`: what listing the root group of that
+/// file costs lazily, at 1 MiB and 64 KiB blocks (a measurement, printed).
+#[test]
+fn listing_cost_of_a_given_file() {
+    let Ok(path) = std::env::var("CLAWHDF5_WASM_LIST_FILE") else {
+        return;
+    };
+    let data = std::fs::read(&path).unwrap();
+    for block in [1 << 20, 64 << 10] {
+        let lazy = Lazy::open(
+            data.clone(),
+            LazyConfig {
+                block_size: block,
+                ..LazyConfig::default()
+            },
+        )
+        .unwrap();
+        let open = lazy.storage.stats();
+        let n = lazy.call(|r| r.list("/")).unwrap().len();
+        let st = lazy.storage.stats();
+        eprintln!(
+            "{path} ({} bytes), {block}-byte blocks: open {} requests / {} passes; list('/') of {n}: {} passes, {} requests, {} bytes",
+            data.len(),
+            open.requests,
+            open.passes,
+            st.passes - open.passes,
+            st.requests - open.requests,
+            st.bytes_fetched - open.bytes_fetched
+        );
+    }
+}