matterviz 0.4.0 → 0.4.2

package/dist/convex-hull/helpers.js

@@ -1,30 +1,115 @@
-import { get_d3_interpolator } from '../colors';
+import { add_alpha, get_d3_interpolator } from '../colors';
 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 } 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);
     return { e_above_hull, is_stable: e_above_hull <= tol };
 }
+// Look up the original (un-projected) entry by id and return its structure if any.
+// Shared by ConvexHull2D/3D/4D for the click-to-preview structure popup.
+export const extract_structure_from_entry = (entries, entry) => {
+    if (!entry.entry_id)
+        return null;
+    const orig_entry = entries.find((ent) => ent.entry_id === entry.entry_id);
+    return orig_entry?.structure || null;
+};
+// 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` && 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;
 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));
+// Normalize a raw value to a canonical category value: case-insensitive match against
+// config.markers keys, then config.aliases. Returns null for unrecognized values.
+function normalize_category_value(raw, config) {
+    if (typeof raw !== `string`)
+        return null;
+    const lower = raw.trim().toLowerCase();
+    if (!lower)
+        return null;
+    const canonical = Object.keys(config.markers).find((value) => value.toLowerCase() === lower);
+    if (canonical)
+        return canonical;
+    const alias = config.aliases?.[lower];
+    return alias && alias in config.markers ? alias : null;
+}
+// Resolve an entry's category: first *recognized* value wins. Properties are checked in
+// config order (property-major), each looked up top-level, then in the pymatgen `data`
+// and Materials Project `attributes` dicts — so a `magnetic_ordering` in any source
+// beats a generic `ordering`. Unrecognized values (e.g. MP's ordering='Unknown') fall
+// through; returns null when none resolve.
+export function get_entry_category(entry, config) {
+    if (!config)
+        return null;
+    const props = Array.isArray(config.property) ? config.property : [config.property];
+    for (const prop of props) {
+        for (const source of [entry, entry.data, entry.attributes]) {
+            if (!source)
+                continue;
+            const value = normalize_category_value(source[prop], config);
+            if (value)
+                return value;
+        }
+    }
+    return null;
+}
+// Assign default marker shapes by category (per config.markers). Explicit entry.marker
+// values win. Returns the input array unchanged when no marker was assigned (e.g. when
+// config is null or entries lack category data).
+export function apply_category_markers(entries, config) {
+    if (!config)
+        return entries;
+    let any_assigned = false;
+    const result = entries.map((entry) => {
+        const value = entry.marker ? null : get_entry_category(entry, config);
+        if (!value)
+            return entry;
+        any_assigned = true;
+        return { ...entry, marker: config.markers[value] };
+    });
+    return any_assigned ? result : entries;
+}
+export const entry_is_visible = (entry, show_stable, show_unstable, category = null, hidden_categories = []) => {
+    if (!(entry_is_stable(entry) ? show_stable : show_unstable))
+        return false;
+    if (!category || hidden_categories.length === 0)
+        return true;
+    const value = get_entry_category(entry, category);
+    return value === null || !hidden_categories.includes(value);
+};
+export const visible_entries = (entries, show_stable, show_unstable, category = null, hidden_categories = []) => entries.filter((entry) => entry_is_visible(entry, show_stable, show_unstable, category, hidden_categories));
 // 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)
