matterviz 0.3.0 → 0.3.2

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

@@ -1,7 +1,8 @@
 import type { ElementSymbol } from '../element';
+import type { IsosurfaceSettings, VolumetricData } from '../isosurface/types';
 import type { Vec3 } from '../math';
 import { type CameraProjection, type ShowBonds } from '../settings';
-import type { AnyStructure, Site } from './';
+import type { AnyStructure, MeasureMode, Site } from './';
 import { Lattice } from './';
 import type { AtomColorConfig } from './atom-properties';
 import type { MoyoDataset } from '@spglib/moyo-wasm';
@@ -9,7 +10,7 @@ import * as extras from '@threlte/extras';
 import type { ComponentProps } from 'svelte';
 import { type Snippet } from 'svelte';
 import { SvelteMap } from 'svelte/reactivity';
-import type { Camera, Scene } from 'three';
+import { type Camera, type Scene } from 'three';
 import type { BondingStrategy } from './bonding';
 type $$ComponentProps = {
     structure?: AnyStructure;
@@ -17,6 +18,7 @@ type $$ComponentProps = {
     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;
@@ -59,7 +61,7 @@ type $$ComponentProps = {
     camera_is_moving?: boolean;
     width?: number;
     height?: number;
-    measure_mode?: `distance` | `angle` | `edit-bonds`;
+    measure_mode?: MeasureMode;
     selected_sites?: number[];
     measured_sites?: number[];
     added_bonds?: [number, number][];
@@ -79,7 +81,16 @@ type $$ComponentProps = {
     site_radius_overrides?: Map<number, number> | SvelteMap<number, number>;
     atom_color_config?: Partial<AtomColorConfig>;
     sym_data?: MoyoDataset | null;
+    on_sites_moved?: (scene_indices: number[], delta: Vec3) => void;
+    on_operation_start?: () => void;
+    on_add_atom?: (xyz: Vec3, element: ElementSymbol) => void;
+    add_atom_mode?: boolean;
+    add_element?: ElementSymbol;
+    cursor?: string;
+    dragging_atoms?: boolean;
+    volumetric_data?: VolumetricData;
+    isosurface_settings?: IsosurfaceSettings;
 };
-declare const StructureScene: import("svelte").Component<$$ComponentProps, {}, "site_label_offset" | "hidden_elements" | "hidden_prop_vals" | "element_radius_overrides" | "site_radius_overrides" | "selected_sites" | "hovered_idx" | "hovered_site" | "camera_is_moving" | "measured_sites" | "added_bonds" | "removed_bonds" | "active_sites" | "scene" | "camera" | "orbit_controls" | "rotation_target_ref" | "initial_computed_zoom">;
+declare const StructureScene: import("svelte").Component<$$ComponentProps, {}, "cursor" | "site_label_offset" | "scene" | "camera" | "orbit_controls" | "hidden_elements" | "hidden_prop_vals" | "element_radius_overrides" | "site_radius_overrides" | "selected_sites" | "hovered_idx" | "hovered_site" | "camera_is_moving" | "measured_sites" | "added_bonds" | "removed_bonds" | "active_sites" | "rotation_target_ref" | "initial_computed_zoom" | "add_atom_mode" | "add_element" | "dragging_atoms">;
 type StructureScene = ReturnType<typeof StructureScene>;
 export default StructureScene;

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

@@ -1,6 +1,6 @@
-import type { AnyStructure, Site } from './';
 import type { ColorScaleType, D3InterpolateName } from '../colors';
 import type { AtomColorMode } from '../settings';
+import type { AnyStructure, Site } from './';
 import type { BondingStrategy } from './bonding';
 import type { MoyoDataset } from '@spglib/moyo-wasm';
 export interface AtomColorConfig {
@@ -16,6 +16,9 @@ export interface AtomPropertyColors {
     max_value?: number;
     unique_values?: (number | string)[];
 }
+type SymmetryDataWithOrigMap = MoyoDataset & {
+    orig_site_indices_by_std_idx?: number[][];
+};
 export declare const get_d3_color_scales: () => string[];
 export declare function apply_color_scale(vals: number[], scale?: string, type?: ColorScaleType): {
     colors: string[];
@@ -27,7 +30,8 @@ export declare const apply_categorical_color_scale: (vals: string[], scale?: str
 };
 export declare const get_orig_site_idx: (site: Site | undefined, site_idx: number) => number;
 export declare function get_coordination_colors(structure: AnyStructure, strategy?: BondingStrategy, scale?: string, type?: ColorScaleType): AtomPropertyColors;
-export declare function get_wyckoff_colors(structure: AnyStructure, sym_data: MoyoDataset | null, scale?: string): AtomPropertyColors;
+export declare function get_wyckoff_colors(structure: AnyStructure, sym_data: SymmetryDataWithOrigMap | null, scale?: string): AtomPropertyColors;
 export declare function get_custom_colors(structure: AnyStructure, fn: (site: Site, idx: number) => number | string, scale?: string, type?: ColorScaleType): AtomPropertyColors;
 export declare function get_atom_colors(structure: AnyStructure, config: Partial<AtomColorConfig>, bonding_strategy?: BondingStrategy, sym_data?: MoyoDataset | null): AtomPropertyColors;
 export declare function get_property_colors(structure: AnyStructure | undefined, config: Partial<AtomColorConfig>, bonding_strategy: BondingStrategy, sym_data: MoyoDataset | null): AtomPropertyColors | null;
+export {};

package/dist/structure/atom-properties.js

@@ -15,6 +15,25 @@ const get_interpolator = (scale) => {
     return interp_fn;
 };
 const to_hex = (interp_fn, t) => rgb(interp_fn(t)).formatHex();
+const build_image_site = (site, lattice_T, offset, orig_idx) => {
+    const img_abc = [
+        site.abc[0] + offset[0],
+        site.abc[1] + offset[1],
+        site.abc[2] + offset[2],
+    ];
+    return {
+        ...site,
+        abc: img_abc,
+        xyz: math.mat3x3_vec3_multiply(lattice_T, img_abc),
+        properties: { ...site.properties, orig_site_idx: orig_idx },
+    };
+};
+const get_all_offsets = (pbc) => [-1, 0, 1]
+    .flatMap((dx) => [-1, 0, 1].flatMap((dy) => [-1, 0, 1].map((dz) => [dx, dy, dz])))
+    .filter(([dx, dy, dz]) => !(dx === 0 && dy === 0 && dz === 0) &&
+    (pbc[0] || dx === 0) &&
+    (pbc[1] || dy === 0) &&
+    (pbc[2] || dz === 0));
 const make_categorical = (vals, scale, sort_fn) => {
     const interp_fn = get_interpolator(scale);
     const uniq = sort_fn ? [...new Set(vals)].sort(sort_fn) : [...new Set(vals)].sort();
@@ -68,24 +87,10 @@ function expand_structure_for_pbc(structure) {
     const { sites, lattice } = structure;
     const lattice_T = math.transpose_3x3_matrix(lattice.matrix);
     const pbc = lattice.pbc ?? [true, true, true];
-    // All valid image offsets respecting PBC
-    const all_offsets = [-1, 0, 1]
-        .flatMap((dx) => [-1, 0, 1].flatMap((dy) => [-1, 0, 1].map((dz) => [dx, dy, dz])))
-        .filter(([dx, dy, dz]) => !(dx === 0 && dy === 0 && dz === 0) &&
-        (pbc[0] || dx === 0) &&
-        (pbc[1] || dy === 0) &&
-        (pbc[2] || dz === 0));
+    const all_offsets = get_all_offsets(pbc);
     // Small structures: expand all atoms
     if (sites.length < 20 || !pbc.some((periodic) => periodic)) {
-        const image_sites = sites.flatMap((site, orig_idx) => all_offsets.map(([dx, dy, dz]) => {
-            const img_abc = [site.abc[0] + dx, site.abc[1] + dy, site.abc[2] + dz];
-            return {
-                ...site,
-                abc: img_abc,
-                xyz: math.mat3x3_vec3_multiply(lattice_T, img_abc),
-                properties: { ...site.properties, orig_site_idx: orig_idx },
-            };
-        }));
+        const image_sites = sites.flatMap((site, orig_idx) => all_offsets.map((offset) => build_image_site(site, lattice_T, offset, orig_idx)));
         return { ...structure, sites: [...sites, ...image_sites] };
     }
     // Large structures: only expand atoms near boundaries (within 5Å bond distance)
@@ -96,15 +101,7 @@ function expand_structure_for_pbc(structure) {
             .filter(([dx, dy, dz]) => (dx === 0 || (dx === -1 ? norm[0] <= cutoff[0] : norm[0] >= 1 - cutoff[0])) &&
             (dy === 0 || (dy === -1 ? norm[1] <= cutoff[1] : norm[1] >= 1 - cutoff[1])) &&
             (dz === 0 || (dz === -1 ? norm[2] <= cutoff[2] : norm[2] >= 1 - cutoff[2])))
-            .map(([dx, dy, dz]) => {
-            const img_abc = [site.abc[0] + dx, site.abc[1] + dy, site.abc[2] + dz];
-            return {
-                ...site,
-                abc: img_abc,
-                xyz: math.mat3x3_vec3_multiply(lattice_T, img_abc),
-                properties: { ...site.properties, orig_site_idx: orig_idx },
-            };
-        });
+            .map((offset) => build_image_site(site, lattice_T, offset, orig_idx));
     });
     return { ...structure, sites: [...sites, ...image_sites] };
 }
@@ -135,9 +132,25 @@ export function get_wyckoff_colors(structure, sym_data, scale = DEFAULT_COLOR_SC
             unique_values: [`unknown`],
         };
     }
+    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] ?? []) {
+                if (!wyckoff_by_orig_idx.has(orig_idx))
+                    wyckoff_by_orig_idx.set(orig_idx, wyckoff);
+            }
+        }
+    }
     // Create unique orbit identifiers: Wyckoff position + element symbol
     const orbit_ids = structure.sites.map((site, idx) => {
         const sym_idx = get_orig_site_idx(site, idx);
+        const mapped_wyckoff = wyckoff_by_orig_idx.get(sym_idx);
+        if (mapped_wyckoff !== undefined) {
+            const element = site.species[0]?.element ?? `?`;
+            return mapped_wyckoff ? `${mapped_wyckoff}|${element}` : `unknown`;
+        }
         if (sym_idx >= sym_data.wyckoffs.length) {
             console.error(`[get_wyckoff_colors] Site ${idx} (maps to ${sym_idx}) has no Wyckoff data. ` +
                 `Structure has ${n} sites but symmetry data only has ${sym_data.wyckoffs.length}.`);

package/dist/structure/export.js

@@ -10,13 +10,16 @@ export function has_color_property(mat) {
     if (!(`color` in mat))
         return false;
     const color = mat.color;
-    // Check for Color-like object with r, g, b properties (duck typing)
-    return (color !== null &&
-        typeof color === `object` &&
-        `r` in color &&
-        `g` in color &&
-        `b` in color &&
-        typeof color.r === `number`);
+    if (!color || typeof color !== `object`)
+        return false;
+    // Check for Color-like object with numeric r/g/b channels (duck typing)
+    const color_obj = color;
+    const red_channel = color_obj.r;
+    const green_channel = color_obj.g;
+    const blue_channel = color_obj.b;
+    return typeof red_channel === `number` &&
+        typeof green_channel === `number` &&
+        typeof blue_channel === `number`;
 }
 // Extract color from a ShaderMaterial by checking common color uniform patterns
 function extract_shader_color(shader_mat) {

package/dist/structure/ferrox-wasm-types.d.ts

@@ -1,3 +1,4 @@
+import type { Vec3 } from '../math';
 export type WasmResult<T> = {
     ok: T;
 } | {
@@ -14,7 +15,7 @@ export declare function unwrap_or<T>(result: WasmResult<T>, default_value: T): T
 export interface NeighborListResult {
     center_indices: number[];
     neighbor_indices: number[];
-    image_offsets: [number, number, number][];
+    image_offsets: Vec3[];
     distances: number[];
 }
 export interface MatcherOptions {
@@ -28,7 +29,7 @@ export interface MatcherOptions {
 export type StructureFormat = `cif` | `poscar` | `json`;
 export type ReductionAlgorithm = `niggli` | `lll`;
 export interface HklInfo {
-    hkl: [number, number, number];
+    hkl: Vec3;
     multiplicity: number;
 }
 export interface XrdPattern {

package/dist/structure/ferrox-wasm-types.js

@@ -1,6 +1,3 @@
-// Pure type definitions and utility functions for ferrox-wasm results.
-// This module has no WASM side effects, making it safe to import in tests
-// without triggering WASM resolution.
 // Type guard to check if result is successful
 export function is_ok(result) {
     return `ok` in result;

package/dist/structure/ferrox-wasm.d.ts

@@ -1,3 +1,4 @@
+import type { Vec3 } from '../math';
 import type { Crystal } from './';
 import type { MatcherOptions, NeighborListResult, ReductionAlgorithm, StructureFormat, WasmResult, XrdOptions, XrdPattern } from './ferrox-wasm-types';
 export * from './ferrox-wasm-types';
@@ -81,8 +82,8 @@ export declare function interpolate_structures(start: Crystal, end: Crystal, n_i
 }): Promise<WasmResult<Crystal[]>>;
 export declare function copy_structure(structure: Crystal, sanitize?: boolean): Promise<WasmResult<Crystal>>;
 export declare function wrap_to_unit_cell(structure: Crystal): Promise<WasmResult<Crystal>>;
-export declare function create_supercell_matrix(structure: Crystal, matrix: [[number, number, number], [number, number, number], [number, number, number]]): Promise<WasmResult<Crystal>>;
-export declare function translate_sites(structure: Crystal, indices: number[], vector: [number, number, number], frac_coords?: boolean): Promise<WasmResult<Crystal>>;
+export declare function create_supercell_matrix(structure: Crystal, matrix: [Vec3, Vec3, Vec3]): Promise<WasmResult<Crystal>>;
+export declare function translate_sites(structure: Crystal, indices: number[], vector: Vec3, frac_coords?: boolean): Promise<WasmResult<Crystal>>;
 export declare function perturb_structure(structure: Crystal, distance: number, options?: {
     min_distance?: number;
     seed?: number;

package/dist/structure/ferrox-wasm.js

@@ -25,8 +25,7 @@ export function ensure_ferrox_wasm_ready() {
         init_promise = (async () => {
             try {
                 // Dynamic import to avoid loading WASM until needed
-                const { default: init } = (await import(
-                /* @vite-ignore */ `matterviz-wasm`));
+                const { default: init } = (await import(`matterviz-wasm`));
                 // Initialize WASM module (the package handles WASM loading internally)
                 wasm_module = await init();
                 return wasm_module;

package/dist/structure/index.d.ts

@@ -20,6 +20,7 @@ export { default as StructureExportPane } from './StructureExportPane.svelte';
 export { default as StructureInfoPane } from './StructureInfoPane.svelte';
 export { default as StructureScene } from './StructureScene.svelte';
 export * from './supercell';
+export type MeasureMode = `distance` | `angle` | `edit-bonds` | `edit-atoms`;
 export type Species = {
     element: ElementSymbol;
     occu: number;
@@ -66,6 +67,11 @@ export declare function format_formula_by_electronegativity(structure: AnyStruct
 export declare const atomic_radii: CompositionType;
 export declare function get_density(structure: Crystal): number;
 export declare function get_center_of_mass(structure: AnyStructure): Vec3;
+export declare function get_site_vector_info(site: Site): {
+    vec: Vec3;
+    key: string;
+} | null;
+export declare function get_site_vector(site: Site): Vec3 | null;
 export interface StructureHandlerData {
     structure?: AnyStructure;
     filename?: string;
@@ -74,6 +80,7 @@ export interface StructureHandlerData {
     error_msg?: string;
     fullscreen?: boolean;
     camera_position?: Vec3;
+    camera_target?: Vec3;
     camera_has_moved?: boolean;
     color_scheme?: string;
     performance_mode?: `quality` | `speed`;

package/dist/structure/index.js

@@ -84,3 +84,25 @@ export function get_center_of_mass(structure) {
     }
     return math.scale(center, 1 / total_weight);
 }
+// Property keys checked for per-site vector data (force, magnetic moment, spin)
+const VECTOR_PROPERTY_KEYS = [`force`, `magmom`, `spin`];
+// Extract a vector and its source key from a site's properties. Checks force, magmom,
+// and spin in priority order. Scalar values are converted to z-directed vectors [0, 0, val].
+export function get_site_vector_info(site) {
+    const props = site.properties;
+    if (!props)
+        return null;
+    for (const key of VECTOR_PROPERTY_KEYS) {
+        const val = props[key];
+        if (Array.isArray(val) && val.length === 3 &&
+            val.every((elem) => typeof elem === `number` && isFinite(elem)))
+            return { vec: val, key };
+        if (typeof val === `number` && isFinite(val))
+            return { vec: [0, 0, val], key };
+    }
+    return null;
+}
+// Convenience wrapper returning just the vector (preserves existing API)
+export function get_site_vector(site) {
+    return get_site_vector_info(site)?.vec ?? null;
+}

package/dist/structure/parse.js

@@ -2,9 +2,8 @@ import { COMPRESSION_EXTENSIONS_REGEX, CONFIG_DIRS_REGEX, STRUCT_KEYWORDS_REGEX,
 import { ELEM_SYMBOLS } from '../labels';
 import * as math from '../math';
 import { wrap_to_unit_cell } from './pbc';
+import { normalize_scientific_notation } from '../utils';
 import { load as yaml_load } from 'js-yaml';
-// Normalize scientific notation in coordinate strings (handles eEdD and *^ notation variants)
-const normalize_scientific_notation = (str) => str.toLowerCase().replace(/d/g, `e`).replace(/\*\^/g, `e`);
 // Parse a coordinate value that might be in various scientific notation formats
 function parse_coordinate(str) {
     const normalized = normalize_scientific_notation(str.trim());
@@ -939,11 +938,10 @@ function find_structure_in_json(obj, visited = new WeakSet()) {
         return null;
     }
     // Check if this object looks like a valid structure
-    const potential_structure = obj;
-    if (is_parsed_structure(potential_structure))
-        return potential_structure;
+    if (is_parsed_structure(obj))
+        return obj;
     // Otherwise, recursively search through all properties
-    for (const value of Object.values(potential_structure)) {
+    for (const value of Object.values(obj)) {
         const result = find_structure_in_json(value, visited);
         if (result)
             return result;
@@ -954,17 +952,19 @@ function find_structure_in_json(obj, visited = new WeakSet()) {
 function is_parsed_structure(obj) {
     if (!obj || typeof obj !== `object`)
         return false;
-    const record = obj;
-    // Must have non-empty sites array
-    if (!Array.isArray(record.sites) || record.sites.length === 0)
+    const parsed_obj = obj;
+    const sites = parsed_obj.sites;
+    if (!Array.isArray(sites) || sites.length === 0)
         return false;
-    // Check if first site looks valid (has species and coordinates)
-    const first_site = record.sites[0];
+    const first_site = sites[0];
     if (!first_site || typeof first_site !== `object`)
         return false;
-    // Must have species (array) and either abc or xyz coordinates
-    const has_species = Array.isArray(first_site.species) && first_site.species.length > 0;
-    const has_coords = Array.isArray(first_site.abc) || Array.isArray(first_site.xyz);
+    const first_site_obj = first_site;
+    const species = first_site_obj.species;
+    const abc = first_site_obj.abc;
+    const xyz = first_site_obj.xyz;
+    const has_species = Array.isArray(species) && species.length > 0;
+    const has_coords = Array.isArray(abc) || Array.isArray(xyz);
     return has_species && has_coords;
 }
 // Normalize structure coordinates: wrap fractional coords to [0,1) and recompute Cartesian
@@ -1268,8 +1268,11 @@ function is_optimade_structure_object(value) {
     if (!value || typeof value !== `object`)
         return false;
     const obj = value;
-    return obj.type === `structures` && typeof obj.id === `string` &&
-        typeof obj.attributes === `object` && obj.attributes !== null;
+    const type = obj.type;
+    const id = obj.id;
+    const attributes = obj.attributes;
+    return type === `structures` && typeof id === `string` &&
+        typeof attributes === `object` && attributes !== null;
 }
 // Convert OPTIMADE structure to Crystal format
 export function optimade_to_crystal(optimade_structure) {

package/dist/structure/partial-occupancy.d.ts

@@ -0,0 +1,25 @@
+import type { Site } from './';
+export declare const PARTIAL_OCCUPANCY_SLICE_GAP_RAD = 0.001;
+export type RenderSite = {
+    site_idx: number;
+    site: Site;
+    is_image_atom: boolean;
+    source_site_indices: number[];
+};
+export type SliceGeometry = {
+    element: string;
+    occupancy: number;
+    start_phi: number;
+    end_phi: number;
+    phi_length: number;
+    render_start_cap: boolean;
+    render_end_cap: boolean;
+};
+export type CapArcConfig = {
+    start_cap_arc_start: number;
+    end_cap_arc_start: number;
+    arc_length: number;
+};
+export declare const PARTIAL_OCCUPANCY_CAP_ARC: CapArcConfig;
+export declare const merge_split_partial_sites: (sites: Site[], hidden_elements?: ReadonlySet<string>) => RenderSite[];
+export declare const compute_slice_geometry: (visible_species: Site[`species`], slice_gap_rad?: number) => SliceGeometry[];

package/dist/structure/partial-occupancy.js

@@ -0,0 +1,102 @@
+export const PARTIAL_OCCUPANCY_SLICE_GAP_RAD = 1e-3;
+const OCCUPANCY_EPS = 1e-6;
+const MIN_PHI_LENGTH = 1e-4;
+const MERGE_DISTANCE_TOLERANCE = 1e-8;
+const CAP_ARC_START = Math.PI / 2;
+const is_image_atom = (site) => typeof site.properties?.orig_site_idx === `number`;
+const make_render_site = (sites, site_idx, source_site_indices, site_override) => ({
+    site_idx,
+    site: site_override ?? sites[site_idx],
+    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);
+    return visible_species.length === 1 && total_visible_occupancy < 1 - OCCUPANCY_EPS;
+};
+const group_split_partial_indices = (sites, hidden_elements) => {
+    const grouped_centers = [];
+    const grouped_site_indices = [];
+    const non_grouped_site_indices = [];
+    for (const [site_idx, site] of sites.entries()) {
+        if (!is_split_partial_site(site, 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);
+        if (matched_group_idx === -1) {
+            grouped_centers.push(site.xyz);
+            grouped_site_indices.push([site_idx]);
+            continue;
+        }
+        grouped_site_indices[matched_group_idx].push(site_idx);
+    }
+    return { non_grouped_site_indices, grouped_site_indices };
+};
+const build_render_sites = (sites, non_grouped_site_indices, grouped_site_indices) => {
+    const render_sites = non_grouped_site_indices.map((site_idx) => make_render_site(sites, site_idx, [site_idx]));
+    for (const grouped_indices of grouped_site_indices) {
+        if (grouped_indices.length === 1) {
+            const site_idx = grouped_indices[0];
+            render_sites.push(make_render_site(sites, site_idx, [site_idx]));
+            continue;
+        }
+        const representative_site_idx = grouped_indices[0];
+        const representative_site = sites[representative_site_idx];
+        const merged_species = grouped_indices.flatMap((grouped_site_idx) => sites[grouped_site_idx].species);
+        render_sites.push(make_render_site(sites, representative_site_idx, [...grouped_indices], { ...representative_site, species: merged_species }));
+    }
+    return render_sites;
+};
+export const PARTIAL_OCCUPANCY_CAP_ARC = {
+    start_cap_arc_start: CAP_ARC_START,
+    end_cap_arc_start: CAP_ARC_START,
+    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);
+};
+export const compute_slice_geometry = (visible_species, slice_gap_rad = PARTIAL_OCCUPANCY_SLICE_GAP_RAD) => {
+    if (visible_species.length === 0)
+        return [];
+    const total_visible_occupancy = visible_species.reduce((occupancy_sum, { occu }) => occupancy_sum + occu, 0);
+    // Preserve total angular coverage at one full turn for invalid overfull inputs.
+    const occupancy_scale_factor = total_visible_occupancy > 1 + OCCUPANCY_EPS
+        ? 1 / total_visible_occupancy
+        : 1;
+    const normalized_species = visible_species.map(({ element, occu }) => ({
+        element,
+        occu: occu * occupancy_scale_factor,
+    }));
+    const normalized_total_occupancy = normalized_species.reduce((occupancy_sum, { occu }) => occupancy_sum + occu, 0);
+    const has_vacancy_gap = normalized_total_occupancy < 1 - OCCUPANCY_EPS;
+    const last_visible_species_idx = normalized_species.length - 1;
+    let start_angle = 0;
+    return normalized_species.map(({ element, occu }, species_idx) => {
+        const start_phi_raw = 2 * Math.PI * start_angle;
+        const end_phi_raw = 2 * Math.PI * (start_angle += occu);
+        // Keep neighboring wedges from sharing the exact same plane (z-fighting).
+        const phi_span_raw = Math.max(0, end_phi_raw - start_phi_raw);
+        const max_safe_gap = Math.max(0, phi_span_raw - MIN_PHI_LENGTH);
+        const desired_gap = visible_species.length > 1
+            ? Math.min(slice_gap_rad, phi_span_raw * 0.25)
+            : 0;
+        const phi_gap = Math.min(desired_gap, max_safe_gap);
+        const start_phi = start_phi_raw + phi_gap / 2;
+        const end_phi = end_phi_raw - phi_gap / 2;
+        return {
+            element,
+            occupancy: occu,
+            start_phi,
+            end_phi,
+            phi_length: Math.max(MIN_PHI_LENGTH, end_phi - start_phi),
+            render_start_cap: has_vacancy_gap && species_idx === 0,
+            render_end_cap: has_vacancy_gap && species_idx === last_visible_species_idx,
+        };
+    });
+};

package/dist/structure/validation.js

@@ -1,8 +1,11 @@
 export function is_crystal(obj) {
     if (obj === null || typeof obj !== `object`)
         return false;
-    const input = obj;
-    const has_sites = Array.isArray(input.sites) && input.sites.length > 0;
-    const has_lattice = Boolean(input.lattice) && typeof input.lattice === `object`;
+    const structure_obj = obj;
+    const sites = structure_obj.sites;
+    const lattice = structure_obj.lattice;
+    const has_sites = Array.isArray(sites) && sites.length > 0;
+    const has_lattice = lattice !== undefined && lattice !== null &&
+        typeof lattice === `object`;
     return has_sites && has_lattice;
 }

package/dist/symmetry/SymmetryStats.svelte

@@ -4,6 +4,7 @@ import { default_sym_settings, wyckoff_positions_from_moyo } from './index';
 import * as spg from './spacegroups';
 let { sym_data, settings = $bindable(default_sym_settings), show_tooltips = true, children, label = `Symmetry`, header, ...rest } = $props();
 const wyckoff_count = $derived(sym_data ? wyckoff_positions_from_moyo(sym_data).length : 0);
+const display_hm_symbol = $derived(sym_data?.hm_symbol?.replace(/\s+/g, ``) ?? `?`);
 const sym_ops_counts = $derived.by(() => {
     const EPS = 1e-10;
     if (!sym_data?.operations) {
@@ -36,6 +37,13 @@ const titles = {
     roto_translations: `Number of roto-translations in the crystal structure.`,
 };
 const tooltips = $derived(show_tooltips ? titles : {});
+function get_step_from_order_of_magnitude(value) {
+    if (!Number.isFinite(value) || value <= 0)
+        return 1e-5;
+    const exponent = Math.floor(Math.log10(value));
+    return Math.pow(10, exponent);
+}
+const symprec_step = $derived(get_step_from_order_of_magnitude(settings.symprec));
 </script>
 
 <div {...rest} class="symmetry-stats {rest.class ?? ``}">
@@ -55,15 +63,21 @@ const tooltips = $derived(show_tooltips ? titles : {});
       <span {@attach tooltip()} title={tooltips?.symprec}>Precision</span>
       <input
         type="number"
-        step="1e-5"
+        step={symprec_step}
         value={settings.symprec}
-        onchange={(evt) => {
+        oninput={(evt) => {
           const { value } = evt.currentTarget
-          const parsed = parseFloat(value)
+          if (value === ``) return
+          const parsed = Number(value)
           if (Number.isFinite(parsed)) {
             settings = { ...settings, symprec: parsed }
           }
         }}
+        onkeydown={(evt) => {
+          if (evt.key === `Escape`) {
+            evt.currentTarget.blur()
+          }
+        }}
       />
     </label>
     <label>
@@ -91,7 +105,7 @@ const tooltips = $derived(show_tooltips ? titles : {});
         title="{tooltips?.space_group} at {settings.symprec} (using {settings.algo} algo). {tooltips?.hermann_mauguin}"
         {@attach tooltip()}
       >
-        Space Group <strong>{sym_data.number} ({sym_data.hm_symbol ?? `?`})</strong>
+        Space Group <strong>{sym_data.number} ({display_hm_symbol})</strong>
       </div>
       <div title={tooltips?.crystal_system} {@attach tooltip()}>
         Crystal System <strong>{spg.spacegroup_to_crystal_sys(sym_data.number)}</strong>

package/dist/symmetry/WyckoffTable.svelte

@@ -2,7 +2,8 @@
 import { format_fractional } from '../labels';
 import { colors } from '../state.svelte';
 let { wyckoff_positions, on_hover, on_click, active_color = `#2563eb`, ...rest } = $props();
-let selected_wyckoff = $state(null);
+let selected_key = $state(null);
+const get_row_key = (wyckoff_pos, row_idx) => `${wyckoff_pos.wyckoff}-${wyckoff_pos.elem}-${wyckoff_pos.site_indices?.join(`,`) ?? `none`}-${row_idx}`;
 </script>
 
 {#if wyckoff_positions && wyckoff_positions.length > 0}
@@ -22,10 +23,14 @@ let selected_wyckoff = $state(null);
       </tr>
     </thead>
     <tbody>
-      {#each wyckoff_positions as wyckoff_pos (JSON.stringify(wyckoff_pos))}
+      {#each wyckoff_positions as
+        wyckoff_pos,
+        row_idx
+        (get_row_key(wyckoff_pos, row_idx))
+      }
         {@const { wyckoff, elem, abc, site_indices } = wyckoff_pos}
-        {@const is_selected =
-        JSON.stringify(selected_wyckoff) === JSON.stringify(wyckoff_pos)}
+        {@const row_key = get_row_key(wyckoff_pos, row_idx)}
+        {@const is_selected = selected_key === row_key}
         <tr
           class="wyckoff-row"
           tabindex="0"
@@ -35,16 +40,14 @@ let selected_wyckoff = $state(null);
           onmouseenter={() => on_hover?.(site_indices ?? null)}
           onmouseleave={() => on_hover?.(null)}
           onclick={() => {
-            selected_wyckoff = is_selected ? null : wyckoff_pos
-            on_click?.(selected_wyckoff?.site_indices ?? null)
+            selected_key = is_selected ? null : row_key
+            on_click?.(is_selected ? null : (wyckoff_pos.site_indices ?? null))
           }}
           onkeydown={(event) => {
             if ([`Enter`, ` `].includes(event.key)) {
               event.preventDefault()
-              const is_selected =
-                JSON.stringify(selected_wyckoff) === JSON.stringify(wyckoff_pos)
-              selected_wyckoff = is_selected ? null : wyckoff_pos
-              on_click?.(selected_wyckoff?.site_indices ?? null)
+              selected_key = is_selected ? null : row_key
+              on_click?.(is_selected ? null : (wyckoff_pos.site_indices ?? null))
             }
           }}
         >
@@ -69,6 +72,11 @@ let selected_wyckoff = $state(null);
   .wyckoff-table {
     margin-top: 1em;
   }
+  .wyckoff-table :is(th, td) {
+    padding: 2px 6px;
+    text-align: center;
+    vertical-align: middle;
+  }
   .wyckoff-row {
     cursor: pointer;
     transition: background-color 0.2s ease;