matterviz 0.3.7 → 0.4.1

package/dist/composition/PieChart.svelte

@@ -75,12 +75,12 @@
 
         // Single element: full circle with no radial stroke line, label at center
         if (fraction === 1) {
-          const r = outer_radius
+          const radius = outer_radius
           const ir = inner_radius_adjusted
           // Two semicircular arcs to form a full circle (avoids SVG 360° arc bug)
-          const outer_arc = `M ${center} ${center - r} A ${r} ${r} 0 1 1 ${center} ${
-            center + r
-          } A ${r} ${r} 0 1 1 ${center} ${center - r} Z`
+          const outer_arc = `M ${center} ${center - radius} A ${radius} ${radius} 0 1 1 ${center} ${
+            center + radius
+          } A ${radius} ${radius} 0 1 1 ${center} ${center - radius} Z`
           const path = ir > 0
             ? `${outer_arc} M ${center} ${
               center - ir
@@ -101,7 +101,7 @@
             label_x: center,
             label_y: center,
             is_outside_slice: false,
-            font_scale: get_chart_font_scale(2.6, label_text, r * 2),
+            font_scale: get_chart_font_scale(2.6, label_text, radius * 2),
             text_color: pick_contrast_color({ bg_color: color }),
           }
         }
@@ -151,11 +151,9 @@
         } else if (is_medium_slice) {
           // Medium slices: place closer to outer edge, proportional to chart size
           label_radius = outer_radius - outer_radius * 0.3
-          is_outside_slice = false
         } else {
           // Large slices: place in middle of ring
           label_radius = (outer_radius + inner_radius_adjusted) / 2
-          is_outside_slice = false
         }
 
         // Calculate font scale based on slice size and smart text fitting
@@ -293,9 +291,15 @@
   .pie-segment.interactive:focus {
     outline: none;
   }
+  svg {
+    /* very thin slices place their labels outside the pie at 1.2x the outer radius,
+    past the square viewBox - the default svg overflow: hidden would clip them */
+    overflow: visible;
+  }
   foreignobject {
     pointer-events: none;
     transition: all 0.2s ease;
+    overflow: visible;
   }
   foreignobject.hovered {
     font-weight: 700;
@@ -310,9 +314,6 @@
     transition: all 0.2s ease;
     white-space: nowrap;
   }
-  foreignobject {
-    overflow: visible;
-  }
   .pie-label.hovered {
     font-weight: 700;
   }

package/dist/composition/chem-sys.d.ts

@@ -0,0 +1,8 @@
+import type { SunburstNode } from '../plot/core/types';
+export interface ChemSysSunburstMetadata {
+    chem_sys: string;
+    arity: number;
+    [key: string]: unknown;
+}
+export declare const arity_name: (arity: number) => string;
+export declare function chem_sys_sunburst_data(entries: readonly string[]): SunburstNode<ChemSysSunburstMetadata>[];

package/dist/composition/chem-sys.js

@@ -0,0 +1,86 @@
+// Build arity -> chemical-system hierarchy data for the Sunburst component
+// (counterpart to pymatviz's chem_sys_sunburst).
+import { is_elem_symbol } from '../element';
+import { parse_formula } from './parse';
+const ARITY_NAMES = [
+    ``,
+    `unary`,
+    `binary`,
+    `ternary`,
+    `quaternary`,
+    `quinary`,
+    `senary`,
+    `septenary`,
+    `octonary`,
+    `nonary`,
+    `denary`,
+];
+// || (not ??) so the empty index-0 placeholder also falls through to "0-ary"
+export const arity_name = (arity) => ARITY_NAMES[arity] || `${arity}-ary`;
+// Build arity -> chemical-system sunburst data from a list of chemical systems
+// ("Li-Fe-O") and/or formulas ("LiFePO4"), one entry per occurrence (counts become
+// leaf values). Systems are normalized to alphabetical element order, so "O-Li" and
+// "Li2O" both count toward "Li-O". Ids follow the "<arity>/<system>" scheme.
+export function chem_sys_sunburst_data(entries) {
+    // Inputs are one entry per occurrence, so the same formula typically repeats many
+    // times - memoize raw entry -> normalized system (null = invalid) to parse each
+    // distinct string only once
+    const normalized = new Map();
+    const normalize = (entry) => {
+        let elements;
+        if (entry.includes(`-`)) {
+            elements = entry.split(`-`).map((el) => el.trim());
+            if (!elements.every(is_elem_symbol))
+                return null;
+        }
+        else {
+            try {
+                elements = Object.keys(parse_formula(entry));
+            }
+            catch {
+                return null;
+            }
+        }
+        if (elements.length === 0)
+            return null;
+        return [...new Set(elements)].sort().join(`-`);
+    };
+    const counts = new Map();
+    let n_invalid = 0;
+    for (const entry of entries) {
+        let chem_sys = normalized.get(entry);
+        if (chem_sys === undefined) {
+            chem_sys = normalize(entry);
+            normalized.set(entry, chem_sys);
+        }
+        if (chem_sys === null) {
+            n_invalid += 1;
+            continue;
+        }
+        counts.set(chem_sys, (counts.get(chem_sys) ?? 0) + 1);
+    }
+    if (n_invalid > 0) {
+        console.warn(`chem_sys_sunburst_data: skipped ${n_invalid} invalid entr${n_invalid === 1 ? `y` : `ies`} (expected chemical systems like "Li-Fe-O" or formulas like "LiFePO4")`);
+    }
+    // One composite sort (arity ascending, then count descending) puts systems in
+    // final order; consecutive same-arity runs then collapse into one branch each
+    const sorted = [...counts]
+        .map(([chem_sys, count]) => ({ chem_sys, count, arity: chem_sys.split(`-`).length }))
+        .sort((sys_a, sys_b) => sys_a.arity - sys_b.arity || sys_b.count - sys_a.count);
+    const roots = [];
+    let branch;
+    for (const { chem_sys, count, arity } of sorted) {
+        const name = arity_name(arity);
+        if (branch?.id !== name) {
+            branch = { id: name, label: name, children: [] };
+            roots.push(branch);
+        }
+        branch.children?.push({
+            id: `${name}/${chem_sys}`,
+            label: chem_sys,
+            value: count,
+            metadata: { chem_sys, arity },
+        });
+    }
+    return roots;
+}

package/dist/composition/format.js

@@ -1,5 +1,6 @@
 import { format_num } from '../labels';
-import { ELEMENT_ELECTRONEGATIVITY_MAP, is_valid_element, parse_composition } from './parse';
+import { is_elem_symbol } from '../element';
+import { ELEMENT_ELECTRONEGATIVITY_MAP, parse_composition } from './parse';
 // Extract composition from structure object
 const structure_to_composition = (structure) => {
     if (!structure.sites || !Array.isArray(structure.sites)) {
@@ -20,14 +21,16 @@ const structure_to_composition = (structure) => {
 const is_structure_like = (input) => `sites` in input || `lattice` in input;
 // Format composition into chemical formula string
 export const format_composition_formula = (composition, sort_fn, plain_text = false, delim = ` `, amount_format = `.3~s`) => {
-    const symbols = Object.keys(composition).filter(is_valid_element);
+    const symbols = Object.keys(composition).filter(is_elem_symbol);
     return sort_fn(symbols)
         .filter((el) => composition[el] && composition[el] > 0)
         .map((el) => {
-        const amount = composition[el];
+        const amount = Number(composition[el]);
         if (amount === 1)
             return el;
-        const formatted_amount = format_num(Number(amount), amount_format);
+        // avoid d3 SI prefixes for sub-1 amounts (`s` formats render 0.5 as 500m)
+        const fmt = amount_format.endsWith(`s`) && Math.abs(amount) < 1 ? `.3~g` : amount_format;
+        const formatted_amount = format_num(amount, fmt);
         return plain_text ? `${el}${formatted_amount}` : `${el}<sub>${formatted_amount}</sub>`;
     })
         .join(delim);

package/dist/composition/index.d.ts

@@ -1,6 +1,7 @@
 import type { ElementSymbol } from '../element';
 export { default as BarChart } from './BarChart.svelte';
 export { default as BubbleChart } from './BubbleChart.svelte';
+export * from './chem-sys';
 export { default as Composition } from './Composition.svelte';
 export * from './format';
 export { default as Formula } from './Formula.svelte';

package/dist/composition/index.js

@@ -1,5 +1,6 @@
 export { default as BarChart } from './BarChart.svelte';
 export { default as BubbleChart } from './BubbleChart.svelte';
+export * from './chem-sys';
 export { default as Composition } from './Composition.svelte';
 export * from './format';
 export { default as Formula } from './Formula.svelte';

package/dist/composition/parse.d.ts

@@ -6,7 +6,6 @@ export declare const ATOMIC_WEIGHTS: Map<"S" | "K" | "B" | "H" | "He" | "Li" | "
 export declare const ELEMENT_ELECTRONEGATIVITY_MAP: Map<"S" | "K" | "B" | "H" | "He" | "Li" | "Be" | "C" | "N" | "O" | "F" | "Ne" | "Na" | "Mg" | "Al" | "Si" | "P" | "Cl" | "Ar" | "Ca" | "Sc" | "Ti" | "V" | "Cr" | "Mn" | "Fe" | "Co" | "Ni" | "Cu" | "Zn" | "Ga" | "Ge" | "As" | "Se" | "Br" | "Kr" | "Rb" | "Sr" | "Y" | "Zr" | "Nb" | "Mo" | "Tc" | "Ru" | "Rh" | "Pd" | "Ag" | "Cd" | "In" | "Sn" | "Sb" | "Te" | "I" | "Xe" | "Cs" | "Ba" | "La" | "Ce" | "Pr" | "Nd" | "Pm" | "Sm" | "Eu" | "Gd" | "Tb" | "Dy" | "Ho" | "Er" | "Tm" | "Yb" | "Lu" | "Hf" | "Ta" | "W" | "Re" | "Os" | "Ir" | "Pt" | "Au" | "Hg" | "Tl" | "Pb" | "Bi" | "Po" | "At" | "Rn" | "Fr" | "Ra" | "Ac" | "Th" | "Pa" | "U" | "Np" | "Pu" | "Am" | "Cm" | "Bk" | "Cf" | "Es" | "Fm" | "Md" | "No" | "Lr" | "Rf" | "Db" | "Sg" | "Bh" | "Hs" | "Mt" | "Ds" | "Rg" | "Cn" | "Nh" | "Fl" | "Mc" | "Lv" | "Ts" | "Og", number>;
 export declare const ELEM_NAME_TO_SYMBOL: Record<string, ElementSymbol>;
 export declare const ELEM_SYMBOL_TO_NAME: Partial<Record<ElementSymbol, string>>;
-export declare const is_valid_element: (sym: string) => sym is ElementSymbol;
 export declare const atomic_num_to_symbols: (atomic_composition: Record<number, number>) => CompositionType;
 export declare const atomic_symbol_to_num: (symbol_composition: CompositionType) => Record<number, number>;
 export declare const parse_formula: (formula: string) => CompositionType;

package/dist/composition/parse.js

@@ -1,4 +1,4 @@
-import { element_data } from '../element';
+import { element_data, is_elem_symbol } from '../element';
 import { ELEM_SYMBOLS } from '../labels';
 // Create symbol/number/mass/electronegativity lookup maps for O(1) access
 export const ATOMIC_NUMBER_TO_SYMBOL = {};
@@ -16,8 +16,6 @@ for (const element of element_data) {
     ELEM_NAME_TO_SYMBOL[element.name] = element.symbol;
     ELEM_SYMBOL_TO_NAME[element.symbol] = element.name;
 }
-// Type guard: check if a string is a valid element symbol
-export const is_valid_element = (sym) => ELEM_SYMBOLS.includes(sym);
 // Check if object has atomic numbers as keys (1-118)
 const is_atomic_number_composition = (obj) => {
     const keys = Object.keys(obj);
@@ -51,7 +49,7 @@ export const atomic_num_to_symbols = (atomic_composition) => {
 export const atomic_symbol_to_num = (symbol_composition) => {
     const atomic_composition = {};
     for (const [symbol, amount] of Object.entries(symbol_composition)) {
-        if (!is_valid_element(symbol))
+        if (!is_elem_symbol(symbol))
             throw new Error(`Invalid element symbol: ${symbol}`);
         const atomic_num = SYMBOL_TO_ATOMIC_NUMBER[symbol];
         if (!atomic_num)
@@ -65,26 +63,38 @@ export const atomic_symbol_to_num = (symbol_composition) => {
 // Expand parentheses in chemical formulas
 const expand_parentheses = (formula) => {
     while (formula.includes(`(`)) {
-        formula = formula.replace(/\(([^()]+)\)(\d+(?:\.\d+)?|\.\d+)?/g, (_match, group, multiplier) => {
+        const expanded = formula.replaceAll(/\(([^()]+)\)(\d+(?:\.\d+)?|\.\d+)?/g, (_match, group, multiplier) => {
             const mult = parse_count(multiplier);
-            return group.replace(/([A-Z][a-z]?)(\d+(?:\.\d+)?|\.\d+)?/g, (_m, element, count) => {
+            return group.replaceAll(/([A-Z][a-z]?)(\d+(?:\.\d+)?|\.\d+)?/g, (_m, element, count) => {
                 const count_str = format_count(parse_count(count) * mult);
                 return element + (count_str === `1` ? `` : count_str);
             });
         });
+        if (expanded === formula) {
+            // unclosed/empty parens match nothing -> would loop forever
+            throw new Error(`Unbalanced or empty parentheses in formula: ${formula}`);
+        }
+        formula = expanded;
     }
     return formula;
 };
-// Parse chemical formula string into composition object
+// Parse chemical formula string into composition object. Hydrate/adduct segments
+// joined by ·, ⋅, or * are scaled by their leading coefficient (CuSO4·5H2O -> Cu S O9 H10)
 export const parse_formula = (formula) => {
     const composition = {};
-    const cleaned_formula = expand_parentheses(formula.replace(/\s/g, ``));
-    for (const match of cleaned_formula.matchAll(/([A-Z][a-z]?)(\d+(?:\.\d+)?|\.\d+)?/g)) {
-        const element = match[1];
-        const count = parse_count(match[2]);
-        if (!is_valid_element(element))
-            throw new Error(`Invalid element symbol: ${element}`);
-        composition[element] = (composition[element] ?? 0) + count;
+    const cleaned = formula.replaceAll(/\s/g, ``);
+    const segments = cleaned.split(/[·⋅*]/).filter(Boolean);
+    for (const [seg_idx, segment] of segments.entries()) {
+        // only hydrate segments (after a separator) carry a leading multiplier
+        const coeff = seg_idx > 0 ? /^(?:\d+(?:\.\d+)?|\.\d+)/.exec(segment)?.[0] : undefined;
+        const multiplier = coeff ? parseFloat(coeff) : 1;
+        const expanded = expand_parentheses(segment.slice(coeff?.length ?? 0));
+        for (const match of expanded.matchAll(/([A-Z][a-z]?)(\d+(?:\.\d+)?|\.\d+)?/g)) {
+            const [, element, count] = match;
+            if (!is_elem_symbol(element))
+                throw new Error(`Invalid element symbol: ${element}`);
+            composition[element] = (composition[element] ?? 0) + parse_count(count) * multiplier;
+        }
     }
     return composition;
 };
@@ -95,7 +105,7 @@ export const normalize_composition = (composition) => {
     }
     const normalized = {};
     for (const [element, amount] of Object.entries(composition)) {
-        if (typeof amount === `number` && amount > 0 && is_valid_element(element)) {
+        if (typeof amount === `number` && amount > 0 && is_elem_symbol(element)) {
             normalized[element] = amount;
         }
     }
@@ -113,7 +123,7 @@ export const sanitize_composition_keys = (composition) => {
         if (typeof amount !== `number` || amount <= 0)
             continue;
         // Extract first valid element symbol from key (e.g. "B0." -> "B", "Fe2+" -> "Fe")
-        const elem = (key.match(/[A-Z][a-z]?/g) ?? []).find(is_valid_element);
+        const elem = (key.match(/[A-Z][a-z]?/g) ?? []).find(is_elem_symbol);
         if (elem)
             sanitized[elem] = (sanitized[elem] || 0) + amount;
     }
@@ -127,7 +137,7 @@ export const fractional_composition = (composition, by_weight = false) => {
     const filtered = Object.fromEntries(Object.entries(composition).filter(([, amount]) => amount > 0));
     if (by_weight) {
         const element_weights = Object.fromEntries(Object.entries(filtered).map(([element, amount]) => {
-            if (!is_valid_element(element))
+            if (!is_elem_symbol(element))
                 throw new Error(`Unknown element: ${element}`);
             const atomic_mass = ATOMIC_WEIGHTS.get(element);
             if (!atomic_mass)
@@ -179,14 +189,14 @@ export const get_reduced_formula = (composition) => {
         return composition;
     const reduced = {};
     for (const [elem, amt] of Object.entries(composition)) {
-        if (is_valid_element(elem))
+        if (is_elem_symbol(elem))
             reduced[elem] = amt / divisor;
     }
     return reduced;
 };
 // Calculate molecular weight (sum of atomic masses * amounts)
 export const get_molecular_weight = (composition) => Object.entries(composition).reduce((total, [elem, amount]) => {
-    const mass = is_valid_element(elem) ? (ATOMIC_WEIGHTS.get(elem) ?? 0) : 0;
+    const mass = is_elem_symbol(elem) ? (ATOMIC_WEIGHTS.get(elem) ?? 0) : 0;
     return total + mass * amount;
 }, 0);
 // Parse oxidation state string (e.g. "+2", "2+", "-", "[2-]") to number
@@ -210,7 +220,7 @@ const parse_oxidation_state = (oxidation_str) => {
 // When strict=true, throws on conflicting oxidation states for the same element.
 export const parse_formula_with_oxidation = (formula, strict = false) => {
     const elements = [];
-    const cleaned_formula = expand_parentheses(formula.replace(/\s/g, ``));
+    const cleaned_formula = expand_parentheses(formula.replaceAll(/\s/g, ``));
     // Regex to match: Element, optional oxidation state and/or count in either order
     // Pattern: ([A-Z][a-z]?)  - element symbol
     //          Followed by one of:
@@ -229,7 +239,7 @@ export const parse_formula_with_oxidation = (formula, strict = false) => {
         const oxidation_str = match[2] || match[3] || match[6] || match[7];
         const count_str = match[4] || match[5];
         const count = parse_count(count_str);
-        if (!is_valid_element(element))
+        if (!is_elem_symbol(element))
             throw new Error(`Invalid element symbol: ${element}`);
         const oxidation_state = oxidation_str ? parse_oxidation_state(oxidation_str) : undefined;
         // Find or add element entry
@@ -257,7 +267,7 @@ export const parse_formula_with_oxidation = (formula, strict = false) => {
 };
 // Convert OxiComposition to ElementWithOxidation array
 // Does not preserve original order since objects don't have a defined order
-export const oxi_composition_to_elements = (composition) => Object.entries(composition).flatMap(([element, { amount, oxidation_state }], idx) => is_valid_element(element) ? [{ element, amount, oxidation_state, orig_idx: idx }] : []);
+export const oxi_composition_to_elements = (composition) => Object.entries(composition).flatMap(([element, { amount, oxidation_state }], idx) => is_elem_symbol(element) ? [{ element, amount, oxidation_state, orig_idx: idx }] : []);
 // Extract element symbols from a chemical formula.
 // Default (unique=true, sorted=true): "NbZr2Nb" -> ["Nb", "Zr"]
 // unique=false: Fast token extraction preserving order without parentheses expansion
@@ -271,12 +281,12 @@ export function extract_formula_elements(formula, { unique = true, sorted = true
         const matches = formula.match(/[A-Z][a-z]?/g) ?? [];
         const elements = [];
         for (const match of matches) {
-            if (is_valid_element(match))
+            if (is_elem_symbol(match))
                 elements.push(match);
         }
         return elements;
     }
-    const symbols = Object.keys(parse_formula(formula)).filter(is_valid_element);
+    const symbols = Object.keys(parse_formula(formula)).filter(is_elem_symbol);
     return sorted ? symbols.sort() : symbols;
 }
 // Generate all non-empty subsets of a chemical system as hyphenated strings.
@@ -290,7 +300,7 @@ export function generate_chem_sys_subspaces(input) {
     else if (Array.isArray(input)) {
         const uniq = [...new Set(input)];
         for (const elem of uniq) {
-            if (!is_valid_element(elem))
+            if (!is_elem_symbol(elem))
                 throw new Error(`Invalid element symbol: ${elem}`);
         }
         elements = uniq;
@@ -298,7 +308,7 @@ export function generate_chem_sys_subspaces(input) {
     else {
         elements = [];
         for (const elem of Object.keys(input)) {
-            if (!is_valid_element(elem))
+            if (!is_elem_symbol(elem))
                 throw new Error(`Invalid element symbol: ${elem}`);
             elements.push(elem);
         }
@@ -332,7 +342,7 @@ export const has_wildcards = (input) => input.includes(`*`);
 // Throws if any non-wildcard token is not a valid element symbol.
 export function parse_chemsys_with_wildcards(input) {
     const tokens = input
-        .replace(/-/g, `,`)
+        .replaceAll('-', `,`)
         .split(`,`)
         .map((tok) => tok.trim())
         .filter(Boolean);
@@ -342,7 +352,7 @@ export function parse_chemsys_with_wildcards(input) {
         if (token === `*`) {
             wildcard_count++;
         }
-        else if (is_valid_element(token)) {
+        else if (is_elem_symbol(token)) {
             elements.push(token);
         }
         else {
@@ -368,7 +378,7 @@ export const ELEM_WILDCARD = {
 export function parse_formula_with_wildcards(formula) {
     const tokens = [];
     // Expand parentheses, treating * as a pseudo-element (temporarily replace to protect it)
-    let cleaned = formula.replace(/\s/g, ``);
+    let cleaned = formula.replaceAll(/\s/g, ``);
     // Protect wildcards from parentheses expansion by replacing * with placeholder
     cleaned = cleaned.replace(ELEM_WILDCARD.to_placeholder, ELEM_WILDCARD.placeholder);
     cleaned = expand_parentheses(cleaned);
@@ -389,7 +399,7 @@ export function parse_formula_with_wildcards(formula) {
             // Element symbol match
             const element = match[1];
             const count = parse_count(match[2]);
-            if (!is_valid_element(element)) {
+            if (!is_elem_symbol(element)) {
                 throw new Error(`Invalid element symbol: ${element}`);
             }
             tokens.push({ element, count });
@@ -410,7 +420,7 @@ export function matches_chemsys_wildcard(formula, explicit_elements, wildcard_co
         // Must contain all explicit elements
         const formula_set = new Set(formula_elements);
         for (const elem of explicit_elements) {
-            if (!is_valid_element(elem) || !formula_set.has(elem))
+            if (!is_elem_symbol(elem) || !formula_set.has(elem))
                 return false;
         }
         return true;

package/dist/controls.d.ts

@@ -5,6 +5,7 @@ export type ShowControlsConfig = {
     style?: string;
 };
 export type ShowControlsProp = ControlsVisibility | ShowControlsConfig | boolean;
+export type ShowControlsState = ReturnType<typeof normalize_show_controls>;
 export declare function normalize_show_controls(prop: ShowControlsProp | undefined): {
     mode: ControlsVisibility;
     hidden: Set<string>;

package/dist/controls.js

@@ -1,6 +1,5 @@
 // Controls visibility configuration for visualization components
 // Manages visibility of control buttons in Structure, Trajectory, BrillouinZone
-// Normalize show_controls prop into consistent config with helper methods
 export function normalize_show_controls(prop) {
     // Extract mode, hidden, style from various prop forms
     let mode = `hover`;

package/dist/convex-hull/ConvexHull.svelte

@@ -8,17 +8,13 @@
   import ConvexHull3D from './ConvexHull3D.svelte'
   import ConvexHull4D from './ConvexHull4D.svelte'
   import type { BaseConvexHullProps, Hull3DProps } from './index'
-  import type { GasSpecies, GasThermodynamicsConfig } from './types'
 
   // Union type combining all possible props from 2D, 3D, and 4D components
   // each specific component will only use its relevant props from this super set
+  // (gas_config/gas_pressures already come from BaseConvexHullProps)
   type ConvexHullProps = BaseConvexHullProps & Hull3DProps & {
     x_axis?: AxisConfig
     y_axis?: AxisConfig
-    // Gas thermodynamics config - enables atmosphere-controlled phase diagrams
-    gas_config?: GasThermodynamicsConfig
-    // Gas pressure binding - enables two-way binding for atmosphere control
-    gas_pressures?: Partial<Record<GasSpecies, number>>
   }
 
   let {
@@ -28,6 +24,7 @@
     wrapper = $bindable(),
     show_stable = $bindable(true),
     show_unstable = $bindable(true),
+    hidden_categories = $bindable([]),
     show_hull_faces = $bindable(true),
     hull_face_opacity: hull_face_opacity_prop = $bindable(
       undefined as number | undefined,
@@ -35,7 +32,7 @@
     color_mode = $bindable(`energy`),
     color_scale = $bindable(`interpolateViridis`),
     info_pane_open = $bindable(false),
-    legend_pane_open = $bindable(false),
+    controls_open = $bindable(false),
     max_hull_dist_show_phases = $bindable(0.1),
     max_hull_dist_show_labels = $bindable(0.1),
     show_stable_labels = $bindable(true),
@@ -87,9 +84,9 @@
     hull_face_opacity_prop = hull_face_opacity
   })
 
-  // Map element count to corresponding component
-  // Note: Type assertion needed because TypeScript can't infer that all components
-  // accept a compatible superset of props (BaseConvexHullProps + dimension-specific)
+  // Map element count to component. Deliberate cast: the wrapper passes the prop superset
+  // while each component declares only its dimension's props (2D lacks Hull3DProps, 3D/4D
+  // lack x/y_axis), so a constructor union wouldn't compile. Svelte ignores extra props.
   const ConvexHullComponent = $derived(
     { 2: ConvexHull2D, 3: ConvexHull3D, 4: ConvexHull4D }[element_count] ??
       null,
@@ -104,12 +101,13 @@
     bind:wrapper
     bind:show_stable
     bind:show_unstable
+    bind:hidden_categories
     bind:show_hull_faces
     bind:hull_face_opacity
     bind:color_mode
     bind:color_scale
     bind:info_pane_open
-    bind:legend_pane_open
+    bind:controls_open
     bind:max_hull_dist_show_phases
     bind:max_hull_dist_show_labels
     bind:show_stable_labels

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

@@ -1,13 +1,10 @@
 import type { AxisConfig } from '../plot';
 import type { Component } from 'svelte';
 import type { BaseConvexHullProps, Hull3DProps } from './index';
-import type { GasSpecies, GasThermodynamicsConfig } from './types';
 type ConvexHullProps = BaseConvexHullProps & Hull3DProps & {
     x_axis?: AxisConfig;
     y_axis?: AxisConfig;
-    gas_config?: GasThermodynamicsConfig;
-    gas_pressures?: Partial<Record<GasSpecies, number>>;
 };
-declare const ConvexHull: Component<ConvexHullProps, {}, "temperature" | "display" | "fullscreen" | "show_hull_faces" | "hull_face_opacity" | "color_mode" | "color_scale" | "show_stable" | "show_unstable" | "show_stable_labels" | "show_unstable_labels" | "max_hull_dist_show_phases" | "max_hull_dist_show_labels" | "info_pane_open" | "legend_pane_open" | "wrapper" | "energy_source_mode" | "stable_entries" | "unstable_entries" | "phase_stats" | "highlighted_entries" | "selected_entry" | "gas_pressures">;
+declare const ConvexHull: Component<ConvexHullProps, {}, "display" | "temperature" | "fullscreen" | "wrapper" | "controls_open" | "color_scale" | "info_pane_open" | "show_hull_faces" | "hull_face_opacity" | "color_mode" | "show_stable" | "show_unstable" | "show_stable_labels" | "show_unstable_labels" | "max_hull_dist_show_phases" | "max_hull_dist_show_labels" | "hidden_categories" | "energy_source_mode" | "stable_entries" | "unstable_entries" | "phase_stats" | "highlighted_entries" | "selected_entry" | "gas_pressures">;
 type ConvexHull = ReturnType<typeof ConvexHull>;
 export default ConvexHull;