matterviz 0.3.5 → 0.3.7

package/dist/convex-hull/helpers.js

@@ -16,12 +16,15 @@ export function compute_hull_stability(raw_distance, exclude_from_hull, tol = HU
     const e_above_hull = Math.abs(raw_distance) < tol ? 0 : Math.max(0, raw_distance);
     return { e_above_hull, is_stable: e_above_hull <= tol };
 }
+export const entry_is_stable = (entry, tol = HULL_STABILITY_TOL) => entry.is_stable === true ||
+    (entry.is_stable !== false && Math.abs(entry.e_above_hull ?? Infinity) <= tol);
 // Check if entry is on the convex hull (stable or e_above_hull ≈ 0)
-export const is_on_hull = (entry, tol = HULL_STABILITY_TOL) => !entry.exclude_from_hull &&
-    (entry.is_stable === true ||
-        (typeof entry.e_above_hull === `number` && entry.e_above_hull < tol));
+export const is_on_hull = (entry, tol = HULL_STABILITY_TOL) => !entry.exclude_from_hull && entry_is_stable(entry, tol);
 export const get_arity = (entry) => Object.values(entry.composition).filter((count) => count > 0).length;
 export const is_unary_entry = (entry) => get_arity(entry) === 1;
+export const entry_is_unstable = (entry) => !entry_is_stable(entry);
+export const entry_is_visible = (entry, show_stable, show_unstable) => (entry_is_stable(entry) ? show_stable : show_unstable);
+export const visible_entries = (entries, show_stable, show_unstable) => entries.filter((entry) => entry_is_visible(entry, show_stable, show_unstable));
 // Energy color scale factory (shared)
 export function get_energy_color_scale(color_mode, color_scale, plot_entries) {
     if (color_mode !== `energy` || plot_entries.length === 0)
@@ -43,7 +46,7 @@ export function get_energy_color_scale(color_mode, color_scale, plot_entries) {
 }
 // Point color resolver (shared)
 export function get_point_color_for_entry(entry, color_mode, colors, energy_scale) {
-    const is_stable = Boolean(entry.is_stable) || entry.e_above_hull === 0;
+    const is_stable = entry_is_stable(entry);
     if (color_mode === `stability`) {
         return is_stable ? colors?.stable || `#0072B2` : colors?.unstable || `#E69F00`;
     }
@@ -95,6 +98,28 @@ export function compute_auto_hull_dist_threshold(n_entries, max_hull_dist_in_dat
     const t = (n_entries - LOW) / (HIGH - LOW);
     return max_hull_dist_in_data * (1 - t) + static_default * t;
 }
+export function auto_threshold_reset(default_threshold) {
+    let source;
+    let auto_threshold = default_threshold;
+    let initialized = false;
+    return (next_source, current_threshold, next_auto_threshold) => {
+        if (initialized && next_source === source)
+            return undefined;
+        const user_changed = initialized && Math.abs(current_threshold - auto_threshold) > 0.001;
+        source = next_source;
+        auto_threshold = next_auto_threshold;
+        initialized = true;
+        return user_changed ? undefined : next_auto_threshold;
+    };
+}
+export function current_entry(entry, entries) {
+    if (!entry)
+        return null;
+    if (entry.entry_id) {
+        return entries.find((candidate) => candidate.entry_id === entry.entry_id) ?? null;
+    }
+    return entries.includes(entry) ? entry : null;
+}
 // Build a tooltip text for any phase entry (shared)
 export function build_entry_tooltip_text(entry) {
     const is_element = is_unary_entry(entry);
@@ -119,7 +144,7 @@ export function build_entry_tooltip_text(entry) {
         text += `E<sub>above hull</sub>: ${e_hull_str} eV/atom\n`;
     }
     // Fallback to energy_per_atom if e_form_per_atom is absent
-    const e_form_display = entry.e_form_per_atom !== undefined ? entry.e_form_per_atom : entry.energy_per_atom;
+    const e_form_display = entry.e_form_per_atom ?? entry.energy_per_atom;
     if (e_form_display !== undefined) {
         const e_form_str = format_num(e_form_display, `.3~`);
         text += `E<sub>form</sub>: ${e_form_str} eV/atom`;
@@ -137,11 +162,9 @@ export function find_hull_entry_at_mouse(canvas, event, plot_entries, project_po
     const mouse_y = event.clientY - rect.top;
     const container_scale = Math.min(canvas.clientWidth || 600, canvas.clientHeight || 600) / 600;
     for (const entry of plot_entries) {
-        if (!entry.visible)
-            continue;
         const projected = project_point(entry.x, entry.y, entry.z);
         const distance = Math.hypot(mouse_x - projected.x, mouse_y - projected.y);
-        const base = entry.size ?? (entry.is_stable || entry.e_above_hull === 0 ? 6 : 4);
+        const base = entry.size ?? (entry_is_stable(entry) ? 6 : 4);
         if (distance < base * container_scale + 5)
             return entry;
     }
@@ -421,10 +444,10 @@ export function draw_highlight_effect(ctx, projected, size, container_scale, pul
     if (effect === `pulse`) {
         // Smooth pulsating effect with moderate size and opacity changes
         const pulse_val = 0.5 + 0.5 * Math.sin(pulse_time * pulse_speed);
-        const hl_size = size * (size_multiplier + 0.5 * pulse_val); // Moderate pulse amplitude
-        const hl_opacity = opacity * (0.5 + 0.5 * pulse_val); // Smooth opacity variation
+        const hl_size = size * (size_multiplier + 0.5 * pulse_val);
+        const hl_opacity = opacity * (0.5 + 0.5 * pulse_val);
         // Draw pulsating ring
-        ctx.lineWidth = (1.5 + 1 * pulse_val) * container_scale;
+        ctx.lineWidth = (1.5 + pulse_val) * container_scale;
         ctx.beginPath();
         ctx.arc(projected.x, projected.y, hl_size, 0, 2 * Math.PI);
         ctx.fillStyle = apply_alpha_to_color(hl_color, hl_opacity * 0.3);
@@ -522,9 +545,7 @@ function entry_has_temp_data(entry) {
         temperatures.length === free_energies.length);
 }
 // Check if entry has data at exact temperature T
-export function entry_has_temperature(entry, T) {
-    return entry_has_temp_data(entry) && (entry.temperatures?.includes(T) ?? false);
-}
+export const entry_has_temperature = (entry, T) => entry_has_temp_data(entry) && (entry.temperatures?.includes(T) ?? false);
 // Get energy at temperature T (throws if T not found - validate with entry_has_temperature first)
 export function get_energy_at_temperature(entry, T) {
     const temps = entry.temperatures ?? [];
@@ -625,7 +646,7 @@ export function filter_entries_at_temperature(entries, T, options = {}) {
 // Analyze entries for gas-dependent elements (safe wrapper with optional config)
 // Returns information about which gases are relevant for the chemical system.
 export function safe_analyze_gas_data(entries, config) {
-    if (!config || !config.enabled_gases?.length) {
+    if (!config?.enabled_gases?.length) {
         return {
             has_gas_dependent_elements: false,
             gas_elements: [],
@@ -638,7 +659,7 @@ export function safe_analyze_gas_data(entries, config) {
 // This adjusts formation energies based on gas atmosphere conditions (T, P).
 // Should be applied after temperature filtering.
 export function safe_apply_gas_corrections(entries, config, T) {
-    if (!config || !config.enabled_gases?.length)
+    if (!config?.enabled_gases?.length)
         return entries;
     return _apply_gas_corrections(entries, config, T);
 }

package/dist/convex-hull/index.d.ts

@@ -11,6 +11,7 @@ export { default as ConvexHullControls } from './ConvexHullControls.svelte';
 export { default as ConvexHullInfoPane } from './ConvexHullInfoPane.svelte';
 export { default as ConvexHullStats } from './ConvexHullStats.svelte';
 export { default as ConvexHullTooltip } from './ConvexHullTooltip.svelte';
+export { default as StructurePopup } from './StructurePopup.svelte';
 export * from './demo-temperature';
 export * from './gas-thermodynamics';
 export { default as GasPressureControls } from './GasPressureControls.svelte';

package/dist/convex-hull/index.js

@@ -7,6 +7,7 @@ export { default as ConvexHullControls } from './ConvexHullControls.svelte';
 export { default as ConvexHullInfoPane } from './ConvexHullInfoPane.svelte';
 export { default as ConvexHullStats } from './ConvexHullStats.svelte';
 export { default as ConvexHullTooltip } from './ConvexHullTooltip.svelte';
+export { default as StructurePopup } from './StructurePopup.svelte';
 export * from './demo-temperature';
 export * from './gas-thermodynamics';
 export { default as GasPressureControls } from './GasPressureControls.svelte';

package/dist/convex-hull/thermodynamics.d.ts

@@ -1,5 +1,6 @@
 import type { ElementSymbol } from '../element';
-import type { ConvexHullEntry, ConvexHullTriangle, PhaseData, PhaseStats, Point2D, Point3D, ProcessedPhaseData } from './types';
+import type { Point2D, Point3D } from '../math';
+import type { ConvexHullEntry, ConvexHullTriangle, PhaseData, PhaseStats, ProcessedPhaseData } from './types';
 export declare function normalize_hull_composition_keys(composition: Record<string, number>): Partial<Record<ElementSymbol, number>>;
 export declare function process_hull_entries(entries: PhaseData[]): ProcessedPhaseData;
 export declare function compute_e_form_per_atom(entry: PhaseData, el_refs: Record<string, PhaseData>): number | null;

package/dist/convex-hull/thermodynamics.js

@@ -4,6 +4,8 @@ import { barycentric_to_ternary_xyz, barycentric_to_tetrahedral, composition_to_
 import { get_arity, HULL_STABILITY_TOL, is_on_hull, is_unary_entry } from './helpers';
 // Track warned keys to avoid log spam on large datasets with repeated invalid keys
 const warned_keys = new Set();
+const cross_point_2d = (origin, point_a, point_b) => (point_a.x - origin.x) * (point_b.y - origin.y) -
+    (point_a.y - origin.y) * (point_b.x - origin.x);
 // Normalize convex hull composition keys by stripping oxidation states (e.g. "V4+" -> "V")
 // and merging amounts for keys that map to the same element. Filters non-positive amounts.
 // Only extracts FIRST valid element from each key (e.g. "Fe2O3" -> "Fe", not both Fe and O).
@@ -22,7 +24,7 @@ export function normalize_hull_composition_keys(composition) {
             }
             continue;
         }
-        normalized[elem] = (normalized[elem] || 0) + amount;
+        normalized[elem] = (normalized[elem] ?? 0) + amount;
     }
     return normalized;
 }
@@ -153,7 +155,7 @@ export function calculate_e_above_hull(input, reference_entries) {
             const total = count_atoms_in_composition(ref.composition);
             if (total <= 0)
                 continue;
-            const x = (ref.composition[el2] || 0) / total;
+            const x = (ref.composition[el2] ?? 0) / total;
             const current = hull_input_map.get(x);
             if (current === undefined || e_form < current) {
                 hull_input_map.set(x, e_form);
@@ -178,7 +180,7 @@ export function calculate_e_above_hull(input, reference_entries) {
                 results[id] = NaN;
                 continue;
             }
-            const x = (entry.composition[el2] || 0) / total;
+            const x = (entry.composition[el2] ?? 0) / total;
             const y_hull = interpolate_hull_2d(lower_hull, x);
             results[id] = y_hull === null ? NaN : Math.max(0, e_form - y_hull);
         }
@@ -438,7 +440,6 @@ export function get_convex_hull_stats(processed_entries, elements, max_arity = 4
 function to_hull_entry(entry) {
     return {
         ...entry,
-        visible: true,
         is_element: get_arity(entry) === 1,
         x: 0,
         y: 0,
@@ -501,10 +502,9 @@ export function compute_lower_hull_2d(points) {
     // Sort by x then y
     const sorted = [...points].sort((p1, p2) => p1.x - p2.x || p1.y - p2.y);
     const lower = [];
-    const cross = (o, a, b) => (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
     for (const point of sorted) {
         while (lower.length >= 2 &&
-            cross(lower[lower.length - 2], lower[lower.length - 1], point) <= 0)
+            cross_point_2d(lower[lower.length - 2], lower[lower.length - 1], point) <= 0)
             lower.pop();
         lower.push(point);
     }
@@ -838,7 +838,7 @@ export const compute_e_above_hull_for_points = (points, models) => points.map((p
     const z_hull = e_hull_at_xy(models, point.x, point.y);
     if (z_hull === null)
         return 0;
-    return point.z - z_hull;
+    return Math.max(0, point.z - z_hull);
 });
 const subtract_4d = (pt1, pt2) => ({
     x: pt1.x - pt2.x,

package/dist/convex-hull/types.d.ts

@@ -1,9 +1,20 @@
 import type { CompositionType } from '../composition';
 import type { ShowControlsProp } from '../controls';
 import type { ElementSymbol } from '../element';
-import type { Vec3 } from '../math';
-import type { Sides } from '../plot';
-import type { Rect } from '../plot/layout';
+import type { Point2D, Point3D, Vec3 } from '../math';
+import type { Rect, Sides } from '../plot/layout';
+import type { AnyStructure } from '../structure';
+export interface StructurePopupStats {
+    id?: string;
+    formula?: string;
+    e_above_hull?: number;
+    e_form?: number;
+}
+export interface StructurePopupContext {
+    structure: AnyStructure;
+    stats?: StructurePopupStats;
+    formula_html: string;
+}
 export interface PhaseData {
     composition: CompositionType;
     energy: number;
@@ -33,13 +44,6 @@ export interface ProcessedPhaseData {
     elements: ElementSymbol[];
     el_refs: Record<string, PhaseData>;
 }
-export interface Point2D {
-    x: number;
-    y: number;
-}
-export interface Point3D extends Point2D {
-    z: number;
-}
 export type MarkerSymbol = // Marker symbol types for convex hull entries
 `circle` | `star` | `triangle` | `cross` | `diamond` | `square` | `wye`;
 export type HullFaceColorMode = `uniform` | `formation_energy` | `dominant_element` | `facet_index`;
@@ -47,7 +51,6 @@ export declare const HULL_FACE_COLOR_MODES: readonly HullFaceColorMode[];
 export interface ConvexHullEntry extends PhaseData, Point3D {
     is_element: boolean;
     size?: number;
-    visible: boolean;
     marker?: MarkerSymbol;
 }
 export interface ConvexHullConfig {
@@ -103,10 +106,7 @@ export interface LabelPlacement {
 }
 export interface HoverData3D<T = ConvexHullEntry> {
     entry: T;
-    position: {
-        x: number;
-        y: number;
-    };
+    position: Point2D;
 }
 export interface PhaseStats {
     total: number;

package/dist/effects.svelte.d.ts

@@ -0,0 +1,12 @@
+type PulseAnimationOptions = {
+    step?: number;
+    frequency?: number;
+    on_tick?: () => void;
+    reset_when_inactive?: boolean;
+};
+type PulseAnimation = {
+    readonly time: number;
+    readonly unit: number;
+};
+export declare function create_pulse_animation(active: () => boolean, options?: PulseAnimationOptions): PulseAnimation;
+export {};

package/dist/effects.svelte.js

@@ -0,0 +1,37 @@
+export function create_pulse_animation(active, options = {}) {
+    let time = $state(0);
+    let frame_id = null;
+    const { step = 0.02, frequency = 4, on_tick, reset_when_inactive = true } = options;
+    const cancel_frame = () => {
+        if (frame_id == null)
+            return;
+        cancelAnimationFrame(frame_id);
+        frame_id = null;
+    };
+    const stop = () => {
+        cancel_frame();
+        if (reset_when_inactive)
+            time = 0;
+    };
+    $effect(() => {
+        if (!active())
+            return stop();
+        const animate = () => {
+            time += step;
+            on_tick?.();
+            if (!active())
+                return stop();
+            frame_id = requestAnimationFrame(animate);
+        };
+        frame_id = requestAnimationFrame(animate);
+        return cancel_frame;
+    });
+    return {
+        get time() {
+            return time;
+        },
+        get unit() {
+            return 0.5 + 0.5 * Math.sin(time * frequency);
+        },
+    };
+}

package/dist/element/BohrAtom.svelte

@@ -84,10 +84,10 @@
 
   <!-- electron orbitals -->
   {#each shells as electrons, shell_idx (`${shell_idx}-${electrons}`)}
-    {@const n = shell_idx + 1}
-    {@const shell_radius = nucleus_svg_props.r + n * shell_width}
-    {@const active = n === highlight_shell}
-    <g class="shell" style:animation-duration="{orbital_period * n ** 1.5}s">
+    {@const shell_number = shell_idx + 1}
+    {@const shell_radius = nucleus_svg_props.r + shell_number * shell_width}
+    {@const active = shell_number === highlight_shell}
+    <g class="shell" style:animation-duration="{orbital_period * shell_number ** 1.5}s">
       <circle
         r={shell_radius}
         {...shell_svg_props}

package/dist/element/data.json.gz.d.ts

@@ -1,2 +1,4 @@
-declare const data: import('./types.ts').ChemicalElement[]
+import type { ChemicalElement } from './types'
+
+declare const data: ChemicalElement[]
 export default data

package/dist/element/index.d.ts

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

package/dist/element/index.js

@@ -1,4 +1,3 @@
-export * from './types';
 export { default as BohrAtom } from './BohrAtom.svelte';
 export { default as element_data } from './data';
 export { default as ElementHeading } from './ElementHeading.svelte';

package/dist/fermi-surface/FermiSurface.svelte

@@ -165,8 +165,8 @@
 
   // Yield to browser so spinner can render before heavy computation
   const tick = () =>
-    new Promise<void>((r) =>
-      requestAnimationFrame(() => requestAnimationFrame(() => r()))
+    new Promise<void>((resolve) =>
+      requestAnimationFrame(() => requestAnimationFrame(() => resolve()))
     )
 
   // Parse and load Fermi surface from content (async for UI responsiveness)
@@ -339,8 +339,8 @@
   })
 
   function handle_keydown(event: KeyboardEvent) {
-    const target = event.target as HTMLElement
-    if ([`INPUT`, `TEXTAREA`].includes(target.tagName)) return
+    const target = event.target
+    if (target instanceof HTMLElement && [`INPUT`, `TEXTAREA`].includes(target.tagName)) return
     // Only handle shortcuts when component is focused/hovered or contains focus
     if (!wrapper?.contains(document.activeElement) && !hovered) return
 

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" | "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">;
+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">;
 type FermiSurface = ReturnType<typeof FermiSurface>;
 export default FermiSurface;

package/dist/fermi-surface/FermiSurfaceControls.svelte

@@ -2,7 +2,8 @@
   import SettingsSection from '../layout/SettingsSection.svelte'
   import DraggablePane from '../overlays/DraggablePane.svelte'
   import type { CameraProjection } from '../settings'
-  import { type Snippet } from 'svelte'
+  import { make_change_detector } from '../utils'
+  import type { Snippet } from 'svelte'
   import type {
     BandGridData,
     ColorProperty,
@@ -80,9 +81,9 @@
     { value: `interpolateSpectral`, label: `Spectral` },
   ]
 
-  // Check if custom properties are available on any surface
-  let has_custom_properties = $derived(
-    fermi_data?.isosurfaces?.some((iso) => iso.properties?.length) ?? false,
+  let has_custom_color = $derived(
+    Boolean(custom_property_label) ||
+      (fermi_data?.isosurfaces?.some((iso) => iso.properties?.length) ?? false),
   )
 
   // Get unique band indices from Fermi surface data
@@ -93,18 +94,14 @@
       )
       : [],
   )
-  // Track previous available bands to detect when fermi_data changes
-  let prev_available_bands = $state<number[]>([])
+  let available_bands_key = $derived(available_bands.join(`,`))
+  const available_bands_changed = make_change_detector()
 
-  // Reset selected_bands when available_bands changes (new file loaded)
-  // This ensures band selection doesn't persist across different files
   $effect(() => {
-    const bands_changed = available_bands.length !== prev_available_bands.length ||
-      available_bands.some((band, idx) => band !== prev_available_bands[idx])
-    if (bands_changed) { // Always update tracking variable to avoid stale comparisons
-      prev_available_bands = [...available_bands]
-      // Only reset selected_bands when there are bands to select
-      if (available_bands.length > 0) selected_bands = [...available_bands]
+    if (color_property === `custom` && !has_custom_color) color_property = `band`
+    const bands_changed = available_bands_changed(available_bands_key)
+    if (available_bands.length > 0 && (selected_bands === undefined || bands_changed)) {
+      selected_bands = [...available_bands]
     }
   })
 
@@ -121,9 +118,8 @@
     }
   }
 
-  function handle_mu_change(event: Event) {
-    const target = event.target as HTMLInputElement
-    const trimmed = target.value.trim()
+  function handle_mu_change(event: Event & { currentTarget: HTMLInputElement }) {
+    const trimmed = event.currentTarget.value.trim()
     const parsed = parseFloat(trimmed)
     // Only update mu when input is valid; keep last valid value during transient
     // invalid states (e.g. empty string while user is typing a new value)
@@ -216,7 +212,7 @@
         <option value="band">Band</option>
         <option value="velocity">Velocity</option>
         <option value="spin">Spin</option>
-        {#if has_custom_properties || custom_property_label}
+        {#if has_custom_color}
           <option value="custom">{custom_property_label ?? `Custom`}</option>
         {/if}
       </select>
@@ -334,7 +330,7 @@
         <select
           value={interpolation_factor}
           onchange={(event) => {
-            const val = parseFloat((event.target as HTMLSelectElement).value)
+            const val = parseFloat(event.currentTarget.value)
             if (!Number.isFinite(val)) return
             interpolation_factor = val
             on_interpolation_change?.(val)

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

@@ -1,5 +1,5 @@
 import type { CameraProjection } from '../settings';
-import { type Snippet } from 'svelte';
+import type { Snippet } from 'svelte';
 import type { BandGridData, ColorProperty, FermiSurfaceData, RepresentationMode } from './types';
 type $$ComponentProps = {
     controls_open?: boolean;

package/dist/fermi-surface/FermiSurfaceScene.svelte

@@ -307,8 +307,8 @@
           const e2: Vec3 = math.subtract(v2, v0)
           const normal = math.cross_3d(e1, e2)
           const len = Math.hypot(...normal)
-          const n = len > 1e-10 ? normal.map((x) => x / len) : [0, 0, 1]
-          normals.push(...n, ...n, ...n)
+          const unit_normal = len > 1e-10 ? normal.map((coord) => coord / len) : [0, 0, 1]
+          normals.push(...unit_normal, ...unit_normal, ...unit_normal)
         }
 
         // Per-vertex colors for this triangle
@@ -394,7 +394,9 @@
 
   const computed_camera_position = $derived.by(
     () =>
-      camera_position || ([10, 3, 8].map((x) => x * Math.max(1, scene_size)) as Vec3),
+      camera_position || ([10, 3, 8].map((coord) =>
+        coord * Math.max(1, scene_size)
+      ) as Vec3),
   )
 
   const gizmo_props = $derived({
@@ -463,7 +465,7 @@
         const e2: Vec3 = math.subtract(v2, v0)
         const normal_vec = math.cross_3d(e1, e2)
         const len = Math.hypot(...normal_vec)
-        const norm = len > 1e-10 ? normal_vec.map((x) => x / len) : [0, 0, 0]
+        const norm = len > 1e-10 ? normal_vec.map((coord) => coord / len) : [0, 0, 0]
         normals.push(...norm, ...norm, ...norm)
       }
     }
@@ -656,8 +658,8 @@
   <!-- Reciprocal lattice vectors -->
   {#if show_vectors && fermi_data?.k_lattice}
     {#each fermi_data.k_lattice as vec, idx (idx)}
-      {@const scaled_vec = vec.map((x) => x * vector_scale) as Vec3}
-      {@const label_position = scaled_vec.map((x) => x * 1.15) as Vec3}
+      {@const scaled_vec = vec.map((coord) => coord * vector_scale) as Vec3}
+      {@const label_position = scaled_vec.map((coord) => coord * 1.15) as Vec3}
       <Arrow
         position={[0, 0, 0]}
         vector={scaled_vec}

package/dist/fermi-surface/compute.js

@@ -3,6 +3,7 @@ import * as math from '../math';
 import { EPS } from '../math';
 import { CLOSED_CONTOUR_TOLERANCE, IRREDUCIBLE_BZ_MIN_VERTICES, IRREDUCIBLE_BZ_TOLERANCE, SPANNING_THRESHOLD, } from './constants';
 import { marching_cubes } from './marching-cubes';
+const safe_mod = (val, dim) => ((val % dim) + dim) % dim;
 // Precompute Catmull-Rom coefficients for a given t value
 // Returns [c0, c1, c2, c3] where result = c0*p0 + c1*p1 + c2*p2 + c3*p3
 function catmull_rom_coeffs(t) {
@@ -238,7 +239,6 @@ function trilinear_interpolate_vec3(grid, x, y, z) {
     if (nx === 0 || ny === 0 || nz === 0)
         return [0, 0, 0];
     // Use safe modulo pattern to handle negative values from floating-point edge cases
-    const safe_mod = (val, n) => ((val % n) + n) % n;
     const x0 = safe_mod(Math.floor(x), nx);
     const y0 = safe_mod(Math.floor(y), ny);
     const z0 = safe_mod(Math.floor(z), nz);
@@ -387,7 +387,7 @@ function slice_surface_with_plane(surface, plane_normal, plane_distance, in_plan
             if (intersection) {
                 crossing_edges.push({ edge_key, intersection });
                 // Register this face with the edge
-                const faces = edge_to_faces.get(edge_key) || [];
+                const faces = edge_to_faces.get(edge_key) ?? [];
                 faces.push(face_idx);
                 edge_to_faces.set(edge_key, faces);
             }

package/dist/fermi-surface/export.js

@@ -1,16 +1,3 @@
-// Dynamic imports for Three.js exporters (tree-shaking friendly)
-async function get_stl_exporter() {
-    const { STLExporter } = await import(`three/addons/exporters/STLExporter.js`);
-    return new STLExporter();
-}
-async function get_obj_exporter() {
-    const { OBJExporter } = await import(`three/addons/exporters/OBJExporter.js`);
-    return new OBJExporter();
-}
-async function get_gltf_exporter() {
-    const { GLTFExporter } = await import(`three/addons/exporters/GLTFExporter.js`);
-    return new GLTFExporter();
-}
 // Helper to trigger file download
 function download_file(content, filename, mime_type) {
     const blob = new Blob([content], { type: mime_type });
@@ -25,7 +12,8 @@ function download_file(content, filename, mime_type) {
 }
 // Export scene to STL format (good for 3D printing)
 export async function export_to_stl(scene, filename) {
-    const exporter = await get_stl_exporter();
+    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;
@@ -33,13 +21,15 @@ export async function export_to_stl(scene, filename) {
 }
 // Export scene to OBJ format (widely compatible)
 export async function export_to_obj(scene, filename) {
-    const exporter = await get_obj_exporter();
+    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, filename) {
-    const exporter = await get_gltf_exporter();
+    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);
@@ -50,14 +40,11 @@ export async function export_to_gltf(scene, filename) {
 }
 // Main export function that dispatches to the appropriate format
 export function export_scene(scene, format, filename) {
-    switch (format) {
-        case `stl`:
-            return export_to_stl(scene, filename);
-        case `obj`:
-            return export_to_obj(scene, filename);
-        case `gltf`:
-            return export_to_gltf(scene, filename);
-        default:
-            return Promise.reject(new Error(`Unsupported export format: ${format}`));
-    }
+    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}`));
 }