matterviz 0.3.6 → 0.3.7

package/dist/src/lib/fermi-surface/constants.ts

@@ -1,32 +0,0 @@
-// Constants and thresholds for Fermi surface computation
-
-// Maximum triangles for BZ symmetry tiling (48x for Oh symmetry)
-// Above this, tiling is auto-disabled for performance
-export const MAX_TRIANGLES_FOR_TILING = 50_000
-
-// Throttle interval (ms) for pointer move events during hover
-// Prevents expensive nearest-vertex O(n) lookups from causing UI jank
-export const HOVER_THROTTLE_MS = 16 // ~60fps
-
-// Numerical tolerances
-export const CLOSED_CONTOUR_TOLERANCE = 1e-6 // Distance threshold for detecting closed contours
-export const IRREDUCIBLE_BZ_TOLERANCE = 0.01 // Threshold for detecting irreducible BZ (vertices in positive octant)
-export const IRREDUCIBLE_BZ_MIN_VERTICES = 10 // Minimum significant vertex count for irreducible BZ detection
-
-export const SPANNING_THRESHOLD = 0.8 // Fraction of BZ extent a surface must cover to be considered "spanning" that direction
-export const BOHR_TO_ANGSTROM = 0.529177 // 1 Bohr = 0.529177 Angstrom
-export const HARTREE_TO_EV = 27.2114 // 1 Hartree = 27.2114 eV
-
-// Band colors (ColorBrewer Set1 palette for categorical data)
-export const BAND_COLORS = [
-  `#e41a1c`, // red
-  `#377eb8`, // blue
-  `#4daf4a`, // green
-  `#984ea3`, // purple
-  `#ff7f00`, // orange
-  `#ffff33`, // yellow
-  `#a65628`, // brown
-  `#f781bf`, // pink
-  `#999999`, // gray
-  `#66c2a5`, // teal
-] as const

package/dist/src/lib/fermi-surface/export.ts

@@ -1,64 +0,0 @@
-// Export Fermi surface to various 3D formats
-import type { Scene } from 'three'
-
-// Helper to trigger file download
-function download_file(content: string | ArrayBuffer, filename: string, mime_type: string) {
-  const blob = new Blob([content], { type: mime_type })
-  const url = URL.createObjectURL(blob)
-  const link = document.createElement(`a`)
-  link.href = url
-  link.download = filename
-  document.body.appendChild(link)
-  link.click()
-  document.body.removeChild(link)
-  URL.revokeObjectURL(url)
-}
-
-// Export scene to STL format (good for 3D printing)
-export async function export_to_stl(scene: Scene, filename: string): Promise<void> {
-  const { STLExporter } = await import(`three/addons/exporters/STLExporter.js`)
-  const exporter = new STLExporter()
-  const result = exporter.parse(scene, { binary: true })
-  // Binary STL returns DataView, convert to ArrayBuffer for Blob
-  const buffer = result instanceof DataView ? result.buffer : result
-  download_file(buffer, `${filename}.stl`, `application/octet-stream`)
-}
-
-// Export scene to OBJ format (widely compatible)
-export async function export_to_obj(scene: Scene, filename: string): Promise<void> {
-  const { OBJExporter } = await import(`three/addons/exporters/OBJExporter.js`)
-  const exporter = new OBJExporter()
-  const result = exporter.parse(scene)
-  download_file(result, `${filename}.obj`, `text/plain`)
-}
-
-// Export scene to GLTF format (modern web/AR standard)
-export async function export_to_gltf(scene: Scene, filename: string): Promise<void> {
-  const { GLTFExporter } = await import(`three/addons/exporters/GLTFExporter.js`)
-  const exporter = new GLTFExporter()
-
-  return new Promise((resolve, reject) => {
-    exporter.parse(
-      scene,
-      (gltf) => {
-        const output = JSON.stringify(gltf, null, 2)
-        download_file(output, `${filename}.gltf`, `application/json`)
-        resolve()
-      },
-      (error) => reject(error),
-      { binary: false },
-    )
-  })
-}
-
-// Main export function that dispatches to the appropriate format
-export function export_scene(
-  scene: Scene,
-  format: `stl` | `obj` | `gltf`,
-  filename: string,
-): Promise<void> {
-  if (format === `stl`) return export_to_stl(scene, filename)
-  if (format === `obj`) return export_to_obj(scene, filename)
-  if (format === `gltf`) return export_to_gltf(scene, filename)
-  return Promise.reject(new Error(`Unsupported export format: ${format}`))
-}

