matterviz 0.3.7 → 0.4.0

package/dist/convex-hull/TemperatureSlider.svelte

@@ -25,7 +25,7 @@
   function handle_slider_input(
     event: Event & { currentTarget: HTMLInputElement },
   ): void {
-    const new_index = +event.currentTarget.value
+    const new_index = Number(event.currentTarget.value)
     preview_index = new_index
     // Throttle parent updates during drag to prevent scene flashing
     const now = Date.now()
@@ -38,7 +38,7 @@
   function handle_slider_end(
     event: Event & { currentTarget: HTMLInputElement },
   ): void {
-    const new_temp = available_temperatures[+event.currentTarget.value]
+    const new_temp = available_temperatures[Number(event.currentTarget.value)]
     if (new_temp !== undefined) temperature = new_temp
     preview_index = null
   }

package/dist/convex-hull/demo-temperature.d.ts

@@ -2,5 +2,5 @@ import type { PhaseData } from './types';
 export declare const demo_temperatures: number[];
 type Composition = Record<string, number>;
 export declare function make_demo_phase(composition: Composition, seed: number, entropy_boost?: number): PhaseData;
-export declare function create_temp_ternary_entries_li_fe_o(): PhaseData[];
+export declare const create_temp_ternary_entries_li_fe_o: () => PhaseData[];
 export {};

package/dist/convex-hull/demo-temperature.js

@@ -16,25 +16,23 @@ export function make_demo_phase(composition, seed, entropy_boost = 0) {
             0.00005 * temp_kelvin * Math.log(temp_kelvin)),
     };
 }
-export function create_temp_ternary_entries_li_fe_o() {
-    return [
-        ...[`Li`, `Fe`, `O`].map((element, idx) => make_demo_phase({ [element]: 1 }, idx)),
-        ...[
-            [`Li`, `Fe`],
-            [`Li`, `O`],
-            [`Fe`, `O`],
-        ].flatMap(([element_a, element_b], idx) => [0.33, 0.5, 0.67].flatMap((fraction, jdx) => [
-            make_demo_phase({ [element_a]: fraction, [element_b]: 1 - fraction }, 100 + idx * 10 + jdx),
-            make_demo_phase({ [element_a]: fraction, [element_b]: 1 - fraction }, 200 + idx * 10 + jdx, 3),
-        ])),
-        ...[
-            { Li: 0.33, Fe: 0.33, O: 0.34 },
-            { Li: 0.5, Fe: 0.25, O: 0.25 },
-            { Li: 0.25, Fe: 0.5, O: 0.25 },
-            { Li: 0.25, Fe: 0.25, O: 0.5 },
-        ].flatMap((composition, idx) => [
-            make_demo_phase(composition, 300 + idx),
-            make_demo_phase(composition, 400 + idx, 4),
-        ]),
-    ];
-}
+export const create_temp_ternary_entries_li_fe_o = () => [
+    ...[`Li`, `Fe`, `O`].map((element, idx) => make_demo_phase({ [element]: 1 }, idx)),
+    ...[
+        [`Li`, `Fe`],
+        [`Li`, `O`],
+        [`Fe`, `O`],
+    ].flatMap(([element_a, element_b], idx) => [0.33, 0.5, 0.67].flatMap((fraction, jdx) => [
+        make_demo_phase({ [element_a]: fraction, [element_b]: 1 - fraction }, 100 + idx * 10 + jdx),
+        make_demo_phase({ [element_a]: fraction, [element_b]: 1 - fraction }, 200 + idx * 10 + jdx, 3),
+    ])),
+    ...[
+        { Li: 0.33, Fe: 0.33, O: 0.34 },
+        { Li: 0.5, Fe: 0.25, O: 0.25 },
+        { Li: 0.25, Fe: 0.5, O: 0.25 },
+        { Li: 0.25, Fe: 0.25, O: 0.5 },
+    ].flatMap((composition, idx) => [
+        make_demo_phase(composition, 300 + idx),
+        make_demo_phase(composition, 400 + idx, 4),
+    ]),
+];

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

