matterviz 0.4.2 → 0.4.3

package/dist/element/index.d.ts

@@ -1,6 +1,6 @@
 export type * from './types';
 export { default as BohrAtom } from './BohrAtom.svelte';
-export { default as element_data } from './data';
+export { default as element_data, element_by_symbol } from './data';
 export { default as ElementHeading } from './ElementHeading.svelte';
 export { default as ElementPhoto } from './ElementPhoto.svelte';
 export { default as ElementStats } from './ElementStats.svelte';

package/dist/element/index.js

@@ -1,5 +1,5 @@
 export { default as BohrAtom } from './BohrAtom.svelte';
-export { default as element_data } from './data';
+export { default as element_data, element_by_symbol } from './data';
 export { default as ElementHeading } from './ElementHeading.svelte';
 export { default as ElementPhoto } from './ElementPhoto.svelte';
 export { default as ElementStats } from './ElementStats.svelte';

package/dist/fermi-surface/FermiSurface.svelte

@@ -5,7 +5,7 @@
   import EmptyState from '../EmptyState.svelte'
   import { StatusMessage } from '../feedback'
   import Spinner from '../feedback/Spinner.svelte'
-  import { create_file_drop_handler, drag_over_handlers, load_from_url } from '../io'
+  import * as io from '../io'
   import { type FullscreenToggleProp, toggle_fullscreen, ViewerChrome } from '../layout'
   import { sync_fullscreen } from '../layout/fullscreen.svelte'
   import { PlotTooltip } from '../plot'
@@ -34,13 +34,9 @@
     RepresentationMode,
   } from './types'
 
