matterviz 0.3.7 → 0.4.0

package/dist/coordination/CoordinationBarPlot.svelte.d.ts

@@ -1,5 +1,5 @@
 import { BarPlot } from '../plot';
-import type { AxisConfig } from '../plot/types';
+import type { AxisConfig } from '../plot/core/types';
 import type { AnyStructure } from '../structure';
 import type { BondingStrategy } from '../structure/bonding';
 import type { ComponentProps } from 'svelte';

package/dist/element/ElementTile.svelte.d.ts

@@ -24,6 +24,6 @@ type $$ComponentProps = Omit<HTMLAttributes<HTMLElement>, `onclick`> & {
         event: MouseEvent;
     }) => void;
 };
-declare const ElementTile: import("svelte").Component<$$ComponentProps, {}, "text_color" | "node">;
+declare const ElementTile: import("svelte").Component<$$ComponentProps, {}, "node" | "text_color">;
 type ElementTile = ReturnType<typeof ElementTile>;
 export default ElementTile;

package/dist/fermi-surface/FermiSlice.svelte

@@ -8,6 +8,7 @@
   import { compute_fermi_slice } from './compute'
   import { BAND_COLORS } from './constants'
   import type { FermiSliceData, FermiSurfaceData } from './types'
+  import { to_error } from '../utils'
 
   let {
     fermi_data,
@@ -60,7 +61,7 @@
       slice_data = compute_fermi_slice(fermi_data, { miller_indices, distance })
     } catch (err) {
       slice_data = null
-      on_error?.(err instanceof Error ? err : new Error(String(err)))
+      on_error?.(to_error(err))
     }
   })
 
@@ -114,7 +115,7 @@
     const band = slice_data?.isolines[series_idx]?.band_index
     if (band === undefined) return
     const all_bands = [
-      ...new Set(slice_data?.isolines.map((iso) => iso.band_index) ?? []),
+      ...new Set(slice_data?.isolines.map((iso) => iso.band_index)),
     ]
     const is_solo = all_bands.every((bid) => bid === band || hidden_bands.has(bid))
     hidden_bands.clear()
@@ -136,12 +137,19 @@
   x_axis={{ ticks: [], range: [bounds.min[0], bounds.max[0]] }}
   y_axis={{ ticks: [], range: [bounds.min[1], bounds.max[1]] }}
   range_padding={0}
+  line_tween={{ duration: 0 }}
   display={{ x_grid: false, y_grid: false, x_zero_line: show_axes, y_zero_line: show_axes }}
   styles={{ show_points: false, show_lines: true }}
   controls={{ show: false }}
   fullscreen_toggle={false}
   legend={show_legend && series.length > 0
-  ? { on_toggle: toggle_band, on_double_click: isolate_band, draggable: false }
+  ? {
+    on_toggle: toggle_band,
+    on_double_click: isolate_band,
+    draggable: false,
+    // pin bottom-right so it clears the top-left title/controls overlay (e.g. in the demo)
+    style: `left: auto; top: auto; right: 8px; bottom: 8px`,
+  }
   : null}
   padding={{ t: 5, b: 5, l: 5, r: 5 }}
   class="fermi-slice {rest.class ?? ``}"
@@ -177,12 +185,12 @@
   :global(.fermi-slice .zero-line) {
     display: none;
   }
