matterviz 0.4.1 → 0.4.2

package/dist/convex-hull/GasPressureControls.svelte

@@ -59,8 +59,7 @@
 
   // Convert pressure to log scale slider position (0-100)
   const pressure_to_slider = (P: number): number =>
-    ((Math.max(LOG_P_MIN, Math.min(LOG_P_MAX, Math.log10(P))) - LOG_P_MIN) /
-      LOG_P_RANGE) * 100
+    ((Math.max(LOG_P_MIN, Math.min(LOG_P_MAX, Math.log10(P))) - LOG_P_MIN) / LOG_P_RANGE) * 100
 
   // Convert slider position (0-100) to pressure
   const slider_to_pressure = (value: number): number =>
@@ -68,7 +67,7 @@
 
   // Format gas name for display (subscript numbers)
   const format_gas_name = (gas: GasSpecies): string =>
-    gas.replaceAll(/(\d+)/g, `<sub>$1</sub>`)
+    gas.replaceAll(/(?<digits>\d+)/g, `<sub>$1</sub>`)
 
   // Format pressure as plain text (no HTML) for the number input
   function format_pressure(P: number): string {
@@ -102,24 +101,18 @@
   }
 
   function set_pressure_direct(gas: GasSpecies, value: number): void {
-    const clamped = Math.max(
-      10 ** LOG_P_MIN,
-      Math.min(10 ** LOG_P_MAX, value),
-    )
+    const clamped = Math.max(10 ** LOG_P_MIN, Math.min(10 ** LOG_P_MAX, value))
     pressures = { ...pressures, [gas]: clamped }
   }
 </script>
 
 {#if enabled_gases.length > 0}
-  <div {...rest} class="pressure-controls {position} {rest.class ?? ``}">
+  <div {...rest} class={[`pressure-controls`, position, rest.class]}>
     {#each enabled_gases as gas (gas)}
       {@const P = get_pressure(gas)}
       {@const mu = get_mu(gas)}
       {@const tooltip_content = `${gas} partial pressure for μ(T,P)\nμ = ${format_chemical_potential(mu, 3)}`}
-      <div
-        class="pressure-slider"
-        {@attach tooltip({ content: tooltip_content })}
-      >
+      <div class="pressure-slider" {@attach tooltip({ content: tooltip_content })}>
         <label class="pressure-label">
           <input
             type="text"

package/dist/convex-hull/StructurePopup.svelte

@@ -3,7 +3,7 @@
   import { get_electro_neg_formula } from '../composition'
   import Icon from '../Icon.svelte'
   import { format_num } from '../labels'
-  import { DragControlTab } from '../overlays'
+  import { DragControlTab, GlassChip } from '../overlays'
   import { sanitize_formula } from '../sanitize'
   import { Structure } from '../structure'
   import type { StructurePopupContext, StructurePopupStats } from './types'
@@ -17,6 +17,8 @@
     width = 500,
     height = 400,
     onclose,
+    close_on_outside = true,
+    show_drag_handle = true,
     stats,
     top_left,
     children,
@@ -28,6 +30,8 @@
     width?: number
     height?: number
     onclose?: () => void
+    close_on_outside?: boolean
+    show_drag_handle?: boolean
     stats?: StructurePopupStats
     top_left?: Snippet<[StructurePopupContext]>
     children?: Snippet<[StructurePopupContext]>
@@ -35,7 +39,8 @@
   } = $props()
 
   const formula_html = $derived.by(() =>
-    sanitize_formula(get_electro_neg_formula(stats?.formula ?? structure, true)))
+    sanitize_formula(get_electro_neg_formula(stats?.formula ?? structure, true)),
+  )
   const context = $derived({ structure, stats, formula_html })
 </script>
 
@@ -48,6 +53,7 @@
 <svelte:window
   onkeydown={(event) => event.key === `Escape` && onclose?.()}
   onmousedown={(event) => {
+    if (!close_on_outside) return
     if (!popup_div || !(event.target instanceof Node)) return
     if (!popup_div.contains(event.target)) onclose?.()
   }}
@@ -58,34 +64,36 @@
     handle_selector: `.drag-handle`,
   })}
   {...rest}