@@ -4,7 +4,7 @@ export declare const R_EV_PER_K = 0.00008617333262;
 export declare const P_REF = 1;
 export declare const DEFAULT_ELEMENT_TO_GAS: Readonly<Partial<Record<ElementSymbol, GasSpecies>>>;
 export declare const GAS_STOICHIOMETRY: Readonly<Record<GasSpecies, Partial<Record<ElementSymbol, number>>>>;
-export declare function create_default_gas_provider(): GasThermodynamicsProvider;
+export declare const create_default_gas_provider: () => GasThermodynamicsProvider;
 export declare function get_default_gas_provider(): GasThermodynamicsProvider;
 export declare function compute_gas_chemical_potential(provider: GasThermodynamicsProvider, gas: GasSpecies, T: number, P: number): number;
 export declare function compute_element_chemical_potential(provider: GasThermodynamicsProvider, gas: GasSpecies, element: ElementSymbol, T: number, P: number): number;
@@ -12,5 +12,5 @@ export declare function analyze_gas_data(entries: PhaseData[], config: GasThermo
 export declare function get_effective_pressures(config: GasThermodynamicsConfig): Record<GasSpecies, number>;
 export declare function compute_gas_correction(entry: PhaseData, config: GasThermodynamicsConfig, T: number, pressures: Record<GasSpecies, number>): number;
 export declare function apply_gas_corrections(entries: PhaseData[], config: GasThermodynamicsConfig | undefined, T: number): PhaseData[];
-export declare function format_chemical_potential(mu: number, decimals?: number): string;
+export declare const format_chemical_potential: (mu: number, decimals?: number) => string;
 export declare function format_pressure(P: number): string;

package/dist/convex-hull/gas-thermodynamics.js

@@ -100,23 +100,21 @@ function interpolate_ts(data, T) {
 }
 // Default Provider Implementation
 // Create the default gas thermodynamics provider using built-in data
-export function create_default_gas_provider() {
-    return {
-        get_standard_chemical_potential(gas, T) {
-            // μ°(T) = H_f - T*S
-            // For elemental gases (O2, N2, H2, F2), H_f = 0
-            const H_f = DEFAULT_ENTHALPY[gas] ?? 0;
-            const TS = interpolate_ts(DEFAULT_TS_DATA[gas], T);
-            return H_f - TS;
-        },
-        get_supported_gases() {
-            return [...GAS_SPECIES];
-        },
-        get_temperature_range() {
-            return [0, 2000];
-        },
-    };
-}
+export const create_default_gas_provider = () => ({
+    get_standard_chemical_potential(gas, T) {
+        // μ°(T) = H_f - T*S
+        // For elemental gases (O2, N2, H2, F2), H_f = 0
+        const H_f = DEFAULT_ENTHALPY[gas] ?? 0;
+        const TS = interpolate_ts(DEFAULT_TS_DATA[gas], T);
+        return H_f - TS;
+    },
+    get_supported_gases() {
+        return [...GAS_SPECIES];
+    },
+    get_temperature_range() {
+        return [0, 2000];
+    },
+});
 // Singleton default provider
 let default_provider = null;
 // Get the default gas thermodynamics provider (lazy initialization)
@@ -237,7 +235,7 @@ export function compute_gas_correction(entry, config, T, pressures) {
         ...DEFAULT_ELEMENT_TO_GAS,
         ...config.element_to_gas,
     };
-    const enabled_gases = new Set(config.enabled_gases ?? []);
+    const enabled_gases = new Set(config.enabled_gases);
     let correction = 0;
     const n_atoms = count_atoms_in_composition(entry.composition);
     for (const [el_str, amount] of Object.entries(entry.composition)) {
@@ -290,21 +288,15 @@ export function apply_gas_corrections(entries, config, T) {
         // If no correction needed, return entry unchanged
         if (Math.abs(correction) < 1e-12)
             return entry;
-        // Apply correction to energy (update both energy and energy_per_atom
-        // so downstream formation energy calculations use the corrected value)
-        // Both fields store per-atom values, and correction is also per-atom
-        const corrected_energy = entry.energy + correction;
-        return {
-            ...entry,
-            energy: corrected_energy,
-            energy_per_atom: corrected_energy,
-        };
+        // compute_gas_correction is PER-ATOM: shift energy_per_atom by it and rescale total
+        // energy by atom count so downstream formation energies use the corrected values
+        const atoms = count_atoms_in_composition(entry.composition);
+        const energy_per_atom = (entry.energy_per_atom ?? entry.energy / atoms) + correction;
+        return { ...entry, energy: energy_per_atom * atoms, energy_per_atom };
     });
 }
 // Format chemical potential for display (e.g., "-1.23 eV")
