matterviz 0.3.7 → 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}

@@ -26,8 +26,8 @@ export const choose_site_label_offset = (bond_directions, base_offset) => {
     if (offset_length < LABEL_OFFSET_EPS || bond_directions.length === 0) {
         return base_offset;
     }
-    const preferred_direction = math.normalize_vec3(base_offset, [0, 1, 0]);
-    const repulsion_direction = math.normalize_vec3(bond_directions.reduce((offset_sum, bond_direction) => math.subtract(offset_sum, bond_direction), [0, 0, 0]), preferred_direction);
+    const preferred_direction = math.normalize_vec(base_offset, [0, 1, 0]);
+    const repulsion_direction = math.normalize_vec(bond_directions.reduce((offset_sum, bond_direction) => math.subtract(offset_sum, bond_direction), [0, 0, 0]), preferred_direction);
     let best_direction = preferred_direction;
     let best_score = -Infinity;
     for (const candidate_direction of [
@@ -35,7 +35,7 @@ export const choose_site_label_offset = (bond_directions, base_offset) => {
         repulsion_direction,
         ...LABEL_OFFSET_DIRECTIONS,
     ]) {
-        const direction = math.normalize_vec3(candidate_direction, preferred_direction);
+        const direction = math.normalize_vec(candidate_direction, preferred_direction);
         const score = label_direction_score(direction, bond_directions, preferred_direction);
         if (score <= best_score + LABEL_OFFSET_EPS)
             continue;
@@ -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_vec3(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)));
@@ -55,13 +48,13 @@ const build_prop_colors = (vals, colors, unique_values) => {
     return { colors, values: vals, min_value, max_value, unique_values: uniq };
 };
 export function apply_color_scale(vals, scale = DEFAULT_COLOR_SCALE, type = `continuous`) {
-    if (!vals.length)
+    if (vals.length === 0)
         return { colors: [] };
     if (type === `categorical`) {
         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) {
@@ -74,7 +67,7 @@ export function apply_color_scale(vals, scale = DEFAULT_COLOR_SCALE, type = `con
         colors: vals.map((val) => to_hex(interp_fn, max === min ? 0.5 : (val - min) / (max - min))),
     };
 }
-export const apply_categorical_color_scale = (vals, scale = DEFAULT_COLOR_SCALE) => vals.length ? make_categorical(vals, scale) : { colors: [], unique_values: [] };
+export const apply_categorical_color_scale = (vals, scale = DEFAULT_COLOR_SCALE) => vals.length > 0 ? make_categorical(vals, scale) : { colors: [], unique_values: [] };
 // Get original site index for property color lookup.
 // Supercell atoms use orig_unit_cell_idx, image atoms use orig_site_idx, otherwise use site_idx.
 export const get_orig_site_idx = (site, site_idx) => typeof site?.properties?.orig_unit_cell_idx === `number`
@@ -84,7 +77,7 @@ export const get_orig_site_idx = (site, site_idx) => typeof site?.properties?.or
         : site_idx;
 // Expand structure with PBC images - use minimal expansion based on atom positions
 function expand_structure_for_pbc(structure) {
-    if (!(`lattice` in structure) || !structure.lattice || !structure.sites.length) {
+    if (!(`lattice` in structure) || !structure.lattice || structure.sites.length === 0) {
         return structure;
     }
     const { sites, lattice } = structure;
@@ -92,7 +85,7 @@ function expand_structure_for_pbc(structure) {
     const pbc = lattice.pbc ?? [true, true, true];
     const all_offsets = get_all_offsets(pbc);
     // Small structures: expand all atoms
-    if (sites.length < 20 || !pbc.some((periodic) => periodic)) {
+    if (sites.length < 20 || !pbc.some(Boolean)) {
         const image_sites = sites.flatMap((site, orig_idx) => all_offsets.map((offset) => build_image_site(site, frac_to_cart, offset, orig_idx)));
         return { ...structure, sites: [...sites, ...image_sites] };
     }
@@ -113,7 +106,7 @@ export function get_coordination_colors(structure, strategy = `electroneg_ratio`
     // Check if structure has periodic boundary conditions
     const has_lattice = `lattice` in structure && structure.lattice !== undefined;
     const pbc = has_lattice ? structure.lattice.pbc : undefined;
-    const has_pbc = has_lattice && (pbc === undefined || pbc.some((is_periodic) => is_periodic));
+    const has_pbc = has_lattice && (pbc === undefined || pbc.some(Boolean));
     // For PBC structures, expand with images from neighboring cells for accurate coordination
     const coord_structure = has_pbc ? expand_structure_for_pbc(structure) : structure;
     // Calculate coordination numbers on the (potentially expanded) structure
@@ -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);
             }
@@ -196,5 +191,5 @@ export function get_property_colors(structure, config, bonding_strategy, sym_dat
     if (!structure || config.mode === `element`)
         return null;
     const result = get_atom_colors(structure, config, bonding_strategy, sym_data);
-    return result.colors.length ? result : null;
+    return result.colors.length > 0 ? result : null;
 }

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 = {
@@ -71,7 +69,7 @@ function split_fragments(n_atoms, edges) {
         const stack = [start];
         const frag = [];
         seen.add(start);
-        while (stack.length) {
+        while (stack.length > 0) {
             const node = stack.pop();
             if (node === undefined)
                 break;

package/dist/structure/bonding.d.ts

@@ -1,7 +1,11 @@
+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[];
 export type BondEditState = {
     added_bonds: StructureBond[];
     removed_bonds: 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))
@@ -45,6 +52,31 @@ export const get_bond_key = (idx_1, idx_2, cell_shift) => {
     const normalized = normalize_bond_endpoints(idx_1, idx_2, cell_shift);
     return `${normalized.site_idx_1}-${normalized.site_idx_2}${format_cell_shift(normalized.cell_shift)}`;
 };
+// Remap explicit bond metadata after site deletion: drop bonds touching deleted
+// sites and shift each surviving index down by the number of deleted indices below it.
+export function remap_bonds_after_deletion(bonds, deleted_indices) {
+    // Sort the deleted indices once; shift each surviving index down by the count of deleted
+    // indices below it via binary search (O(log m) per lookup vs re-filtering the set each call).
+    const sorted = [...deleted_indices].sort((idx_a, idx_b) => idx_a - idx_b);
+    const shift = (idx) => {
+        let [lo, hi] = [0, sorted.length];
+        while (lo < hi) {
+            const mid = (lo + hi) >> 1;
+            if (sorted[mid] < idx)
+                lo = mid + 1;
+            else
+                hi = mid;
+        }
+        return idx - lo; // lo == count of deleted indices < idx
+    };
+    return bonds
+        .filter((bond) => !deleted_indices.has(bond.site_idx_1) && !deleted_indices.has(bond.site_idx_2))
+        .map((bond) => ({
+        ...bond,
+        site_idx_1: shift(bond.site_idx_1),
+        site_idx_2: shift(bond.site_idx_2),
+    }));
+}
 export const BOND_ORDER_OPTIONS = [
     { order: 1, label: `Single` },
     { order: 1.5, label: `1.5` },
@@ -364,29 +396,30 @@ export function scale_and_offset_bond_matrix(transform_matrix, offset, radius_sc
 export function get_bond_render_matrices(bond, bond_thickness) {
     const order = bond.bond_order ?? 1;
     const gap = bond_thickness * 1.8;
-    const offsets_and_scales = order === 2
-        ? [
+    // Parallel cylinder [offset, radius_scale] pairs per bond order; empty → a single
+    // full-width bond (handled by the fallback below)
+    let offsets_and_scales = [];
+    if (order === 2)
+        offsets_and_scales = [
             [-gap / 2, 0.65],
             [gap / 2, 0.65],
-        ]
-        : order === 3
-            ? [
-                [-gap, 0.55],
-                [0, 0.55],
-                [gap, 0.55],
-            ]
-            : order === 1.5 || order === `aromatic`
-                ? [
-                    [-gap / 2, 0.75],
-                    [gap / 2, 0.4],
-                ]
-                : [];
+        ];
+    else if (order === 3)
+        offsets_and_scales = [
+            [-gap, 0.55],
+            [0, 0.55],
+            [gap, 0.55],
+        ];
+    else if (order === 1.5 || order === `aromatic`) {
+        offsets_and_scales = [
+            [-gap / 2, 0.75],
+            [gap / 2, 0.4],
+        ];
+    }
     return offsets_and_scales.length === 0
         ? [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;
@@ -468,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);
@@ -493,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);
             }
         }
     }
@@ -529,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)
@@ -551,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;
@@ -584,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,
@@ -617,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
@@ -657,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);