-  type FermiHandlerData = {
+  type FermiFullscreenData = {
     fermi_data?: FermiSurfaceData
-    band_data?: BandGridData
     bz_data?: BrillouinZoneData
-    filename?: string
-    file_size?: number
-    error_msg?: string
     fullscreen?: boolean
   }
 
@@ -140,7 +136,7 @@
     on_file_drop?: (filename: string) => void
     on_file_load?: (data: FermiFileLoadData) => void
     on_error?: (data: FermiErrorData) => void
-    on_fullscreen_change?: (data: FermiHandlerData) => void
+    on_fullscreen_change?: (data: FermiFullscreenData) => void
     on_mu_change?: (mu: number) => void
     tooltip_config?: Snippet<[{ hover_data: FermiHoverData }]> | FermiTooltipConfig
     on_point_hover?: (data: FermiHoverData | null) => void
@@ -303,23 +299,26 @@
   // Load from URL (with race condition protection for rapid URL changes)
   let load_id = 0
   $effect(() => {
-    if (data_url && !fermi_data && !band_data) {
-      const current_load_id = ++load_id
-      loading = true
-      error_msg = undefined
-      load_from_url(data_url, safe_parse)
-        .catch((err) => {
-          if (current_load_id !== load_id) return // stale request
-          error_msg = to_error(err).message
-          on_error?.({ error_msg, filename: data_url })
-        })
-        .finally(() => {
-          if (current_load_id === load_id) loading = false
-        })
-    }
+    const requested_url = data_url
+    if (!requested_url || fermi_data || band_data) return
+    const current_load_id = ++load_id
+    loading = true
+    error_msg = undefined
+    io.load_from_url(requested_url, (content, filename) => {
+      if (current_load_id !== load_id) return
+      return safe_parse(content, filename)
+    })
+      .catch((err) => {
+        if (current_load_id !== load_id) return
+        error_msg = to_error(err).message
+        on_error?.({ error_msg, filename: io.basename_from_url(requested_url) })
+      })
+      .finally(() => {
+        if (current_load_id === load_id) loading = false
+      })
   })
 
-  const handle_file_drop = create_file_drop_handler({
+  const handle_file_drop = io.create_file_drop_handler({
     allow: () => allow_file_drop,
     on_drop: async (content, filename) => {
       on_file_drop?.(filename)
@@ -368,7 +367,7 @@
   onmouseenter={() => (hovered = true)}
   onmouseleave={() => (hovered = false)}
   ondrop={handle_file_drop}
-  {...drag_over_handlers({
+  {...io.drag_over_handlers({
     allow: () => allow_file_drop,
     set_dragover: (over) => (dragover = over),
   })}

package/dist/fermi-surface/FermiSurface.svelte.d.ts

@@ -7,13 +7,9 @@ import type { Crystal } from '../structure';
 import type { ComponentProps, Snippet } from 'svelte';
 import type { HTMLAttributes } from 'svelte/elements';
 import type { BandGridData, ColorProperty, FermiErrorData, FermiFileLoadData, FermiHoverData, FermiSurfaceData, FermiTooltipConfig, RepresentationMode } from './types';
-type FermiHandlerData = {
+type FermiFullscreenData = {
     fermi_data?: FermiSurfaceData;
-    band_data?: BandGridData;
     bz_data?: BrillouinZoneData;
-    filename?: string;
-    file_size?: number;
-    error_msg?: string;
     fullscreen?: boolean;
 };
 type $$ComponentProps = {
@@ -59,7 +55,7 @@ type $$ComponentProps = {
     on_file_drop?: (filename: string) => void;
     on_file_load?: (data: FermiFileLoadData) => void;
     on_error?: (data: FermiErrorData) => void;
-    on_fullscreen_change?: (data: FermiHandlerData) => void;
+    on_fullscreen_change?: (data: FermiFullscreenData) => void;
     on_mu_change?: (mu: number) => void;
     tooltip_config?: Snippet<[{
         hover_data: FermiHoverData;

package/dist/fermi-surface/FermiSurfaceScene.svelte

@@ -172,21 +172,11 @@
 
   // Map from surface to its render order based on size (inner surfaces first)
   let surface_render_orders = $derived.by((): Map<Isosurface, number> => {
-    const order_map = new SvelteMap<Isosurface, number>()
-    if (visible_surfaces.length === 0) return order_map
-
-    // Compute radius for each surface and sort by it
-    const surfaces_with_radius = visible_surfaces.map((surface) => ({
-      surface,
-      radius: compute_surface_radius(surface),
-    }))
-    surfaces_with_radius.sort((a, b) => a.radius - b.radius)
-
-    // Assign render order: smaller radius (inner) = lower order = rendered first
-    for (let idx = 0; idx < surfaces_with_radius.length; idx++) {
-      order_map.set(surfaces_with_radius[idx].surface, idx)
-    }
-    return order_map
+    const by_radius = visible_surfaces
+      .map((surface) => ({ surface, radius: compute_surface_radius(surface) }))
+      .toSorted((surf_a, surf_b) => surf_a.radius - surf_b.radius)
+    // Smaller radius (inner) = lower order = rendered first
+    return new SvelteMap(by_radius.map(({ surface }, idx) => [surface, idx]))
   })
 
   // Compute property range for color scaling
@@ -538,79 +528,44 @@
 
     {#if geo_data}
       {#each symmetry_ops as sym_matrix, sym_idx (`sym-${sym_idx}`)}
-        {#if representation === `wireframe`}
+        {#snippet mesh_pass(order: number, pass: `wireframe` | `front` | `back`)}
           <T.Mesh
             geometry={geo_data.geometry}
             matrix={sym_matrix}
             matrixAutoUpdate={false}
-            {renderOrder}
+            renderOrder={order}
             onpointermove={(event: ThreltePointerEvent) =>
               handle_pointer_move(event, surface, surface_color, sym_idx, sym_matrix)}
             onpointerleave={clear_hover}
           >
-            <T.MeshBasicMaterial
-              color={surface_color}
-              wireframe
-              transparent={surface_opacity < 1}
-              opacity={surface_opacity}
-              depthWrite={true}
-              depthTest={true}
-            />
+            {#if pass === `wireframe`}
+              <T.MeshBasicMaterial
+                color={surface_color}
+                wireframe
+                transparent={surface_opacity < 1}
+                opacity={surface_opacity}
+                depthWrite={true}
+                depthTest={true}
+              />
+            {:else}
+              <T.MeshStandardMaterial
+                {...get_material_props(surface_color, use_vertex_colors, surface_idx, pass)}
+                metalness={0.1}
+                roughness={0.6}
+                flatShading={false}
+              />
+            {/if}
           </T.Mesh>
+        {/snippet}
+
+        {#if representation === `wireframe`}
+          {@render mesh_pass(renderOrder, `wireframe`)}
         {:else if surface_opacity < 1}
-          <!-- Two-pass rendering for transparent surfaces -->
-          <!-- Pass 1: Back faces (rendered first, lower renderOrder) -->
-          <T.Mesh
-            geometry={geo_data.geometry}
-            matrix={sym_matrix}
-            matrixAutoUpdate={false}
-            renderOrder={renderOrder * 2}
-            onpointermove={(event: ThreltePointerEvent) =>
-              handle_pointer_move(event, surface, surface_color, sym_idx, sym_matrix)}
-            onpointerleave={clear_hover}
-          >
-            <T.MeshStandardMaterial
-              {...get_material_props(surface_color, use_vertex_colors, surface_idx, `back`)}
-              metalness={0.1}
-              roughness={0.6}
-              flatShading={false}
-            />
-          </T.Mesh>
-          <!-- Pass 2: Front faces (rendered second, higher renderOrder) -->
-          <T.Mesh
-            geometry={geo_data.geometry}
-            matrix={sym_matrix}
-            matrixAutoUpdate={false}
-            renderOrder={renderOrder * 2 + 1}
-            onpointermove={(event: ThreltePointerEvent) =>
-              handle_pointer_move(event, surface, surface_color, sym_idx, sym_matrix)}
-            onpointerleave={clear_hover}
-          >
-            <T.MeshStandardMaterial
-              {...get_material_props(surface_color, use_vertex_colors, surface_idx, `front`)}
-              metalness={0.1}
-              roughness={0.6}
-              flatShading={false}
-            />
-          </T.Mesh>
+          <!-- Two-pass transparent rendering: back faces first, front faces on top -->
+          {@render mesh_pass(renderOrder * 2, `back`)}
+          {@render mesh_pass(renderOrder * 2 + 1, `front`)}
         {:else}
-          <!-- Single pass for opaque surfaces -->
-          <T.Mesh
-            geometry={geo_data.geometry}
-            matrix={sym_matrix}
-            matrixAutoUpdate={false}
-            {renderOrder}
-            onpointermove={(event: ThreltePointerEvent) =>
-              handle_pointer_move(event, surface, surface_color, sym_idx, sym_matrix)}
-            onpointerleave={clear_hover}
-          >
-            <T.MeshStandardMaterial
-              {...get_material_props(surface_color, use_vertex_colors, surface_idx, `front`)}
-              metalness={0.1}
-              roughness={0.6}
-              flatShading={false}
-            />
-          </T.Mesh>
+          {@render mesh_pass(renderOrder, `front`)}
         {/if}
       {/each}
     {/if}

package/dist/fermi-surface/compute.js

@@ -26,18 +26,15 @@ function tricubic_interpolate(grid, fx, fy, fz, px, py, pz) {
     const iy = Math.floor(fy);
     const iz = Math.floor(fz);
     // Precompute Catmull-Rom coefficients
-    const [cx0, cx1, cx2, cx3] = catmull_rom_coeffs(fx - ix);
-    const [cy0, cy1, cy2, cy3] = catmull_rom_coeffs(fy - iy);
-    const [cz0, cz1, cz2, cz3] = catmull_rom_coeffs(fz - iz);
+    const cx = catmull_rom_coeffs(fx - ix);
+    const cy = catmull_rom_coeffs(fy - iy);
+    const cz = catmull_rom_coeffs(fz - iz);
     // Wrapped stencil indices (modulo hoisted out of the inner loop); a zero period
     // (single-point axis) has no neighbours, so collapse the stencil onto index 0
     const stencil = (idx, period) => [idx - 1, idx, idx + 1, idx + 2].map((stencil_idx) => period > 0 ? ((stencil_idx % period) + period) % period : 0);
     const [wx, wy, wz] = [stencil(ix, px), stencil(iy, py), stencil(iz, pz)];
     // Interpolate along z, then y, then x (fully inlined)
     let result = 0;
-    const cx = [cx0, cx1, cx2, cx3];
-    const cy = [cy0, cy1, cy2, cy3];
-    const cz = [cz0, cz1, cz2, cz3];
     for (let xi = 0; xi < 4; xi++) {
         const row = grid[wx[xi]];
         let y_sum = 0;
@@ -286,36 +283,26 @@ function analyze_surface_topology(surface, k_lattice) {
         spans[axis_idx] = surface_size > SPANNING_THRESHOLD * bz_size;
     }
     const n_spanning = spans.filter(Boolean).length;
-    if (n_spanning === 0) {
-        // Closed surface, no spanning directions
+    // 0 spanning = closed 3D pocket; 3 spanning = complex warped network
+    if (n_spanning === 0)
         return { dimensionality: `3D`, orientation: null };
-    }
-    else if (n_spanning === 1) {
-        // 2D sheet spanning one direction
-        const axis_idx = spans.indexOf(true);
-        const orientation = [0, 0, 0];
-        orientation[axis_idx] = 1;
-        return { dimensionality: `2D`, orientation };
-    }
-    else if (n_spanning === 2) {
-        // 1D noodle-like (tube spanning 2 directions, bounded in 1)
-        const axis_idx = spans.indexOf(false);
-        const orientation = [0, 0, 0];
-        orientation[axis_idx] = 1;
-        return { dimensionality: `1D`, orientation };
-    }
-    // Spans all 3 directions - complex warped network
-    return { dimensionality: `quasi-2D`, orientation: null };
+    if (n_spanning === 3)
+        return { dimensionality: `quasi-2D`, orientation: null };
+    // 1 spanning = 2D sheet (oriented along the spanning axis);
+    // 2 spanning = 1D noodle-like tube (oriented along the bounded axis)
+    const axis_idx = n_spanning === 1 ? spans.indexOf(true) : spans.indexOf(false);
+    const orientation = [0, 0, 0];
+    orientation[axis_idx] = 1;
+    return { dimensionality: n_spanning === 1 ? `2D` : `1D`, orientation };
 }
 // Compute 2D Fermi slice along a specified plane
 export function compute_fermi_slice(fermi_data, options = {}) {
     const { miller_indices = [0, 0, 1], distance = 0 } = options;
-    // Validate miller indices are not all zero
-    if (miller_indices[0] === 0 && miller_indices[1] === 0 && miller_indices[2] === 0) {
+    if (miller_indices.every((miller_idx) => miller_idx === 0)) {
         throw new Error(`Invalid miller indices [0, 0, 0]: at least one index must be non-zero to define a plane`);
     }
     // Compute plane normal in Cartesian coordinates
-    const plane_normal = math.add(math.add(math.scale(fermi_data.k_lattice[0], miller_indices[0]), math.scale(fermi_data.k_lattice[1], miller_indices[1])), math.scale(fermi_data.k_lattice[2], miller_indices[2]));
+    const plane_normal = math.add(math.scale(fermi_data.k_lattice[0], miller_indices[0]), math.scale(fermi_data.k_lattice[1], miller_indices[1]), math.scale(fermi_data.k_lattice[2], miller_indices[2]));
     const normal_len = Math.hypot(...plane_normal);
     if (normal_len < EPS) {
         throw new Error(`Degenerate plane normal: k_lattice vectors produce a zero-length normal for miller indices [${miller_indices.join(`, `)}]`);
@@ -324,11 +311,7 @@ export function compute_fermi_slice(fermi_data, options = {}) {
     // Compute in-plane basis vectors
     const [in_plane_u, in_plane_v] = math.compute_in_plane_basis(unit_normal);
     // Slice each isosurface
-    const isolines = [];
-    for (const surface of fermi_data.isosurfaces) {
-        const lines = slice_surface_with_plane(surface, unit_normal, distance, in_plane_u, in_plane_v);
-        isolines.push(...lines);
-    }
+    const isolines = fermi_data.isosurfaces.flatMap((surface) => slice_surface_with_plane(surface, unit_normal, distance, in_plane_u, in_plane_v));
     return {
         isolines,
         plane_normal: unit_normal,
@@ -340,8 +323,6 @@ export function compute_fermi_slice(fermi_data, options = {}) {
         },
     };
 }
-// Helper to create edge key (sorted vertex indices)
-const make_edge_key = (v0_idx, v1_idx) => `${Math.min(v0_idx, v1_idx)},${Math.max(v0_idx, v1_idx)}`;
 // Compute intersection point on an edge
 function compute_edge_intersection(surface, vertex_distances, v0_idx, v1_idx) {
     const d0 = vertex_distances[v0_idx];
@@ -383,7 +364,7 @@ function slice_surface_with_plane(surface, plane_normal, plane_distance, in_plan
         for (let edge_idx = 0; edge_idx < face.length; edge_idx++) {
             const v0_idx = face[edge_idx];
             const v1_idx = face[(edge_idx + 1) % face.length];
-            const edge_key = make_edge_key(v0_idx, v1_idx);
+            const edge_key = `${Math.min(v0_idx, v1_idx)},${Math.max(v0_idx, v1_idx)}`;
             const intersection = compute_edge_intersection(surface, vertex_distances, v0_idx, v1_idx);
             if (intersection) {
                 crossing_edges.push({ edge_key, intersection });
@@ -516,24 +497,10 @@ function slice_surface_with_plane(surface, plane_normal, plane_distance, in_plan
 // For cubic Oh symmetry, this is the region where all vertices are in the first octant
 // (x >= 0, y >= 0, z >= 0) with some tolerance. Such data needs tiling to show the full BZ.
 export function detect_irreducible_bz(fermi_data) {
-    if (fermi_data.isosurfaces.length === 0)
+    const vertex_count = fermi_data.isosurfaces.reduce((sum, surface) => sum + surface.vertices.length, 0);
+    // Only consider it irreducible if we have significant data and all vertices are
+    // in the positive octant (with small tolerance for numerical error)
+    if (vertex_count <= IRREDUCIBLE_BZ_MIN_VERTICES)
         return false;
-    // Check if all vertices are in the positive octant (with small tolerance for numerical error)
-    let all_positive = true;
-    let vertex_count = 0;
-    for (const surface of fermi_data.isosurfaces) {
-        for (const vertex of surface.vertices) {
-            vertex_count++;
-            if (vertex[0] < -IRREDUCIBLE_BZ_TOLERANCE ||
-                vertex[1] < -IRREDUCIBLE_BZ_TOLERANCE ||
-                vertex[2] < -IRREDUCIBLE_BZ_TOLERANCE) {
-                all_positive = false;
-                break;
-            }
-        }
-        if (!all_positive)
-            break;
-    }
-    // Only consider it irreducible if we have significant data and all positive
-    return all_positive && vertex_count > IRREDUCIBLE_BZ_MIN_VERTICES;
+    return fermi_data.isosurfaces.every((surface) => surface.vertices.every((vertex) => vertex.every((coord) => coord >= -IRREDUCIBLE_BZ_TOLERANCE)));
 }

package/dist/fermi-surface/parse.js

@@ -95,18 +95,11 @@ function parse_bxsf(content) {
         if (energy_values.length < total_points) {
             throw new Error(`Band ${band_idx}: expected ${total_points} values, got ${energy_values.length}`);
         }
-        // Reshape into 3D grid [kx][ky][kz] (preallocated for speed)
-        const band_grid = Array(nx);
-        let val_idx = 0;
-        for (let ix = 0; ix < nx; ix++) {
-            const iy_arr = Array(ny);
-            for (let iy = 0; iy < ny; iy++) {
-                const iz_arr = energy_values.slice(val_idx, val_idx + nz);
-                val_idx += nz;
-                iy_arr[iy] = iz_arr;
-            }
-            band_grid[ix] = iy_arr;
-        }
+        // Reshape into 3D grid [kx][ky][kz]
+        const band_grid = Array.from({ length: nx }, (_x_row, ix) => Array.from({ length: ny }, (_y_row, iy) => {
+            const offset = (ix * ny + iy) * nz;
+            return energy_values.slice(offset, offset + nz);
+        }));
         energies[0].push(band_grid);
     }
     // Try to find Fermi energy (often in a comment or as FERMI_ENERGY keyword)
@@ -159,58 +152,40 @@ function parse_frmsf(content) {
     if (isNaN(n_bands) || n_bands <= 0) {
         throw new Error(`FRMSF: Invalid number of bands`);
     }
-    // FRMSF format has single spin channel (no spin-polarized support in standard format)
-    const n_spins = 1;
     // Lines 4-6: reciprocal lattice vectors (in Bohr^-1, convert to Å^-1)
     const inv_bohr = 1 / constants.BOHR_TO_ANGSTROM;
-    const k_lattice = [
-        parse_floats(lines[line_idx++])
-            .slice(0, 3)
-            .map((val) => val * inv_bohr),
-        parse_floats(lines[line_idx++])
-            .slice(0, 3)
-            .map((val) => val * inv_bohr),
-        parse_floats(lines[line_idx++])
-            .slice(0, 3)
-            .map((val) => val * inv_bohr),
-    ];
+    const parse_k_vector = () => parse_floats(lines[line_idx++])
+        .slice(0, 3)
+        .map((val) => val * inv_bohr);
+    const k_lattice = [parse_k_vector(), parse_k_vector(), parse_k_vector()];
     const [nx, ny, nz] = k_grid;
     const total_points = nx * ny * nz;
-    // Parse band energies for each spin and band
-    // FRMSF format: one energy value per line per grid point. Any additional columns
-    // (e.g. auxiliary color/velocity data) are ignored to prevent grid corruption.
-    const energies = [];
-    for (let spin_idx = 0; spin_idx < n_spins; spin_idx++) {
-        energies[spin_idx] = [];
-        for (let band_idx = 0; band_idx < n_bands; band_idx++) {
-            const energy_values = [];
-            // Read energy values (first value per line only, ignore auxiliary columns;
-            // normalize Fortran D-exponents like parse_floats does)
-            while (energy_values.length < total_points && line_idx < lines.length) {
-                const energy = parse_leading_num(normalize_scientific_notation(lines[line_idx] ?? ``));
-                if (isNaN(energy))
-                    break;
-                energy_values.push(energy);
-                line_idx++;
-            }
-            if (energy_values.length < total_points) {
-                throw new Error(`FRMSF spin ${spin_idx} band ${band_idx}: expected ${total_points} values, got ${energy_values.length}`);
-            }
-            // Reshape into 3D grid [kx][ky][kz]
-            const band_grid = [];
-            let val_idx = 0;
-            for (let ix = 0; ix < nx; ix++) {
-                band_grid[ix] = [];
-                for (let iy = 0; iy < ny; iy++) {
-                    band_grid[ix][iy] = [];
-                    for (let iz = 0; iz < nz; iz++) {
-                        // FRMSF uses Hartree, convert to eV
-                        band_grid[ix][iy][iz] = energy_values[val_idx++] * constants.HARTREE_TO_EV;
-                    }
-                }
-            }
-            energies[spin_idx].push(band_grid);
+    // Parse band energies (FRMSF has a single spin channel — no spin-polarized support
+    // in the standard format). One energy value per line per grid point; any additional
+    // columns (e.g. auxiliary color/velocity data) are ignored to prevent grid corruption.
+    const energies = [[]];
+    for (let band_idx = 0; band_idx < n_bands; band_idx++) {
+        const energy_values = [];
+        // Read energy values (first value per line only, ignore auxiliary columns;
+        // normalize Fortran D-exponents like parse_floats does)
+        while (energy_values.length < total_points && line_idx < lines.length) {
+            const energy = parse_leading_num(normalize_scientific_notation(lines[line_idx] ?? ``));
+            if (isNaN(energy))
+                break;
+            energy_values.push(energy);
+            line_idx++;
+        }
+        if (energy_values.length < total_points) {
+            throw new Error(`FRMSF band ${band_idx}: expected ${total_points} values, got ${energy_values.length}`);
         }
+        // Reshape into 3D grid [kx][ky][kz], converting Hartree to eV
+        const band_grid = Array.from({ length: nx }, (_x_row, ix) => Array.from({ length: ny }, (_y_row, iy) => {
+            const offset = (ix * ny + iy) * nz;
+            return energy_values
+                .slice(offset, offset + nz)
+                .map((energy) => energy * constants.HARTREE_TO_EV);
+        }));
+        energies[0].push(band_grid);
     }
     return {
         energies,
@@ -218,7 +193,7 @@ function parse_frmsf(content) {
         k_lattice,
         fermi_energy: 0, // FRMSF typically expects Fermi level at 0
         n_bands,
-        n_spins,
+        n_spins: 1,
         periodic: true, // FRMSF stores k=i/n with no duplicated endpoint (unlike BXSF)
     };
 }
@@ -357,16 +332,9 @@ function parse_ifermi_surface(data) {
             const faces = ifermi_iso.faces;
             // Compute vertex normals from faces
             const normals = compute_vertex_normals(vertices, faces);
-            // Extract properties if available
-            let properties;
-            if (ifermi_iso.properties) {
-                // IFermi stores properties like fermi_velocity, spin, etc.
-                const prop_keys = Object.keys(ifermi_iso.properties);
-                if (prop_keys.length > 0) {
-                    // Use first available property as vertex colors
-                    properties = ifermi_iso.properties[prop_keys[0]];
-                }
-            }
+            // IFermi stores properties like fermi_velocity, spin, etc.
+            // Use first available property as vertex colors
+            const properties = Object.values(ifermi_iso.properties ?? {})[0];
             // Parse dimensionality
             let dimensionality;
             if (ifermi_iso.dimensionality) {