@@ -95,8 +180,8 @@ export function compute_auto_hull_dist_threshold(n_entries, max_hull_dist_in_dat
         return max_hull_dist_in_data;
     if (n_entries >= HIGH)
         return static_default;
-    const t = (n_entries - LOW) / (HIGH - LOW);
-    return max_hull_dist_in_data * (1 - t) + static_default * t;
+    const frac = (n_entries - LOW) / (HIGH - LOW);
+    return max_hull_dist_in_data * (1 - frac) + static_default * frac;
 }
 export function auto_threshold_reset(default_threshold) {
     let source;
@@ -131,7 +216,7 @@ export function same_entry(a, b) {
     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) {
+export function build_entry_tooltip_text(entry, category = MAGNETIC_ORDERING_CATEGORY) {
     const is_element = is_unary_entry(entry);
     const elem_symbol = is_element ? Object.keys(entry.composition)[0] : ``;
     const elem_name = is_element ? (ELEM_SYMBOL_TO_NAME[elem_symbol] ?? ``) : ``;
@@ -139,15 +224,9 @@ export function build_entry_tooltip_text(entry) {
         ? `${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~`);
@@ -159,6 +238,9 @@ export function build_entry_tooltip_text(entry) {
         const e_form_str = format_num(e_form_display, `.3~`);
         text += `E<sub>form</sub>: ${e_form_str} eV/atom`;
     }
+    const category_value = get_entry_category(entry, category);
+    if (category && category_value)
+        text += `\n${category.label}: ${category_value}`;
     if (entry.entry_id)
         text += `\nID: ${entry.entry_id}`;
     return text;
@@ -180,6 +262,11 @@ export function find_hull_entry_at_mouse(canvas, event, plot_entries, project_po
     }
     return null;
 }
+// Shared CSS custom-property block for hull wrapper styling (2D/3D/4D)
+export const hull_style_css = (colors) => `--hull-stable-color: ${colors?.stable ?? `#0072B2`};
+    --hull-unstable-color: ${colors?.unstable ?? `#E69F00`};
+    --hull-edge-color: ${colors?.edge ?? `var(--text-color, #212121)`};
+    --hull-text-color: ${colors?.annotation ?? `var(--text-color, #212121)`}`;
 // Calculate which side of the viewport has more space for modal placement
 export function calculate_modal_side(wrapper) {
     if (!wrapper)
@@ -210,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,
     };
@@ -245,8 +332,8 @@ compute_e_form_fn) {
     });
 }
 // Copy text to clipboard with visual feedback
-export async function copy_entry_to_clipboard(entry, position, on_feedback) {
-    const text = build_entry_tooltip_text(entry);
+export async function copy_entry_to_clipboard(entry, position, on_feedback, category = MAGNETIC_ORDERING_CATEGORY) {
+    const text = build_entry_tooltip_text(entry, category);
     await navigator.clipboard.writeText(text);
     on_feedback(true, position);
     setTimeout(() => on_feedback(false, position), 1500);
@@ -423,30 +510,6 @@ export function compute_all_polymorph_stats(all_entries) {
     }
     return stats_map;
 }
-function apply_alpha_to_color(color, alpha) {
-    // Handle existing rgba format
-    if (color.includes(`rgba`))
-        return color.replace(/[\d.]+\)$/, `${alpha})`);
-    if (color.includes(`rgb(`)) {
-        // Convert rgb to rgba
-        return color.replace(/rgb\(/, `rgba(`).replace(/\)$/, `, ${alpha})`);
-    }
-    const hex_match = /^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/.exec(color); // Convert hex to rgba
-    if (hex_match) {
-        let hex = hex_match[1];
-        // Expand short form (e.g. "03F") to full form (e.g. "0033FF")
-        if (hex.length === 3)
-            hex = hex
-                .split(``)
-                .map((char) => char + char)
-                .join(``);
-        const red = parseInt(hex.slice(0, 2), 16);
-        const green = parseInt(hex.slice(2, 4), 16);
-        const blue = parseInt(hex.slice(4, 6), 16);
-        return `rgba(${red}, ${green}, ${blue}, ${alpha})`;
-    }
-    return color; // Return unchanged if format not recognized
-}
 export function draw_highlight_effect(ctx, projected, size, container_scale, pulse_time, style) {
     const { effect, color: hl_color, size_multiplier, opacity, pulse_speed } = style;
     if (effect === `pulse`) {
@@ -458,8 +521,8 @@ export function draw_highlight_effect(ctx, projected, size, container_scale, pul
         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);
-        ctx.strokeStyle = apply_alpha_to_color(hl_color, hl_opacity);
+        ctx.fillStyle = add_alpha(hl_color, hl_opacity * 0.3);
+        ctx.strokeStyle = add_alpha(hl_color, hl_opacity);
         ctx.fill();
         ctx.stroke();
     }
@@ -469,14 +532,14 @@ export function draw_highlight_effect(ctx, projected, size, container_scale, pul
         // Outer soft glow
         ctx.beginPath();
         ctx.arc(projected.x, projected.y, hl_size * 1.3, 0, 2 * Math.PI);
-        ctx.fillStyle = apply_alpha_to_color(hl_color, opacity * 0.15);
+        ctx.fillStyle = add_alpha(hl_color, opacity * 0.15);
         ctx.fill();
         // Inner glow with stroke
         ctx.lineWidth = 1.5 * container_scale;
         ctx.beginPath();
         ctx.arc(projected.x, projected.y, hl_size, 0, 2 * Math.PI);
-        ctx.fillStyle = apply_alpha_to_color(hl_color, opacity * 0.4);
-        ctx.strokeStyle = apply_alpha_to_color(hl_color, opacity * 0.8);
+        ctx.fillStyle = add_alpha(hl_color, opacity * 0.4);
+        ctx.strokeStyle = add_alpha(hl_color, opacity * 0.8);
         ctx.fill();
         ctx.stroke();
     }
@@ -494,8 +557,8 @@ export function draw_highlight_effect(ctx, projected, size, container_scale, pul
 // Draw selection highlight for currently selected entry (with pulsing animation)
 export function draw_selection_highlight(ctx, projected, base_size, container_scale, pulse_time, pulse_opacity) {
     const highlight_size = base_size * (1.8 + 0.3 * Math.sin(pulse_time * 4));
-    ctx.fillStyle = apply_alpha_to_color(`rgba(102, 240, 255, 1)`, pulse_opacity * 0.6);
-    ctx.strokeStyle = apply_alpha_to_color(`rgba(102, 240, 255, 1)`, pulse_opacity);
+    ctx.fillStyle = add_alpha(`rgba(102, 240, 255, 1)`, pulse_opacity * 0.6);
+    ctx.strokeStyle = add_alpha(`rgba(102, 240, 255, 1)`, pulse_opacity);
     ctx.lineWidth = 2 * container_scale;
     ctx.beginPath();
     ctx.arc(projected.x, projected.y, highlight_size, 0, 2 * Math.PI);
@@ -514,19 +577,69 @@ export function get_canvas_text_color(dark_mode, element) {
     // Check for unsupported CSS functions that canvas can't render
     return css_value && !/light-dark|var\(/i.test(css_value) ? css_value : fallback;
 }
-// Create a Path2D for a marker symbol. Uses d3-shape for consistent rendering with ScatterPlot.
-export function create_marker_path(size, marker = `circle`) {
-    const safe_size = Number.isFinite(size) ? size : 0;
-    const rounded_size = Math.max(0, Number(safe_size.toFixed(3)));
+// Draw depth-sorted hull points with shadow, selection/highlight effects and marker
+// symbols. Shared by the ConvexHull3D/4D canvas renderers (which differ only in
+// shadow_factor and in how labels are drawn afterwards).
+export function draw_hull_points(ctx, sorted_points, opts) {
+    const { scale, shadow_factor, selected_entry, highlight_style, is_highlighted, get_point_color, pulse_time, pulse_opacity, } = opts;
+    for (const { entry, projected } of sorted_points) {
+        const is_stable = entry_is_stable(entry);
+        const entry_highlighted = is_highlighted(entry);
+        const color = get_point_color(entry);
+        // `||` (not ??) on purpose: size=0 / empty marker fall back to defaults
+        // oxlint-disable-next-line typescript/prefer-nullish-coalescing
+        const size = (entry.size || (is_stable ? 6 : 4)) * scale;
+        // oxlint-disable-next-line typescript/prefer-nullish-coalescing
+        const marker = entry.marker || `circle`;
+        // Shadow
+        const shadow_offset = Math.abs(entry.z) * shadow_factor * scale;
+        ctx.fillStyle = `rgba(0, 0, 0, 0.2)`;
+        const shadow_path = create_marker_path(size * 0.8, marker);
+        ctx.save();
+        ctx.translate(projected.x + shadow_offset, projected.y + shadow_offset);
+        ctx.fill(shadow_path);
+        ctx.restore();
+        // Highlights (same_entry, not raw entry_id comparison: undefined === undefined
+        // would mark EVERY id-less point as selected)
+        if (same_entry(selected_entry, entry)) {
+            draw_selection_highlight(ctx, projected, size, scale, pulse_time, pulse_opacity);
+        }
+        if (entry_highlighted) {
+            draw_highlight_effect(ctx, projected, size, scale, pulse_time, highlight_style);
+        }
+        // Main point with marker symbol
+        ctx.fillStyle =
+            entry_highlighted && highlight_style.effect === `color` ? highlight_style.color : color;
+        ctx.strokeStyle = is_stable ? `#ffffff` : `#000000`;
+        ctx.lineWidth = 0.5 * scale;
+        const marker_path = create_marker_path(size, marker);
+        ctx.save();
+        ctx.translate(projected.x, projected.y);
+        ctx.fill(marker_path);
+        ctx.stroke(marker_path);
+        ctx.restore();
+    }
+}
+// SVG path data for a marker symbol of given radius, or null for unknown marker names.
+// Uses d3-shape for consistent rendering with ScatterPlot.
+export function marker_path_data(radius, marker) {
     // Capitalize first letter to get D3 symbol name (e.g. 'circle' -> 'Circle')
     const d3_name = marker.charAt(0).toUpperCase() + marker.slice(1);
     const symbol_type = symbol_map[d3_name];
-    const symbol_area = Math.PI * rounded_size * rounded_size;
-    const path_data = symbol_type ? symbol().type(symbol_type).size(symbol_area)() : null;
+    return symbol_type
+        ? symbol()
+            .type(symbol_type)
+            .size(Math.PI * radius * radius)()
+        : null;
+}
+// Create a Path2D for a marker symbol (canvas rendering in ConvexHull3D/4D)
+export function create_marker_path(size, marker = `circle`) {
+    const safe_size = Number.isFinite(size) ? size : 0;
+    const rounded_size = Math.max(0, Number(safe_size.toFixed(3)));
+    const path_data = marker_path_data(rounded_size, marker);
     const path = new Path2D(path_data ?? undefined);
-    if (!path_data) {
+    if (!path_data)
         path.arc(0, 0, rounded_size, 0, 2 * Math.PI);
-    }
     return path;
 }
 // Analyze entries for temperature-dependent free energy data.
