tests, fix wasm swallowed error

Signed-off-by: Onur Satici <onur@spiraldb.com>

Author: onursatici

vortex-file/src/tests.rs

@@ -1910,76 +1910,50 @@ async fn test_segment_ordering_zonemaps_after_data() -> VortexResult<()> {
 
     check_zoned_ordering(root.as_ref(), segment_specs);
 
-    // Additionally: all zone map segments across all columns should appear after
-    // all data segments across all columns. Array tree segments (if present) appear
-    // between data and zones.
+    // Additionally: every zone-map segment across all columns must appear after every data
+    // segment across all columns. This holds even with cross-column interleaving inside the
+    // metadata phase because the root writer splits the sequence universe — chunk data uses
+    // IDs derived from `ptr` and all metadata (zones, etc.) derives from `eof`, with
+    // `ptr < eof` so all data segments globally precede all metadata segments.
+    //
+    // Per-column `data < array_trees < zones` ordering for the new `ArrayTreeLayout` is
+    // covered separately by the array-tree-specific ordering tests.
     let mut all_data_offsets = Vec::new();
-    let mut all_array_tree_offsets = Vec::new();
     let mut all_zones_offsets = Vec::new();
 
     fn collect_all_zoned(
         layout: &dyn Layout,
         segment_specs: &[SegmentSpec],
         all_data: &mut Vec<u64>,
-        all_array_trees: &mut Vec<u64>,
         all_zones: &mut Vec<u64>,
     ) {
         if layout.encoding_id().as_ref() == "vortex.stats" {
-            // child 0 = data (may contain array_tree layouts), child 1 = zones
-            let data_child = layout.child(0).unwrap();
-            // If the data child is an array_tree layout, split its segments.
-            if data_child.encoding_id().as_ref() == "vortex.array_tree" {
-                // child 0 = actual data, child 1 = array_trees auxiliary
-                all_data.extend(collect_segment_offsets(
-                    data_child.child(0).unwrap().as_ref(),
-                    segment_specs,
-                ));
-                all_array_trees.extend(collect_segment_offsets(
-                    data_child.child(1).unwrap().as_ref(),
-                    segment_specs,
-                ));
-            } else {
-                all_data.extend(collect_segment_offsets(data_child.as_ref(), segment_specs));
-            }
+            all_data.extend(collect_segment_offsets(
+                layout.child(0).unwrap().as_ref(),
+                segment_specs,
+            ));
             all_zones.extend(collect_segment_offsets(
                 layout.child(1).unwrap().as_ref(),
                 segment_specs,
             ));
             return;
         }
         for child in layout.children().unwrap() {
-            collect_all_zoned(
-                child.as_ref(),
-                segment_specs,
-                all_data,
-                all_array_trees,
-                all_zones,
-            );
+            collect_all_zoned(child.as_ref(), segment_specs, all_data, all_zones);
         }
     }
 
     collect_all_zoned(
         root.as_ref(),
         segment_specs,
         &mut all_data_offsets,
-        &mut all_array_tree_offsets,
         &mut all_zones_offsets,
     );
 
-    // The root writer splits the sequence universe into two: data chunks use IDs from `ptr`
-    // and all metadata (array trees, zones) derive from `eof`. Since ptr < eof, all data
-    // segments are globally before all metadata segments.
-    //
-    // Within the eof universe, per-column ordering guarantees array_trees < zones within
-    // each column, but cross-column interleaving means we cannot assert
-    // all_array_trees < all_zones globally.
-    let mut all_metadata_offsets = all_array_tree_offsets;
-    all_metadata_offsets.extend(&all_zones_offsets);
-
     assert_offsets_ordered(
         &all_data_offsets,
-        &all_metadata_offsets,
-        "global: all data segments should come before all metadata segments (array trees + zone maps)",
+        &all_zones_offsets,
+        "global: all data segments should come before all zone-map segments",
     );
 
     Ok(())
@@ -2146,3 +2120,77 @@ async fn test_segment_ordering_array_trees_before_zones() -> VortexResult<()> {
 
     Ok(())
 }
+
+#[tokio::test]
+#[cfg_attr(miri, ignore)]
+async fn test_roundtrip_array_tree_layout() -> VortexResult<()> {
+    // End-to-end coverage of the new ArrayTreeLayout: write a multi-column struct with
+    // `with_array_tree(true)`, then read it back through the override-registration path and
+    // assert the data matches. Exercises:
+    //   - ArrayTreeCollectorStrategy collecting compact trees via the side-channel sink
+    //   - ArrayTreeLayout::new_reader deriving a ctx with the source-injecting override
+    //   - ArrayTreeFlatReader looking up its compact tree from ArrayTreesSource by segment_id
+    //   - SerializedArray::from_flatbuffer_and_segment decoding the data segment
+    let mut ctx = SESSION.create_execution_ctx();
+
+    let n = 10_000;
+    let strings_in: Vec<&str> = (0..n).map(|i| ["alpha", "beta", "gamma"][i % 3]).collect();
+    let strings = VarBinArray::from(strings_in.clone()).into_array();
+    let numbers_in: Vec<i32> = (0..n as i32).collect();
+    let numbers = PrimitiveArray::from_iter(numbers_in.iter().copied()).into_array();
+
+    let st = StructArray::from_fields(&[("strings", strings), ("numbers", numbers)])?.into_array();
+    let dtype = st.dtype().clone();
+
+    let mut buf = ByteBufferMut::empty();
+    let strategy = crate::WriteStrategyBuilder::default()
+        .with_array_tree(true)
+        .build();
+    SESSION
+        .write_options()
+        .with_strategy(strategy)
+        .write(&mut buf, st.to_array_stream())
+        .await?;
+
+    // Sanity-check that we actually wrote ArrayTreeLayout nodes — otherwise the test would
+    // silently pass on the default code path.
+    let file = SESSION.open_options().open_buffer(buf)?;
+    fn has_array_tree(layout: &dyn Layout) -> bool {
+        if layout.encoding_id().as_ref() == "vortex.array_tree" {
+            return true;
+        }
+        layout
+            .children()
+            .map(|cs| cs.iter().any(|c| has_array_tree(c.as_ref())))
+            .unwrap_or(false)
+    }
+    assert!(
+        has_array_tree(file.footer().layout().as_ref()),
+        "test expected ArrayTreeLayout in the written file"
+    );
+
+    // Read back and assert structure + data round-trip cleanly.
+    let result = file.scan()?.into_array_stream()?.read_all().await?;
+    assert_eq!(result.len(), n);
+    assert_eq!(result.dtype(), &dtype);
+
+    let struct_array = result.execute::<StructArray>(&mut ctx)?;
+
+    let read_numbers = struct_array.unmasked_field_by_name("numbers").cloned()?;
+    let expected_numbers = PrimitiveArray::from_iter(numbers_in.iter().copied()).into_array();
+    assert_arrays_eq!(read_numbers, expected_numbers);
+
+    let read_strings = struct_array
+        .unmasked_field_by_name("strings")
+        .cloned()?
+        .execute::<VarBinViewArray>(&mut ctx)?
+        .with_iterator(|iter| {
+            iter.map(|s| s.map(|st| unsafe { String::from_utf8_unchecked(st.to_vec()) }))
+                .collect::<Vec<_>>()
+        });
+    let expected_strings: Vec<Option<String>> =
+        strings_in.iter().map(|s| Some((*s).to_string())).collect();
+    assert_eq!(read_strings, expected_strings);
+
+    Ok(())
+}

vortex-layout/src/display.rs

@@ -262,7 +262,7 @@ mod tests {
 
     /// Test display_tree for a struct layout (fallback rendering, no inline array_tree).
     #[test]
-    fn test_display_tree_inline_array_tree() {
+    fn test_display_tree_struct_layout_fallback() {
         block_on(|handle| async move {
             let session = SESSION.clone().with_handle(handle);
             let ctx = ArrayContext::empty();

vortex-layout/src/layouts/array_tree/mod.rs

@@ -124,9 +124,7 @@ impl ArrayTreeLayout {
     ) -> VortexResult<LayoutReaderContext> {
         // Construct the array_trees auxiliary reader using the unmodified incoming context —
         // the array_trees subtree is a vanilla struct of (u32, bytes) and needs no overrides.
-        let array_trees_child = self
-            .children
-            .child(1, &Self::array_trees_dtype())?;
+        let array_trees_child = self.children.child(1, &Self::array_trees_dtype())?;
         let trees_reader = array_trees_child.new_reader_in_ctx(
             Arc::from(format!("{name}/array_trees")),
             segment_source,

vortex-web/crate/src/wasm.rs

@@ -316,6 +316,7 @@ impl VortexFileHandle {
             node_id,
             Some((&segment_source, &self.session)),
         )
+        .map_err(|e| JsValue::from_str(&e.to_string()))?
         .ok_or_else(|| JsValue::from_str(&format!("Layout node not found: {node_id}")))?;
 
         let reader = layout
@@ -709,7 +710,12 @@ fn build_array_encoding_tree_from_array(
 /// IDs match the format: "root.field_name.chunked.[0]" where each segment
 /// corresponds to a `LayoutChildType::name()`.
 fn find_layout_by_id(root: &LayoutRef, node_id: &str) -> Option<LayoutRef> {
-    find_layout_with_ctx(root, node_id, None).map(|(layout, _)| layout)
+    match find_layout_with_ctx(root, node_id, None) {
+        Ok(Some((layout, _))) => Some(layout),
+        Ok(None) => None,
+        // No derivation requested → derive_reader_ctx is never called, so this can't fail.
+        Err(_) => None,
+    }
 }
 
 /// Like [`find_layout_by_id`], but also builds a [`LayoutReaderContext`] that registers a
@@ -726,36 +732,55 @@ fn find_layout_by_id(root: &LayoutRef, node_id: &str) -> Option<LayoutRef> {
 /// Pass `Some((segment_source, session))` to actually derive the context. When passed
 /// `None`, the function still navigates the tree and returns an empty context — useful for
 /// callers that only need the layout reference.
+///
+/// Return shape:
+/// - `Ok(Some((layout, ctx)))` — target found.
+/// - `Ok(None)` — `node_id` does not resolve to a layout in the tree (bad path).
+/// - `Err(e)` — `derive_reader_ctx` failed on some ancestor (e.g. the trees segment is
+///   unreadable). Surfaces the real cause instead of silently producing a ctx that would
+///   make the leaf bail with "missing override".
 fn find_layout_with_ctx(
     root: &LayoutRef,
     node_id: &str,
-    derive: Option<(&Arc<dyn vortex::layout::segments::SegmentSource>, &VortexSession)>,
-) -> Option<(LayoutRef, LayoutReaderContext)> {
+    derive: Option<(
+        &Arc<dyn vortex::layout::segments::SegmentSource>,
+        &VortexSession,
+    )>,
+) -> VortexResult<Option<(LayoutRef, LayoutReaderContext)>> {
     let segments: Vec<&str> = node_id.split('.').collect();
     if segments.is_empty() || segments[0] != "root" {
-        return None;
+        return Ok(None);
     }
 
     let mut current = root.clone();
     let mut current_id = String::from("root");
     let mut ctx = LayoutReaderContext::new();
 
-    let maybe_derive = |layout: &LayoutRef, name: &str, ctx: &LayoutReaderContext| {
+    // For every layout we walk through, if it's an ArrayTree and we have the deps to derive,
+    // overlay its source-injecting override onto the ctx; any other layout is a passthrough.
+    let try_derive = |layout: &LayoutRef,
+                      name: &str,
+                      ctx: &LayoutReaderContext|
+     -> VortexResult<LayoutReaderContext> {
         let Some((segment_source, session)) = derive else {
-            return Some(ctx.clone());
+            return Ok(ctx.clone());
         };
-        layout.as_opt::<ArrayTree>().and_then(|atl| {
-            atl.derive_reader_ctx(name, Arc::clone(segment_source), session, ctx).ok()
-        }).or_else(|| Some(ctx.clone()))
+        match layout.as_opt::<ArrayTree>() {
+            Some(atl) => atl.derive_reader_ctx(name, Arc::clone(segment_source), session, ctx),
+            None => Ok(ctx.clone()),
+        }
     };
 
-    ctx = maybe_derive(&current, &current_id, &ctx)?;
+    ctx = try_derive(&current, &current_id, &ctx)?;
     if segments.len() == 1 {
-        return Some((current, ctx));
+        return Ok(Some((current, ctx)));
     }
 
     for seg in &segments[1..] {
-        let children = current.children().ok()?;
+        let children = match current.children() {
+            Ok(c) => c,
+            Err(_) => return Ok(None),
+        };
         let mut found = None;
         for (i, child) in children.into_iter().enumerate() {
             let name = current.child_type(i).name();
@@ -764,13 +789,13 @@ fn find_layout_with_ctx(
                 break;
             }
         }
-        let child = found?;
+        let Some(child) = found else { return Ok(None) };
         current = child;
         current_id.push('.');
         current_id.push_str(seg);
-        ctx = maybe_derive(&current, &current_id, &ctx)?;
+        ctx = try_derive(&current, &current_id, &ctx)?;
     }
-    Some((current, ctx))
+    Ok(Some((current, ctx)))
 }
 
 /// Downgrade Arrow `*View` types to their non-view equivalents so the JS