-  class="structure-popup {place_right ? `right` : `left`} {rest.class ?? ``}"
+  class={[`structure-popup`, place_right ? `right` : `left`, rest.class]}
   role="dialog"
   aria-modal="true"
   tabindex="-1"
   bind:this={popup_div}
 >
-  <DragControlTab />
+  {#if show_drag_handle}
+    <DragControlTab />
+  {/if}
   <div class="structure-popup-content">
     {#if top_left || stats}
-      <div class="structure-stats">
+      <GlassChip class="structure-stats">
         {#if top_left}
           {@render top_left(context)}
         {:else if stats}
           {#if stats.id}
-            ID = {stats.id}<br>
+            ID = {stats.id}<br />
           {/if}
           {#if formula_html}
-            {@html formula_html}<br>
+            {@html formula_html}<br />
           {/if}
           {#if stats.e_above_hull != null}
-            E<sub>above hull</sub> = {format_num(stats.e_above_hull, `.3~`)} eV/atom<br>
+            E<sub>above hull</sub> = {format_num(stats.e_above_hull, `.3~`)} eV/atom<br />
           {/if}
           {#if stats.e_form != null}
             E<sub>form</sub> = {format_num(stats.e_form, `.3~`)}
             eV/atom
           {/if}
         {/if}
-      </div>
+      </GlassChip>
     {/if}
 
     <Structure
@@ -136,16 +144,4 @@
   .close-btn:hover {
     background: var(--pane-btn-bg-hover);
   }
-  .structure-stats {
-    position: absolute;
-    top: 10px;
-    left: 10px;
-    background: transparent;
-    backdrop-filter: blur(8px);
-    color: var(--text-color);
-    padding: 4px 8px;
-    border-radius: 6px;
-    font-size: 0.85em;
-    z-index: 2;
-  }
 </style>

package/dist/convex-hull/StructurePopup.svelte.d.ts

@@ -8,6 +8,8 @@ type $$ComponentProps = Omit<HTMLAttributes<HTMLDivElement>, 'children'> & {
     width?: number;
     height?: number;
     onclose?: () => void;
+    close_on_outside?: boolean;
+    show_drag_handle?: boolean;
     stats?: StructurePopupStats;
     top_left?: Snippet<[StructurePopupContext]>;
     children?: Snippet<[StructurePopupContext]>;

package/dist/convex-hull/TemperatureSlider.svelte

@@ -16,15 +16,11 @@
   let last_update_time = 0
   const THROTTLE_MS = 100
 
-  const temp_index = $derived(
-    Math.max(0, available_temperatures.indexOf(temperature)),
-  )
+  const temp_index = $derived(Math.max(0, available_temperatures.indexOf(temperature)))
   const display_index = $derived(preview_index ?? temp_index)
   const display_temp = $derived(available_temperatures[display_index] ?? temperature)
 
-  function handle_slider_input(
-    event: Event & { currentTarget: HTMLInputElement },
-  ): void {
+  function handle_slider_input(event: Event & { currentTarget: HTMLInputElement }): void {
     const new_index = Number(event.currentTarget.value)
     preview_index = new_index
     // Throttle parent updates during drag to prevent scene flashing
@@ -35,9 +31,7 @@
     }
   }
 
-  function handle_slider_end(
-    event: Event & { currentTarget: HTMLInputElement },
-  ): void {
+  function handle_slider_end(event: Event & { currentTarget: HTMLInputElement }): void {
     const new_temp = available_temperatures[Number(event.currentTarget.value)]
     if (new_temp !== undefined) temperature = new_temp
     preview_index = null
@@ -53,7 +47,7 @@
 
 <div
   {...rest}
-  class="temperature-slider {rest.class ?? ``}"
+  class={[`temperature-slider`, rest.class]}
   {@attach tooltip({ content: `Temperature for G(T) free energies` })}
 >
   <label class="temp-label">

package/dist/convex-hull/canvas-interactions.svelte.js

@@ -123,7 +123,8 @@ export function create_canvas_interactions(inputs) {
     };
     const handle_wheel = (event) => {
         event.preventDefault();
-        inputs.set_zoom(Math.max(zoom_min, Math.min(zoom_max, inputs.zoom() * (event.deltaY > 0 ? 0.98 : 1.02))));
+        const zoomed = inputs.zoom() * (event.deltaY > 0 ? 0.98 : 1.02);
+        inputs.set_zoom(Math.max(zoom_min, Math.min(zoom_max, zoomed)));
     };
     const handle_hover = (event) => {
         if (is_dragging)

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

@@ -3,12 +3,11 @@ import type { EnergyModeInfo } from './';
 import type { ElementSymbol } from '../element';
 import type { AnyStructure } from '../structure';
 import type { ConvexHullConfig, EntryCategoryConfig, GasAnalysis, GasThermodynamicsConfig, HighlightStyle, MarkerSymbol, PhaseData } from './types';
-import { DEFAULT_GAS_TEMP } from './types';
-export { DEFAULT_GAS_TEMP };
+export { DEFAULT_GAS_TEMP } from './types';
 export declare const HULL_STABILITY_TOL = 0.000001;
-export declare function compute_hull_stability(raw_distance: number, exclude_from_hull?: boolean, tol?: number): {
-    e_above_hull: number;
-    is_stable: boolean;
+export declare function compute_hull_stability(raw_distance: number | null | undefined, exclude_from_hull?: boolean, tol?: number): {
+    e_above_hull: number | undefined;
+    is_stable: boolean | undefined;
 };
 type StabilityEntry = {
     is_stable?: boolean;
@@ -17,8 +16,11 @@ type StabilityEntry = {
 export declare const extract_structure_from_entry: (entries: PhaseData[], entry: {
     entry_id?: string;
 }) => AnyStructure | null;
+export declare const array_min: (values: readonly number[]) => number;
+export declare const array_max: (values: readonly number[]) => number;
 export declare const hull_distance_range: (entries: PhaseData[]) => [number, number];
 export declare const entry_is_stable: (entry: StabilityEntry, tol?: number) => boolean;
+export declare const entry_within_hull_dist: (entry: StabilityEntry, max_dist: number) => boolean;
 export declare const is_on_hull: (entry: PhaseData, tol?: number) => boolean;
 export declare const get_arity: (entry: PhaseData) => number;
 export declare const is_unary_entry: (entry: PhaseData) => boolean;
@@ -142,8 +144,4 @@ export declare function get_gas_corrected_entries(entries: PhaseData[], gas_conf
     analysis: GasAnalysis;
     merged_config: GasThermodynamicsConfig | undefined;
 };
-export declare function get_entry_label(entry: {
-    reduced_formula?: string;
-    name?: string;
-    composition: Record<string, number>;
-}, elements?: ElementSymbol[]): string;
+export declare function get_entry_label(entry: Pick<PhaseData, `reduced_formula` | `name` | `composition`>, elements?: ElementSymbol[]): string;

package/dist/convex-hull/helpers.js

@@ -3,14 +3,19 @@ import { ELEM_SYMBOL_TO_NAME } from '../composition';
 import { format_fractional, format_num, symbol_map } from '../labels';
 import { scaleSequential } from 'd3-scale';
 import { symbol } from 'd3-shape';
-import { analyze_gas_data as _analyze_gas_data, apply_gas_corrections as _apply_gas_corrections, } from './gas-thermodynamics';
-import { DEFAULT_GAS_TEMP, MAGNETIC_ORDERING_CATEGORY } from './types';
-export { DEFAULT_GAS_TEMP };
+import { analyze_gas_data, apply_gas_corrections } from './gas-thermodynamics';
+import { MAGNETIC_ORDERING_CATEGORY } from './types';
+export { DEFAULT_GAS_TEMP } from './types';
 // Tolerance for classifying a phase as on the convex hull (eV/atom)
 export const HULL_STABILITY_TOL = 1e-6;
 // Clamp raw hull distance and compute stability for a single entry.
 // Excluded entries keep their raw (possibly negative) distance and are never stable.
 export function compute_hull_stability(raw_distance, exclude_from_hull, tol = HULL_STABILITY_TOL) {
+    // unknown distance (degenerate hull / point outside hull projection / missing energy):
+    // not 0/stable — leave both undefined so it isn't mislabeled on-hull
+    if (raw_distance == null || !Number.isFinite(raw_distance)) {
+        return { e_above_hull: undefined, is_stable: undefined };
+    }
     if (exclude_from_hull)
         return { e_above_hull: raw_distance, is_stable: false };
     const e_above_hull = Math.abs(raw_distance) < tol ? 0 : Math.max(0, raw_distance);
@@ -24,15 +29,23 @@ export const extract_structure_from_entry = (entries, entry) => {
     const orig_entry = entries.find((ent) => ent.entry_id === entry.entry_id);
     return orig_entry?.structure || null;
 };
-// [min, max] energy above hull across entries, for ColorBar ranges (max floored at 0.1)
+// Loop-based min/max — Math.min/max(...arr) blows the stack on large (>~100k) arrays
+export const array_min = (values) => values.reduce((min, val) => (val < min ? val : min), Infinity);
+export const array_max = (values) => values.reduce((max, val) => (val > max ? val : max), -Infinity);
+// [min, max] energy above hull across entries, for ColorBar ranges (max floored at 0.1).
+// Filter to finite values: NaN/undefined distances would otherwise produce a broken range.
 export const hull_distance_range = (entries) => {
     const dists = entries
         .map((entry) => entry.e_above_hull)
-        .filter((val) => typeof val === `number`);
-    return dists.length > 0 ? [Math.min(...dists), Math.max(...dists, 0.1)] : [0, 0.1];
+        .filter((val) => typeof val === `number` && Number.isFinite(val));
+    return dists.length > 0 ? [array_min(dists), Math.max(array_max(dists), 0.1)] : [0, 0.1];
 };
 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);
+// Whether to plot an entry at a given max hull distance: stable, or a finite distance
+// within max_dist. Unknown distance (undefined) is excluded, not treated as 0/stable.
+export const entry_within_hull_dist = (entry, max_dist) => entry_is_stable(entry) ||
+    (typeof entry.e_above_hull === `number` && entry.e_above_hull <= max_dist);
 // 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(entry, tol);
 export const get_arity = (entry) => Object.values(entry.composition).filter((count) => count > 0).length;
@@ -211,15 +224,9 @@ export function build_entry_tooltip_text(entry, category = MAGNETIC_ORDERING_CAT
         ? `${elem_symbol}${elem_name ? ` (${elem_name})` : ``}\n`
         : `${entry.name ?? entry.reduced_formula ?? ``}\n`;
     if (!is_element) {
-        const total = Object.values(entry.composition).reduce((sum, amt) => sum + amt, 0);
-        if (total > 0) {
-            const fractions = Object.entries(entry.composition)
-                .filter(([, amt]) => amt > 0)
-                .map(([el, amt]) => `${el}: ${format_fractional(amt / total)}`);
-            if (fractions.length > 1) {
-                text += `Composition: ${fractions.join(`, `)}\n`;
-            }
-        }
+        const fractions = Object.entries(get_fractional_composition(entry.composition)).map(([elem, frac]) => `${elem}: ${format_fractional(frac)}`);
+        if (fractions.length > 1)
+            text += `Composition: ${fractions.join(`, `)}\n`;
     }
     if (entry.e_above_hull !== undefined) {
         const e_hull_str = format_num(entry.e_above_hull, `.3~`);
@@ -290,21 +297,21 @@ energy_source_mode) {
             break;
         }
     }
-    const can_compute_hull = can_compute_e_form;
     // Resolve mode to avoid inconsistent states:
     // - If full precomputed available, honor user toggle
-    // - Else if we can compute both, use on-the-fly automatically
+    // - Else if we can compute, use on-the-fly automatically
     // - Else fall back to precomputed (best-effort)
     const energy_mode = has_precomputed_e_form && has_precomputed_hull
         ? energy_source_mode
-        : can_compute_e_form && can_compute_hull
+        : can_compute_e_form
             ? `on-the-fly`
             : `precomputed`;
     return {
         has_precomputed_e_form,
         has_precomputed_hull,
         can_compute_e_form,
-        can_compute_hull,
+        // hull needs the same unary references as e_form, so the two always agree
+        can_compute_hull: can_compute_e_form,
         energy_mode,
         unary_refs,
     };
@@ -752,8 +759,7 @@ export function filter_entries_at_temperature(entries, T, options = {}) {
                 return [{ ...entry, energy, energy_per_atom: energy }];
             }
         }
-        // Exclude entry (has temp data but can't get energy at T)
-        return [];
+        return []; // Exclude entry (has temp data but can't get energy at T)
     });
 }
 // Get gas-corrected entries in one call (consolidates analysis + correction)
@@ -762,29 +768,23 @@ export function filter_entries_at_temperature(entries, T, options = {}) {
 // if no gas config or no relevant gases.
 export function get_gas_corrected_entries(entries, gas_config, gas_pressures, temperature) {
     if (!gas_config?.enabled_gases?.length) {
-        return {
-            entries,
-            analysis: {
-                has_gas_dependent_elements: false,
-                gas_elements: [],
-                relevant_gases: [],
-            },
-            merged_config: undefined,
+        const analysis = {
+            has_gas_dependent_elements: false,
+            gas_elements: [],
+            relevant_gases: [],
         };
+        return { entries, analysis, merged_config: undefined };
     }
     const merged_config = {
         ...gas_config,
         pressures: { ...gas_config.pressures, ...gas_pressures },
     };
-    const analysis = _analyze_gas_data(entries, merged_config);
+    const analysis = analyze_gas_data(entries, merged_config);
     if (!analysis.has_gas_dependent_elements) {
         return { entries, analysis, merged_config };
     }
-    return {
-        entries: _apply_gas_corrections(entries, merged_config, temperature),
-        analysis,
-        merged_config,
-    };
+    const corr_entries = apply_gas_corrections(entries, merged_config, temperature);
+    return { entries: corr_entries, analysis, merged_config };
 }
 // Derive a display label for a convex hull entry, falling back to composition
 // when reduced_formula and name are both missing.
@@ -793,7 +793,7 @@ export function get_entry_label(entry, elements) {
         return entry.reduced_formula;
     if (entry.name)
         return entry.name;
-    let pairs = Object.entries(entry.composition).filter(([, amt]) => amt > 0);
+    let pairs = Object.entries(entry.composition).filter(([, amt]) => (amt ?? 0) > 0);
     if (elements) {
         pairs = pairs.sort(([el1], [el2]) => elements.indexOf(el1) - elements.indexOf(el2));
     }

package/dist/convex-hull/hull-state.svelte.d.ts

@@ -36,7 +36,7 @@ export declare function create_hull_data_pipeline<Entry extends PhaseData>(input
     })[];
     readonly pd_data: import("./types").ProcessedPhaseData;
     readonly polymorph_stats_map: Map<string, helpers.PolymorphStats>;
-    readonly elements: ("S" | "K" | "B" | "H" | "He" | "Li" | "Be" | "C" | "N" | "O" | "F" | "Ne" | "Na" | "Mg" | "Al" | "Si" | "P" | "Cl" | "Ar" | "Ca" | "Sc" | "Ti" | "V" | "Cr" | "Mn" | "Fe" | "Co" | "Ni" | "Cu" | "Zn" | "Ga" | "Ge" | "As" | "Se" | "Br" | "Kr" | "Rb" | "Sr" | "Y" | "Zr" | "Nb" | "Mo" | "Tc" | "Ru" | "Rh" | "Pd" | "Ag" | "Cd" | "In" | "Sn" | "Sb" | "Te" | "I" | "Xe" | "Cs" | "Ba" | "La" | "Ce" | "Pr" | "Nd" | "Pm" | "Sm" | "Eu" | "Gd" | "Tb" | "Dy" | "Ho" | "Er" | "Tm" | "Yb" | "Lu" | "Hf" | "Ta" | "W" | "Re" | "Os" | "Ir" | "Pt" | "Au" | "Hg" | "Tl" | "Pb" | "Bi" | "Po" | "At" | "Rn" | "Fr" | "Ra" | "Ac" | "Th" | "Pa" | "U" | "Np" | "Pu" | "Am" | "Cm" | "Bk" | "Cf" | "Es" | "Fm" | "Md" | "No" | "Lr" | "Rf" | "Db" | "Sg" | "Bh" | "Hs" | "Mt" | "Ds" | "Rg" | "Cn" | "Nh" | "Fl" | "Mc" | "Lv" | "Ts" | "Og")[];
+    readonly elements: ("Ac" | "Ag" | "Al" | "Am" | "Ar" | "As" | "At" | "Au" | "B" | "Ba" | "Be" | "Bh" | "Bi" | "Bk" | "Br" | "C" | "Ca" | "Cd" | "Ce" | "Cf" | "Cl" | "Cm" | "Co" | "Cr" | "Cs" | "Cu" | "Db" | "Dy" | "Er" | "Es" | "Eu" | "F" | "Fe" | "Fm" | "Fr" | "Ga" | "Gd" | "Ge" | "H" | "He" | "Hf" | "Hg" | "Ho" | "Hs" | "I" | "In" | "Ir" | "K" | "Kr" | "La" | "Li" | "Lr" | "Lu" | "Md" | "Mg" | "Mn" | "Mo" | "Mt" | "N" | "Na" | "Nb" | "Nd" | "Ne" | "Ni" | "No" | "Np" | "O" | "Os" | "P" | "Pa" | "Pb" | "Pd" | "Pm" | "Po" | "Pr" | "Pt" | "Pu" | "Ra" | "Rb" | "Re" | "Rf" | "Rh" | "Rn" | "Ru" | "S" | "Sb" | "Sc" | "Se" | "Sg" | "Si" | "Sm" | "Sn" | "Sr" | "Ta" | "Tb" | "Tc" | "Te" | "Th" | "Ti" | "Tl" | "Tm" | "U" | "V" | "W" | "Xe" | "Y" | "Yb" | "Zn" | "Zr" | "Ds" | "Rg" | "Cn" | "Nh" | "Fl" | "Mc" | "Lv" | "Ts" | "Og")[];
     readonly max_hull_dist_in_data: number;
     readonly auto_default_threshold: number;
     readonly plot_entries: Entry[];

package/dist/convex-hull/thermodynamics.js

@@ -1,7 +1,7 @@
 import { count_atoms_in_composition, extract_formula_elements, sort_by_electronegativity, } from '../composition';
 import * as math from '../math';
 import { composition_to_barycentric_nd } from './barycentric-coords';
-import { get_arity, HULL_STABILITY_TOL, is_on_hull, is_unary_entry } from './helpers';
+import { array_max, array_min, 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();
 // Normalize convex hull composition keys by stripping oxidation states (e.g. "V4+" -> "V")
@@ -49,13 +49,7 @@ export function process_hull_entries(entries) {
     const el_refs = Object.fromEntries(stable_entries
         .filter(is_unary_entry)
         .map((entry) => [Object.keys(entry.composition)[0], entry]));
-    return {
-        entries: normalized_entries,
-        stable_entries,
-        unstable_entries,
-        elements,
-        el_refs,
-    };
+    return { entries: normalized_entries, stable_entries, unstable_entries, elements, el_refs };
 }
 // Get energy per atom with correction applied, or fallback to raw energy_per_atom/energy.
 // Note: correction is expected to be a total-entry value (eV), not per-atom.
@@ -99,8 +93,14 @@ export function find_lowest_energy_unary_refs(entries) {
     }
     return refs;
 }
-// Result key for an entry: entry_id, falling back to its serialized composition
-const id_of = (entry) => entry.entry_id ?? JSON.stringify(entry.composition);
+// Result key: entry_id, else composition|energy|structure. Composition alone collides for
+// same-stoichiometry polymorphs (last distance would win), so add energy + structure.
+const id_of = (entry) => {
+    if (entry.entry_id)
+        return entry.entry_id;
+    const structure_hash = entry.structure ? JSON.stringify(entry.structure) : ``;
+    return `${JSON.stringify(entry.composition)}|${entry.energy}|${structure_hash}`;
+};
 export function calculate_e_above_hull(input, reference_entries) {
     const is_single = !Array.isArray(input);
     const entries_of_interest = is_single ? [input] : input;
@@ -302,11 +302,12 @@ export function get_convex_hull_stats(processed_entries, elements, max_arity = 4
     const energies = processed_entries
         .map((entry) => entry.e_form_per_atom ?? entry.energy_per_atom ?? get_energy_per_atom(entry))
         .filter(Number.isFinite);
-    // Use reduce instead of Math.min/max(...arr) to avoid stack overflow on large datasets
+    // array_min/array_max reduce instead of Math.min/max(...arr) to avoid stack
+    // overflow on large datasets
     const energy_range = energies.length > 0
         ? {
-            min: energies.reduce((min, val) => (val < min ? val : min), Infinity),
-            max: energies.reduce((max, val) => (val > max ? val : max), -Infinity),
+            min: array_min(energies),
+            max: array_max(energies),
             avg: energies.reduce((sum, val) => sum + val, 0) / energies.length,
         }
         : { min: 0, max: 0, avg: 0 };
@@ -315,7 +316,7 @@ export function get_convex_hull_stats(processed_entries, elements, max_arity = 4
         .filter((val) => typeof val === `number` && val >= 0);
     const hull_distance = hull_distances.length > 0
         ? {
-            max: hull_distances.reduce((max, val) => (val > max ? val : max), -Infinity),
+            max: array_max(hull_distances),
             avg: hull_distances.reduce((sum, val) => sum + val, 0) / hull_distances.length,
         }
         : { max: 0, avg: 0 };
@@ -505,7 +506,7 @@ export function e_hull_at_xy(models, x, y) {
 export const compute_e_above_hull_for_points = (points, models) => points.map((point) => {
     const z_hull = e_hull_at_xy(models, point.x, point.y);
     if (z_hull === null)
-        return 0;
+        return NaN; // unknown: no hull face covers this point
     return Math.max(0, point.z - z_hull);
 });
 // Map an ND facet (vertex indices into `points`) back to the public tetrahedron shape
@@ -851,8 +852,8 @@ const build_simplex_models_nd = (simplices) => simplices.map((vertices) => {
     const vertices_spatial = vertices.map((pt) => pt.slice(0, dim - 1));
     // Compute bounding box in spatial dimensions
     const spatial_dim = dim - 1;
-    const bbox_min = Array.from({ length: spatial_dim }, (_, idx) => Math.min(...vertices_spatial.map((pt) => pt[idx])));
-    const bbox_max = Array.from({ length: spatial_dim }, (_, idx) => Math.max(...vertices_spatial.map((pt) => pt[idx])));
+    const bbox_min = Array.from({ length: spatial_dim }, (_, idx) => array_min(vertices_spatial.map((pt) => pt[idx])));
+    const bbox_max = Array.from({ length: spatial_dim }, (_, idx) => array_max(vertices_spatial.map((pt) => pt[idx])));
     return { vertices, vertices_spatial, bbox_min, bbox_max };
 });
 // Check if point is inside simplex and return barycentric coordinates

package/dist/coordination/CoordinationBarPlot.svelte

@@ -12,12 +12,13 @@
     Orientation,
   } from '../plot/core/types'
   import type { AnyStructure } from '../structure'
+  import { calc_structure_coordination } from '../structure/atom-properties'
   import type { BondingStrategy } from '../structure/bonding'
   import { parse_any_structure } from '../structure/parse'
   import { is_crystal } from '../structure/validation'
   import type { ComponentProps } from 'svelte'
   import { SvelteMap, SvelteSet } from 'svelte/reactivity'
-  import { calc_coordination_nums, type CoordinationData } from './calc-coordination'
+  import type { CoordinationData } from './calc-coordination'
   import type { SplitMode } from './index'
   import { to_error } from '../utils'
 
@@ -70,28 +71,31 @@
 
     const base_entries = Array.isArray(structures)
       ? (structures as StructureEntry[])
-      : (is_crystal(structures)
+      : is_crystal(structures)
         ? [{ label: `Structure`, structure: structures as AnyStructure }]
         : Object.entries(
-          structures as Record<
-            string,
-            AnyStructure | { structure: AnyStructure; color?: string }
-          >,
-        ).map(([label, value]) =>
-          `structure` in value
-            ? { label, ...value }
-            : { label, structure: value as AnyStructure }
-        ))
+            structures as Record<
+              string,
+              AnyStructure | { structure: AnyStructure; color?: string }
+            >,
+          ).map(([label, value]) =>
+            `structure` in value
+              ? { label, ...value }
+              : { label, structure: value as AnyStructure },
+          )
 
     // Merge user-provided structures with dropped structures
     return [...base_entries, ...dropped_entries]
   })
 
-  // Compute coordination data for each structure
-  const entries_with_data = $derived(structure_entries.map((entry) => ({
-    ...entry,
-    data: calc_coordination_nums(entry.structure, strategy),
-  })))
+  // Compute coordination data for each structure via the shared PBC-aware helper so
+  // boundary-atom coordination matches the 3D viewer (which uses the same path).
+  const entries_with_data = $derived(
+    structure_entries.map((entry) => ({
+      ...entry,
+      data: calc_structure_coordination(entry.structure, strategy),
+    })),
+  )
 
   // Compute appropriate ranges
   const ranges = $derived.by(() => {
@@ -116,7 +120,6 @@
     }
     return Array.from(all_cns).sort((cn1, cn2) => cn1 - cn2)
   })
-
   // Build BarPlot series based on split_mode
   const bar_series = $derived.by<BarSeries<CoordinationMetadata>[]>(() => {
     if (split_mode === `by_element`) {
@@ -208,29 +211,28 @@
 
   const compute_and_add = (content: string | ArrayBuffer, filename: string) => {
     try {
-      const text_content = content instanceof ArrayBuffer
-        ? new TextDecoder().decode(content)
-        : content
+      const text_content =
+        content instanceof ArrayBuffer ? new TextDecoder().decode(content) : content
       const parsed_structure = parse_any_structure(text_content, filename)
       if (is_crystal(parsed_structure)) {
-        dropped_entries = [{
-          label: filename || `Dropped structure`,
-          structure: parsed_structure,
-        }, ...dropped_entries]
+        dropped_entries = [
+          {
+            label: filename || `Dropped structure`,
+            structure: parsed_structure,
+          },
+          ...dropped_entries,
+        ]
       } else {
         error_msg = `Structure has no lattice or sites; cannot compute coordination`
       }
     } catch (exc) {
-      error_msg = `Failed to process structure: ${
-        to_error(exc).message
-      }`
+      error_msg = `Failed to process structure: ${to_error(exc).message}`
     }
   }
 
   const handle_file_drop = create_file_drop_handler({
     allow: () => allow_file_drop,
-    on_drop: (content, filename) =>
-      (on_file_drop || compute_and_add)(content, filename),
+    on_drop: (content, filename) => (on_file_drop || compute_and_add)(content, filename),
     on_error: (msg) => {
       error_msg = msg
     },
@@ -256,8 +258,8 @@
 {#if bar_series.length === 0}
   <StatusMessage
     message={allow_file_drop
-    ? `Drag and drop structure files here to compute coordination numbers`
-    : `No coordination data to display`}
+      ? `Drag and drop structure files here to compute coordination numbers`
+      : `No coordination data to display`}
   />
 {:else}
   {#snippet tooltip(info: BarHandlerProps<CoordinationMetadata>)}
@@ -298,7 +300,10 @@
     bind:display
     {tooltip}
     ondrop={handle_file_drop}
-    {...drag_over_handlers({ allow: () => allow_file_drop, set_dragover: (over) => dragover = over })}
-    class={(rest.class ?? ``) + (dragover ? ` dragover` : ``)}
+    {...drag_over_handlers({
+      allow: () => allow_file_drop,
+      set_dragover: (over) => (dragover = over),
+    })}
+    class={[rest.class, dragover && `dragover`]}
   />
 {/if}

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

@@ -3,7 +3,7 @@ import type { AxisConfig } from '../plot/core/types';
 import type { AnyStructure } from '../structure';
 import type { BondingStrategy } from '../structure/bonding';
 import type { ComponentProps } from 'svelte';
-import { type CoordinationData } from './calc-coordination';
+import type { CoordinationData } from './calc-coordination';
 import type { SplitMode } from './index';
 interface StructureEntry {
     label: string;