-  :global(.fermi-axis) {
+  .fermi-axis {
     stroke: var(--fermi-surface-axis-color, #888);
     stroke-dasharray: 4, 4;
     stroke-width: 1;
   }
-  :global(.fermi-label) {
+  .fermi-label {
     fill: var(--fermi-surface-axis-color, #888);
     font: 12px system-ui, sans-serif;
   }

package/dist/fermi-surface/FermiSurface.svelte

@@ -24,6 +24,7 @@
   import FermiSurfaceScene from './FermiSurfaceScene.svelte'
   import FermiSurfaceTooltip from './FermiSurfaceTooltip.svelte'
   import { parse_fermi_file } from './parse'
+  import { to_error } from '../utils'
   import type {
     BandGridData,
     ColorProperty,
@@ -202,7 +203,7 @@
       await parse_fermi_content(content, filename)
     } catch (err) {
       error_msg = `Failed to parse ${filename}: ${
-        err instanceof Error ? err.message : err
+        to_error(err).message
       }`
       on_error?.({ error_msg, filename })
     }
@@ -263,7 +264,7 @@
       await export_scene(scene, format, current_filename || `fermi-surface`)
     } catch (err) {
       console.error(`Export failed:`, err)
-      error_msg = `Export failed: ${err instanceof Error ? err.message : err}`
+      error_msg = `Export failed: ${to_error(err).message}`
     }
   }
 
@@ -284,7 +285,7 @@
     try {
       bz_data = compute_brillouin_zone(k_lattice, 1)
     } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err)
+      const msg = to_error(err).message
       console.warn(`BZ computation failed:`, msg)
       bz_data = undefined
       // Only report error for structure-derived lattice (user-provided data)
@@ -313,7 +314,7 @@
       load_from_url(data_url, safe_parse)
         .catch((err) => {
           if (current_load_id !== load_id) return // stale request
-          error_msg = err instanceof Error ? err.message : String(err)
+          error_msg = to_error(err).message
           on_error?.({ error_msg, filename: data_url })
         })
         .finally(() => {
@@ -401,7 +402,12 @@
       {...spinner_props}
     />
   {:else if error_msg}
-    <StatusMessage bind:message={error_msg} type="error" dismissible />
+    <StatusMessage
+      bind:message={error_msg}
+      type="error"
+      dismissible
+      style="position: absolute; top: 50%; left: 50%; transform: translate(-50%, -50%); max-width: 90%; text-align: center"
+    />
   {:else if fermi_data || band_data}
     <section
       class="control-buttons {controls_config.class}"

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

@@ -78,6 +78,6 @@ type $$ComponentProps = {
     }]> | FermiTooltipConfig;
     on_hover?: (data: FermiHoverData | null) => void;
 } & HTMLAttributes<HTMLDivElement>;
-declare const FermiSurface: import("svelte").Component<$$ComponentProps, {}, "height" | "width" | "dragover" | "loading" | "fullscreen" | "hovered" | "controls_open" | "camera_projection" | "color_scale" | "wrapper" | "error_msg" | "surface_opacity" | "show_vectors" | "bz_data" | "mu" | "selected_bands" | "interpolation_factor" | "fermi_data" | "band_data" | "color_property" | "representation" | "show_bz" | "bz_opacity" | "tile_bz" | "clip_enabled" | "clip_axis" | "clip_position" | "clip_flip">;
+declare const FermiSurface: import("svelte").Component<$$ComponentProps, {}, "dragover" | "height" | "width" | "fullscreen" | "hovered" | "controls_open" | "loading" | "camera_projection" | "color_scale" | "wrapper" | "error_msg" | "surface_opacity" | "show_vectors" | "bz_data" | "mu" | "selected_bands" | "interpolation_factor" | "fermi_data" | "band_data" | "color_property" | "representation" | "show_bz" | "bz_opacity" | "tile_bz" | "clip_enabled" | "clip_axis" | "clip_position" | "clip_flip">;
 type FermiSurface = ReturnType<typeof FermiSurface>;
 export default FermiSurface;

package/dist/fermi-surface/FermiSurfaceControls.svelte

@@ -111,7 +111,7 @@
       return
     }
     const idx = selected_bands.indexOf(band_idx)
