matterviz 0.4.1 → 0.4.3

package/dist/structure/partial-occupancy.js

@@ -10,7 +10,6 @@ const make_render_site = (sites, site_idx, source_site_indices, site_override) =
     is_image_atom: source_site_indices.some((source_site_idx) => is_image_atom(sites[source_site_idx])),
     source_site_indices,
 });
-const sq_dist = (xyz_1, xyz_2) => (xyz_1[0] - xyz_2[0]) ** 2 + (xyz_1[1] - xyz_2[1]) ** 2 + (xyz_1[2] - xyz_2[2]) ** 2;
 const is_split_partial_site = (site, hidden_elements) => {
     const visible_species = site.species.filter(({ element }) => !hidden_elements.has(element));
     const total_visible_occupancy = visible_species.reduce((occupancy_sum, { occu }) => occupancy_sum + occu, 0);
@@ -25,7 +24,12 @@ const group_split_partial_indices = (sites, hidden_elements) => {
             non_grouped_site_indices.push(site_idx);
             continue;
         }
-        const matched_group_idx = grouped_centers.findIndex((center_xyz) => sq_dist(center_xyz, site.xyz) <= MERGE_DISTANCE_TOLERANCE ** 2);
+        const matched_group_idx = grouped_centers.findIndex((center_xyz) => {
+            const dx = center_xyz[0] - site.xyz[0];
+            const dy = center_xyz[1] - site.xyz[1];
+            const dz = center_xyz[2] - site.xyz[2];
+            return dx * dx + dy * dy + dz * dz <= MERGE_DISTANCE_TOLERANCE ** 2;
+        });
         if (matched_group_idx === -1) {
             grouped_centers.push(site.xyz);
             grouped_site_indices.push([site_idx]);
@@ -59,8 +63,8 @@ export const PARTIAL_OCCUPANCY_CAP_ARC = {
     arc_length: Math.PI,
 };
 export const merge_split_partial_sites = (sites, hidden_elements = new Set()) => {
-    const grouped_indices = group_split_partial_indices(sites, hidden_elements);
-    return build_render_sites(sites, grouped_indices.non_grouped_site_indices, grouped_indices.grouped_site_indices);
+    const { non_grouped_site_indices, grouped_site_indices } = group_split_partial_indices(sites, hidden_elements);
+    return build_render_sites(sites, non_grouped_site_indices, grouped_site_indices);
 };
 export const compute_slice_geometry = (visible_species, slice_gap_rad = PARTIAL_OCCUPANCY_SLICE_GAP_RAD) => {
     if (visible_species.length === 0)
@@ -72,7 +76,8 @@ export const compute_slice_geometry = (visible_species, slice_gap_rad = PARTIAL_
         element,
         occu: occu * occupancy_scale_factor,
     }));
-    const normalized_total_occupancy = normalized_species.reduce((occupancy_sum, { occu }) => occupancy_sum + occu, 0);
+    // Sum of scaled occupancies equals total * scale (avoids a second O(n) pass)
+    const normalized_total_occupancy = total_visible_occupancy * occupancy_scale_factor;
     const has_vacancy_gap = normalized_total_occupancy < 1 - OCCUPANCY_EPS;
     const last_visible_species_idx = normalized_species.length - 1;
     let start_angle = 0;

package/dist/structure/pbc.js

@@ -1,5 +1,7 @@
+// Periodic boundary conditions utilities
+import { element_by_symbol } from '../element/data';
 import * as math from '../math';
-import { element_lookup, get_majority_element } from './bonding';
+import { get_majority_element, has_framework_potential, is_spectator_center, pack_cell_key, } from './bonding';
 // Distance slack added to the covalent-radii sum when deciding whether a
 // candidate image atom bonds to a base atom (VESTA-like bond search criterion)
 const BOND_SLACK = 0.4; // Å
@@ -34,42 +36,30 @@ const is_scattered_trajectory = (sites) => {
     const atoms_outside_cell = sites.filter(({ abc }) => abc.some((coord) => coord < -0.1 || coord > 1.1));
     return atoms_outside_cell.length > sites.length * 0.1;
 };
-// Cartesian position of fractional coords abc in the given lattice (rows = lattice vectors)
-const frac_to_cart_pos = (abc, lattice_vecs) => math.add(math.scale(lattice_vecs[0], abc[0]), math.scale(lattice_vecs[1], abc[1]), math.scale(lattice_vecs[2], abc[2]));
 export function find_image_atoms(structure, { tolerance } = {}) {
     // Find image atoms for PBC. Returns [atom_idx, image_xyz, image_abc, is_completion?]
-    // tuples; is_completion marks phase-2 images that exist only to complete bonds /
-    // coordination polyhedra at cell faces (renderers may hide them when neither shows).
-    // Skips image generation for trajectory data with scattered atoms.
+    // tuples; is_completion marks phase-2 images that only complete bonds / coordination
+    // polyhedra at cell faces (renderers may hide them). Skips scattered trajectories.
     if (!structure.lattice || !structure.sites || structure.sites.length === 0)
         return [];
     if (is_scattered_trajectory(structure.sites))
         return [];
-    // Check if this is a supercell to correctly identify external boundaries correctly
     const image_sites = [];
     const lattice_vecs = structure.lattice.matrix;
-    // Scale zero-displacement threshold by lattice length scale to avoid hard-coded magic numbers
-    const lattice_norm = Math.max(Math.hypot(...lattice_vecs[0]), Math.hypot(...lattice_vecs[1]), Math.hypot(...lattice_vecs[2]));
-    // Threshold to filter out floating-point-identical (zero-displacement) images; rarely triggers but guards against edge cases
+    const frac_to_cart = math.create_frac_to_cart(lattice_vecs);
+    const vec_lens = lattice_vecs.map((vec) => Math.hypot(...vec));
+    // Scale zero-displacement threshold by lattice length scale to avoid magic numbers
+    const lattice_norm = Math.max(...vec_lens);
     const displacement_eps_sq = (1e-10 * lattice_norm) ** 2;
-    // Tolerances determine which atoms are near cell boundaries and need image generation
-    // Use provided tolerance or default to physical tolerance of 0.5 Angstroms converted to fractional
-    // This prevents excessive image generation for large unit cells (e.g. MOFs) where 0.05 fractional is huge
-    const PHYSICAL_TOLERANCE = 0.5; // Angstroms
-    const tolerances = [0, 1, 2].map((dim) => {
-        if (tolerance !== undefined)
-            return tolerance;
-        const vec_len = Math.hypot(...lattice_vecs[dim]);
-        // zero-length lattice vector should not occur in valid structures,
-        // but fall back to 0.05 fractional tolerance if it does
-        return vec_len > 0 ? PHYSICAL_TOLERANCE / vec_len : 0.05;
-    });
-    // Respect per-axis periodicity: no images across non-periodic (vacuum) directions
-    const pbc = structure.lattice.pbc ?? [true, true, true];
+    // Boundary tolerance: physical 0.5 Å as fractional per-axis, so large cells (MOFs)
+    // don't over-generate (a flat 0.05 fractional would be huge there)
+    const PHYSICAL_TOLERANCE = 0.5; // Å
+    const tolerances = vec_lens.map((vec_len) => tolerance ?? (vec_len > 0 ? PHYSICAL_TOLERANCE / vec_len : 0.05));
+    const pbc = structure.lattice.pbc ?? [true, true, true]; // no images across vacuum
+    // Phase 1: true periodic copies of atoms within `tolerance` of a cell face (bond
+    // lengths preserved, rather than clamping the copy to the cell face)
     for (const [idx, site] of structure.sites.entries()) {
-        // Find edge dimensions and translation directions
         const edge_dims = [];
-        // Find boundary dimensions
         for (let dim = 0; dim < 3; dim++) {
             if (!pbc[dim])
                 continue;
@@ -80,10 +70,9 @@ export function find_image_atoms(structure, { tolerance } = {}) {
             if (Math.abs(coord - 1) < dim_tolerance)
                 edge_dims.push({ dim, direction: -1 });
         }
-        // Generate all translation combinations
+        // Generate all translation combinations; if both +1 and -1 are selected for a dim the
+        // net shift is zero and we skip (yields no image).
         for (let mask = 1; mask < 1 << edge_dims.length; mask++) {
-            // Track selected translation per dimension. If both +1 and -1 are selected for a dim,
-            // the net shift is zero and we skip because it yields no image.
             const selected_shift = [0, 0, 0];
             for (let bit = 0; bit < edge_dims.length; bit++) {
                 if (mask & (1 << bit)) {
@@ -91,25 +80,18 @@ export function find_image_atoms(structure, { tolerance } = {}) {
                     selected_shift[dim] += direction;
                 }
             }
-            // Early skip if no net shift across any dimension
             if (selected_shift.every((val) => val === 0))
                 continue;
-            // Build fractional coordinates by applying the integer translation
-            // This ensures the image is a true periodic copy (preserving bond lengths)
-            // rather than clamping it to the cell face.
+            const [s_a, s_b, s_c] = site.abc;
             const img_abc = [
-                site.abc[0] + selected_shift[0],
-                site.abc[1] + selected_shift[1],
-                site.abc[2] + selected_shift[2],
+                s_a + selected_shift[0],
+                s_b + selected_shift[1],
+                s_c + selected_shift[2],
             ];
-            // If no dimension actually shifted, continue
-            if (img_abc[0] === site.abc[0] &&
-                img_abc[1] === site.abc[1] &&
-                img_abc[2] === site.abc[2])
+            if (img_abc[0] === s_a && img_abc[1] === s_b && img_abc[2] === s_c)
                 continue;
-            // Compute xyz from img_abc to ensure consistency
-            const img_xyz = frac_to_cart_pos(img_abc, lattice_vecs);
-            // Skip zero-displacement images (should not happen, guards against FP edge cases)
+            const img_xyz = frac_to_cart(img_abc);
+            // Skip zero-displacement images (guards against FP edge cases)
             const displacement = math.subtract(img_xyz, site.xyz);
             const displacement_len_sq = displacement.reduce((sum, val) => sum + val * val, 0);
             if (displacement_len_sq < displacement_eps_sq)
@@ -117,87 +99,91 @@ export function find_image_atoms(structure, { tolerance } = {}) {
             image_sites.push([idx, img_xyz, img_abc]);
         }
     }
-    // Phase 2: polyhedra-completing images (VESTA boundary-mode-like). The face
-    // tolerance above only catches atoms within ~0.5 Å of a boundary, but bonds
-    // reach a covalent-radii sum further: an anion just beyond a cell face may be
-    // needed to complete the coordination shell of a cation near that face, so
-    // bonds and coordination polyhedra at cell edges come out truncated without it.
-    // Phase 2 adds ONLY such anion images: a candidate must qualify as a polyhedron
-    // vertex (a non-metal/metalloid - same condition as is_anion_vertex in
-    // polyhedra.ts) and be strictly more electronegative than the anchor atom it
-    // bonds to. Everything else - elemental metals, intermetallics (incl. multi
-    // metal ones like Al-Fe-Ni where EN differs but no polyhedra exist), equal-EN
-    // covalent networks, cation copies - gets no phase-2 images, so the default
-    // render stays minimal and grows uniformly from all cell surfaces (the phase-1
-    // boundary copies above are the only non-anion atoms outside the cell).
+    // Per-site element data for the phase-2 completion pass. present_elements is the tiny
+    // composition (so has_framework_potential doesn't re-scan every site in big supercells).
+    const site_elements = [];
     const site_radii = [];
     const site_en = [];
     const site_is_metal = [];
+    const present_elements = new Set();
     let max_radius = 0;
-    // Minimum electronegativity among potential anchors: a candidate can only ever
-    // complete some cation's shell if it's strictly more electronegative than this
-    let min_anchor_en = Infinity;
     for (const site of structure.sites) {
         const elem = get_majority_element(site);
-        const data = elem === null ? undefined : element_lookup.get(elem);
+        const data = elem === null ? undefined : element_by_symbol.get(elem);
         const radius = data?.covalent_radius ?? null;
-        const en = data?.electronegativity ?? null;
+        site_elements.push(elem);
+        if (elem !== null)
+            present_elements.add(elem);
         site_radii.push(radius);
-        site_en.push(en);
+        site_en.push(data?.electronegativity ?? null);
         site_is_metal.push(data?.metal === true);
         if (radius !== null && radius > max_radius)
             max_radius = radius;
-        if (radius !== null && en !== null && en < min_anchor_en)
+    }
+    // Skip spectator A-site cations (Li/Na, heavy alkaline earths) when a framework cation
+    // is present: they render no polyhedron, so completing their shells floats coordination
+    // groups (e.g. a PO4 around a corner Li) beyond the cell. Purely ionic binaries (NaCl)
+    // keep theirs. Note: a spectator force-included as a polyhedra center (compute_polyhedra's
+    // included_center_elements) is still skipped here, so its boundary polyhedra truncate at
+    // cell faces - accepted to keep image generation independent of render-only settings.
+    const skip_spectators = has_framework_potential(present_elements);
+    const site_skipped = site_elements.map((elem) => skip_spectators && elem !== null && is_spectator_center(elem));
+    // Phase 2: anion images that complete coordination polyhedra / bonds at cell faces.
+    // Phase 1's ~0.5 Å face tolerance misses anions just beyond a face that still bond a
+    // cation near it, truncating boundary polyhedra. We add ONLY such images: a candidate
+    // must be a polyhedron vertex (non-metal/metalloid, like is_anion_vertex in polyhedra.ts)
+    // AND strictly more electronegative than the anchor it bonds. Metals, intermetallics,
+    // equal-EN networks and cation copies get none, keeping renders minimal.
+    // Min anchor EN: a candidate only completes a cation's shell if more electronegative
+    // than it. Over non-skipped anchors only, so skipped spectators can't loosen the filter.
+    let min_anchor_en = Infinity;
+    for (let idx = 0; idx < structure.sites.length; idx++) {
+        if (site_skipped[idx])
+            continue;
+        const en = site_en[idx];
+        if (site_radii[idx] !== null && en !== null && en < min_anchor_en)
             min_anchor_en = en;
     }
     const max_bond_dist = 2 * max_radius + BOND_SLACK;
     if (max_bond_dist > BOND_SLACK && min_anchor_en < Infinity) {
-        // Perpendicular cell heights: |frac| * height lower-bounds the Cartesian
-        // distance along each axis (valid for oblique cells)
-        const volume = Math.abs(math.dot(lattice_vecs[0], math.cross_3d(lattice_vecs[1], lattice_vecs[2])));
-        // height = volume / opposite-face area. A zero-volume (degenerate) cell has two
-        // parallel lattice vectors and ill-defined heights; treat every axis as
-        // infinitely tall so the pad logic below adds no images (pad -> 0) instead of
-        // dividing by zero. When volume > 0 the vectors are linearly independent, so no
-        // pairwise cross product can be zero.
-        const heights = volume === 0
-            ? [Infinity, Infinity, Infinity]
-            : [
-                volume / Math.hypot(...math.cross_3d(lattice_vecs[1], lattice_vecs[2])),
-                volume / Math.hypot(...math.cross_3d(lattice_vecs[0], lattice_vecs[2])),
-                volume / Math.hypot(...math.cross_3d(lattice_vecs[0], lattice_vecs[1])),
-            ];
-        // Anchor set for the bond test: base atoms plus the phase-1 boundary images
-        // (corner/edge/face copies). Anchoring on those too matches VESTA - every
-        // displayed boundary cation gets its shell completed (e.g. all 8 corner
-        // octahedra in rutile, not just the one at the origin).
+        // Per-axis fractional bond reach via perpendicular cell heights (correct for oblique
+        // cells; 0 for degenerate cells → no images). The + face tolerance covers phase-1
+        // anchors sitting slightly outside the cell.
+        const pad_per_axis = math.frac_cutoff_per_axis(lattice_vecs, max_bond_dist + PHYSICAL_TOLERANCE);
+        // Bond-test anchors = base atoms + phase-1 boundary images, so every displayed
+        // boundary cation gets its shell completed (VESTA-like; e.g. all 8 rutile corners).
         const anchor_positions = structure.sites.map((site) => site.xyz);
         const anchor_radii = [...site_radii];
         const anchor_en = [...site_en];
+        const anchor_skipped = [...site_skipped];
         for (const [src_idx, img_xyz] of image_sites) {
             anchor_positions.push(img_xyz);
             anchor_radii.push(site_radii[src_idx]);
             anchor_en.push(site_en[src_idx]);
+            anchor_skipped.push(site_skipped[src_idx]);
         }
-        // Spatial grid over anchors for the bond check
+        // Spatial grid over anchors for the bond check (integer-packed keys: this
+        // grid is probed 27x per candidate image in the loop below)
         const grid = new Map();
-        const grid_key = (pos) => pos.map((coord) => Math.floor(coord / max_bond_dist)).join(`,`);
         for (const [idx, pos] of anchor_positions.entries()) {
-            const key = grid_key(pos);
+            const key = pack_cell_key(Math.floor(pos[0] / max_bond_dist), Math.floor(pos[1] / max_bond_dist), Math.floor(pos[2] / max_bond_dist));
             const cell = grid.get(key);
             if (cell)
                 cell.push(idx);
             else
                 grid.set(key, [idx]);
         }
-        // True when the candidate (an anion image) bonds a strictly less
-        // electronegative anchor, i.e. completes some cation's coordination shell
+        // True when the candidate (an anion image) bonds a strictly less electronegative
+        // anchor, i.e. completes some cation's coordination shell
         const completes_cation_shell = (pos, radius, en) => {
             const [cx, cy, cz] = pos.map((coord) => Math.floor(coord / max_bond_dist));
             for (let dx = -1; dx <= 1; dx++) {
                 for (let dy = -1; dy <= 1; dy++) {
                     for (let dz = -1; dz <= 1; dz++) {
-                        for (const anchor_idx of grid.get(`${cx + dx},${cy + dy},${cz + dz}`) ?? []) {
+                        for (const anchor_idx of grid.get(pack_cell_key(cx + dx, cy + dy, cz + dz)) ??
+                            []) {
+                            if (anchor_skipped[anchor_idx])
+                                continue;
                             const anchor_radius = anchor_radii[anchor_idx];
                             const anchor_electroneg = anchor_en[anchor_idx];
                             if (anchor_radius === null)
@@ -221,22 +207,19 @@ export function find_image_atoms(structure, { tolerance } = {}) {
         for (const [idx, site] of structure.sites.entries()) {
             const radius = site_radii[idx];
             const en = site_en[idx];
-            // Skip candidates that could never be a polyhedron vertex: metals (e.g.
-            // Fe/Ni in Al-Fe-Ni intermetallics, despite their higher EN) and anything
-            // not strictly more electronegative than at least one anchor (covers all
-            // sites of elemental/equal-EN structures and all cations)
+            // Skip candidates that could never be a polyhedron vertex: metals (e.g. Fe/Ni in
+            // Al-Fe-Ni intermetallics) and anything not strictly more electronegative than at
+            // least one anchor (covers elemental/equal-EN structures and all cations)
             if (radius === null || en === null || en <= min_anchor_en)
                 continue;
             if (site_is_metal[idx])
                 continue;
-            // Per-axis shifts that could land a copy of this atom within bonding reach
-            // of the cell: {0} plus +1/-1 when the atom is within max_bond_dist of the
-            // respective boundary
+            // Per-axis shifts that could land a copy of this atom within bonding reach of the
+            // cell: {0} plus +1/-1 when the atom is within max_bond_dist of the boundary
             const axis_shifts = [0, 1, 2].map((axis) => {
                 if (!pbc[axis])
                     return [0];
-                // + face tolerance: anchors (phase-1 images) can sit slightly outside the cell
-                const pad = (max_bond_dist + PHYSICAL_TOLERANCE) / heights[axis];
+                const pad = pad_per_axis[axis];
                 const shifts = [0];
                 if (site.abc[axis] < pad)
                     shifts.push(1);
@@ -257,7 +240,7 @@ export function find_image_atoms(structure, { tolerance } = {}) {
                             site.abc[1] + shift_b,
                             site.abc[2] + shift_c,
                         ];
-                        const img_xyz = frac_to_cart_pos(img_abc, lattice_vecs);
+                        const img_xyz = frac_to_cart(img_abc);
                         if (!completes_cation_shell(img_xyz, radius, en))
                             continue;
                         seen_images.add(key);
@@ -269,19 +252,14 @@ export function find_image_atoms(structure, { tolerance } = {}) {
     }
     return image_sites;
 }
-// Return structure with image atoms added
+// Return structure with image atoms added (unchanged when none are generated,
+// e.g. for scattered trajectory-like data)
 export function get_pbc_image_sites(...args) {
     const structure = args[0];
-    if (!structure || !structure.sites || structure.sites.length === 0) {
-        return structure;
-    }
-    // Return trajectory data unchanged
-    if (is_scattered_trajectory(structure.sites))
-        return structure;
-    // Add image atoms to regular crystal structures
     const image_sites = find_image_atoms(...args);
+    if (image_sites.length === 0)
+        return structure;
     const imaged_struct = { ...structure, sites: [...structure.sites] };
-    // Add image atoms as new sites using provided (xyz, abc) from find_image_atoms
     for (const [site_idx, img_xyz, img_abc, is_completion] of image_sites) {
         const orig_site = structure.sites[site_idx];
         imaged_struct.sites.push({

package/dist/structure/polyhedra.d.ts

@@ -36,6 +36,5 @@ export interface MergedPolyhedraBuffers {
 }
 export declare function convex_hull_3d(points: readonly Vec3[], eps_scale?: number): ConvexHullResult;
 export declare function build_adjacency(bonds: readonly BondPair[]): Map<number, Set<number>>;
-export declare const is_spectator_center: (element: string) => boolean;
 export declare function compute_polyhedra(structure: AnyStructure, bonds: readonly BondPair[], options?: PolyhedraOptions): Polyhedron[];
 export declare function merge_polyhedra_buffers(polyhedra: readonly Polyhedron[], get_vertex_color: (poly: Polyhedron, vertex_idx: number) => string, coplanar_tol?: number): MergedPolyhedraBuffers;

package/dist/structure/polyhedra.js

@@ -4,9 +4,10 @@
 // so the whole scene renders in 1-2 draw calls regardless of supercell size.
 // Hot paths use scalar math and per-element caches to scale to large structures.
 import { rgb as parse_rgb } from 'd3-color';
+import { element_by_symbol } from '../element/data';
 import { DEFAULTS } from '../settings';
 import { get_orig_site_idx } from './atom-properties';
-import { element_lookup, get_majority_element } from './bonding';
+import { get_majority_element, has_framework_potential, is_spectator_center } from './bonding';
 const face_of = (points, vert_a, vert_b, vert_c) => {
     const [ax, ay, az] = points[vert_a];
     const abx = points[vert_b][0] - ax;
@@ -294,15 +295,6 @@ export function build_adjacency(bonds) {
     return adjacency;
 }
 // --- Center selection ---
-// Large low-valent A-site cations whose coordination polyhedra (CN 8-12) tend to
-// obscure the structural framework. VESTA-style figures draw the framework
-// (e.g. TiO6 in BaTiO3, FeO6/PO4 in LiFePO4) and leave these as plain spheres.
-// They still get polyhedra when they are the only qualifying cations (e.g. NaCl)
-// or when force-included via `included_center_elements`.
-const SPECTATOR_CATEGORIES = new Set([`alkali metal`]);
-const HEAVY_ALKALINE_EARTHS = new Set([`Ca`, `Sr`, `Ba`, `Ra`]);
-export const is_spectator_center = (element) => SPECTATOR_CATEGORIES.has(element_lookup.get(element)?.category ?? ``) ||
-    HEAVY_ALKALINE_EARTHS.has(element);
 // A bonded neighbor counts as a polyhedron vertex only if it's an anion-former:
 // a nonmetal or metalloid that is more electronegative than the center. This keeps
 // spurious cation-cation bonds (e.g. Ti-Ba in perovskites, Li-P in thiophosphates)
@@ -310,7 +302,7 @@ export const is_spectator_center = (element) => SPECTATOR_CATEGORIES.has(element
 function is_anion_vertex(center_en, center_is_metal, neighbor_element, electronegativity_margin) {
     if (!neighbor_element)
         return false;
-    const n_data = element_lookup.get(neighbor_element);
+    const n_data = element_by_symbol.get(neighbor_element);
     if (n_data?.metal)
         return false;
     const n_en = n_data?.electronegativity ?? null;
@@ -350,12 +342,12 @@ export function compute_polyhedra(structure, bonds, options = {}) {
     const center_info = (element) => {
         let info = center_info_cache.get(element);
         if (!info) {
-            const data = element_lookup.get(element);
+            const data = element_by_symbol.get(element);
             const center_en = data?.electronegativity ?? null;
             const r_center = data?.covalent_radius ?? null;
             const accepts = new Set(unique_elements.filter((n_elem) => is_anion_vertex(center_en, data?.metal === true, n_elem, electronegativity_margin)));
             const radii_sums = new Map(unique_elements.map((n_elem) => {
-                const r_n = element_lookup.get(n_elem)?.covalent_radius ?? null;
+                const r_n = element_by_symbol.get(n_elem)?.covalent_radius ?? null;
                 return [n_elem, r_center !== null && r_n !== null ? r_center + r_n : null];
             }));
             info = { accepts, radii_sums };
@@ -426,13 +418,7 @@ export function compute_polyhedra(structure, bonds, options = {}) {
     // the anions). Composition-based rather than candidate-based so boundary
     // truncation of framework polyhedra doesn't promote Li/Na/Ba clutter; purely
     // ionic binaries like NaCl or CaF2 still draw their spectator polyhedra.
-    const max_en = Math.max(...unique_elements.map((el) => element_lookup.get(el)?.electronegativity ?? -Infinity));
-    const has_framework_potential = unique_elements.some((el) => {
-        if (is_spectator_center(el))
-            return false;
-        const en = element_lookup.get(el)?.electronegativity;
-        return en !== null && en !== undefined && en < max_en;
-    });
+    const has_framework = has_framework_potential(unique_elements);
     // Weakly-bound center species (mean bond length well beyond the covalent-radii
     // sum, e.g. lone-pair Bi3+ with 8 long Bi-O bonds) are hidden when a
     // strongly-bound framework species exists - mirrors how pyrochlore-type figures
@@ -455,7 +441,7 @@ export function compute_polyhedra(structure, bonds, options = {}) {
     const visible = candidates.filter(({ element }) => {
         if (included.has(element))
             return true;
-        if (is_spectator_center(element) && has_framework_potential)
+        if (is_spectator_center(element) && has_framework)
             return false;
         return !is_weak_species(element);
     });

package/dist/structure/prop-groups.d.ts

@@ -0,0 +1,85 @@
+import type { DefaultSettings } from '../settings';
+export declare const build_structure_props_from_settings: (defaults: DefaultSettings) => {
+    scene_props: {
+        gizmo: boolean;
+        atom_radius: number;
+        same_size_atoms: boolean;
+        show_atoms: boolean;
+        show_image_atoms: boolean;
+        sphere_segments: number;
+        bond_thickness: number;
+        auto_bond_order: boolean;
+        aromatic_display: "aromatic" | "kekule";
+        show_bonds: "always" | "never" | "crystals" | "molecules";
+        bond_color: string;
+        bonding_strategy: "electroneg_ratio" | "solid_angle";
+        show_polyhedra: "always" | "never" | "crystals" | "molecules";
+        polyhedra_opacity: number;
+        polyhedra_show_edges: boolean;
+        polyhedra_edge_color: string;
+        polyhedra_color_mode: import("./polyhedra").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[];
+        atom_color_mode: "element" | "coordination" | "wyckoff" | "custom";
+        atom_color_scale: import("..").D3InterpolateName;
+        atom_color_scale_type: "continuous" | "categorical";
+        show_gizmo: boolean;
+        camera_position: import("..").Vec3;
+        camera_projection: import("../settings").CameraProjection;
+        initial_zoom: number;
+        fov: number;
+        rotation_damping: number;
+        rotate_speed: number;
+        zoom_speed: number;
+        pan_speed: number;
+        zoom_to_cursor: boolean;
+        max_zoom: number | undefined;
+        min_zoom: number | undefined;
+        auto_rotate: number;
+        rotation: import("..").Vec3;
+        show_site_labels: boolean;
+        show_site_indices: boolean;
+        site_label_size: number;
+        site_label_color: string;
+        site_label_bg_color: string;
+        site_label_padding: number;
+        site_label_offset: import("..").Vec3;
+        ambient_light: number;
+        directional_light: number;
+        vector_configs: Record<string, import("../settings").VectorLayerConfig>;
+        vector_scale: number;
+        vector_color: string;
+        vector_color_mode: "auto" | "element" | "uniform" | "spin_direction" | "magnitude";
+        vector_color_scale: import("..").D3InterpolateName;
+        vector_normalize: boolean;
+        vector_uniform_thickness: boolean;
+        vector_origin_gap: number;
+        vector_shaft_radius: number;
+        vector_arrow_head_radius: number;
+        vector_arrow_head_length: number;
+        show_cell: boolean;
+        show_cell_vectors: boolean;
+        cell_edge_opacity: number;
+        cell_surface_opacity: number;
+        cell_edge_color: string;
+        cell_surface_color: string;
+        cell_edge_width: number;
+        fullscreen_toggle: boolean;
+    };
+    lattice_props: {
+        cell_edge_opacity: number;
+        cell_surface_opacity: number;
+        cell_edge_color: string;
+        cell_surface_color: string;
+        cell_edge_width: number;
+        show_cell_vectors: boolean;
+    };
+    color_scheme: string;
+    background_color: string;
+    background_opacity: number;
+    show_image_atoms: boolean;
+};

package/dist/structure/prop-groups.js

@@ -0,0 +1,18 @@
+export const build_structure_props_from_settings = (defaults) => {
+    const { structure } = defaults;
+    return {
+        scene_props: { ...structure, gizmo: structure.show_gizmo },
+        lattice_props: {
+            cell_edge_opacity: structure.cell_edge_opacity,
+            cell_surface_opacity: structure.cell_surface_opacity,
+            cell_edge_color: structure.cell_edge_color,
+            cell_surface_color: structure.cell_surface_color,
+            cell_edge_width: structure.cell_edge_width,
+            show_cell_vectors: structure.show_cell_vectors,
+        },
+        color_scheme: defaults.color_scheme,
+        background_color: defaults.background_color,
+        background_opacity: defaults.background_opacity,
+        show_image_atoms: structure.show_image_atoms,
+    };
+};

package/dist/structure/supercell.d.ts

@@ -1,8 +1,7 @@
 import type { Vec3 } from '../math';
-import { scale_lattice_matrix } from '../math';
 import type { Crystal } from './index';
 export declare function parse_supercell_scaling(scaling: string | number | Vec3): Vec3;
 export declare function generate_lattice_points(scaling_factors: Vec3): Vec3[];
-export { scale_lattice_matrix };
+export { scale_lattice_matrix } from '../math';
 export declare function make_supercell(structure: Crystal, scaling: string | number | Vec3, to_unit_cell?: boolean): Crystal;
 export declare function is_valid_supercell_input(input: string): boolean;

package/dist/structure/supercell.js

@@ -1,5 +1,4 @@
 import * as math from '../math';
-import { scale_lattice_matrix } from '../math';
 import { wrap_frac_coord } from './pbc';
 import { normalize_structure_bond } from './bonding';
 const mod = (value, divisor) => ((value % divisor) + divisor) % divisor;
@@ -79,7 +78,7 @@ export function generate_lattice_points(scaling_factors) {
     return points;
 }
 // Re-export from $lib/math for backward compatibility
-export { scale_lattice_matrix };
+export { scale_lattice_matrix } from '../math';
 // Create a supercell from a Crystal
 // Takes original structure, scaling factors, and whether to fold coordinates back to unit cell (default: true)
 // Returns new supercell structure
@@ -96,19 +95,14 @@ export function make_supercell(structure, scaling, to_unit_cell = true) {
     }
     const orig_matrix = structure.lattice.matrix;
     // Create new scaled lattice
-    const new_lattice_matrix = scale_lattice_matrix(orig_matrix, supercell_scaling);
-    const lattice_params = math.calc_lattice_params(new_lattice_matrix);
-    const new_lattice = {
-        ...structure.lattice,
-        matrix: new_lattice_matrix,
-        ...lattice_params,
-    };
+    const new_matrix = math.scale_lattice_matrix(orig_matrix, supercell_scaling);
+    const lattice_params = math.calc_lattice_params(new_matrix);
+    const new_lattice = { ...structure.lattice, matrix: new_matrix, ...lattice_params };
     // Pre-allocate sites array
     const n_sites = structure.sites.length;
     const new_sites = Array(n_sites * total_cells);
     // Destructure lattice vectors for fast inline arithmetic (avoid function calls in hot loop)
     const [[ax, ay, az], [bx, by, bz], [cx, cy, cz]] = orig_matrix;
-    const [sx, sy, sz] = supercell_scaling;
     let write_idx = 0;
     const sites = structure.sites;
     // Loop order: k, j, i to match typical pymatgen/standard ordering
@@ -124,9 +118,9 @@ export function make_supercell(structure, scaling, to_unit_cell = true) {
                 for (let site_idx = 0; site_idx < n_sites; site_idx++) {
                     const site = sites[site_idx];
                     // new_abc = (old_abc + [ii, jj, kk]) / supercell_scaling
-                    let new_a = (site.abc[0] + ii) / sx;
-                    let new_b = (site.abc[1] + jj) / sy;
-                    let new_c = (site.abc[2] + kk) / sz;
+                    let new_a = (site.abc[0] + ii) / scale_x;
+                    let new_b = (site.abc[1] + jj) / scale_y;
+                    let new_c = (site.abc[2] + kk) / scale_z;
                     if (to_unit_cell) {
                         new_a = wrap_frac_coord(new_a);
                         new_b = wrap_frac_coord(new_b);