package/dist/src/lib/fermi-surface/index.ts

@@ -1,14 +0,0 @@
-// Fermi surface visualization module
-export { default as FermiSlice } from './FermiSlice.svelte'
-export { default as FermiSurface } from './FermiSurface.svelte'
-export { default as FermiSurfaceControls } from './FermiSurfaceControls.svelte'
-export { default as FermiSurfaceScene } from './FermiSurfaceScene.svelte'
-export { default as FermiSurfaceTooltip } from './FermiSurfaceTooltip.svelte'
-
-export * from './compute'
-export * from './constants'
-export * from './export'
-export * from './marching-cubes'
-export * from './parse'
-export * from './symmetry'
-export * from './types'

package/dist/src/lib/fermi-surface/marching-cubes.ts

@@ -1,3 +0,0 @@
-// Re-export from shared location for backward compatibility
-export { compute_vertex_normals, marching_cubes } from '$lib/marching-cubes'
-export type { MarchingCubesOptions, MarchingCubesResult } from '$lib/marching-cubes'

package/dist/src/lib/fermi-surface/parse.ts

@@ -1,574 +0,0 @@
-// Parsers for Fermi surface file formats (BXSF, FRMSF, JSON)
-import type { Matrix3x3, Vec3 } from '$lib/math'
-import * as constants from './constants'
-import { compute_vertex_normals } from './marching-cubes'
-import type {
-  BandGridData,
-  EnergyGrid5D,
-  FermiSurfaceData,
-  Isosurface,
-  SpinChannel,
-  SurfaceDimensionality,
-} from './types'
-
-const parse_number_tokens = (line: string): string[] => line.split(/\s+/).filter(Boolean)
-
-// Parse whitespace-separated floats from a line (optimized with unary +)
-const parse_floats = (line: string): number[] => parse_number_tokens(line).map((part) => +part)
-
-// Parse whitespace-separated integers from a line
-const parse_ints = (line: string): number[] =>
-  parse_number_tokens(line).map((part) => parseInt(part, 10))
-
-// Parse BXSF (Band-XSF) format used by XCrySDen, Quantum ESPRESSO, etc.
-// Format specification: http://www.xcrysden.org/doc/XSF.html
-function parse_bxsf(content: string): BandGridData {
-  const lines = content.split(/\r?\n/).map((line) => line.trim())
-  let line_idx = 0
-
-  // Helper to get next non-empty, non-comment line
-  const next_line = (): string => {
-    while (line_idx < lines.length) {
-      const line = lines[line_idx++]
-      if (line && !line.startsWith(`#`)) return line
-    }
-    throw new Error(`Unexpected end of BXSF file`)
-  }
-
-  // Find BEGIN_BLOCK_BANDGRID_3D
-  while (line_idx < lines.length) {
-    if (lines[line_idx].includes(`BEGIN_BLOCK_BANDGRID_3D`)) {
-      line_idx++
-      break
-    }
-    line_idx++
-  }
-  if (line_idx >= lines.length) {
-    throw new Error(`BXSF file missing BEGIN_BLOCK_BANDGRID_3D`)
-  }
-
-  // Skip block identifier line (e.g. "band_energies")
-  next_line()
-
-  // Parse BEGIN_BANDGRID_3D or BANDGRID_3D_BANDS (both variants exist)
-  const bandgrid_line = next_line()
-  if (!bandgrid_line.includes(`BANDGRID_3D`)) {
-    throw new Error(`Expected BANDGRID_3D header, got: ${bandgrid_line}`)
-  }
-
-  // Parse number of bands
-  const n_bands = parseInt(next_line(), 10)
-  if (isNaN(n_bands) || n_bands <= 0) {
-    throw new Error(`Invalid number of bands in BXSF file`)
-  }
-
-  // Parse grid dimensions (nx ny nz)
-  const grid_dims = parse_ints(next_line())
-  if (grid_dims.length !== 3) {
-    throw new Error(`Expected 3 grid dimensions, got ${grid_dims.length}`)
-  }
-  const k_grid: Vec3 = [grid_dims[0], grid_dims[1], grid_dims[2]]
-
-  // Parse origin
-  const origin_vals = parse_floats(next_line())
-  if (origin_vals.length !== 3) {
-    throw new Error(`Expected 3 origin values, got ${origin_vals.length}`)
-  }
-  const origin: Vec3 = [origin_vals[0], origin_vals[1], origin_vals[2]]
-
-  // Parse 3 spanning vectors (reciprocal lattice)
-  const spanning_vectors: Matrix3x3 = [
-    parse_floats(next_line()).slice(0, 3) as Vec3,
-    parse_floats(next_line()).slice(0, 3) as Vec3,
-    parse_floats(next_line()).slice(0, 3) as Vec3,
-  ]
-
-  // Validate spanning vectors
-  for (const vec of spanning_vectors) {
-    if (vec.length !== 3 || vec.some(isNaN)) {
-      throw new Error(`Invalid spanning vector in BXSF file`)
-    }
-  }
-
-  // Parse band data
-  // Format: BAND: band_number followed by energy values on grid
-  const energies: EnergyGrid5D = [[]] // [spin=1][band][kx][ky][kz]
-  const [nx, ny, nz] = k_grid
-  const total_points = nx * ny * nz
-
-  for (let band_idx = 0; band_idx < n_bands; band_idx++) {
-    // Find BAND: line
-    let band_line = next_line()
-    while (!band_line.startsWith(`BAND:`)) {
-      band_line = next_line()
-    }
-
-    // Read energy values for this band
-    const energy_values: number[] = []
-    while (energy_values.length < total_points) {
-      const line = next_line()
-      if (line.startsWith(`END_BANDGRID`) || line.startsWith(`BAND:`)) {
-        // Unread this line: after next_line() returns, line_idx points past the
-        // returned line, so decrementing by 1 restores to the line just read
-        line_idx--
-        break
-      }
-      energy_values.push(...parse_floats(line))
-    }
-
-    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: number[][][] = Array(nx)
-    let val_idx = 0
-    for (let ix = 0; ix < nx; ix++) {
-      const iy_arr: number[][] = 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
-    }
-    energies[0].push(band_grid)
-  }
-
-  // Try to find Fermi energy (often in a comment or as FERMI_ENERGY keyword)
-  let fermi_energy = 0
-  for (const line of lines) {
-    const lower = line.toLowerCase()
-    if (lower.includes(`fermi`) && lower.includes(`energy`)) {
-      // Match patterns like "Fermi Energy = 5.123" or "fermi_energy: -0.5"
-      const match = /(?:=|:)\s*([-+]?\d*\.?\d+(?:[eE][-+]?\d+)?)/i.exec(line)
-      if (match) {
-        fermi_energy = parseFloat(match[1])
-        break
-      }
-    }
-  }
-
-  return {
-    energies,
-    k_grid,
-    k_lattice: spanning_vectors,
-    fermi_energy,
-    n_bands,
-    n_spins: 1,
-    origin,
-  }
-}
-
-// Parse FRMSF format used by FermiSurfer
-// Format: https://mitsuaki1987.github.io/fermisurfer/en/_build/html/ops.html
-function parse_frmsf(content: string): BandGridData {
-  const lines = content
-    .split(/\r?\n/)
-    .map((line) => line.trim())
-    .filter(Boolean)
-  let line_idx = 0
-
-  // Line 1: grid dimensions (ng[0] ng[1] ng[2])
-  const grid_dims = parse_ints(lines[line_idx++])
-  if (grid_dims.length !== 3) {
-    throw new Error(`FRMSF: Expected 3 grid dimensions`)
-  }
-  const k_grid: Vec3 = [grid_dims[0], grid_dims[1], grid_dims[2]]
-
-  // Line 2: lshift (grid shift type)
-  // 0 = Monkhorst-Pack grid (shifted)
-  // 1 = Gamma-centered grid
-  // 2 = Gamma + half grid shift
-  const lshift = parseInt(lines[line_idx++], 10)
-  if (isNaN(lshift) || lshift < 0 || lshift > 2) {
-    throw new Error(`FRMSF: Invalid lshift value (expected 0, 1, or 2)`)
-  }
-
-  // Line 3: number of bands
-  const n_bands = parseInt(lines[line_idx++], 10)
-  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: Matrix3x3 = [
-    parse_floats(lines[line_idx++])
-      .slice(0, 3)
-      .map((val) => val * inv_bohr) as Vec3,
-    parse_floats(lines[line_idx++])
-      .slice(0, 3)
-      .map((val) => val * inv_bohr) as Vec3,
-    parse_floats(lines[line_idx++])
-      .slice(0, 3)
-      .map((val) => val * inv_bohr) as Vec3,
-  ]
-
-  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: EnergyGrid5D = []
-  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: number[] = []
-
-      // Read energy values (first value per line only, ignore auxiliary columns)
-      while (energy_values.length < total_points && line_idx < lines.length) {
-        const line = lines[line_idx]
-        const first_token = line?.split(/\s+/)[0]
-        if (first_token && !isNaN(parseFloat(first_token))) {
-          energy_values.push(parseFloat(first_token))
-          line_idx++
-        } else {
-          break
-        }
-      }
-
-      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: number[][][] = []
-      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)
-    }
-  }
-
-  return {
-    energies,
-    k_grid,
-    k_lattice,
-    fermi_energy: 0, // FRMSF typically expects Fermi level at 0
-    n_bands,
-    n_spins,
-  }
-}
-
-// Validate that an object has the required Isosurface shape
-function is_valid_isosurface(obj: unknown): obj is Isosurface {
-  if (!obj || typeof obj !== `object`) return false
-  const isosurface_obj = obj as Record<string, unknown>
-  const vertices = isosurface_obj.vertices
-  const faces = isosurface_obj.faces
-  const normals = isosurface_obj.normals
-  const band_index = isosurface_obj.band_index
-  const spin = isosurface_obj.spin
-
-  if (!Array.isArray(vertices) || vertices.length === 0) return false
-  if (!Array.isArray(faces)) return false
-  if (!Array.isArray(normals)) return false
-  if (typeof band_index !== `number` || !Number.isFinite(band_index)) return false
-  if (spin !== null && spin !== `up` && spin !== `down`) return false
-
-  return true
-}
-
-// Validate FermiSurfaceData shape
-function is_valid_fermi_surface_data(obj: unknown): obj is FermiSurfaceData {
-  if (!obj || typeof obj !== `object`) return false
-  const data = obj as Record<string, unknown>
-
-  // Check required fields
-  if (!Array.isArray(data.isosurfaces)) return false
-  if (!Array.isArray(data.k_lattice) || data.k_lattice.length !== 3) return false
-  if (typeof data.fermi_energy !== `number`) return false
-  if (data.reciprocal_cell !== `wigner_seitz` && data.reciprocal_cell !== `parallelepiped`) {
-    return false
-  }
-  if (!data.metadata || typeof data.metadata !== `object`) return false
-
-  // Validate each isosurface
-  for (const iso of data.isosurfaces) {
-    if (!is_valid_isosurface(iso)) return false
-  }
-
-  return true
-}
-
-// Parse Matterviz/IFermi JSON format for Fermi surface data
-// Throws on invalid input; returns parsed data on success
-function parse_fermi_json(content: string): FermiSurfaceData | BandGridData {
-  const data = JSON.parse(content)
-
-  // Check if it's already in our FermiSurfaceData format with full validation
-  if (data.isosurfaces && Array.isArray(data.isosurfaces)) {
-    if (is_valid_fermi_surface_data(data)) {
-      return data
-    }
-    throw new Error(
-      `Invalid FermiSurfaceData JSON: isosurfaces array present but missing required fields`,
-    )
-  }
-
-  // Check if it's IFermi format (isosurfaces is an object keyed by band index)
-  if (
-    data[`@class`] === `FermiSurface` &&
-    data.isosurfaces &&
-    typeof data.isosurfaces === `object`
-  ) {
-    return parse_ifermi_surface(data)
-  }
-
-  // Check if it's BandGridData (raw grid data)
-  if (data.energies && data.k_grid && data.k_lattice) {
-    // Minimal validation of required fields
-    if (
-      !Array.isArray(data.energies) ||
-      !Array.isArray(data.k_grid) ||
-      data.k_grid.length !== 3 ||
-      !Array.isArray(data.k_lattice) ||
-      data.k_lattice.length !== 3
-    )
-      throw new Error(`Invalid BandGridData JSON: malformed required fields`)
-    return data as BandGridData
-  }
-
-  // Try to extract from nested structure (e.g. IFermi output)
-  if (data.fermi_surface) {
-    return data.fermi_surface as FermiSurfaceData
-  }
-
-  if (data.band_structure?.energies || data.bands?.energies) {
-    const bs = data.band_structure ?? data.bands
-    return {
-      energies: bs.energies,
-      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,
-    } as BandGridData
-  }
-
-  // Check for pymatgen BandStructure format (k-path, not k-grid)
-  // These files cannot be used for Fermi surface visualization directly
-  if (data.bs?.[`@class`] === `BandStructure` || data[`@class`] === `BandStructure`) {
-    throw new Error(
-      `This is a pymatgen BandStructure file (band data along k-path). ` +
-        `Fermi surface visualization requires a uniform 3D k-grid of eigenvalues. ` +
-        `Use IFermi or a BXSF/FRMSF file instead.`,
-    )
-  }
-
-  throw new Error(`Unrecognized JSON format: missing required fields for Fermi surface data`)
-}
-
-// Helper type for IFermi Isosurface format
-interface IFermiIsosurface {
-  vertices: number[][]
-  faces: number[][]
-  band_idx: number
-  properties?: Record<string, number[]>
-  dimensionality?: string
-  orientation?: number[] | null
-}
-
-// Parse IFermi's JSON output format
-function parse_ifermi_surface(data: Record<string, unknown>): FermiSurfaceData {
-  const isosurfaces_obj = data.isosurfaces as Record<string, IFermiIsosurface[]>
-  const reciprocal_space = data.reciprocal_space as
-    | {
-        reciprocal_lattice?: number[][]
-        vertices?: number[][]
-        faces?: number[][]
-      }
-    | undefined
-
-  // Extract reciprocal lattice
-  const k_lattice: Matrix3x3 = reciprocal_space?.reciprocal_lattice
-    ? (reciprocal_space.reciprocal_lattice as Matrix3x3)
-    : [
-        [1, 0, 0],
-        [0, 1, 0],
-        [0, 0, 1],
-      ]
-
-  // Convert IFermi isosurfaces to our format
-  const isosurfaces: Isosurface[] = []
-  const band_indices = new Set<number>()
-  let has_spin = false
-
-  for (const [band_key, iso_list] of Object.entries(isosurfaces_obj)) {
-    const band_index = parseInt(band_key, 10)
-    // spin is determined by sign: positive = up, negative = down
-    const spin: SpinChannel = band_index < 0 ? `down` : `up`
-    const abs_band_idx = Math.abs(band_index)
-    band_indices.add(abs_band_idx)
-    if (band_index < 0) has_spin = true
-
-    for (const ifermi_iso of iso_list) {
-      const vertices = ifermi_iso.vertices as Vec3[]
-      const faces = ifermi_iso.faces
-
-      // Compute vertex normals from faces
-      const normals = compute_vertex_normals(vertices, faces)
-
-      // Extract properties if available
-      let properties: number[] | undefined
-      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]]
-        }
-      }
-
-      // Parse dimensionality
-      let dimensionality: SurfaceDimensionality | undefined
-      if (ifermi_iso.dimensionality) {
-        const dim = ifermi_iso.dimensionality.toLowerCase()
-        if (dim.includes(`1d`) || dim === `1d`) dimensionality = `1D`
-        else if (dim.includes(`quasi`) || dim === `quasi-2d`) dimensionality = `quasi-2D`
-        else if (dim.includes(`2d`) || dim === `2d`) dimensionality = `2D`
-        else if (dim.includes(`3d`) || dim === `3d`) dimensionality = `3D`
-      }
-
-      // Compute area for this isosurface using fan triangulation for N-gons
-      let area = 0
-      for (const face of faces) {
-        if (face.length < 3) continue
-        // Validate face indices are within bounds to prevent NaN from undefined vertices
-        if (face.some((idx) => idx < 0 || idx >= vertices.length)) continue
-        // Fan triangulation: for N vertices, create N-2 triangles (0,1,2), (0,2,3), ...
-        const v0 = vertices[face[0]]
-        for (let fan_idx = 1; fan_idx < face.length - 1; fan_idx++) {
-          const v1 = vertices[face[fan_idx]]
-          const v2 = vertices[face[fan_idx + 1]]
-          const e1: Vec3 = [v1[0] - v0[0], v1[1] - v0[1], v1[2] - v0[2]]
-          const e2: Vec3 = [v2[0] - v0[0], v2[1] - v0[1], v2[2] - v0[2]]
-          const cross: Vec3 = [
-            e1[1] * e2[2] - e1[2] * e2[1],
-            e1[2] * e2[0] - e1[0] * e2[2],
-            e1[0] * e2[1] - e1[1] * e2[0],
-          ]
-          area += 0.5 * Math.hypot(cross[0], cross[1], cross[2])
-        }
-      }
-
-      isosurfaces.push({
-        vertices,
-        faces,
-        normals,
-        properties,
-        band_index: abs_band_idx,
-        spin,
-        area,
-        dimensionality,
-        orientation: ifermi_iso.orientation as Vec3 | null,
-      })
-    }
-  }
-
-  // Compute total surface area
-  const total_area = isosurfaces.reduce((sum, iso) => sum + (iso.area ?? 0), 0)
-
-  return {
-    isosurfaces,
-    k_lattice,
-    fermi_energy: 0, // IFermi surfaces are typically relative to Fermi level
-    reciprocal_cell: `wigner_seitz`, // IFermi typically uses Wigner-Seitz cells
-    metadata: {
-      n_bands: band_indices.size,
-      n_surfaces: isosurfaces.length,
-      total_area,
-      source_format: `ifermi-json`,
-      has_spin,
-      has_velocities: isosurfaces.some((iso) => iso.properties !== undefined),
-    },
-  }
-}
-
-// Auto-detect file format and parse accordingly
-export function parse_fermi_file(
-  content: string,
-  filename?: string,
-): BandGridData | FermiSurfaceData | null {
-  const lower_name = filename?.toLowerCase() || ``
-
-  // Detect by filename extension
-  if (lower_name.endsWith(`.bxsf`) || lower_name.endsWith(`.bxsf.gz`)) {
-    try {
-      return parse_bxsf(content)
-    } catch (error) {
-      console.error(`BXSF parse error:`, error)
-      return null
-    }
-  }
-
-  if (lower_name.endsWith(`.frmsf`) || lower_name.endsWith(`.frmsf.gz`)) {
-    try {
-      return parse_frmsf(content)
-    } catch (error) {
-      console.error(`FRMSF parse error:`, error)
-      return null
-    }
-  }
-
-  if (lower_name.endsWith(`.json`) || lower_name.endsWith(`.json.gz`)) {
-    try {
-      return parse_fermi_json(content)
-    } catch (error) {
-      console.error(`JSON parse error:`, error)
-      return null
-    }
-  }
-
-  // Try auto-detection based on content
-  const trimmed = content.trim()
-
-  // BXSF format detection
-  if (trimmed.includes(`BEGIN_BLOCK_BANDGRID_3D`) || trimmed.includes(`BEGIN_BANDGRID_3D`)) {
-    try {
-      return parse_bxsf(content)
-    } catch (error) {
-      console.error(`BXSF auto-detect parse error:`, error)
-    }
-  }
-
-  // JSON format detection
-  if (trimmed.startsWith(`{`) || trimmed.startsWith(`[`)) {
-    try {
-      return parse_fermi_json(content)
-    } catch (error) {
-      console.error(`JSON auto-detect parse error:`, error)
-    }
-  }
-
-  // FRMSF format detection (starts with grid dimensions)
-  const first_line = trimmed.split(/\r?\n/)[0]
-  const first_tokens = first_line.split(/\s+/).filter(Boolean)
-  if (first_tokens.length === 3 && first_tokens.every((token) => /^\d+$/.test(token))) {
-    try {
-      return parse_frmsf(content)
-    } catch (error) {
-      console.error(`FRMSF auto-detect parse error:`, error)
-    }
-  }
-
-  console.warn(`Could not detect Fermi surface file format for: ${filename}`)
-  return null
-}