matterviz 0.3.2 → 0.3.3

package/dist/chempot-diagram/ChemPotScene3D.svelte

@@ -1,8 +1,11 @@
-<script lang="ts">// Scene wrapper that enables Threlte pointer events for hover tooltips.
-// Must be rendered inside <Canvas>, mirroring ScatterPlot3DScene / StructureScene pattern.
-import { interactivity } from '@threlte/extras';
-let { children } = $props();
-interactivity();
+<script lang="ts">
+  // Scene wrapper that enables Threlte pointer events for hover tooltips.
+  // Must be rendered inside <Canvas>, mirroring ScatterPlot3DScene / StructureScene pattern.
+  import { interactivity } from '@threlte/extras'
+  import type { Snippet } from 'svelte'
+
+  let { children }: { children?: Snippet } = $props()
+  interactivity()
 </script>
 
 {@render children?.()}

package/dist/chempot-diagram/async-compute.svelte.d.ts

@@ -0,0 +1,3 @@
+import type { ChemPotDiagramConfig, ChemPotDiagramData } from './types';
+import type { PhaseData } from '../convex-hull/types';
+export declare function compute_chempot_async(entries: PhaseData[], config?: ChemPotDiagramConfig): Promise<ChemPotDiagramData>;

package/dist/chempot-diagram/async-compute.svelte.js

@@ -0,0 +1,77 @@
+// Async wrapper for compute_chempot_diagram via Web Worker.
+// Falls back to synchronous main-thread computation during SSR.
+import { compute_chempot_diagram, formula_key_from_composition } from './compute';
+let worker = null;
+let next_id = 0;
+const pending = new Map();
+const pending_by_key = new Map();
+function make_compute_request_key(entries, config) {
+    const keyed_entries = entries
+        .map((entry) => [
+        formula_key_from_composition(entry.composition),
+        entry.energy,
+        entry.energy_per_atom ?? ``,
+        entry.e_form_per_atom ?? ``,
+        entry.is_stable ?? ``,
+        entry.e_above_hull ?? ``,
+        entry.exclude_from_hull ?? ``,
+    ].join(`:`))
+        .sort();
+    return `${keyed_entries.join(`,`)}|${JSON.stringify(config)}`;
+}
+function track_pending(request_key, promise) {
+    pending_by_key.set(request_key, promise);
+    promise.then(() => pending_by_key.delete(request_key), () => pending_by_key.delete(request_key));
+    return promise;
+}
+function get_worker() {
+    if (typeof Worker === `undefined`)
+        return null;
+    if (!worker) {
+        worker = new Worker(new URL(`./chempot-worker.ts`, import.meta.url), { type: `module` });
+        worker.onmessage = ({ data: { id, result, error } }) => {
+            const req = pending.get(id);
+            if (!req)
+                return;
+            pending.delete(id);
+            if (error || !result)
+                req.reject(new Error(error ?? `Worker returned null`));
+            else
+                req.resolve(result);
+        };
+        worker.onerror = (event) => {
+            event.preventDefault();
+            const err = new Error(event.message || `Worker initialization error`);
+            for (const req of pending.values())
+                req.reject(err);
+            pending.clear();
+            worker = null;
+        };
+    }
+    return worker;
+}
+export function compute_chempot_async(entries, config = {}) {
+    const request_key = make_compute_request_key(entries, config);
+    const existing = pending_by_key.get(request_key);
+    if (existing)
+        return existing;
+    const wkr = get_worker();
+    // SSR / no-Worker fallback: run synchronously (wrapped so throws → rejections)
+    if (!wkr) {
+        const promise = Promise.resolve().then(() => compute_chempot_diagram(entries, config));
+        return track_pending(request_key, promise);
+    }
+    const promise = new Promise((resolve, reject) => {
+        const id = ++next_id;
+        pending.set(id, { resolve, reject });
+        try {
+            // $state.snapshot strips Svelte $state proxies (not structured-cloneable)
+            wkr.postMessage($state.snapshot({ id, entries, config }));
+        }
+        catch (err) {
+            pending.delete(id);
+            reject(err instanceof Error ? err : new Error(String(err)));
+        }
+    });
+    return track_pending(request_key, promise);
+}

