matterviz 0.4.0 → 0.4.1

package/dist/structure/StructureScene.svelte.d.ts

@@ -2,31 +2,26 @@ import type { D3InterpolateName } from '../colors';
 import type { ElementSymbol } from '../element';
 import type { IsosurfaceSettings, VolumetricData } from '../isosurface/types';
 import type { Vec3 } from '../math';
-import type { CameraProjection, ShowBonds, VectorColorMode, VectorLayerConfig } from '../settings';
+import type { SceneControlProps } from '../scene';
+import type { ShowBonds, VectorColorMode, VectorLayerConfig } from '../settings';
 import type { AnyStructure, BondEditMode, BondOrder, MeasureMode, Site, StructureBond } from './';
 import { Lattice } from './';
 import type { AtomColorConfig } from './atom-properties';
+import type { SymmetryElement } from '../symmetry';
+import SymmetryElements from '../symmetry/SymmetryElements.svelte';
 import type { MoyoDataset } from '@spglib/moyo-wasm';
 import * as extras from '@threlte/extras';
 import { type ComponentProps, type Snippet } from 'svelte';
 import { SvelteMap } from 'svelte/reactivity';
-import { type Camera, type Scene } from 'three';
 import type { BondingStrategy } from './bonding';
-type $$ComponentProps = {
+import type { PolyhedraColorMode } from './polyhedra';
+type $$ComponentProps = SceneControlProps & {
     structure?: AnyStructure;
     base_structure?: AnyStructure;
     atom_radius?: number;
     same_size_atoms?: boolean;
     camera_position?: [x: number, y: number, z: number];
     camera_target?: Vec3;
-    camera_projection?: CameraProjection;
-    rotation_damping?: number;
-    max_zoom?: number;
-    min_zoom?: number;
-    rotate_speed?: number;
-    zoom_speed?: number;
-    pan_speed?: number;
-    zoom_to_cursor?: boolean;
     show_atoms?: boolean;
     show_bonds?: ShowBonds;
     show_site_labels?: boolean;
@@ -42,23 +37,32 @@ type $$ComponentProps = {
     vector_shaft_radius?: number;
     vector_arrow_head_radius?: number;
     vector_arrow_head_length?: number;
-    gizmo?: boolean | ComponentProps<typeof extras.Gizmo>;
     hovered_idx?: number | null;
     hovered_site?: Site | null;
     float_fmt?: string;
-    auto_rotate?: number;
-    initial_zoom?: number;
     bond_thickness?: number;
     bond_color?: string;
     bonding_strategy?: BondingStrategy;
     auto_bond_order?: boolean;
     aromatic_display?: `aromatic` | `kekule`;
     bonding_options?: Record<string, unknown>;
-    fov?: number;
-    ambient_light?: number;
-    directional_light?: number;
+    show_polyhedra?: ShowBonds;
+    polyhedra_opacity?: number;
+    polyhedra_show_edges?: boolean;
+    polyhedra_edge_color?: string;
+    polyhedra_color_mode?: PolyhedraColorMode;
+    polyhedra_color?: string;
+    polyhedra_hide_center_atoms?: boolean;
+    polyhedra_min_neighbors?: number;
+    polyhedra_max_neighbors?: number;
+    polyhedra_excluded_elements?: readonly string[];
+    polyhedra_included_elements?: readonly string[];
+    polyhedra_rendered_elements?: string[];
     sphere_segments?: number;
     lattice_props?: ComponentProps<typeof Lattice>;
+    symmetry_elements?: SymmetryElement[];
+    symmetry_elements_props?: Omit<ComponentProps<typeof SymmetryElements>, `elements` | `lattice`>;
+    symmetry_declutter?: boolean;
     atom_label?: Snippet<[{
         site: Site;
         site_idx: number;
@@ -84,8 +88,6 @@ type $$ComponentProps = {
     active_sites?: number[];
     active_highlight_color?: string;
     rotation?: Vec3;
-    scene?: Scene;
-    camera?: Camera;
     orbit_controls?: ComponentProps<typeof extras.OrbitControls>[`ref`];
     rotation_target_ref?: Vec3;
     initial_computed_zoom?: number;
@@ -106,6 +108,6 @@ type $$ComponentProps = {
     volumetric_data?: VolumetricData;
     isosurface_settings?: IsosurfaceSettings;
 };
-declare const StructureScene: import("svelte").Component<$$ComponentProps, {}, "cursor" | "site_label_offset" | "vector_configs" | "camera" | "scene" | "orbit_controls" | "site_radius_overrides" | "hovered_idx" | "hovered_site" | "camera_is_moving" | "selected_sites" | "measured_sites" | "added_bonds" | "removed_bonds" | "bond_order_overrides" | "bond_edit_mode" | "active_sites" | "rotation_target_ref" | "initial_computed_zoom" | "hidden_elements" | "hidden_prop_vals" | "element_radius_overrides" | "add_atom_mode" | "add_element" | "dragging_atoms">;
+declare const StructureScene: import("svelte").Component<$$ComponentProps, {}, "cursor" | "hidden_elements" | "hidden_prop_vals" | "element_radius_overrides" | "site_radius_overrides" | "selected_sites" | "site_label_offset" | "vector_configs" | "hovered_idx" | "hovered_site" | "polyhedra_rendered_elements" | "camera_is_moving" | "measured_sites" | "added_bonds" | "removed_bonds" | "bond_order_overrides" | "bond_edit_mode" | "active_sites" | "scene" | "camera" | "orbit_controls" | "rotation_target_ref" | "initial_computed_zoom" | "add_atom_mode" | "add_element" | "dragging_atoms">;
 type StructureScene = ReturnType<typeof StructureScene>;
 export default StructureScene;

package/dist/structure/{label-placement.d.ts → atom-label-placement.d.ts}

@@ -1,4 +1,4 @@
-import type { Vec3 } from '../math';
+import type { Vec2, Vec3 } from '../math';
 import type { Camera, Object3D } from 'three';
 export declare const LABEL_OFFSET_EPS = 1e-9;
 type LabelOffsetSource = Vec3 | (() => Vec3);
@@ -6,9 +6,9 @@ export declare const choose_site_label_offset: (bond_directions: Vec3[], base_of
 export declare const label_screen_position: (atom_position: Vec3, label_offset: Vec3, visual_radius: number, label_screen_margin: number, label_camera: Camera, size: {
     width: number;
     height: number;
-}) => [number, number];
+}) => Vec2;
 export declare const make_label_position_calculator: (_atom_position: Vec3, label_offset: LabelOffsetSource, visual_radius: number, label_screen_margin: number) => (object: Object3D, label_camera: Camera, size: {
     width: number;
     height: number;
-}) => [number, number];
+}) => Vec2;
 export {};

package/dist/structure/{label-placement.js → atom-label-placement.js}

@@ -59,8 +59,18 @@ export const label_screen_position = (atom_position, label_offset, visual_radius
     const offset_length = Math.hypot(offset_x, offset_y);
     const direction_x = offset_length > LABEL_OFFSET_EPS ? offset_x / offset_length : 0;
     const direction_y = offset_length > LABEL_OFFSET_EPS ? offset_y / offset_length : label_offset[1] >= 0 ? -1 : 1;
-    const radius_direction = math.normalize_vec(label_offset, [0, 1, 0]);
-    const radius_edge = math.add(atom_position, math.scale(radius_direction, visual_radius));
+    // Measure the atom's projected radius along the camera's right axis (always
+    // view-perpendicular). Measuring along label_offset would collapse the clearance
+    // to ~zero for offsets near the view axis, letting the label overlap the atom.
+    const radius_dir = new Vector3()
+        .setFromMatrixColumn(label_camera.matrixWorld, 0)
+        .normalize()
+        .multiplyScalar(visual_radius);
+    const radius_edge = math.add(atom_position, [
+        radius_dir.x,
+        radius_dir.y,
+        radius_dir.z,
+    ]);
     const radius_screen = project_to_screen(radius_edge, label_camera, size);
     const atom_screen_radius = Math.hypot(radius_screen[0] - atom_screen[0], radius_screen[1] - atom_screen[1]);
     const screen_gap = atom_screen_radius + label_screen_margin;

package/dist/structure/atom-properties.d.ts

@@ -17,7 +17,7 @@ export interface AtomPropertyColors {
     unique_values?: (number | string)[];
 }
 type SymmetryDataWithOrigMap = MoyoDataset & {
-    orig_site_indices_by_std_idx?: number[][];
+    orig_site_indices_by_input_idx?: number[][];
 };
 export declare const get_d3_color_scales: () => string[];
 export declare function apply_color_scale(vals: number[], scale?: string, type?: ColorScaleType): {

package/dist/structure/atom-properties.js

@@ -1,4 +1,5 @@
 // Utility functions for computing atom properties and applying color scales
+import { get_d3_interpolator } from '../colors';
 import { calc_coordination_nums } from '../coordination';
 import * as math from '../math';
 import { wrap_to_unit_cell } from './pbc';
@@ -7,15 +8,7 @@ import * as d3_sc from 'd3-scale-chromatic';
 const GRAY = `#808080`;
 const DEFAULT_COLOR_SCALE = `interpolateViridis`;
 export const get_d3_color_scales = () => Object.keys(d3_sc).filter((key) => key.startsWith(`interpolate`));
-const get_interpolator = (scale) => {
-    const interp_fn = d3_sc[scale];
-    if (typeof interp_fn !== `function`) {
-        console.warn(`Unknown D3 scale: ${scale}, using ${DEFAULT_COLOR_SCALE}`);
-        return d3_sc.interpolateViridis;
-    }
-    return interp_fn;
-};
-const to_hex = (interp_fn, t) => rgb(interp_fn(t)).formatHex();
+const to_hex = (interp_fn, frac) => rgb(interp_fn(frac)).formatHex();
 const build_image_site = (site, frac_to_cart, offset, orig_idx) => {
     const img_abc = [
         site.abc[0] + offset[0],
@@ -36,7 +29,7 @@ const get_all_offsets = (pbc) => [-1, 0, 1]
     (pbc[1] || dy === 0) &&
     (pbc[2] || dz === 0));
 const make_categorical = (vals, scale, sort_fn) => {
-    const interp_fn = get_interpolator(scale);
+    const interp_fn = get_d3_interpolator(scale);
     const uniq = sort_fn
         ? [...new Set(vals)].sort(sort_fn)
         : [...new Set(vals)].sort((val_a, val_b) => String(val_a).localeCompare(String(val_b)));
@@ -61,7 +54,7 @@ export function apply_color_scale(vals, scale = DEFAULT_COLOR_SCALE, type = `con
         const result = make_categorical(vals, scale, (val_a, val_b) => val_a - val_b);
         return { colors: result.colors, unique_values: result.unique_values };
     }
-    const interp_fn = get_interpolator(scale);
+    const interp_fn = get_d3_interpolator(scale);
     // Compute min/max in single pass to avoid spreading large arrays
     let [min, max] = [vals[0], vals[0]];
     for (const val of vals) {
@@ -134,12 +127,14 @@ export function get_wyckoff_colors(structure, sym_data, scale = DEFAULT_COLOR_SC
             unique_values: [`unknown`],
         };
     }
+    // moyo's wyckoffs array is indexed by INPUT cell sites (the merged moyo input cell),
+    // so map letters to original sites through orig_site_indices_by_input_idx
     const wyckoff_by_orig_idx = new Map();
-    const mapping_by_std_idx = sym_data.orig_site_indices_by_std_idx;
-    if (mapping_by_std_idx) {
-        for (let std_idx = 0; std_idx < sym_data.wyckoffs.length; std_idx += 1) {
-            const wyckoff = sym_data.wyckoffs[std_idx];
-            for (const orig_idx of mapping_by_std_idx[std_idx] ?? []) {
+    const mapping_by_input_idx = sym_data.orig_site_indices_by_input_idx;
+    if (mapping_by_input_idx) {
+        for (let input_idx = 0; input_idx < sym_data.wyckoffs.length; input_idx += 1) {
+            const wyckoff = sym_data.wyckoffs[input_idx];
+            for (const orig_idx of mapping_by_input_idx[input_idx] ?? []) {
                 if (!wyckoff_by_orig_idx.has(orig_idx))
                     wyckoff_by_orig_idx.set(orig_idx, wyckoff);
             }

package/dist/structure/bond-order-perception.js

@@ -1,7 +1,5 @@
-import { get_bond_key } from './bonding';
-const primary_element = (site) => {
-    return (site.species?.reduce((best_species, species) => (species.occu > best_species.occu ? species : best_species), site.species[0])?.element ?? ``);
-};
+import { get_bond_key, get_majority_element } from './bonding';
+const primary_element = (site) => get_majority_element(site) ?? ``;
 // xyz2mol atomic_valence. Valence combinations are re-sorted by total
 // valence sum so the least-saturated solution is tried first.
 const ATOMIC_VALENCE = {

package/dist/structure/bonding.d.ts

@@ -1,5 +1,8 @@
+import type { ElementSymbol } from '../element';
 import type { Vec3 } from '../math';
 import type { AnyStructure, BondOrder, BondPair, Site, StructureBond } from './';
+export declare const element_lookup: 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", import("../element").ChemicalElement>;
+export declare const get_majority_element: (site: Site | undefined) => ElementSymbol | null;
 export declare const normalize_structure_bond: (site_idx_1: number, site_idx_2: number, order: BondOrder, cell_shift?: Vec3) => StructureBond;
 export declare const get_bond_key: (idx_1: number, idx_2: number, cell_shift?: Vec3) => string;
 export declare function remap_bonds_after_deletion(bonds: readonly StructureBond[], deleted_indices: ReadonlySet<number>): StructureBond[];

package/dist/structure/bonding.js

@@ -1,8 +1,15 @@
 // Bonding algorithms for structure visualization
 import { element_data } from '../element';
 import * as math from '../math';
-const element_lookup = new Map(element_data.map((el) => [el.symbol, el]));
+// Shared per-symbol element data lookup (also used by pbc.ts and polyhedra.ts)
+export const element_lookup = new Map(element_data.map((el) => [el.symbol, el]));
 const covalent_radii = new Map(element_data.flatMap((el) => el.covalent_radius === null ? [] : [[el.symbol, el.covalent_radius]]));
+// Majority-occupancy element of a (possibly disordered) site
+export const get_majority_element = (site) => {
+    if (!site?.species?.length)
+        return null;
+    return site.species.reduce((max, spec) => (spec.occu > max.occu ? spec : max)).element;
+};
 const is_zero_cell_shift = (cell_shift) => cell_shift === undefined || cell_shift.every((val) => val === 0);
 const format_cell_shift = (cell_shift) => {
     if (cell_shift === undefined || is_zero_cell_shift(cell_shift))
@@ -413,8 +420,6 @@ export function get_bond_render_matrices(bond, bond_thickness) {
         ? [bond.transform_matrix]
         : offsets_and_scales.map(([offset, radius_scale]) => scale_and_offset_bond_matrix(bond.transform_matrix, offset, radius_scale));
 }
-// Get the species with highest occupancy from a site.
-const get_majority_species = (site) => (site.species ?? []).reduce((max_species, species) => (species.occu > max_species.occu ? species : max_species), site.species?.[0] ?? { element: ``, occu: -1 });
 // Helper to extract numeric index from site properties
 function get_orig_idx(site, fallback) {
     const props = site.properties;
@@ -496,12 +501,16 @@ export function compute_bond_transform(pos_1, pos_2) {
         1,
     ]);
 }
+// Pack quantized cell coordinates into one integer key (exact for cell coords in
+// [-512, 511], i.e. structures up to ~1000 cells per axis - far beyond any real
+// case). Integer Map keys avoid per-lookup string building in the hot pair loop.
+const CELL_OFFSET = 512;
+const pack_cell_key = (x, y, z) => (x + CELL_OFFSET) * 1048576 + (y + CELL_OFFSET) * 1024 + (z + CELL_OFFSET);
 // Build spatial grid by dividing 3D space into cubic cells.
 function build_spatial_grid(sites, cell_size) {
     const grid = new Map();
     for (let idx = 0; idx < sites.length; idx++) {
-        const [x, y, z] = sites[idx].xyz.map((coord) => Math.floor(coord / cell_size));
-        const key = `${x},${y},${z}`;
+        const key = pack_cell_key(Math.floor(sites[idx].xyz[0] / cell_size), Math.floor(sites[idx].xyz[1] / cell_size), Math.floor(sites[idx].xyz[2] / cell_size));
         const cell = grid.get(key);
         if (cell)
             cell.push(idx);
@@ -521,9 +530,10 @@ function get_neighbors_from_grid(pos, grid, cell_size) {
     for (let dx = -1; dx <= 1; dx++) {
         for (let dy = -1; dy <= 1; dy++) {
             for (let dz = -1; dz <= 1; dz++) {
-                const cell = grid.get(`${cx + dx},${cy + dy},${cz + dz}`);
+                const cell = grid.get(pack_cell_key(cx + dx, cy + dy, cz + dz));
                 if (cell)
-                    neighbors.push(...cell);
+                    for (const idx of cell)
+                        neighbors.push(idx);
             }
         }
     }
@@ -557,19 +567,39 @@ strength_threshold = 0.3, // Minimum bond strength to include in results
         return [];
     const bonds = [];
     const min_dist_sq = min_bond_dist ** 2;
-    const closest = new Map();
-    const props = sites.map((site) => {
-        const majority = get_majority_species(site);
-        const elem = majority.element;
-        const data = element_lookup.get(elem);
-        return {
-            element: elem,
-            electroneg: data?.electronegativity ?? 2.0,
-            is_metal: data?.metal ?? false,
-            is_nonmetal: data?.nonmetal ?? false,
-            radius: elem ? covalent_radii.get(elem) : undefined,
-        };
-    });
+    // Per-site properties in flat typed arrays - the pair loop below visits
+    // millions of candidate pairs in large supercells, so object property chains
+    // and Map lookups are replaced with indexed array reads.
+    const n_sites = sites.length;
+    const electronegs = new Float64Array(n_sites);
+    const radii = new Float64Array(n_sites); // 0 = no covalent radius known
+    const metal_flags = new Uint8Array(n_sites);
+    const nonmetal_flags = new Uint8Array(n_sites);
+    const elem_ids = new Int32Array(n_sites); // same-species check via integer ids
+    const orig_idxs = new Int32Array(n_sites);
+    const elem_id_lookup = new Map();
+    for (let idx = 0; idx < n_sites; idx++) {
+        const elem = get_majority_element(sites[idx]);
+        const data = elem ? element_lookup.get(elem) : undefined;
+        electronegs[idx] = data?.electronegativity ?? 2.0;
+        metal_flags[idx] = data?.metal ? 1 : 0;
+        nonmetal_flags[idx] = data?.nonmetal ? 1 : 0;
+        radii[idx] = (elem ? covalent_radii.get(elem) : undefined) ?? 0;
+        let elem_id = elem_id_lookup.get(elem ?? ``);
+        if (elem_id === undefined) {
+            elem_id = elem_id_lookup.size;
+            elem_id_lookup.set(elem ?? ``, elem_id);
+        }
+        elem_ids[idx] = elem_id;
+        // Valid orig indices always reference a site in this structure; fall back to
+        // the site's own index on malformed orig_*_idx properties so the typed
+        // `closest` array below stays bounded by n_sites
+        const orig_idx = get_orig_idx(sites[idx], idx);
+        orig_idxs[idx] =
+            Number.isInteger(orig_idx) && orig_idx >= 0 && orig_idx < n_sites ? orig_idx : idx;
+    }
+    // Closest normalized bond distance per original atom (typed array instead of Map)
+    const closest = new Float64Array(n_sites).fill(Infinity);
     let max_radius = 0;
     for (const radius of covalent_radii.values()) {
         if (radius > max_radius)
@@ -579,29 +609,44 @@ strength_threshold = 0.3, // Minimum bond strength to include in results
     const spatial = setup_spatial_grid(sites, max_cutoff);
     const potential_bonds = [];
     for (let idx_a = 0; idx_a < sites.length - 1; idx_a++) {
+        const radius_a = radii[idx_a];
+        if (radius_a === 0)
+            continue; // no covalent radius -> no pairs (symmetric: idx_b skips too)
         const [x1, y1, z1] = sites[idx_a].xyz;
-        const props_a = props[idx_a];
+        const electroneg_a = electronegs[idx_a];
+        const is_metal_a = metal_flags[idx_a] === 1;
+        const is_nonmetal_a = nonmetal_flags[idx_a] === 1;
+        const elem_id_a = elem_ids[idx_a];
         for (const idx_b of get_candidates(sites[idx_a].xyz, sites, spatial)) {
             if (idx_b <= idx_a)
                 continue;
+            const radius_b = radii[idx_b];
+            if (radius_b === 0)
+                continue;
             const [x2, y2, z2] = sites[idx_b].xyz;
-            const props_b = props[idx_b];
-            const [dx, dy, dz] = [x2 - x1, y2 - y1, z2 - z1];
+            const dx = x2 - x1;
+            const dy = y2 - y1;
+            const dz = z2 - z1;
             const dist_sq = dx * dx + dy * dy + dz * dz;
-            const dist = Math.sqrt(dist_sq);
-            if (dist_sq < min_dist_sq || !props_a.radius || !props_b.radius)
+            if (dist_sq < min_dist_sq)
                 continue;
-            const expected = props_a.radius + props_b.radius;
-            if (dist > expected * max_distance_ratio)
+            // Compare squared distances to defer the sqrt until a pair survives the
+            // cutoff (the vast majority of candidate pairs are rejected here)
+            const expected = radius_a + radius_b;
+            const max_dist = expected * max_distance_ratio;
+            if (dist_sq > max_dist * max_dist)
                 continue;
-            const electroneg_diff = Math.abs(props_a.electroneg - props_b.electroneg);
-            const electroneg_balance = electroneg_diff / (props_a.electroneg + props_b.electroneg);
+            const dist = Math.sqrt(dist_sq);
+            const electroneg_b = electronegs[idx_b];
+            const electroneg_diff = Math.abs(electroneg_a - electroneg_b);
+            const electroneg_balance = electroneg_diff / (electroneg_a + electroneg_b);
+            const is_metal_b = metal_flags[idx_b] === 1;
+            const is_nonmetal_b = nonmetal_flags[idx_b] === 1;
             let bond_strength = 1.0;
-            if (props_a.is_metal && props_b.is_metal) {
+            if (is_metal_a && is_metal_b) {
                 bond_strength *= metal_metal_penalty;
             }
-            else if ((props_a.is_metal && props_b.is_nonmetal) ||
-                (props_a.is_nonmetal && props_b.is_metal)) {
+            else if ((is_metal_a && is_nonmetal_b) || (is_nonmetal_a && is_metal_b)) {
                 bond_strength *= metal_nonmetal_bonus;
                 if (electroneg_diff > electronegativity_threshold)
                     bond_strength *= 1.3;
@@ -612,25 +657,23 @@ strength_threshold = 0.3, // Minimum bond strength to include in results
             const dist_weight = Math.exp(-((dist / expected - 1) ** 2) / 0.18);
             const electroneg_weight = 1.0 - 0.3 * electroneg_balance;
             let strength = bond_strength * dist_weight * electroneg_weight;
-            if (props_a.element === props_b.element)
+            if (elem_id_a === elem_ids[idx_b])
                 strength *= same_species_penalty;
             // If raw strength is already too low, we can skip early
             // (penalty will only reduce it further)
             if (strength <= strength_threshold)
                 continue;
-            // Use helper logic to handle both supercell and image atoms with robust normalization
-            const orig_idx_a = get_orig_idx(sites[idx_a], idx_a);
-            const orig_idx_b = get_orig_idx(sites[idx_b], idx_b);
+            // Use precomputed original-site indices to handle supercell and image atoms
+            const orig_idx_a = orig_idxs[idx_a];
+            const orig_idx_b = orig_idxs[idx_b];
             // Update closest known normalized distance (dist / expected) for original atoms
             // Normalized distance handles atoms of different sizes better than raw distance
             // (e.g. C-H is short but C-C is longer; we don't want C-H to penalize C-C just because H is small)
             const norm_dist = dist / expected;
-            const closest_dist_a = closest.get(orig_idx_a) ?? Infinity;
-            if (norm_dist < closest_dist_a)
-                closest.set(orig_idx_a, norm_dist);
-            const closest_dist_b = closest.get(orig_idx_b) ?? Infinity;
-            if (norm_dist < closest_dist_b)
-                closest.set(orig_idx_b, norm_dist);
+            if (norm_dist < closest[orig_idx_a])
+                closest[orig_idx_a] = norm_dist;
+            if (norm_dist < closest[orig_idx_b])
+                closest[orig_idx_b] = norm_dist;
             potential_bonds.push({
                 site_idx_1: idx_a,
                 site_idx_2: idx_b,
@@ -645,8 +688,8 @@ strength_threshold = 0.3, // Minimum bond strength to include in results
     // Second pass: Apply penalties and filter
     for (const bond of potential_bonds) {
         const { site_idx_1, site_idx_2, dist, expected_dist, base_strength, orig_idx_a, orig_idx_b, } = bond;
-        const closest_dist_a = closest.get(orig_idx_a) ?? Infinity;
-        const closest_dist_b = closest.get(orig_idx_b) ?? Infinity;
+        const closest_dist_a = closest[orig_idx_a];
+        const closest_dist_b = closest[orig_idx_b];
         const norm_dist = dist / expected_dist;
         let strength = base_strength;
         // Apply penalty if this bond is much longer (relative to radii) than the closest known bond
@@ -685,14 +728,14 @@ export function solid_angle(structure, { min_solid_angle = 0.01, min_face_area =
     const spatial = setup_spatial_grid(sites, max_distance);
     for (let idx_a = 0; idx_a < sites.length - 1; idx_a++) {
         const [x1, y1, z1] = sites[idx_a].xyz;
-        const majority_a = get_majority_species(sites[idx_a]);
-        const radius_a = majority_a.element ? covalent_radii.get(majority_a.element) : undefined;
+        const elem_a = get_majority_element(sites[idx_a]);
+        const radius_a = elem_a ? covalent_radii.get(elem_a) : undefined;
         for (const idx_b of get_candidates(sites[idx_a].xyz, sites, spatial)) {
             if (idx_b <= idx_a)
                 continue;
             const [x2, y2, z2] = sites[idx_b].xyz;
-            const majority_b = get_majority_species(sites[idx_b]);
-            const radius_b = majority_b.element ? covalent_radii.get(majority_b.element) : undefined;
+            const elem_b = get_majority_element(sites[idx_b]);
+            const radius_b = elem_b ? covalent_radii.get(elem_b) : undefined;
             const [dx, dy, dz] = [x2 - x1, y2 - y1, z2 - z1];
             const dist_sq = dx * dx + dy * dy + dz * dz;
             const dist = Math.sqrt(dist_sq);

package/dist/structure/export.d.ts

@@ -12,9 +12,29 @@ export declare function structure_to_xyz_str(structure?: AnyStructure): string;
 export declare function structure_to_cif_str(structure?: AnyStructure): string;
 export declare function structure_to_poscar_str(structure?: AnyStructure): string;
 export declare function structure_to_json_str(structure?: AnyStructure): string;
-export declare function export_structure_as_cif(structure?: AnyStructure): void;
-export declare function export_structure_as_poscar(structure?: AnyStructure): void;
-export declare function export_structure_as_xyz(structure?: AnyStructure): void;
-export declare function export_structure_as_json(structure?: AnyStructure): void;
+export declare const STRUCT_TEXT_FORMATS: {
+    readonly json: {
+        readonly to_str: typeof structure_to_json_str;
+        readonly ext: "json";
+        readonly mime: "application/json";
+    };
+    readonly xyz: {
+        readonly to_str: typeof structure_to_xyz_str;
+        readonly ext: "xyz";
+        readonly mime: "text/plain";
+    };
+    readonly cif: {
+        readonly to_str: typeof structure_to_cif_str;
+        readonly ext: "cif";
+        readonly mime: "chemical/x-cif";
+    };
+    readonly poscar: {
+        readonly to_str: typeof structure_to_poscar_str;
+        readonly ext: "poscar";
+        readonly mime: "text/plain";
+    };
+};
+export type StructTextFormat = keyof typeof STRUCT_TEXT_FORMATS;
+export declare function export_structure_as(fmt: StructTextFormat, structure?: AnyStructure): void;
 export declare function export_structure_as_glb(scene: Scene | null, structure: AnyStructure | undefined): void;
 export declare function export_structure_as_obj(scene: Scene | null, structure: AnyStructure | undefined): void;