@@ -646,60 +759,32 @@ 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)
     });
 }
-// Gas-dependent chemical potential helpers
-// 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?.enabled_gases?.length) {
-        return {
-            has_gas_dependent_elements: false,
-            gas_elements: [],
-            relevant_gases: [],
-        };
-    }
-    return _analyze_gas_data(entries, config);
-}
-// Apply gas chemical potential corrections to entries (safe wrapper with optional 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?.enabled_gases?.length)
-        return entries;
-    return _apply_gas_corrections(entries, config, T);
-}
 // Get gas-corrected entries in one call (consolidates analysis + correction)
 // Merges gas_pressures with config.pressures and applies corrections if the
 // chemical system contains gas-dependent elements. Returns original entries
 // 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.
@@ -708,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

@@ -0,0 +1,44 @@
+import * as helpers from './helpers';
+import type { EntryCategoryConfig, GasSpecies, GasThermodynamicsConfig, PhaseData } from './types';
+export interface HullDataPipelineInputs<Entry extends PhaseData> {
+    dim: 2 | 3 | 4;
+    entries: () => PhaseData[];
+    temperature: () => number | undefined;
+    interpolate_temperature: () => boolean;
+    max_interpolation_gap: () => number;
+    gas_config: () => GasThermodynamicsConfig | undefined;
+    gas_pressures: () => Partial<Record<GasSpecies, number>>;
+    energy_source_mode: () => `precomputed` | `on-the-fly`;
+    all_enriched_entries: () => Entry[];
+    max_hull_dist_show_phases: () => number;
+    show_stable: () => boolean;
+    show_unstable: () => boolean;
+    entry_category: () => EntryCategoryConfig | null;
+    hidden_categories: () => readonly string[];
+    keep_plot_entry: (entry: Entry, max_hull_dist: number) => boolean;
+    set_temperature: (temperature: number) => void;
+    set_max_hull_dist_show_phases: (value: number) => void;
+    set_stable_entries: (value: Entry[]) => void;
+    set_unstable_entries: (value: Entry[]) => void;
+}
+export declare function create_hull_data_pipeline<Entry extends PhaseData>(inputs: HullDataPipelineInputs<Entry>): {
+    readonly has_temp_data: boolean;
+    readonly available_temperatures: number[];
+    readonly gas_analysis: import("./types").GasAnalysis;
+    readonly merged_gas_config: GasThermodynamicsConfig | undefined;
+    readonly has_precomputed_e_form: boolean;
+    readonly has_precomputed_hull: boolean;
+    readonly can_compute_e_form: boolean;
+    readonly can_compute_hull: boolean;
+    readonly energy_mode: "precomputed" | "on-the-fly";
+    readonly effective_entries: (PhaseData & {
+        marker?: import("./types").MarkerSymbol;
+    })[];
+    readonly pd_data: import("./types").ProcessedPhaseData;
+    readonly polymorph_stats_map: Map<string, helpers.PolymorphStats>;
+    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[];
+    readonly visible_entries: Entry[];
+};