package/dist/chempot-diagram/chempot-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/chempot-diagram/chempot-worker.js

@@ -0,0 +1,11 @@
+import { compute_chempot_diagram } from './compute';
+self.onmessage = (event) => {
+    const { id, entries, config } = event.data;
+    try {
+        const result = compute_chempot_diagram(entries, config);
+        postMessage({ id, result, error: null });
+    }
+    catch (err) {
+        postMessage({ id, result: null, error: err instanceof Error ? err.message : String(err) });
+    }
+};

package/dist/chempot-diagram/color.js

@@ -10,8 +10,7 @@ export function make_chempot_color_scale(values, interpolator_name, reverse) {
     const finite_values = values.filter(Number.isFinite);
     if (finite_values.length === 0)
         return null;
-    let min_value = finite_values[0];
-    let max_raw_value = finite_values[0];
+    let [min_value, max_raw_value] = [finite_values[0], finite_values[0]];
     for (let idx = 1; idx < finite_values.length; idx++) {
         if (finite_values[idx] < min_value)
             min_value = finite_values[idx];

package/dist/chempot-diagram/compute.d.ts

@@ -35,4 +35,14 @@ export declare function get_3d_domain_simplexes_and_ann_loc(points_3d: number[][
     simplex_indices: number[][];
     ann_loc: number[];
 };
+export declare function bbox_diagonal(points: number[][]): number;
+export declare function scale_to_font_range(sizes: number[], min_font: number, max_font: number): number[];
+export interface VisibleDomainLabel {
+    formula: string;
+    position: [number, number, number];
+    label_font_size: number;
+}
+export declare function get_visible_domain_labels(face_positions: ArrayLike<number>, face_domain_map: string[], label_font_size_by_formula: ReadonlyMap<string, number>, pinned_labels?: VisibleDomainLabel[]): VisibleDomainLabel[];
+export declare function get_ternary_combinations(elements: string[]): string[][];
+export declare function make_nd_cache_key(entries: PhaseData[], formal_chempots: boolean, default_min_limit: number, limits: ChemPotDiagramConfig[`limits`]): string;
 export declare function compute_chempot_diagram(entries: PhaseData[], config?: ChemPotDiagramConfig): ChemPotDiagramData;

package/dist/chempot-diagram/compute.js

@@ -1,9 +1,39 @@
 // Core computational logic for chemical potential diagrams.
 // Ports pymatgen's ChemicalPotentialDiagram algorithm to TypeScript.
 // Reference: pymatgen/analysis/chempot_diagram.py
-import { count_atoms_in_composition, get_reduced_formula } from '../composition';
-import { convex_hull_2d, EPS, polygon_centroid, solve_linear_system, } from '../math';
-import { CHEMPOT_DEFAULTS, } from './types';
+import { convex_hull_2d, EPS, polygon_centroid, solve_linear_system } from '../math';
+import { CHEMPOT_DEFAULTS } from './types';
+// Inlined from $lib/composition/parse to keep this module worker-safe
+// ($lib/composition barrel transitively imports binary .json.gz data
+// that the worker bundler can't handle).
+const count_atoms_in_composition = (composition) => Object.values(composition).reduce((sum, count) => sum + (count ?? 0), 0);
+const gcd = (num_a, num_b) => num_b === 0 ? num_a : gcd(num_b, num_a % num_b);
+const get_reduced_formula = (composition) => {
+    const amounts = Object.values(composition).filter((amt) => amt > 0);
+    if (amounts.length === 0)
+        return {};
+    // For fractional amounts, find smallest multiplier (1–100) that yields near-integer ratios
+    let scale = 1;
+    if (!amounts.every((amt) => Number.isInteger(amt))) {
+        scale = 0;
+        for (let mult = 1; mult <= 100; mult++) {
+            if (amounts.every((amt) => Math.abs(amt * mult - Math.round(amt * mult)) < 0.03)) {
+                scale = mult;
+                break;
+            }
+        }
+        if (scale === 0)
+            return composition;
+    }
+    const int_amounts = amounts.map((amt) => Math.round(amt * scale));
+    const divisor = int_amounts.reduce((acc, amt) => gcd(acc, amt));
+    if (scale === 1 && divisor <= 1)
+        return composition;
+    const factor = scale / divisor;
+    return Object.fromEntries(Object.entries(composition)
+        .filter(([, amt]) => amt > 0)
+        .map(([elem, amt]) => [elem, Math.round(amt * factor)]));
+};
 // === Entry Helpers ===
 // Get energy per atom for a PhaseData entry
 export function get_energy_per_atom(entry) {
@@ -88,9 +118,7 @@ export function renormalize_entries(entries, el_refs, elements) {
         const atoms = count_atoms_in_composition(entry.composition);
         let renorm_energy = 0;
         for (const el of elements) {
-            const frac = atoms > 0
-                ? (entry.composition[el] ?? 0) / atoms
-                : 0;
+            const frac = atoms > 0 ? (entry.composition[el] ?? 0) / atoms : 0;
             const ref = el_refs[el];
             if (ref)
                 renorm_energy += frac * get_energy_per_atom(ref);
@@ -114,6 +142,7 @@ export function build_hyperplanes(min_entries, el_refs, elements) {
     });
     const always_include = new Set(Object.values(el_refs));
     const tol = 1e-6; // PhaseDiagram.formation_energy_tol
+    const use_precomputed_hull = min_entries.every((entry) => typeof entry.is_stable === `boolean` || typeof entry.e_above_hull === `number`);
     const hyperplanes = [];
     const hyperplane_entries = [];
     for (const entry of min_entries) {
@@ -129,7 +158,14 @@ export function build_hyperplanes(min_entries, el_refs, elements) {
             ref_energy += fraction * element_ref_energies[elem_idx];
         }
         const form_energy = energy_per_atom - ref_energy;
-        if (form_energy < -tol || always_include.has(entry)) {
+        const on_precomputed_hull = use_precomputed_hull &&
+            !entry.exclude_from_hull &&
+            (entry.is_stable === true ||
+                (typeof entry.e_above_hull === `number` && entry.e_above_hull <= tol));
+        const include_entry = use_precomputed_hull
+            ? on_precomputed_hull || always_include.has(entry)
+            : form_energy < -tol || always_include.has(entry);
+        if (include_entry) {
             row[n_elems] = -energy_per_atom;
             hyperplanes.push(row);
             hyperplane_entries.push(entry);
@@ -175,15 +211,21 @@ function solve_3x3(a, b, c, offsets, out) {
     if (Math.abs(det) < EPS)
         return false;
     const inv = 1 / det;
-    out[0] = (offsets[0] * (b[1] * c[2] - b[2] * c[1]) -
-        a[1] * (offsets[1] * c[2] - b[2] * offsets[2]) +
-        a[2] * (offsets[1] * c[1] - b[1] * offsets[2])) * inv;
-    out[1] = (a[0] * (offsets[1] * c[2] - b[2] * offsets[2]) -
-        offsets[0] * (b[0] * c[2] - b[2] * c[0]) +
-        a[2] * (b[0] * offsets[2] - offsets[1] * c[0])) * inv;
-    out[2] = (a[0] * (b[1] * offsets[2] - offsets[1] * c[1]) -
-        a[1] * (b[0] * offsets[2] - offsets[1] * c[0]) +
-        offsets[0] * (b[0] * c[1] - b[1] * c[0])) * inv;
+    out[0] =
+        (offsets[0] * (b[1] * c[2] - b[2] * c[1]) -
+            a[1] * (offsets[1] * c[2] - b[2] * offsets[2]) +
+            a[2] * (offsets[1] * c[1] - b[1] * offsets[2])) *
+            inv;
+    out[1] =
+        (a[0] * (offsets[1] * c[2] - b[2] * offsets[2]) -
+            offsets[0] * (b[0] * c[2] - b[2] * c[0]) +
+            a[2] * (b[0] * offsets[2] - offsets[1] * c[0])) *
+            inv;
+    out[2] =
+        (a[0] * (b[1] * offsets[2] - offsets[1] * c[1]) -
+            a[1] * (b[0] * offsets[2] - offsets[1] * c[0]) +
+            offsets[0] * (b[0] * c[1] - b[1] * c[0])) *
+            inv;
     return true;
 }
 // Compute chemical potential domains via vertex enumeration.
@@ -207,9 +249,7 @@ export function compute_domains(hyperplanes, border_hyperplanes, hyperplane_entr
     const mu = new Array(dim).fill(0);
     const offsets = new Array(dim).fill(0);
     // For dim <= 3, use inline solvers; for larger dims, build A on the fly
-    const A_rows = dim > 3
-        ? Array.from({ length: dim }, () => new Array(dim).fill(0))
-        : [];
+    const A_rows = dim > 3 ? Array.from({ length: dim }, () => new Array(dim).fill(0)) : [];
     // Generate all combinations of dim indices from n_total halfspaces
     const combo = new Array(dim).fill(0);
     for (let idx = 0; idx < dim; idx++)
@@ -233,8 +273,8 @@ export function compute_domains(hyperplanes, border_hyperplanes, hyperplane_entr
             has_entry_hyperplane = combo[0] < n_entries || combo[1] < n_entries;
         }
         else if (dim === 3) {
-            has_entry_hyperplane = combo[0] < n_entries || combo[1] < n_entries ||
-                combo[2] < n_entries;
+            has_entry_hyperplane =
+                combo[0] < n_entries || combo[1] < n_entries || combo[2] < n_entries;
         }
         else {
             for (let row = 0; row < dim; row++) {
@@ -283,7 +323,8 @@ export function compute_domains(hyperplanes, border_hyperplanes, hyperplane_entr
             const selected_hs_idx_2 = dim > 2 ? combo[2] : -1;
             for (let idx = 0; idx < n_total; idx++) {
                 if (dim <= 3) {
-                    if (idx === selected_hs_idx_0 || idx === selected_hs_idx_1 ||
+                    if (idx === selected_hs_idx_0 ||
+                        idx === selected_hs_idx_1 ||
                         idx === selected_hs_idx_2)
                         continue;
                 }
@@ -317,11 +358,7 @@ export function compute_domains(hyperplanes, border_hyperplanes, hyperplane_entr
             }
             if (solved) {
                 // Assign vertex to entries whose hyperplanes are active
-                const vertex = dim === 2
-                    ? [mu[0], mu[1]]
-                    : dim === 3
-                        ? [mu[0], mu[1], mu[2]]
-                        : [...mu];
+                const vertex = dim === 2 ? [mu[0], mu[1]] : dim === 3 ? [mu[0], mu[1], mu[2]] : [...mu];
                 for (let idx = 0; idx < dim; idx++) {
                     const hs_idx = combo[idx];
                     if (hs_idx < n_entries) {
@@ -376,8 +413,7 @@ export function pad_domain_points(pts, elem_indices, new_lims, default_min_limit
 // Build per-axis min/max ranges for a set of points
 export function build_axis_ranges(points, elements) {
     return elements.map((element, axis_idx) => {
-        let min_val = Infinity;
-        let max_val = -Infinity;
+        let [min_val, max_val] = [Infinity, -Infinity];
         for (const point of points) {
             const val = point[axis_idx];
             if (val < min_val)
@@ -518,8 +554,7 @@ export function get_3d_domain_simplexes_and_ann_loc(points_3d) {
     // Map hull vertices back to original point indices using nearest projected
     // vertex instead of stringified coordinates to avoid precision aliasing.
     function nearest_projected_idx(target) {
-        let nearest_idx = 0;
-        let min_sq_dist = Infinity;
+        let [nearest_idx, min_sq_dist] = [0, Infinity];
         for (let idx = 0; idx < pts_2d.length; idx++) {
             const dx = pts_2d[idx][0] - target[0];
             const dy = pts_2d[idx][1] - target[1];
@@ -542,6 +577,119 @@ export function get_3d_domain_simplexes_and_ann_loc(points_3d) {
     }
     return { simplex_indices, ann_loc };
 }
+// === Label Sizing ===
+// Bounding box diagonal of a set of N-D points (Euclidean distance between
+// the min and max corners). Returns 0 for fewer than 2 points.
+export function bbox_diagonal(points) {
+    if (points.length < 2)
+        return 0;
+    let sq_sum = 0;
+    for (let col = 0; col < points[0].length; col++) {
+        let lo = Infinity, hi = -Infinity;
+        for (const pt of points) {
+            lo = Math.min(lo, pt[col]);
+            hi = Math.max(hi, pt[col]);
+        }
+        sq_sum += (hi - lo) ** 2;
+    }
+    return Math.sqrt(sq_sum);
+}
+// Map an array of raw size values to font sizes via linear interpolation.
+// Returns a new array of font sizes in [min_font, max_font].
+// If all sizes are equal, returns the midpoint for all.
+export function scale_to_font_range(sizes, min_font, max_font) {
+    const min_size = Math.min(...sizes);
+    const max_size = Math.max(...sizes);
+    const range = max_size - min_size;
+    const mid = (min_font + max_font) / 2;
+    return sizes.map((size) => range > 0 ? min_font + ((max_font - min_font) * (size - min_size)) / range : mid);
+}
+export function get_visible_domain_labels(face_positions, face_domain_map, label_font_size_by_formula, pinned_labels = []) {
+    const n_faces = Math.min(Math.floor(face_positions.length / 9), face_domain_map.length);
+    const accum = new Map();
+    for (let face_idx = 0; face_idx < n_faces; face_idx++) {
+        const formula = face_domain_map[face_idx];
+        if (!formula || !label_font_size_by_formula.has(formula))
+            continue;
+        const base = face_idx * 9;
+        const ax = face_positions[base];
+        const ay = face_positions[base + 1];
+        const az = face_positions[base + 2];
+        const bx = face_positions[base + 3];
+        const by = face_positions[base + 4];
+        const bz = face_positions[base + 5];
+        const cx = face_positions[base + 6];
+        const cy = face_positions[base + 7];
+        const cz = face_positions[base + 8];
+        const abx = bx - ax;
+        const aby = by - ay;
+        const abz = bz - az;
+        const acx = cx - ax;
+        const acy = cy - ay;
+        const acz = cz - az;
+        const cross_x = aby * acz - abz * acy;
+        const cross_y = abz * acx - abx * acz;
+        const cross_z = abx * acy - aby * acx;
+        const area = Math.hypot(cross_x, cross_y, cross_z) / 2;
+        if (area <= EPS)
+            continue;
+        const centroid_x = (ax + bx + cx) / 3;
+        const centroid_y = (ay + by + cy) / 3;
+        const centroid_z = (az + bz + cz) / 3;
+        const entry = accum.get(formula) ?? { area: 0, x: 0, y: 0, z: 0 };
+        entry.area += area;
+        entry.x += centroid_x * area;
+        entry.y += centroid_y * area;
+        entry.z += centroid_z * area;
+        accum.set(formula, entry);
+    }
+    const visible_labels = [...accum.entries()]
+        .filter(([, entry]) => entry.area > EPS)
+        .map(([formula, entry]) => ({
+        formula,
+        position: [entry.x / entry.area, entry.y / entry.area, entry.z / entry.area],
+        label_font_size: label_font_size_by_formula.get(formula) ?? 12,
+    }));
+    for (const label of pinned_labels) {
+        if (!visible_labels.some((visible_label) => visible_label.formula === label.formula)) {
+            visible_labels.push(label);
+        }
+    }
+    return visible_labels.sort((label_a, label_b) => label_a.formula.localeCompare(label_b.formula));
+}
+// === Ternary Combinations ===
+// Generate all C(n,3) ternary element combinations from a sorted element list.
+// Each triplet is sorted alphabetically. Returns empty array for fewer than 3 elements.
+export function get_ternary_combinations(elements) {
+    const sorted = [...elements].sort();
+    const n_elems = sorted.length;
+    if (n_elems < 3)
+        return [];
+    const combos = [];
+    for (let first = 0; first < n_elems - 2; first++) {
+        for (let second = first + 1; second < n_elems - 1; second++) {
+            for (let third = second + 1; third < n_elems; third++) {
+                combos.push([sorted[first], sorted[second], sorted[third]]);
+            }
+        }
+    }
+    return combos;
+}
+let _nd_cache = null;
+// Content-based fingerprint for N-D result caching. Uses sorted formula keys
+// so deserialized Web Worker copies match and different compositions never collide.
+export function make_nd_cache_key(entries, formal_chempots, default_min_limit, limits) {
+    const keyed = entries
+        .map((entry) => [
+        formula_key_from_composition(entry.composition),
+        entry.energy,
+        entry.is_stable ?? ``,
+        entry.e_above_hull ?? ``,
+        entry.exclude_from_hull ?? ``,
+    ].join(`:`))
+        .sort();
+    return `${keyed.join(`,`)}|${formal_chempots}|${default_min_limit}|${JSON.stringify(limits ?? {})}`;
+}
 // === Main Pipeline ===
 // Compute the full chemical potential diagram from entries and config.
 // Returns domains, elements, refs, and all intermediate data.
@@ -564,69 +712,83 @@ export function compute_chempot_diagram(entries, config = {}) {
     }
     const all_data_elements = Array.from(all_data_elements_set).sort();
     // Display elements: user-specified order (controls axis mapping), or auto-detect
-    const display_elements = config.elements?.length
-        ? [...config.elements]
-        : all_data_elements;
+    const display_elements = config.elements?.length ? [...config.elements] : all_data_elements;
     // Projection mode: display fewer axes than the data has elements
     // In this mode, compute in full N-D and project afterward
     const is_projection = display_elements.length < all_data_elements.length &&
         display_elements.every((el) => all_data_elements.includes(el));
     // Computation elements: full element set for projection, display set for subsystem
     const compute_elements = is_projection ? all_data_elements : display_elements;
-    // In subsystem mode, filter entries to only those within the element set
-    let working_entries = entries;
-    if (!is_projection && config.elements?.length) {
-        const target_set = new Set(config.elements);
-        working_entries = entries.filter((entry) => {
-            for (const [element, amount] of Object.entries(entry.composition)) {
-                if (amount > 0 && !target_set.has(element))
-                    return false;
-            }
-            return true;
+    // Try cache for projection mode (same entries + config = same N-D domains)
+    const cache_key = is_projection
+        ? make_nd_cache_key(entries, formal_chempots, default_min_limit, limits)
+        : ``;
+    let nd_result = is_projection && _nd_cache?.key === cache_key ? _nd_cache.result : null;
+    if (!nd_result) {
+        // In subsystem mode, filter entries to only those within the element set
+        let working_entries = entries;
+        if (!is_projection && config.elements?.length) {
+            const target_set = new Set(config.elements);
+            working_entries = entries.filter((entry) => {
+                for (const [element, amount] of Object.entries(entry.composition)) {
+                    if (amount > 0 && !target_set.has(element))
+                        return false;
+                }
+                return true;
+            });
+        }
+        // Sort entries by composition (Schwartzian transform to avoid recomputing keys)
+        const sorted_entries = working_entries
+            .map((entry) => ({ entry, key: formula_key_from_composition(entry.composition) }))
+            .sort((a, b) => a.key.localeCompare(b.key))
+            .map(({ entry }) => entry);
+        // Get min entries and elemental references
+        let { min_entries, el_refs } = get_min_entries_and_el_refs(sorted_entries);
+        const dim = compute_elements.length;
+        if (dim < 2) {
+            throw new Error(`ChemicalPotentialDiagram requires 2+ elements, got ${dim}`);
+        }
+        // Check all elemental refs exist for the computation elements
+        const missing_refs = compute_elements.filter((el) => !el_refs[el]);
+        if (missing_refs.length > 0) {
+            throw new Error(`Missing elemental reference entries for: ${missing_refs.join(`, `)}`);
+        }
+        // Renormalize if using formal chemical potentials
+        if (formal_chempots) {
+            min_entries = renormalize_entries(min_entries, el_refs, compute_elements);
+            const renorm_result = get_min_entries_and_el_refs(min_entries);
+            el_refs = renorm_result.el_refs;
+        }
+        // Build limits array for computation elements
+        const compute_lims = compute_elements.map((el) => {
+            if (limits?.[el])
+                return limits[el];
+            return [default_min_limit, 0];
         });
+        // Build hyperplanes and compute domains in full dimensionality
+        const { hyperplanes, hyperplane_entries } = build_hyperplanes(min_entries, el_refs, compute_elements);
+        const border_hyperplanes = build_border_hyperplanes(compute_lims);
+        const domains = compute_domains(hyperplanes, border_hyperplanes, hyperplane_entries, dim);
+        nd_result = {
+            domains,
+            el_refs,
+            min_entries,
+            hyperplanes,
+            hyperplane_entries,
+            compute_lims,
+        };
+        // Cache for projection mode reuse
+        if (is_projection) {
+            _nd_cache = { key: cache_key, result: nd_result };
+        }
     }
-    // Sort entries by composition (Schwartzian transform to avoid recomputing keys)
-    const sorted_entries = working_entries
-        .map((entry) => ({ entry, key: formula_key_from_composition(entry.composition) }))
-        .sort((a, b) => a.key.localeCompare(b.key))
-        .map(({ entry }) => entry);
-    // Get min entries and elemental references
-    let { min_entries, el_refs } = get_min_entries_and_el_refs(sorted_entries);
-    const dim = compute_elements.length;
-    if (dim < 2) {
-        throw new Error(`ChemicalPotentialDiagram requires 2+ elements, got ${dim}`);
-    }
-    // Check all elemental refs exist for the computation elements
-    const missing_refs = compute_elements.filter((el) => !el_refs[el]);
-    if (missing_refs.length > 0) {
-        throw new Error(`Missing elemental reference entries for: ${missing_refs.join(`, `)}`);
-    }
-    // Renormalize if using formal chemical potentials
-    if (formal_chempots) {
-        min_entries = renormalize_entries(min_entries, el_refs, compute_elements);
-        const renorm_result = get_min_entries_and_el_refs(min_entries);
-        el_refs = renorm_result.el_refs;
-    }
-    // Build limits array for computation elements
-    const compute_lims = compute_elements.map((el) => {
-        if (limits?.[el])
-            return limits[el];
-        return [default_min_limit, 0];
-    });
-    // Build hyperplanes and compute domains in full dimensionality
-    const { hyperplanes, hyperplane_entries } = build_hyperplanes(min_entries, el_refs, compute_elements);
-    const border_hyperplanes = build_border_hyperplanes(compute_lims);
-    let domains = compute_domains(hyperplanes, border_hyperplanes, hyperplane_entries, dim);
+    let domains = nd_result.domains;
+    let output_lims = nd_result.compute_lims;
     // Project domain vertices from N-D to display axes (column extraction)
-    let output_lims = compute_lims;
     if (is_projection) {
-        const compute_index_by_element = new Map();
-        for (let idx = 0; idx < compute_elements.length; idx++) {
-            compute_index_by_element.set(compute_elements[idx], idx);
-        }
         const col_indices = display_elements.map((element) => {
-            const idx = compute_index_by_element.get(element);
-            if (idx === undefined) {
+            const idx = compute_elements.indexOf(element);
+            if (idx < 0) {
                 throw new Error(`Display element ${element} not present in compute element set`);
             }
             return idx;
@@ -636,15 +798,15 @@ export function compute_chempot_diagram(entries, config = {}) {
             projected[formula] = pts.map((pt) => col_indices.map((idx) => pt[idx]));
         }
         domains = projected;
-        output_lims = col_indices.map((idx) => compute_lims[idx]);
+        output_lims = col_indices.map((col_idx) => nd_result.compute_lims[col_idx]);
     }
     return {
         domains,
         elements: display_elements,
-        el_refs,
-        min_entries,
-        hyperplanes,
-        hyperplane_entries,
+        el_refs: nd_result.el_refs,
+        min_entries: nd_result.min_entries,
+        hyperplanes: nd_result.hyperplanes,
+        hyperplane_entries: nd_result.hyperplane_entries,
         lims: output_lims,
     };
 }

package/dist/chempot-diagram/index.d.ts

@@ -1,5 +1,6 @@
 export { default as ChemPotDiagram } from './ChemPotDiagram.svelte';
 export { default as ChemPotDiagram2D } from './ChemPotDiagram2D.svelte';
 export { default as ChemPotDiagram3D } from './ChemPotDiagram3D.svelte';
-export { compute_chempot_diagram } from './compute';
+export { compute_chempot_async } from './async-compute.svelte';
+export { compute_chempot_diagram, get_ternary_combinations } from './compute';
 export * from './types';

package/dist/chempot-diagram/index.js

@@ -1,5 +1,6 @@
 export { default as ChemPotDiagram } from './ChemPotDiagram.svelte';
 export { default as ChemPotDiagram2D } from './ChemPotDiagram2D.svelte';
 export { default as ChemPotDiagram3D } from './ChemPotDiagram3D.svelte';
-export { compute_chempot_diagram } from './compute';
+export { compute_chempot_async } from './async-compute.svelte';
+export { compute_chempot_diagram, get_ternary_combinations } from './compute';
 export * from './types';

package/dist/chempot-diagram/temperature.js

@@ -3,15 +3,14 @@ import { CHEMPOT_DEFAULTS } from './types';
 export function get_projection_source_entries(entries, temp_filtered_entries) {
     return temp_filtered_entries.length > 0 ? temp_filtered_entries : entries;
 }
-function resolve_temp_filter_options(config, props) {
-    return {
-        interpolate: config.interpolate_temperature ?? props.interpolate_temperature ??
-            CHEMPOT_DEFAULTS.interpolate_temperature,
-        max_interpolation_gap: config.max_interpolation_gap ??
-            props.max_interpolation_gap ??
-            CHEMPOT_DEFAULTS.max_interpolation_gap,
-    };
-}
+const resolve_temp_filter_options = (config, props) => ({
+    interpolate: config.interpolate_temperature ??
+        props.interpolate_temperature ??
+        CHEMPOT_DEFAULTS.interpolate_temperature,
+    max_interpolation_gap: config.max_interpolation_gap ??
+        props.max_interpolation_gap ??
+        CHEMPOT_DEFAULTS.max_interpolation_gap,
+});
 export function get_temp_filter_payload(entries, temperature, config, props) {
     const { has_temp_data, available_temperatures } = analyze_temperature_data(entries);
     if (!has_temp_data || temperature === undefined) {

package/dist/chempot-diagram/types.d.ts

@@ -2,6 +2,7 @@ import type { D3InterpolateName } from '../colors';
 import type { PhaseData } from '../convex-hull/types';
 export type ChemPotLimits = Partial<Record<string, [number, number]>>;
 export type ChemPotColorMode = `none` | `energy` | `formation_energy` | `arity` | `entries`;
+export type ChemPotProjectionMode = `single` | `grid`;
 export interface ChemPotDiagramConfig {
     formal_chempots?: boolean;
     default_min_limit?: number;
@@ -20,6 +21,7 @@ export interface ChemPotDiagramConfig {
     reverse_color_scale?: boolean;
     interpolate_temperature?: boolean;
     max_interpolation_gap?: number;
+    projection_mode?: ChemPotProjectionMode;
 }
 export interface ChemPotDiagramData {
     domains: Record<string, number[][]>;
@@ -79,5 +81,6 @@ export declare const CHEMPOT_DEFAULTS: {
     readonly reverse_color_scale: true;
     readonly interpolate_temperature: true;
     readonly max_interpolation_gap: 500;
+    readonly projection_mode: ChemPotProjectionMode;
     readonly formula_colors: readonly ["#1b9e77", "#d95f02", "#7570b3", "#e7298a", "#66a61e", "#e6ab02", "#a6761d", "#666666"];
 };