-    if (idx >= 0) {
+    if (idx !== -1) {
       selected_bands = selected_bands.filter((band) => band !== band_idx)
     } else {
       selected_bands = [...selected_bands, band_idx].toSorted((a, b) => a - b)

package/dist/fermi-surface/FermiSurfaceScene.svelte

@@ -665,6 +665,9 @@
         vector={scaled_vec}
         color={vector_colors[idx]}
         scale={1}
+        shaft_radius={scene_size * 0.008}
+        arrow_head_radius={scene_size * 0.028}
+        arrow_head_length={-0.1}
       />
       <extras.HTML center position={label_position}>
         <span style:color={vector_colors[idx]} style:font-size="1.2em">

package/dist/fermi-surface/FermiSurfaceTooltip.svelte

@@ -1,14 +1,11 @@
 <script lang="ts">
   // Tooltip component for Fermi surface hover information
   // Displays band index, spin, k-coordinates, and optional property values
-  import { format_num, format_vec3 } from '../labels'
-  import { TooltipContent } from '../tooltip'
+  import { format_num } from '../labels'
+  import { KCoords, TooltipContent } from '../tooltip'
   import type { FermiHoverData, FermiTooltipProp } from './types'
 
-  let {
-    hover_data,
-    tooltip,
-  }: {
+  let { hover_data, tooltip }: {
     hover_data: FermiHoverData
     tooltip?: FermiTooltipProp
   } = $props()
@@ -23,18 +20,10 @@
       {/if}
     </div>
 
-    <div class="coords-section">
-      <div class="coord-row">
-        <span class="coord-label">k (Å⁻¹):</span>
-        <span class="coord-values">{format_vec3(hover_data.position_cartesian)}</span>
-      </div>
-      {#if hover_data.position_fractional}
-        <div class="coord-row">
-          <span class="coord-label">k (frac):</span>
-          <span class="coord-values">{format_vec3(hover_data.position_fractional)}</span>
-        </div>
-      {/if}
-    </div>
+    <KCoords
+      cartesian={hover_data.position_cartesian}
+      fractional={hover_data.position_fractional}
+    />
 
     {#if hover_data.property_value != null}
       <div class="property-row">
@@ -56,7 +45,7 @@
 
 <style>
   .tooltip-content {
-    max-width: var(--tooltip-max-width, 220px);
+    max-width: var(--tooltip-max-width, 250px);
   }
   .tooltip-title {
     display: flex;
@@ -78,21 +67,6 @@
     background: #377eb8;
     color: white;
   }
-  .coords-section {
-    margin: 4px 0;
-  }
-  .coord-row {
-    display: flex;
-    gap: 4px;
-    font-size: 0.9em;
-  }
-  .coord-label {
-    opacity: 0.8;
-    min-width: 55px;
-  }
-  .coord-values {
-    font-family: monospace;
-  }
   .property-row {
     margin-top: 4px;
     font-size: 0.9em;

package/dist/fermi-surface/compute.js

@@ -15,8 +15,10 @@ function catmull_rom_coeffs(t) {
     const c4 = 0.5 * (-t2 + t3);
     return [c1, c2, c3, c4];
 }
-// Tricubic interpolation with cached wrap indices and precomputed coefficients
-function tricubic_interpolate(grid, fx, fy, fz, nx, ny, nz) {
+// Tricubic interpolation with cached wrap indices and precomputed coefficients.
+// px/py/pz are the wrap periods (unique points per axis): n for periodic grids,
+// n−1 for endpoint-inclusive grids whose last point duplicates the first.
+function tricubic_interpolate(grid, fx, fy, fz, px, py, pz) {
     // Get integer and fractional parts
     const ix = Math.floor(fx);
     const iy = Math.floor(fy);
@@ -25,13 +27,10 @@ function tricubic_interpolate(grid, fx, fy, fz, nx, ny, nz) {
     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);
-    // Precompute wrapped indices (avoid modulo in inner loop)
-    const wrap_x = (v) => ((v % nx) + nx) % nx;
-    const wrap_y = (v) => ((v % ny) + ny) % ny;
-    const wrap_z = (v) => ((v % nz) + nz) % nz;
-    const wx = [wrap_x(ix - 1), wrap_x(ix), wrap_x(ix + 1), wrap_x(ix + 2)];
-    const wy = [wrap_y(iy - 1), wrap_y(iy), wrap_y(iy + 1), wrap_y(iy + 2)];
-    const wz = [wrap_z(iz - 1), wrap_z(iz), wrap_z(iz + 1), wrap_z(iz + 2)];
+    // 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((v) => period > 0 ? ((v % 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];
@@ -51,26 +50,29 @@ function tricubic_interpolate(grid, fx, fy, fz, nx, ny, nz) {
     }
     return result;
 }
-// Upsample a 3D grid using tricubic interpolation for smoother surfaces
-function upsample_grid(grid, factor) {
+// Upsample a 3D grid with tricubic interpolation, preserving the grid convention:
+// endpoint-inclusive (BXSF, point i ↔ frac i/(n−1)) vs periodic (FRMSF, i ↔ i/n).
+// Mixing conventions rescales the surface and distorts the zone boundary.
+function upsample_grid(grid, factor, periodic = false) {
     if (factor <= 1)
         return grid;
-    const nx = grid.length;
-    const ny = grid[0]?.length || 0;
-    const nz = grid[0]?.[0]?.length || 0;
-    const new_nx = Math.round(nx * factor);
-    const new_ny = Math.round(ny * factor);
-    const new_nz = Math.round(nz * factor);
-    // Precompute fractional coordinates for each axis
-    const fx_arr = new Float64Array(new_nx);
-    const fy_arr = new Float64Array(new_ny);
-    const fz_arr = new Float64Array(new_nz);
-    for (let ix = 0; ix < new_nx; ix++)
-        fx_arr[ix] = (ix / new_nx) * nx;
-    for (let iy = 0; iy < new_ny; iy++)
-        fy_arr[iy] = (iy / new_ny) * ny;
-    for (let iz = 0; iz < new_nz; iz++)
-        fz_arr[iz] = (iz / new_nz) * nz;
+    // Endpoint-inclusive grids carry one duplicated boundary sample per axis; the wrap
+    // period (count of unique points) doubles as the resampling span numerator
+    const endpoint = periodic ? 0 : 1;
+    const dims = [grid.length, grid[0]?.length || 0, grid[0]?.[0]?.length || 0];
+    const [px, py, pz] = dims.map((n) => n - endpoint);
+    const [new_nx, new_ny, new_nz] = [px, py, pz].map((p) => Math.round(p * factor) + endpoint);
+    // Map new index → source coordinate; a single-point axis (span 0) pins its lone
+    // output to source 0 to avoid 0/0 = NaN
+    const src_coords = (new_n, period) => {
+        const span = new_n - endpoint;
+        return Float64Array.from({ length: new_n }, (_, idx) => span > 0 ? (idx / span) * period : 0);
+    };
+    const [fx_arr, fy_arr, fz_arr] = [
+        [new_nx, px],
+        [new_ny, py],
+        [new_nz, pz],
+    ].map(([new_n, period]) => src_coords(new_n, period));
     // Preallocate output grid
     const new_grid = Array(new_nx);
     for (let ix = 0; ix < new_nx; ix++) {
@@ -80,7 +82,7 @@ function upsample_grid(grid, factor) {
             const fy = fy_arr[iy];
             const iz_arr = new Float64Array(new_nz);
             for (let iz = 0; iz < new_nz; iz++) {
-                iz_arr[iz] = tricubic_interpolate(grid, fx, fy, fz_arr[iz], nx, ny, nz);
+                iz_arr[iz] = tricubic_interpolate(grid, fx, fy, fz_arr[iz], px, py, pz);
             }
             // Convert Float64Array back to regular array for compatibility
             iy_arr[iy] = Array.from(iz_arr);
@@ -109,15 +111,16 @@ export function extract_fermi_surface(band_data, options = {}) {
             // Check if Fermi level intersects this band
             if (!band_intersects_fermi(raw_energies, iso_value))
                 continue;
+            // BXSF grids are endpoint-inclusive (store both equivalent k=0 and k=1 → false);
+            // FRMSF grids store k=i/n without the duplicated endpoint (→ true)
+            const periodic = band_data.periodic ?? false;
             // Apply interpolation for smoother surfaces
             const energies = interpolation_factor > 1
-                ? upsample_grid(raw_energies, interpolation_factor)
+                ? upsample_grid(raw_energies, interpolation_factor, periodic)
                 : raw_energies;
             // Extract isosurface using marching cubes
-            // Use periodic: false because BXSF grids include both endpoints (k=0 and k=1)
-            // which are equivalent due to BZ periodicity. This matches scikit-image behavior.
             const mc_result = marching_cubes(energies, iso_value, band_data.k_lattice, {
-                periodic: false,
+                periodic,
                 interpolate: true,
             });
             if (mc_result.vertices.length === 0)
@@ -137,13 +140,13 @@ export function extract_fermi_surface(band_data, options = {}) {
             total_area += isosurface.area;
             // Compute Fermi velocities if requested
             if (compute_velocities && band_data.velocities) {
-                isosurface.properties = compute_fermi_velocities(isosurface, band_data.velocities[spin_idx][band_idx], band_data.k_lattice, band_data.k_grid);
+                isosurface.properties = compute_fermi_velocities(isosurface, band_data.velocities[spin_idx][band_idx], band_data.k_lattice, band_data.k_grid, periodic);
                 isosurface.avg_velocity =
                     isosurface.properties.reduce((s, v) => s + v, 0) / isosurface.properties.length;
             }
             // Compute dimensionality if requested
             if (compute_dimensionality) {
-                const { dimensionality, orientation } = analyze_surface_topology(isosurface, null);
+                const { dimensionality, orientation } = analyze_surface_topology(isosurface, band_data.k_lattice);
                 isosurface.dimensionality = dimensionality;
                 isosurface.orientation = orientation;
             }
@@ -205,24 +208,22 @@ export function compute_surface_area(surface) {
     return total_area;
 }
 // Compute Fermi velocities at surface vertices
-function compute_fermi_velocities(surface, velocity_grid, k_lattice, k_grid) {
+function compute_fermi_velocities(surface, velocity_grid, k_lattice, k_grid, periodic = false) {
     const [nx, ny, nz] = k_grid;
     const velocities = [];
-    // Inverse of k_lattice for Cartesian to fractional conversion
-    const k_inv = math.matrix_inverse_3x3(k_lattice);
+    // Invert the marching-cubes transform cart = k_latticeᵀ·(frac − 0.5): frac =
+    // (k_latticeᵀ)⁻¹·cart + 0.5. Omitting the transpose samples wrong k-points for
+    // non-symmetric lattices; skipping the +0.5 is off by half a reciprocal cell.
+    const k_inv = math.matrix_inverse_3x3(math.transpose_3x3_matrix(k_lattice));
+    // Grid point i sits at frac i/(n−1) (endpoint-inclusive BXSF) or i/n (periodic)
+    const [sx, sy, sz] = periodic ? [nx, ny, nz] : [nx - 1, ny - 1, nz - 1];
+    // Clamp guards float jitter at the cell boundary
+    const clamp01 = (val) => Math.min(Math.max(val, 0), 1);
     for (const vertex of surface.vertices) {
-        // Convert Cartesian to fractional coordinates
-        const frac = math.mat3x3_vec3_multiply(k_inv, vertex);
-        // Wrap to [0, 1)
-        const wrapped = [
-            ((frac[0] % 1) + 1) % 1,
-            ((frac[1] % 1) + 1) % 1,
-            ((frac[2] % 1) + 1) % 1,
-        ];
-        // Grid indices (with interpolation)
-        const gx = wrapped[0] * nx;
-        const gy = wrapped[1] * ny;
-        const gz = wrapped[2] * nz;
+        const frac = math.mat3x3_vec3_multiply(k_inv, vertex); // centered, in [-0.5, 0.5]
+        const gx = clamp01(frac[0] + 0.5) * sx;
+        const gy = clamp01(frac[1] + 0.5) * sy;
+        const gz = clamp01(frac[2] + 0.5) * sz;
         // Trilinear interpolation of velocity
         const velocity = trilinear_interpolate_vec3(velocity_grid, gx, gy, gz);
         velocities.push(Math.hypot(...velocity)); // magnitude
@@ -265,14 +266,15 @@ function trilinear_interpolate_vec3(grid, x, y, z) {
     return math.lerp_vec3(c0, c1, zd);
 }
 // Analyze surface topology to determine dimensionality
-function analyze_surface_topology(surface, bz_data) {
+function analyze_surface_topology(surface, k_lattice) {
     if (surface.vertices.length === 0) {
         return { dimensionality: `3D`, orientation: null };
     }
-    // Check if surface spans the full BZ in each direction
-    const bz_extent = bz_data
-        ? math.compute_bounding_box(bz_data.vertices)
-        : { min: [-1, -1, -1], max: [1, 1, 1] };
+    // Vertices live in the centered parallelepiped k_latticeᵀ·[-0.5, 0.5]³, whose bounding
+    // box along Cartesian axis j has half-extent 0.5·Σᵢ|k_lattice[i][j]| (a hardcoded box
+    // would make dimensionality depend on the absolute lattice scale)
+    const half_extent = [0, 1, 2].map((axis_idx) => 0.5 * k_lattice.reduce((sum, row) => sum + Math.abs(row[axis_idx]), 0));
+    const bz_extent = { min: half_extent.map((ext) => -ext), max: half_extent };
     const surface_extent = math.compute_bounding_box(surface.vertices);
     // Check spanning in each direction
     const spans = [false, false, false];
@@ -301,10 +303,8 @@ function analyze_surface_topology(surface, bz_data) {
         orientation[axis_idx] = 1;
         return { dimensionality: `1D`, orientation };
     }
-    else {
-        // Spans all 3 directions - complex warped network
-        return { dimensionality: `quasi-2D`, orientation: null };
-    }
+    // Spans all 3 directions - complex warped network
+    return { dimensionality: `quasi-2D`, orientation: null };
 }
 // Compute 2D Fermi slice along a specified plane
 export function compute_fermi_slice(fermi_data, options = {}) {
@@ -319,7 +319,7 @@ export function compute_fermi_slice(fermi_data, options = {}) {
     if (normal_len < EPS) {
         throw new Error(`Degenerate plane normal: k_lattice vectors produce a zero-length normal for miller indices [${miller_indices.join(`, `)}]`);
     }
-    const unit_normal = math.normalize_vec3(plane_normal);
+    const unit_normal = math.normalize_vec(plane_normal);
     // Compute in-plane basis vectors
     const [in_plane_u, in_plane_v] = math.compute_in_plane_basis(unit_normal);
     // Slice each isosurface

package/dist/fermi-surface/export.js

@@ -1,3 +1,4 @@
+import { to_error } from '../utils';
 // Helper to trigger file download
 function download_file(content, filename, mime_type) {
     const blob = new Blob([content], { type: mime_type });
@@ -5,7 +6,7 @@ function download_file(content, filename, mime_type) {
     const link = document.createElement(`a`);
     link.href = url;
     link.download = filename;
-    document.body.appendChild(link);
+    document.body.append(link);
     link.click();
     document.body.removeChild(link);
     URL.revokeObjectURL(url);
@@ -35,7 +36,7 @@ export async function export_to_gltf(scene, filename) {
             const output = JSON.stringify(gltf, null, 2);
             download_file(output, `${filename}.gltf`, `application/json`);
             resolve();
-        }, (error) => reject(error), { binary: false });
+        }, (error) => reject(to_error(error)), { binary: false });
     });
 }
 // Main export function that dispatches to the appropriate format

package/dist/fermi-surface/parse.js

@@ -2,7 +2,7 @@ import * as constants from './constants';
 import { compute_vertex_normals } from './marching-cubes';
 const parse_number_tokens = (line) => line.split(/\s+/).filter(Boolean);
 // Parse whitespace-separated floats from a line (optimized with unary +)
-const parse_floats = (line) => parse_number_tokens(line).map((part) => +part);
+const parse_floats = (line) => parse_number_tokens(line).map(Number);
 // Parse whitespace-separated integers from a line
 const parse_ints = (line) => parse_number_tokens(line).map((part) => parseInt(part, 10));
 // Parse BXSF (Band-XSF) format used by XCrySDen, Quantum ESPRESSO, etc.
@@ -219,6 +219,7 @@ function parse_frmsf(content) {
         fermi_energy: 0, // FRMSF typically expects Fermi level at 0
         n_bands,
         n_spins,
+        periodic: true, // FRMSF stores k=i/n with no duplicated endpoint (unlike BXSF)
     };
 }
 // Validate that an object has the required Isosurface shape
@@ -306,8 +307,10 @@ function parse_fermi_json(content) {
             k_grid: bs.k_grid ?? bs.kgrid,
             k_lattice: bs.k_lattice ?? bs.reciprocal_lattice,
             fermi_energy: bs.fermi_energy ?? bs.efermi ?? 0,
-            n_bands: bs.n_bands || bs.nbands || bs.energies[0]?.length || 0,
-            n_spins: bs.n_spins || bs.nspins || bs.energies.length || 1,
+            // oxlint-disable-next-line @typescript-eslint/prefer-nullish-coalescing -- numeric fallback chain (0 falls through)
+            n_bands: (bs.n_bands ?? bs.nbands) || bs.energies[0]?.length || 0,
+            // oxlint-disable-next-line @typescript-eslint/prefer-nullish-coalescing -- numeric fallback chain (0 falls through)
+            n_spins: (bs.n_spins ?? bs.nspins) || bs.energies.length || 1,
         };
     }
     // Check for pymatgen BandStructure format (k-path, not k-grid)
@@ -426,7 +429,7 @@ function parse_ifermi_surface(data) {
 }
 // Auto-detect file format and parse accordingly
 export function parse_fermi_file(content, filename) {
-    const lower_name = filename?.toLowerCase() || ``;
+    const lower_name = filename?.toLowerCase() ?? ``;
     // Detect by filename extension
     if (lower_name.endsWith(`.bxsf`) || lower_name.endsWith(`.bxsf.gz`)) {
         try {

package/dist/fermi-surface/types.d.ts

@@ -48,6 +48,7 @@ export interface BandGridData {
     n_bands: number;
     n_spins: number;
     origin?: Vec3;
+    periodic?: boolean;
 }
 export interface FermiSliceData {
     isolines: Isoline[];

package/dist/heatmap-matrix/HeatmapMatrix.svelte

@@ -3,7 +3,7 @@
   import { is_color, pick_contrast_color } from '../colors'
   import { format_num } from '../labels'
   import type { AxisConfig } from '../plot'
-  import ColorBar from '../plot/ColorBar.svelte'
+  import ColorBar from '../plot/core/components/ColorBar.svelte'
   import { make_change_detector } from '../utils'
   import * as d3_sc from 'd3-scale-chromatic'
   import { type ComponentProps, onDestroy, onMount, type Snippet } from 'svelte'
@@ -334,7 +334,7 @@
   }
 
   function get_quantile(sorted_values: number[], quantile: number): number {
-    if (!sorted_values.length) return 0
+    if (sorted_values.length === 0) return 0
     const clipped_quantile = Math.max(0, Math.min(1, quantile))
     const float_idx = (sorted_values.length - 1) * clipped_quantile
     const low_idx = Math.floor(float_idx)
@@ -358,18 +358,22 @@
     return numeric_values
   })
 
-  // Single-pass min/max to avoid spreading large arrays into Math.min/max
-  let [auto_min, auto_max] = $derived.by(() => {
-    let [min, max] = [Infinity, -Infinity]
+  // Single-pass min/max to avoid spreading large arrays into Math.min/max. min_pos is
+  // the log-mode lower bound when the domain min is <= 0 (the old Number.MIN_VALUE
+  // floor gave log_min ~ -744, squashing all colors to the top)
+  let [auto_min, auto_max, min_pos] = $derived.by(() => {
+    let [min, max, pos] = [Infinity, -Infinity, Infinity]
     for (const value of valid_numeric_values) {
       if (value < min) min = value
       if (value > max) max = value
+      if (value > 0 && value < pos) pos = value
     }
-    return min <= max ? [min, max] as const : [0, 1] as const
+    const min_pos_val = Number.isFinite(pos) ? pos : null
+    return min <= max ? [min, max, min_pos_val] as const : [0, 1, min_pos_val] as const
   })
 
   let [robust_min, robust_max] = $derived.by(() => {
-    if (!valid_numeric_values.length) return [0, 1] as const
+    if (valid_numeric_values.length === 0) return [0, 1] as const
     const sorted_values = valid_numeric_values.toSorted((value_a, value_b) =>
       value_a - value_b
     )
@@ -418,7 +422,7 @@
       const lower_bound = Math.min(cs_min, cs_max)
       const upper_bound = Math.max(cs_min, cs_max)
       if (upper_bound <= 0) return missing_color || null
-      const safe_lower_bound = Math.max(lower_bound, Number.MIN_VALUE)
+      const safe_lower_bound = lower_bound > 0 ? lower_bound : (min_pos ?? upper_bound)
       const safe_value = Math.max(val, safe_lower_bound)
       const log_min = Math.log(safe_lower_bound)
       const log_max = Math.log(upper_bound)
@@ -460,7 +464,7 @@
     return colors
   })
 
-  const to_contrast_colors = (bg_values: Array<string | null>): Array<string | null> =>
+  const to_contrast_colors = (bg_values: (string | null)[]): (string | null)[] =>
     bg_values.map((bg_color) =>
       bg_color ? pick_contrast_color({ bg_color }) : null
     )
@@ -481,16 +485,14 @@
     bg_flat[get_flat_idx(x_idx, y_idx)]
 
   // === Cell context builder (only called for clicks, not per-hover) ===
-  function build_cell_context(x_idx: number, y_idx: number): CellContext {
-    return {
-      x_item: x_items[x_idx],
-      y_item: y_items[y_idx],
-      x_idx,
-      y_idx,
-      value: get_value(x_idx, y_idx),
-      bg_color: get_bg(x_idx, y_idx),
-    }
-  }
+  const build_cell_context = (x_idx: number, y_idx: number): CellContext => ({
+    x_item: x_items[x_idx],
+    y_item: y_items[y_idx],
+    x_idx,
+    y_idx,
+    value: get_value(x_idx, y_idx),
+    bg_color: get_bg(x_idx, y_idx),
+  })
 
   // === Fully imperative hover management ===
   // ZERO $state writes during mouseover — all DOM updates are direct.
@@ -777,7 +779,7 @@
       cell_pos_key(pos.x_idx, pos.y_idx) === clicked_key
     )
     const toggle_mode = selection_mode === `multi` && (event.metaKey || event.ctrlKey)
-    if (existing_idx >= 0 && toggle_mode) next_cells.splice(existing_idx, 1)
+    if (existing_idx !== -1 && toggle_mode) next_cells.splice(existing_idx, 1)
     else if (selection_mode === `multi` && toggle_mode) next_cells.push(clicked_cell)
     else next_cells.splice(0, next_cells.length, clicked_cell)
     selected_cells = next_cells
@@ -1012,7 +1014,7 @@
   }
 
   function compute_summary(summary_values: number[]): number | null {
-    if (!summary_values.length) return null
+    if (summary_values.length === 0) return null
     if (summary_fn) return summary_fn(summary_values)
     const total = summary_values.reduce((sum, value) => sum + value, 0)
     return total / summary_values.length

package/dist/heatmap-matrix/index.js

@@ -40,7 +40,7 @@ function escape_csv_field(value) {
     return `"${field.replaceAll(`"`, `""`)}"`;
 }
 export function rows_to_csv(rows) {
-    if (!rows.length)
+    if (rows.length === 0)
         return ``;
     const headers = Object.keys(rows[0]);
     const lines = [