-export function format_chemical_potential(mu, decimals = 3) {
-    return `${mu >= 0 ? `+` : ``}${mu.toFixed(decimals)} eV`;
-}
+export const format_chemical_potential = (mu, decimals = 3) => `${mu >= 0 ? `+` : ``}${mu.toFixed(decimals)} eV`;
 // Format pressure for display (scientific notation for very small/large values)
 export function format_pressure(P) {
     if (P >= 0.01 && P < 100) {

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

@@ -34,6 +34,9 @@ export declare function auto_threshold_reset(default_threshold: number): (next_s
 export declare function current_entry<Entry extends {
     entry_id?: string;
 }>(entry: Entry | null | undefined, entries: readonly Entry[]): Entry | null;
+export declare function same_entry<Entry extends {
+    entry_id?: string;
+}>(a: Entry | null | undefined, b: Entry | null | undefined): boolean;
 export declare function build_entry_tooltip_text(entry: PhaseData): string;
 export declare function find_hull_entry_at_mouse<T extends {
     x: number;

package/dist/convex-hull/helpers.js

@@ -48,7 +48,7 @@ export function get_energy_color_scale(color_mode, color_scale, plot_entries) {
 export function get_point_color_for_entry(entry, color_mode, colors, energy_scale) {
     const is_stable = entry_is_stable(entry);
     if (color_mode === `stability`) {
-        return is_stable ? colors?.stable || `#0072B2` : colors?.unstable || `#E69F00`;
+        return is_stable ? (colors?.stable ?? `#0072B2`) : (colors?.unstable ?? `#E69F00`);
     }
     return energy_scale && typeof entry.e_above_hull === `number`
         ? energy_scale(entry.e_above_hull)
@@ -120,6 +120,16 @@ export function current_entry(entry, entries) {
     }
     return entries.includes(entry) ? entry : null;
 }
+// Same logical entry: same object or same entry_id. The id check is proxy-safe — a raw
+// plot entry equals its $state-proxied copy, so the selection effect doesn't reassign
+// forever (effect_update_depth_exceeded) on identity mismatch.
+export function same_entry(a, b) {
+    if (a === b)
+        return true;
+    if (!a || !b)
+        return false;
+    return a.entry_id != null && a.entry_id === b.entry_id;
+}
 // Build a tooltip text for any phase entry (shared)
 export function build_entry_tooltip_text(entry) {
     const is_element = is_unary_entry(entry);
@@ -127,7 +137,7 @@ export function build_entry_tooltip_text(entry) {
     const elem_name = is_element ? (ELEM_SYMBOL_TO_NAME[elem_symbol] ?? ``) : ``;
     let text = is_element
         ? `${elem_symbol}${elem_name ? ` (${elem_name})` : ``}\n`
-        : `${entry.name || entry.reduced_formula || ``}\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) {
@@ -254,7 +264,7 @@ export const merge_highlight_style = (custom_style) => ({
 });
 // Check if entry matches any item in highlighted_list (by structure_id or entry_id)
 export function is_entry_highlighted(entry, highlighted_list) {
-    if (!highlighted_list.length)
+    if (highlighted_list.length === 0)
         return false;
     const { entry_id, structure_id } = entry;
     if (!entry_id && !structure_id)
@@ -322,12 +332,10 @@ function get_label_representative_energy(entry) {
         return entry.e_above_hull;
     return Number.POSITIVE_INFINITY;
 }
-function get_fractional_composition_key(composition) {
-    return Object.entries(get_fractional_composition(composition))
-        .sort(([elem_a], [elem_b]) => elem_a.localeCompare(elem_b))
-        .map(([elem, frac]) => `${elem}:${frac.toFixed(6)}`)
-        .join(`|`);
-}
+const get_fractional_composition_key = (composition) => Object.entries(get_fractional_composition(composition))
+    .sort(([elem_a], [elem_b]) => elem_a.localeCompare(elem_b))
+    .map(([elem, frac]) => `${elem}:${frac.toFixed(6)}`)
+    .join(`|`);
 // Pick one label target per normalized composition. Multiple polymorphs, supercell
 // formulas, or same-composition entries often project to the same screen position.
 export function get_composition_label_entries(entries) {

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

@@ -1,4 +1,5 @@
 import type { D3InterpolateName } from '../colors';
+import type { TooltipConfig } from '../tooltip';
 import type { Snippet } from 'svelte';
 import type { HTMLAttributes } from 'svelte/elements';
 import type { ConvexHullConfig, ConvexHullControlsType, GasSpecies, GasThermodynamicsConfig, HighlightStyle, HoverData3D, HullFaceColorMode, PhaseData, PhaseStats } from './types';
@@ -29,7 +30,6 @@ export interface TooltipSnippetProps<AnyDimEntry = PhaseData> {
     entry: AnyDimEntry;
     highlight_style?: HighlightStyle;
 }
-import type { TooltipConfig } from '../tooltip';
 export type ConvexHullTooltipConfig<AnyDimEntry = PhaseData> = TooltipConfig<AnyDimEntry>;
 export type ConvexHullTooltipProp<AnyDimEntry = PhaseData> = Snippet<[TooltipSnippetProps<AnyDimEntry>]> | ConvexHullTooltipConfig<AnyDimEntry>;
 export interface BaseConvexHullProps<AnyDimEntry = PhaseData> extends Omit<HTMLAttributes<HTMLDivElement>, `entries` | `children`> {

package/dist/convex-hull/thermodynamics.js

@@ -101,6 +101,8 @@ 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);
 export function calculate_e_above_hull(input, reference_entries) {
     const is_single = !Array.isArray(input);
     const entries_of_interest = is_single ? [input] : input;
@@ -135,7 +137,7 @@ export function calculate_e_above_hull(input, reference_entries) {
     if (arity === 1) {
         // Unary system
         for (const { entry, e_form } of interest_data) {
-            const id = entry.entry_id ?? JSON.stringify(entry.composition);
+            const id = id_of(entry);
             // For unary, e_above_hull is simply e_form (since stable state is 0)
             // Unless we have multiple polymorphs, in which case the hull is at min(e_form) which should be 0
             // But compute_e_form_per_atom already subtracts the stable unary reference energy.
@@ -149,6 +151,8 @@ export function calculate_e_above_hull(input, reference_entries) {
         // Build hull points from references
         const hull_input_map = new Map(); // x -> min_e_form
         for (const ref of reference_entries) {
+            if (ref.exclude_from_hull)
+                continue; // Shown but not used in hull construction
             const e_form = compute_e_form(ref);
             if (typeof e_form !== `number`)
                 continue;
@@ -169,7 +173,7 @@ export function calculate_e_above_hull(input, reference_entries) {
         const hull_points = Array.from(hull_input_map, ([x, y]) => ({ x, y }));
         const lower_hull = compute_lower_hull_2d(hull_points);
         for (const { entry, e_form } of interest_data) {
-            const id = entry.entry_id ?? JSON.stringify(entry.composition);
+            const id = id_of(entry);
             if (typeof e_form !== `number`) {
                 results[id] = NaN;
                 continue;
@@ -189,6 +193,8 @@ export function calculate_e_above_hull(input, reference_entries) {
         // Ternary system
         const ref_points = [];
         for (const ref of reference_entries) {
+            if (ref.exclude_from_hull)
+                continue; // Shown but not used in hull construction
             const e_form = compute_e_form(ref);
             if (typeof e_form !== `number`)
                 continue;
@@ -204,20 +210,26 @@ export function calculate_e_above_hull(input, reference_entries) {
         // Ensure corner points (pure elements default to e_form = 0)
         for (const el of elements) {
             const corner = barycentric_to_ternary_xyz(composition_to_barycentric_3d({ [el]: 1 }, elements), 0);
-            if (!ref_points.some((point) => Math.hypot(point.x - corner.x, point.y - corner.y, point.z - corner.z) < 1e-9)) {
+            const dist = (point) => Math.hypot(point.x - corner.x, point.y - corner.y, point.z - corner.z);
+            if (!ref_points.some((point) => dist(point) < 1e-9))
                 ref_points.push(corner);
-            }
         }
         const hull_triangles = compute_lower_hull_triangles(ref_points);
         const hull_models = build_lower_hull_model(hull_triangles);
+        // No facets despite enough refs → all coplanar at e_form = 0: use elemental tie-plane
+        const degenerate_hull_3d = hull_triangles.length === 0 && ref_points.length >= arity;
         for (const { entry, e_form } of interest_data) {
-            const id = entry.entry_id ?? JSON.stringify(entry.composition);
+            const id = id_of(entry);
             if (typeof e_form !== `number`) {
                 results[id] = NaN;
                 continue;
             }
             try {
                 const bary = composition_to_barycentric_3d(entry.composition, elements);
+                if (degenerate_hull_3d) {
+                    results[id] = Math.max(0, e_form);
+                    continue;
+                }
                 const point = barycentric_to_ternary_xyz(bary, e_form);
                 const z_hull = e_hull_at_xy(hull_models, point.x, point.y);
                 results[id] = z_hull === null ? NaN : Math.max(0, point.z - z_hull);
@@ -231,6 +243,8 @@ export function calculate_e_above_hull(input, reference_entries) {
         // Quaternary system
         const ref_points = [];
         for (const ref of reference_entries) {
+            if (ref.exclude_from_hull)
+                continue; // Shown but not used in hull construction
             const e_form = compute_e_form(ref);
             if (typeof e_form !== `number`)
                 continue;
@@ -252,46 +266,45 @@ export function calculate_e_above_hull(input, reference_entries) {
                 ref_points.push(corner);
         }
         const hull_tetrahedra = compute_lower_hull_4d(ref_points);
+        // No facets despite enough refs → all coplanar at e_form = 0: use elemental tie-plane
+        const degenerate_hull_4d = hull_tetrahedra.length === 0 && ref_points.length >= arity;
         const interest_points = [];
-        const interest_indices = [];
+        const idx_to_point_idx = new Map(); // entry idx -> point idx
         interest_data.forEach(({ entry, e_form }, idx) => {
-            if (typeof e_form === `number`) {
-                try {
-                    const bary = composition_to_barycentric_4d(entry.composition, elements);
-                    const tet = barycentric_to_tetrahedral(bary);
-                    interest_points.push({ ...tet, w: e_form });
-                    interest_indices.push(idx);
-                }
-                catch {
-                    // Skip
-                }
+            if (typeof e_form !== `number`)
+                return;
+            try {
+                const bary = composition_to_barycentric_4d(entry.composition, elements);
+                const tet = barycentric_to_tetrahedral(bary);
+                idx_to_point_idx.set(idx, interest_points.length);
+                interest_points.push({ ...tet, w: e_form });
+            }
+            catch {
+                // Skip
             }
         });
         const distances = compute_e_above_hull_4d(interest_points, hull_tetrahedra);
-        // Build reverse lookup for O(1) access
-        const idx_to_point_idx = new Map();
-        interest_indices.forEach((original_idx, point_idx) => {
-            idx_to_point_idx.set(original_idx, point_idx);
-        });
         // Map back
         for (let idx = 0; idx < interest_data.length; idx++) {
-            const { entry } = interest_data[idx];
-            const id = entry.entry_id ?? JSON.stringify(entry.composition);
-            const point_idx = idx_to_point_idx.get(idx) ?? -1;
-            if (point_idx !== -1) {
-                results[id] = Math.max(0, distances[point_idx]);
-            }
-            else {
+            const { entry, e_form } = interest_data[idx];
+            const id = id_of(entry);
+            const point_idx = idx_to_point_idx.get(idx);
+            const on_tie_plane = degenerate_hull_4d && typeof e_form === `number`;
+            if (point_idx === undefined)
                 results[id] = NaN;
-            }
+            else
+                results[id] = Math.max(0, on_tie_plane ? e_form : distances[point_idx]);
         }
     }
     else {
         // Arity 5+ uses generalized N-dimensional convex hull
-        // Helper to convert entry to hull point, returns null on expected errors
+        // Helper to convert entry to hull point, returns null on expected errors.
+        // Barycentric coords sum to 1, so the first is dropped: keeping all N would confine
+        // points to an (N-1)-dim affine subspace, leaving the hull permanently degenerate.
         const to_hull_point = (entry, e_form) => {
             try {
-                return [...composition_to_barycentric_nd(entry.composition, elements), e_form];
+                const bary = composition_to_barycentric_nd(entry.composition, elements);
+                return [...bary.slice(1), e_form];
             }
             catch (err) {
                 // Skip expected errors (missing elements), warn on unexpected
@@ -304,6 +317,8 @@ export function calculate_e_above_hull(input, reference_entries) {
         // Build reference points
         const ref_points = [];
         for (const ref of reference_entries) {
+            if (ref.exclude_from_hull)
+                continue; // Shown but not used in hull construction
             const e_form = compute_e_form(ref);
             if (typeof e_form !== `number`)
                 continue;
@@ -311,20 +326,21 @@ export function calculate_e_above_hull(input, reference_entries) {
             if (point)
                 ref_points.push(point);
         }
-        // Ensure corner points (pure elements default to e_form = 0)
+        // Ensure corner points (pure elements default to e_form = 0). In reduced
+        // coordinates, element 0 is the origin; element k > 0 has (k-1)th coord = 1.
         for (let el_idx = 0; el_idx < arity; el_idx++) {
-            const corner = Array(arity + 1).fill(0);
-            corner[el_idx] = 1; // ith barycentric coord = 1
+            const corner = Array(arity).fill(0);
+            if (el_idx > 0)
+                corner[el_idx - 1] = 1;
             if (!ref_points.some((pt) => norm_nd(subtract_nd(pt, corner)) < EPS)) {
                 ref_points.push(corner);
             }
         }
         const hull_facets = compute_lower_hull_nd(compute_quickhull_nd(ref_points));
-        // Warn if hull is degenerate (all points coplanar or insufficient spread)
+        // Degenerate hull (all refs co-hyperplanar, e.g. all e_form = 0): tie-plane fallback is exact
         if (hull_facets.length === 0 && ref_points.length >= arity + 1) {
-            console.warn(`N-dimensional hull for ${arity}-element system is degenerate. ` +
-                `Falling back to tie-hyperplane at energy 0. ` +
-                `Consider using pymatgen for complex high-dimensional phase diagrams.`);
+            console.warn(`N-dimensional hull for ${arity}-element system is degenerate ` +
+                `(all reference points co-hyperplanar). Falling back to tie-hyperplane at energy 0.`);
         }
         // Build query points with mapping back to original indices
         const interest_points = [];
@@ -343,27 +359,20 @@ export function calculate_e_above_hull(input, reference_entries) {
         const distances = hull_facets.length > 0
             ? compute_e_above_hull_nd(interest_points, hull_facets, ref_points)
             : [];
-        // Map results back to entries
+        // Map results back to entries (degenerate hull → tie-hyperplane at energy 0)
         for (let idx = 0; idx < interest_data.length; idx++) {
             const { entry, e_form } = interest_data[idx];
-            const id = entry.entry_id ?? JSON.stringify(entry.composition);
+            const id = id_of(entry);
             const point_idx = idx_to_point_idx.get(idx);
-            if (point_idx === undefined) {
+            const on_tie_plane = hull_facets.length === 0 && typeof e_form === `number`;
+            if (point_idx === undefined)
                 results[id] = NaN;
-            }
-            else if (hull_facets.length === 0 && typeof e_form === `number`) {
-                // Degenerate case: hull is tie-hyperplane at energy 0
-                results[id] = Math.max(0, e_form);
-            }
-            else {
-                results[id] = Math.max(0, distances[point_idx]);
-            }
+            else
+                results[id] = Math.max(0, on_tie_plane ? e_form : distances[point_idx]);
         }
     }
-    if (is_single) {
-        const id = entries_of_interest[0].entry_id ?? JSON.stringify(entries_of_interest[0].composition);
-        return results[id];
-    }
+    if (is_single)
+        return results[id_of(entries_of_interest[0])];
     return results;
 }
 export function get_convex_hull_stats(processed_entries, elements, max_arity = 4) {
@@ -437,25 +446,23 @@ export function get_convex_hull_stats(processed_entries, elements, max_arity = 4
 }
 // Convert a PhaseData entry to a ConvexHullEntry with default visual fields.
 // x/y/z default to 0 since high-dim systems aren't visually plotted.
-function to_hull_entry(entry) {
-    return {
-        ...entry,
-        is_element: get_arity(entry) === 1,
-        x: 0,
-        y: 0,
-        z: 0,
-    };
-}
+const to_hull_entry = (entry) => ({
+    ...entry,
+    is_element: get_arity(entry) === 1,
+    x: 0,
+    y: 0,
+    z: 0,
+});
 // Process raw hull entries for high-dimensional systems (5+ elements) where the
 // ConvexHull visual component can't render. Computes formation energies, hull distances,
 // stable/unstable classification, and phase stats. Returns null on failure.
 // Optionally accepts `elements` to scope the chemical system; if omitted, elements
 // are derived from the entries' compositions.
 export function process_hull_for_stats(entries, elements) {
-    if (!entries.length)
+    if (entries.length === 0)
         return null;
     const processed = process_hull_entries(entries);
-    if (!processed.entries.length)
+    if (processed.entries.length === 0)
         return null;
     const hull_elements = elements ?? processed.elements;
     // Compute formation energies
@@ -473,7 +480,7 @@ export function process_hull_for_stats(entries, elements) {
     try {
         const hull_distances = calculate_e_above_hull(processed.entries, processed.entries);
         for (const entry of processed.entries) {
-            const dist = hull_distances[entry.entry_id ?? JSON.stringify(entry.composition)];
+            const dist = hull_distances[id_of(entry)];
             if (typeof dist === `number` && Number.isFinite(dist)) {
                 entry.e_above_hull = dist;
                 entry.is_stable = dist < HULL_STABILITY_TOL;
@@ -1672,19 +1679,17 @@ export function compute_lower_hull_nd(faces) {
     // Last dimension is energy; negative normal means "downward"
     return faces.filter((face) => (face.plane.normal.at(-1) ?? 0) < -EPS);
 }
-function build_simplex_models_nd(faces, points) {
-    return faces.map((face) => {
-        const vertices = face.vertex_indices.map((idx) => points[idx]);
-        const n = vertices[0].length;
-        // Spatial coords are all except last (energy)
-        const vertices_spatial = vertices.map((pt) => pt.slice(0, n - 1));
-        // Compute bounding box in spatial dimensions
-        const spatial_dim = n - 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])));
-        return { vertices, vertices_spatial, bbox_min, bbox_max };
-    });
-}
+const build_simplex_models_nd = (faces, points) => faces.map((face) => {
+    const vertices = face.vertex_indices.map((idx) => points[idx]);
+    const n = vertices[0].length;
+    // Spatial coords are all except last (energy)
+    const vertices_spatial = vertices.map((pt) => pt.slice(0, n - 1));
+    // Compute bounding box in spatial dimensions
+    const spatial_dim = n - 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])));
+    return { vertices, vertices_spatial, bbox_min, bbox_max };
+});
 // Check if point is inside simplex and return barycentric coordinates
 // Uses linear system solution: point = sum(bary[i] * vertex[i]) with sum(bary) = 1
 function point_in_simplex_nd(point, simplex_vertices) {

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

@@ -2,7 +2,7 @@ import type { CompositionType } from '../composition';
 import type { ShowControlsProp } from '../controls';
 import type { ElementSymbol } from '../element';
 import type { Point2D, Point3D, Vec3 } from '../math';
-import type { Rect, Sides } from '../plot/layout';
+import type { Rect, Sides } from '../plot/core/layout';
 import type { AnyStructure } from '../structure';
 export interface StructurePopupStats {
     id?: string;

package/dist/coordination/CoordinationBarPlot.svelte

@@ -9,7 +9,7 @@
     BarHandlerProps,
     BarSeries,
     Orientation,
-  } from '../plot/types'
+  } from '../plot/core/types'
   import type { AnyStructure } from '../structure'
   import type { BondingStrategy } from '../structure/bonding'
   import { parse_any_structure } from '../structure/parse'
@@ -18,6 +18,7 @@
   import { SvelteMap, SvelteSet } from 'svelte/reactivity'
   import { calc_coordination_nums, type CoordinationData } from './calc-coordination'
   import type { SplitMode } from './index'
+  import { to_error } from '../utils'
 
   type CoordinationMetadata = {
     element?: string
@@ -178,31 +179,30 @@
           metadata: { structure_label: entry.label },
         }
       })
-    } else {
-      // split_mode === 'none': combine all into single series
-      const combined_histogram = new SvelteMap<number, number>()
+    }
+    // split_mode === 'none': combine all into single series
+    const combined_histogram = new SvelteMap<number, number>()
 
-      for (const entry of entries_with_data) {
-        for (const [cn, count] of entry.data.cn_histogram) {
-          combined_histogram.set(cn, (combined_histogram.get(cn) ?? 0) + count)
-        }
+    for (const entry of entries_with_data) {
+      for (const [cn, count] of entry.data.cn_histogram) {
+        combined_histogram.set(cn, (combined_histogram.get(cn) ?? 0) + count)
       }
+    }
 
-      const x_vals = Array.from(combined_histogram.keys()).sort((a, b) => a - b)
-      const y_vals = x_vals.map((cn) => combined_histogram.get(cn) ?? 0)
+    const x_vals = Array.from(combined_histogram.keys()).sort((a, b) => a - b)
+    const y_vals = x_vals.map((cn) => combined_histogram.get(cn) ?? 0)
 
-      return [
-        {
-          x: x_vals,
-          y: y_vals,
-          label: `All Sites`,
-          color: PLOT_COLORS[0],
-          bar_width: 0.8,
-          visible: true,
-          metadata: {},
-        },
-      ]
-    }
+    return [
+      {
+        x: x_vals,
+        y: y_vals,
+        label: `All Sites`,
+        color: PLOT_COLORS[0],
+        bar_width: 0.8,
+        visible: true,
+        metadata: {},
+      },
+    ]
   })
 
   const compute_and_add = (content: string | ArrayBuffer, filename: string) => {
@@ -221,7 +221,7 @@
       }
     } catch (exc) {
       error_msg = `Failed to process structure: ${
-        exc instanceof Error ? exc.message : String(exc)
+        to_error(exc).message
       }`
     }
   }