package/dist/convex-hull/hull-state.svelte.js

@@ -0,0 +1,124 @@
+// Shared reactive data pipeline (runes-in-closure factory) for ConvexHull2D/3D/4D.
+import { DEFAULTS } from '../settings';
+import * as helpers from './helpers';
+import * as thermo from './thermodynamics';
+const DIM_TO_KIND = { 2: `binary`, 3: `ternary`, 4: `quaternary` };
+export function create_hull_data_pipeline(inputs) {
+    const kind = DIM_TO_KIND[inputs.dim];
+    const default_threshold = DEFAULTS.convex_hull[kind].max_hull_dist_show_phases;
+    // Temperature-dependent free energy support
+    const temp_analysis = $derived(helpers.analyze_temperature_data(inputs.entries()));
+    // Initialize or reset temperature when it's undefined or no longer valid
+    $effect(() => {
+        const temperature = inputs.temperature();
+        const { has_temp_data, available_temperatures } = temp_analysis;
+        if (has_temp_data &&
+            available_temperatures.length > 0 &&
+            (temperature === undefined || !available_temperatures.includes(temperature)))
+            inputs.set_temperature(available_temperatures[0]);
+    });
+    // Filter entries by temperature when in temperature mode
+    const temp_filtered_entries = $derived.by(() => {
+        const temperature = inputs.temperature();
+        return temp_analysis.has_temp_data && temperature !== undefined
+            ? helpers.filter_entries_at_temperature(inputs.entries(), temperature, {
+                interpolate: inputs.interpolate_temperature(),
+                max_interpolation_gap: inputs.max_interpolation_gap(),
+            })
+            : inputs.entries();
+    });
+    // Gas-dependent chemical potential support (corrections based on T, P)
+    // defaults to DEFAULT_GAS_TEMP (room temp) when no temperature
+    const gas_result = $derived(helpers.get_gas_corrected_entries(temp_filtered_entries, inputs.gas_config(), inputs.gas_pressures(), inputs.temperature() ?? helpers.DEFAULT_GAS_TEMP));
+    // Compute energy mode information
+    const energy_info = $derived(helpers.compute_energy_mode_info(gas_result.entries, thermo.find_lowest_energy_unary_refs, inputs.energy_source_mode()));
+    // Assign category marker shapes (no-op when entries lack category data)
+    const effective_entries = $derived(helpers.apply_category_markers(helpers.get_effective_entries(gas_result.entries, energy_info.energy_mode, energy_info.unary_refs, thermo.compute_e_form_per_atom), inputs.entry_category()));
+    // Process convex hull data with unified PhaseData interface using effective entries
+    const pd_data = $derived(thermo.process_hull_entries(effective_entries));
+    // Pre-compute polymorph stats once for O(1) tooltip lookups
+    const polymorph_stats_map = $derived(helpers.compute_all_polymorph_stats(effective_entries));
+    const elements = $derived.by(() => {
+        if (pd_data.elements.length > inputs.dim) {
+            console.error(`ConvexHull${inputs.dim}D: Dataset contains ${pd_data.elements.length} elements, but ${kind} diagrams require exactly ${inputs.dim}. Found: [${pd_data.elements.join(`, `)}]`);
+            return [];
+        }
+        return pd_data.elements;
+    });
+    // Auto threshold: show all for few entries, use default for many, interpolate between
+    const max_hull_dist_in_data = $derived(helpers.calc_max_hull_dist_in_data(inputs.all_enriched_entries()));
+    const auto_default_threshold = $derived(helpers.compute_auto_hull_dist_threshold(inputs.all_enriched_entries().length, max_hull_dist_in_data, default_threshold));
+    const next_auto_threshold = helpers.auto_threshold_reset(default_threshold);
+    $effect(() => {
+        const current = inputs.max_hull_dist_show_phases();
+        // Key the reset on the enriched (post-processing) entries, not raw entries(), so the
+        // auto threshold re-derives when temperature/gas/energy-mode change the hull. The
+        // user_changed guard inside auto_threshold_reset still preserves manual adjustments.
+        inputs.set_max_hull_dist_show_phases(next_auto_threshold(inputs.all_enriched_entries(), current, auto_default_threshold) ??
+            current);
+    });
+    // Filter by threshold; visibility is a view predicate, not entry state.
+    const plot_entries = $derived(inputs
+        .all_enriched_entries()
+        .filter((entry) => inputs.keep_plot_entry(entry, inputs.max_hull_dist_show_phases())));
+    const visible_entries = $derived(helpers.visible_entries(plot_entries, inputs.show_stable(), inputs.show_unstable(), inputs.entry_category(), inputs.hidden_categories()));
+    // Update bindable stable/unstable entry arrays when plot_entries change
+    $effect(() => {
+        const is_stable = (entry) => helpers.entry_is_stable(entry);
+        inputs.set_stable_entries(plot_entries.filter(is_stable));
+        inputs.set_unstable_entries(plot_entries.filter((entry) => !is_stable(entry)));
+    });
+    return {
+        get has_temp_data() {
+            return temp_analysis.has_temp_data;
+        },
+        get available_temperatures() {
+            return temp_analysis.available_temperatures;
+        },
+        get gas_analysis() {
+            return gas_result.analysis;
+        },
+        get merged_gas_config() {
+            return gas_result.merged_config;
+        },
+        get has_precomputed_e_form() {
+            return energy_info.has_precomputed_e_form;
+        },
+        get has_precomputed_hull() {
+            return energy_info.has_precomputed_hull;
+        },
+        get can_compute_e_form() {
+            return energy_info.can_compute_e_form;
+        },
+        get can_compute_hull() {
+            return energy_info.can_compute_hull;
+        },
+        get energy_mode() {
+            return energy_info.energy_mode;
+        },
+        get effective_entries() {
+            return effective_entries;
+        },
+        get pd_data() {
+            return pd_data;
+        },
+        get polymorph_stats_map() {
+            return polymorph_stats_map;
+        },
+        get elements() {
+            return elements;
+        },
+        get max_hull_dist_in_data() {
+            return max_hull_dist_in_data;
+        },
+        get auto_default_threshold() {
+            return auto_default_threshold;
+        },
+        get plot_entries() {
+            return plot_entries;
+        },
+        get visible_entries() {
+            return visible_entries;
+        },
+    };
+}