matterviz 0.4.0 → 0.4.2

package/dist/trajectory/parse/hdf5.js

@@ -1,78 +1,96 @@
-// HDF5 trajectory parsing (torch-sim / generic format)
+// HDF5 trajectory parsing: dispatches between VASP vaspout.h5 and the
+// torch-sim / generic dataset-alias layout after a single file open.
 import { calc_lattice_params, transpose_3x3_matrix } from '../../math';
-import * as h5wasm from 'h5wasm';
-import { convert_atomic_numbers, create_trajectory_frame, validate_3x3_matrix, } from '../helpers';
-const is_hdf5_dataset = (entity) => entity !== null && `to_array` in entity && entity instanceof h5wasm.Dataset;
-const is_hdf5_group = (entity) => entity !== null && `keys` in entity && entity instanceof h5wasm.Group;
-export async function parse_torch_sim_hdf5(buffer, filename) {
-    const { FS } = await h5wasm.ready;
-    const file_basename = filename
-        ?.split(`/`)
-        .at(-1)
-        ?.replaceAll(/[^\w.-]/g, `_`) ?? `temp`;
-    const unique_suffix = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
-    const temp_filename = `${file_basename}-${unique_suffix}.h5`;
-    FS.writeFile(temp_filename, new Uint8Array(buffer));
-    let h5_file = null;
-    try {
-        h5_file = new h5wasm.File(temp_filename, `r`);
-        const found_paths = {};
-        let total_groups_found = 0;
-        const find_dataset = (names) => {
-            const discover = (parent, path = ``) => {
-                total_groups_found++;
-                for (const name of parent.keys()) {
-                    const item = parent.get(name);
-                    const full_path = path ? `${path}/${name}` : `/${name}`;
-                    if (names.includes(name) && is_hdf5_dataset(item)) {
-                        const found_name = names.find((dataset_name) => dataset_name === name);
-                        if (found_name)
-                            found_paths[found_name] = full_path;
-                        return item;
-                    }
-                    if (is_hdf5_group(item)) {
-                        const result = discover(item, full_path);
-                        if (result)
-                            return result;
-                    }
+import { convert_atomic_numbers, count_elements, create_trajectory_frame, validate_3x3_matrix, } from '../helpers';
+import { is_hdf5_dataset, is_hdf5_group, read_dataset, with_h5_file } from './h5-utils';
+import { is_vaspout_h5_file, parse_vaspout_h5_file } from './vaspout-h5';
+// Routes an opened HDF5 file to the right parser: vaspout.h5 has the VASP 6.x
+// root-group layout, everything else falls through to the torch-sim recursive
+// dataset-name search. One FS write + open, no parse-and-fallback.
+export async function parse_hdf5_trajectory(buffer, filename) {
+    return with_h5_file(buffer, filename, (h5_file) => is_vaspout_h5_file(h5_file)
+        ? parse_vaspout_h5_file(h5_file)
+        : parse_torch_sim_h5_file(h5_file));
+}
+// Dataset-name aliases searched (in order) across the whole group tree
+const POSITION_ALIASES = [`positions`, `coords`, `coordinates`];
+const ATOMIC_NUMBER_ALIASES = [`atomic_numbers`, `numbers`, `Z`, `species`];
+const CELL_ALIASES = [`cell`, `cells`, `lattice`];
+const ENERGY_ALIASES = [`potential_energy`, `energy`];
+function parse_torch_sim_h5_file(h5_file) {
+    const alias_groups = [POSITION_ALIASES, ATOMIC_NUMBER_ALIASES, CELL_ALIASES, ENERGY_ALIASES];
+    const all_aliases = new Set(alias_groups.flat());
+    const found_paths = {};
+    const found_alias_groups = new Set();
+    let total_groups_found = 0;
+    const discover = (parent, path = ``) => {
+        total_groups_found++;
+        for (const name of parent.keys()) {
+            const item = parent.get(name);
+            const full_path = path ? `${path}/${name}` : `/${name}`;
+            if (is_hdf5_dataset(item) && all_aliases.has(name)) {
+                found_paths[name] ??= full_path;
+                for (const [group_idx, aliases] of alias_groups.entries()) {
+                    if (aliases.includes(name))
+                        found_alias_groups.add(group_idx);
                 }
-                return null;
-            };
-            return discover(h5_file);
-        };
-        const positions_data = find_dataset([`positions`, `coords`, `coordinates`])?.to_array();
-        const atomic_numbers_data = find_dataset([
-            `atomic_numbers`,
-            `numbers`,
-            `Z`,
-            `species`,
-        ])?.to_array();
-        const cells_data = find_dataset([`cell`, `cells`, `lattice`])?.to_array();
-        const energies_data = find_dataset([`potential_energy`, `energy`])?.to_array();
-        if (!positions_data || !atomic_numbers_data) {
-            const missing_datasets = [];
-            if (!positions_data) {
-                missing_datasets.push(`positions (tried: positions, coords, coordinates)`);
+                if (found_alias_groups.size === alias_groups.length)
+                    return;
             }
-            if (!atomic_numbers_data) {
-                missing_datasets.push(`atomic numbers (tried: atomic_numbers, numbers, Z, species)`);
+            else if (is_hdf5_group(item)) {
+                discover(item, full_path);
+                if (found_alias_groups.size === alias_groups.length)
+                    return;
             }
-            const missing_str = missing_datasets.join(`, `);
-            const available_str = Array.from(h5_file.keys()).join(`, `);
-            throw new Error(`Missing required dataset(s) in HDF5 file: ${missing_str}. Available datasets: ${available_str}`);
         }
-        const positions_are_frames = positions_data.length > 0 &&
-            positions_data.every((entry) => Array.isArray(entry) && entry.every((coord) => Array.isArray(coord)));
-        const positions = positions_are_frames ? positions_data : [positions_data];
-        const atomic_numbers_are_frames = atomic_numbers_data.length > 0 &&
-            atomic_numbers_data.every((entry) => Array.isArray(entry));
-        const atomic_numbers = atomic_numbers_are_frames
-            ? atomic_numbers_data
-            : [atomic_numbers_data];
-        const frames = positions.map((frame_pos, idx) => {
+    };
+    discover(h5_file);
+    const first_path = (names) => names.map((name) => found_paths[name]).find(Boolean);
+    const find_dataset = (names) => {
+        const path = first_path(names);
+        return path ? read_dataset(h5_file, path) : null;
+    };
+    const positions_data = find_dataset(POSITION_ALIASES);
+    const atomic_numbers_data = find_dataset(ATOMIC_NUMBER_ALIASES);
+    const cells_data = find_dataset(CELL_ALIASES);
+    const energies_data = find_dataset(ENERGY_ALIASES);
+    if (!positions_data || !atomic_numbers_data) {
+        const missing_datasets = [];
+        if (!positions_data) {
+            missing_datasets.push(`positions (tried: ${POSITION_ALIASES.join(`, `)})`);
+        }
+        if (!atomic_numbers_data) {
+            missing_datasets.push(`atomic numbers (tried: ${ATOMIC_NUMBER_ALIASES.join(`, `)})`);
+        }
+        const missing_str = missing_datasets.join(`, `);
+        const available_str = [...h5_file.keys()].join(`, `);
+        throw new Error(`Missing required dataset(s) in HDF5 file: ${missing_str}. Available datasets: ${available_str}`);
+    }
+    const positions_are_frames = positions_data.length > 0 &&
+        positions_data.every((entry) => Array.isArray(entry) && entry.every((coord) => Array.isArray(coord)));
+    const positions = positions_are_frames ? positions_data : [positions_data];
+    const atomic_numbers_are_frames = atomic_numbers_data.length > 0 &&
+        atomic_numbers_data.every((entry) => Array.isArray(entry));
+    const atomic_numbers = atomic_numbers_are_frames
+        ? atomic_numbers_data
+        : [atomic_numbers_data];
+    // A constant cell may be stored as a single 3x3 matrix; normalize to a
+    // per-frame array so cells[idx] always yields a full lattice (indexing a bare
+    // 3x3 with a frame index would hand a single row to validate_3x3_matrix)
+    const cells_are_frames = cells_data?.every((entry) => Array.isArray(entry) && entry.every((row) => Array.isArray(row)));
+    const cells = cells_data
+        ? cells_are_frames
+            ? cells_data
+            : [cells_data]
+        : null;
+    const frames = [];
+    let dropped_steps = 0;
+    for (const [idx, frame_pos] of positions.entries()) {
+        try {
             const frame_atomic_numbers = atomic_numbers[idx] || atomic_numbers[0];
             const frame_elements = convert_atomic_numbers(frame_atomic_numbers);
-            const cell = cells_data?.[idx];
+            // constant-cell files reuse the single normalized cell for every frame
+            const cell = cells_are_frames ? cells?.[idx] : cells?.[0];
             const lattice_mat = cell ? transpose_3x3_matrix(validate_3x3_matrix(cell)) : undefined;
             const energy_entry = energies_data?.[idx];
             const energy = Array.isArray(energy_entry) ? energy_entry[0] : energy_entry;
@@ -83,45 +101,37 @@ export async function parse_torch_sim_hdf5(buffer, filename) {
                 metadata.volume = calc_lattice_params(lattice_mat).volume;
             }
             const pbc = lattice_mat ? [true, true, true] : [false, false, false];
-            return create_trajectory_frame(frame_pos, frame_elements, lattice_mat, pbc, idx, metadata);
-        });
-        const first_frame_elements = frames[0]?.structure.sites.map((site) => site.species[0].element) ?? [];
-        return {
-            frames,
-            metadata: {
-                source_format: `hdf5_trajectory`,
-                frame_count: frames.length,
-                num_atoms: first_frame_elements.length,
-                periodic_boundary_conditions: cells_data ? [true, true, true] : [false, false, false],
-                element_counts: first_frame_elements.reduce((counts, element) => {
-                    counts[element] = (counts[element] || 0) + 1;
-                    return counts;
-                }, {}),
-                discovered_datasets: {
-                    positions: found_paths.positions ||
-                        found_paths.coords ||
-                        found_paths.coordinates ||
-                        `unknown`,
-                    atomic_numbers: found_paths.atomic_numbers ||
-                        found_paths.numbers ||
-                        found_paths.Z ||
-                        found_paths.species ||
-                        `unknown`,
-                    cells: found_paths.cell || found_paths.cells || found_paths.lattice,
-                    energies: found_paths.potential_energy || found_paths.energy,
-                },
-                total_groups_found,
-                has_cell_info: Boolean(cells_data),
-            },
-        };
-    }
-    finally {
-        h5_file?.close();
-        try {
-            FS.unlink(temp_filename);
+            frames.push(create_trajectory_frame(frame_pos, frame_elements, lattice_mat, pbc, idx, metadata));
         }
-        catch {
-            /* temp file cleanup is best-effort */
+        catch (err) {
+            // Same torn-tail resiliency as the vaspout parser: interrupted writers
+            // zero-fill trailing chunks (atomic number 0, degenerate cells), which
+            // fails validation — keep the frames parsed so far and report the rest
+            // as dropped. A file whose very first frame is unparsable still throws.
+            if (frames.length === 0)
+                throw err;
+            dropped_steps = positions.length - idx;
+            break;
         }
     }
+    const first_frame_elements = frames[0]?.structure.sites.map((site) => site.species[0].element) ?? [];
+    return {
+        frames,
+        metadata: {
+            source_format: `hdf5_trajectory`,
+            frame_count: frames.length,
+            num_atoms: first_frame_elements.length,
+            periodic_boundary_conditions: cells_data ? [true, true, true] : [false, false, false],
+            element_counts: count_elements(first_frame_elements),
+            discovered_datasets: {
+                positions: first_path(POSITION_ALIASES) ?? `unknown`,
+                atomic_numbers: first_path(ATOMIC_NUMBER_ALIASES) ?? `unknown`,
+                cells: first_path(CELL_ALIASES),
+                energies: first_path(ENERGY_ALIASES),
+            },
+            total_groups_found,
+            has_cell_info: Boolean(cells_data),
+            ...(dropped_steps > 0 ? { dropped_steps } : {}),
+        },
+    };
 }

package/dist/trajectory/parse/index.d.ts

@@ -1,10 +1,9 @@
-import { is_trajectory_file } from '../format-detect';
-import { TrajFrameReader } from '../frame-reader';
 import type { FrameLoader, ParseProgress, TrajectoryType } from '../index';
 import type { AtomTypeMapping, LoadingOptions } from '../types';
-export { INDEX_SAMPLE_RATE, LARGE_FILE_THRESHOLD, MAX_BIN_FILE_SIZE, MAX_METADATA_SIZE, MAX_SAFE_STRING_LENGTH, MAX_TEXT_FILE_SIZE, } from '../constants';
+export { LARGE_FILE_THRESHOLD, MAX_BIN_FILE_SIZE, MAX_TEXT_FILE_SIZE, } from '../constants';
 export type { AtomTypeMapping, LoadingOptions } from '../types';
-export { is_trajectory_file, TrajFrameReader };
+export { is_trajectory_file } from '../format-detect';
+export { TrajFrameReader } from '../frame-reader';
 export declare function parse_trajectory_data(data: unknown, filename?: string, atom_type_mapping?: AtomTypeMapping): Promise<TrajectoryType>;
 export declare function get_unsupported_format_message(filename: string, content: string): string | null;
 export declare function parse_trajectory_async(data: ArrayBuffer | string, filename: string, on_progress?: (progress: ParseProgress) => void, options?: LoadingOptions): Promise<TrajectoryType>;

package/dist/trajectory/parse/index.js

@@ -1,26 +1,37 @@
+// Parsing functions for trajectory data from various formats
 import { is_binary } from '../../io/is-binary';
-import * as math from '../../math';
-import { parse_xyz } from '../../structure/parse';
+import { is_plain_object } from '../../utils';
+import { is_parsed_structure, parse_xyz } from '../../structure/parse';
 import { INDEX_SAMPLE_RATE, LARGE_FILE_THRESHOLD } from '../constants';
-import { ext_hint, FORMAT_PATTERNS, is_trajectory_file, strip_compression_extensions, } from '../format-detect';
+import { strip_compression_extensions } from '../../io/decompress';
+import { ext_hint, FORMAT_PATTERNS } from '../format-detect';
 import { TrajFrameReader } from '../frame-reader';
-import { count_xyz_frames, create_trajectory_frame, validate_3x3_matrix, } from '../helpers';
+import { count_xyz_frames } from '../helpers';
 import { parse_ase_trajectory } from './ase';
-import { parse_torch_sim_hdf5 } from './hdf5';
+import { get_traj_parse_warnings, reset_traj_parse_warnings, traj_warn } from './diagnostics';
+import { parse_hdf5_trajectory } from './hdf5';
 import { parse_lammps_trajectory } from './lammps';
+import { parse_pymatgen_trajectory } from './pymatgen';
 import { parse_vasp_xdatcar } from './vasp';
 import { parse_xyz_trajectory } from './xyz';
-// Silently swallow expected parse fallbacks — the caller throws if ALL formats fail
-const log_parse_debug = (_message, _error) => { };
+// Throw on a trajectory frame whose structure isn't a valid parsed structure (non-empty sites with species + coords)
+const assert_frame_structure = (structure, label) => {
+    if (!is_parsed_structure(structure)) {
+        const context = typeof label === `number` ? `trajectory frame ${label}` : label;
+        throw new Error(`Invalid structure in ${context}: expected non-empty 'sites' array with species and coordinates`);
+    }
+};
 // Re-export constants and types for consumers
-export { INDEX_SAMPLE_RATE, LARGE_FILE_THRESHOLD, MAX_BIN_FILE_SIZE, MAX_METADATA_SIZE, MAX_SAFE_STRING_LENGTH, MAX_TEXT_FILE_SIZE, } from '../constants';
-export { is_trajectory_file, TrajFrameReader };
+export { LARGE_FILE_THRESHOLD, MAX_BIN_FILE_SIZE, MAX_TEXT_FILE_SIZE, } from '../constants';
+export { is_trajectory_file } from '../format-detect';
+export { TrajFrameReader } from '../frame-reader';
 export async function parse_trajectory_data(data, filename, atom_type_mapping) {
+    reset_traj_parse_warnings();
     if (data instanceof ArrayBuffer) {
         if (FORMAT_PATTERNS.ase(data, filename))
             return parse_ase_trajectory(data, filename);
         if (FORMAT_PATTERNS.hdf5(data, filename))
-            return parse_torch_sim_hdf5(data, filename);
+            return parse_hdf5_trajectory(data, filename);
         throw new Error(`Unsupported binary format${filename ? `: ${filename}` : ``}`);
     }
     if (typeof data === `string`) {
@@ -35,138 +46,69 @@ export async function parse_trajectory_data(data, filename, atom_type_mapping) {
         }
         // Single XYZ fallback (content-sniffed when the filename gives no format hint,
         // e.g. blob: object URLs whose basenames are UUIDs)
-        const xyz_hint = ext_hint(filename, /\.(xyz|extxyz)$/);
+        const xyz_hint = ext_hint(filename, /\.(?:xyz|extxyz)$/);
         if (xyz_hint || (xyz_hint === null && count_xyz_frames(content) === 1)) {
-            try {
-                const structure = parse_xyz(content);
-                if (structure) {
-                    return {
-                        frames: [{ structure, step: 0, metadata: {} }],
-                        metadata: { source_format: `single_xyz`, frame_count: 1 },
-                    };
-                }
-            }
-            catch (error) {
-                // Single-frame XYZ parsing failed, continue to JSON parsing.
-                log_parse_debug(`Single XYZ parse fallback failed for ${filename ?? `unknown file`}:`, error);
+            // parse_xyz never throws (it returns null); fall through to JSON parsing.
+            const structure = parse_xyz(content);
+            if (structure) {
+                return {
+                    frames: [{ structure, step: 0, metadata: {} }],
+                    metadata: { source_format: `single_xyz`, frame_count: 1 },
+                };
             }
         }
         try {
             data = JSON.parse(content);
         }
         catch (error) {
-            log_parse_debug(`JSON parse failed for ${filename ?? `unknown file`}:`, error);
             throw new Error(`Unsupported text format`, { cause: error });
         }
     }
-    if (!data || typeof data !== `object`)
-        throw new Error(`Invalid data format`);
     // Handle JSON formats
     if (Array.isArray(data)) {
         const frames = data.map((frame_data, idx) => {
             const frame_obj = frame_data;
             const frame_step = frame_obj.step;
+            const structure = frame_obj.structure ?? frame_obj;
+            assert_frame_structure(structure, idx);
             return {
-                structure: (frame_obj.structure ?? frame_obj),
+                structure: structure,
                 step: typeof frame_step === `number` ? frame_step : idx,
                 metadata: frame_obj.metadata || {},
             };
         });
         return { frames, metadata: { source_format: `array`, frame_count: frames.length } };
     }
-    const obj = data;
+    if (!is_plain_object(data))
+        throw new Error(`Invalid data format`);
     // Pymatgen format
-    if (obj[`@class`] === `Trajectory` && obj.species && obj.coords && obj.lattice) {
-        const species = obj.species;
-        const frame_elements = species.map((specie) => specie.element);
-        const coords = obj.coords;
-        const matrix = validate_3x3_matrix(obj.lattice);
-        const frame_properties = obj.frame_properties || [];
-        const frac_to_cart = math.create_frac_to_cart(matrix);
-        const frames = coords.map((frame_coords, idx) => {
-            const positions = frame_coords.map((abc) => frac_to_cart(abc));
-            // Process frame properties to extract numpy arrays
-            const raw_properties = frame_properties[idx] || {};
-            const processed_properties = {};
-            Object.entries(raw_properties).forEach(([key, value]) => {
-                if (value &&
-                    typeof value === `object` &&
-                    value[`@class`] === `array`) {
-                    // Extract numpy array data
-                    const array_obj = value;
-                    processed_properties[key] = array_obj.data;
-                    // Calculate force statistics for forces
-                    if (key === `forces` && Array.isArray(array_obj.data)) {
-                        const forces = array_obj.data;
-                        const force_magnitudes = forces.map((force) => Math.hypot(...force));
-                        if (force_magnitudes.length > 0) {
-                            processed_properties.force_max = force_magnitudes.reduce((max_val, magnitude) => (magnitude > max_val ? magnitude : max_val), force_magnitudes[0]);
-                            processed_properties.force_norm = Math.sqrt(force_magnitudes.reduce((sum, f) => sum + f ** 2, 0) / force_magnitudes.length);
-                        }
-                    }
-                    // Calculate stress statistics for stress tensor
-                    if (key === `stress` && Array.isArray(array_obj.data)) {
-                        const stress_tensor = array_obj.data;
-                        if (!math.is_square_matrix(stress_tensor, 3)) {
-                            console.warn(`Invalid stress tensor structure in frame ${idx}`);
-                        }
-                        else {
-                            // Calculate stress components (diagonal elements represent normal stresses)
-                            const normal_stresses = [
-                                stress_tensor[0][0],
-                                stress_tensor[1][1],
-                                stress_tensor[2][2],
-                            ];
-                            processed_properties.stress_max = Math.max(...normal_stresses.map(Math.abs));
-                            // Calculate hydrostatic pressure (negative of mean normal stress)
-                            processed_properties.pressure =
-                                -(normal_stresses[0] + normal_stresses[1] + normal_stresses[2]) / 3;
-                        }
-                    }
-                }
-                else {
-                    processed_properties[key] = value;
-                }
-            });
-            return create_trajectory_frame(positions, frame_elements, matrix, [true, true, true], idx, processed_properties);
-        });
-        return {
-            frames,
-            metadata: {
-                filename,
-                source_format: `pymatgen_trajectory`,
-                frame_count: frames.length,
-                species_list: [...new Set(species.map((specie) => specie.element))],
-                periodic_boundary_conditions: [true, true, true],
-            },
-        };
+    if (data[`@class`] === `Trajectory` && data.species && data.coords && data.lattice) {
+        return parse_pymatgen_trajectory(data, filename);
     }
     // Object with frames
-    if (Array.isArray(obj.frames)) {
-        const metadata = (obj.metadata ?? {});
-        return {
-            frames: obj.frames,
-            metadata: { ...metadata, source_format: `object_with_frames` },
-        };
+    if (Array.isArray(data.frames)) {
+        const metadata = (data.metadata ?? {});
+        const frames = data.frames;
+        frames.forEach((frame, idx) => assert_frame_structure(frame?.structure, idx));
+        return { frames, metadata: { ...metadata, source_format: `object_with_frames` } };
     }
-    // Single structure
-    if (obj.sites) {
-        return {
-            frames: [{ structure: obj, step: 0, metadata: {} }],
-            metadata: { source_format: `single_structure`, frame_count: 1 },
-        };
+    // Single structure (treated as a 1-frame trajectory)
+    if (data.sites) {
+        assert_frame_structure(data, `single structure`);
+        const frames = [{ structure: data, step: 0, metadata: {} }];
+        const metadata = { source_format: `single_structure`, frame_count: 1 };
+        return { frames, metadata };
     }
     throw new Error(`Unrecognized trajectory format`);
 }
 export function get_unsupported_format_message(filename, content) {
     const lower = filename.toLowerCase();
     // Check for unsupported compression formats first
-    const unsupported_compression = [
-        { ext: `.bz2`, name: `BZ2` },
-        { ext: `.xz`, name: `XZ` },
-        { ext: `.zip`, name: `ZIP` },
-    ];
-    for (const { ext, name } of unsupported_compression) {
+    for (const [ext, name] of [
+        [`.bz2`, `BZ2`],
+        [`.xz`, `XZ`],
+        [`.zip`, `ZIP`],
+    ]) {
         if (lower.endsWith(ext)) {
             return `🚫 ${name} compression not supported in browser\nPlease decompress the file first`;
         }
@@ -187,10 +129,20 @@ export function get_unsupported_format_message(filename, content) {
         ? `🚫 Binary format not supported${filename ? `: ${filename}` : ``}`
         : null;
 }
+// Attach non-fatal parse warnings (skipped atoms, dropped frames, plot-metadata
+// extraction failures, ...) collected during parsing to the trajectory metadata so
+// the UI can surface them instead of leaving them in the console only.
+function attach_parse_warnings(trajectory) {
+    const parse_warnings = get_traj_parse_warnings();
+    if (parse_warnings.length === 0)
+        return trajectory;
+    return { ...trajectory, metadata: { ...trajectory.metadata, parse_warnings } };
+}
 // Unified async parser with streaming support
 export async function parse_trajectory_async(data, filename, on_progress, options = {}) {
     const { use_indexing, index_sample_rate = INDEX_SAMPLE_RATE, extract_plot_metadata = true, atom_type_mapping, } = options;
     const update_progress = (current, stage) => on_progress?.({ current, total: 100, stage });
+    reset_traj_parse_warnings();
     try {
         update_progress(0, `Detecting format...`);
         const data_size = data instanceof ArrayBuffer ? data.byteLength : new TextEncoder().encode(data).byteLength;
@@ -203,21 +155,18 @@ export async function parse_trajectory_async(data, filename, on_progress, option
         // When the filename gives no format hint (e.g. blob: URLs), sniff a content
         // prefix for XYZ frames so large extensionless files still get indexed.
         const base_filename = strip_compression_extensions(filename);
-        const can_index = /\.(xyz|extxyz|traj)$/.test(base_filename) ||
+        const can_index = /\.(?:xyz|extxyz|traj)$/.test(base_filename) ||
             (typeof data === `string` &&
-                ext_hint(filename, /\.(xyz|extxyz)$/) === null &&
+                ext_hint(filename, /\.(?:xyz|extxyz)$/) === null &&
                 count_xyz_frames(data.slice(0, 2 ** 20)) >= 1);
         if (should_use_indexing && can_index) {
-            return await parse_with_unified_loader(data, filename, {
-                index_sample_rate,
-                extract_plot_metadata,
-            }, on_progress);
+            return attach_parse_warnings(await parse_with_unified_loader(data, filename, { index_sample_rate, extract_plot_metadata }, on_progress));
         }
         // Fallback to direct parsing
         update_progress(10, `Parsing trajectory...`);
         const result = await parse_trajectory_data(data, filename, atom_type_mapping);
         update_progress(100, `Complete`);
-        return result;
+        return attach_parse_warnings(result);
     }
     catch (error) {
         const error_message = error instanceof Error ? error.message : `Unknown error`;
@@ -259,7 +208,7 @@ async function parse_with_unified_loader(data, filename, options, on_progress) {
             });
         }
         catch (error) {
-            console.warn(`Failed to extract plot metadata:`, error);
+            traj_warn(`Failed to extract plot metadata`, error);
         }
     }
     const stage = `Ready: ${total_frames} frames indexed`;
@@ -279,7 +228,7 @@ async function parse_with_unified_loader(data, filename, options, on_progress) {
 }
 // Factory function for frame loader (simplified)
 export function create_frame_loader(filename) {
-    if (!/\.(xyz|extxyz|traj)$/.exec(filename.toLowerCase())) {
+    if (!/\.(?:xyz|extxyz|traj)$/.test(filename.toLowerCase())) {
         throw new Error(`Unsupported format for frame loading: ${filename}`);
     }
     return new TrajFrameReader(filename);

package/dist/trajectory/parse/lammps.d.ts

@@ -1,5 +1,3 @@
-import * as math from '../../math';
 import type { TrajectoryType } from '../index';
 import type { AtomTypeMapping } from '../types';
-export declare function parse_lammps_box(box_lines: string[], is_triclinic: boolean): math.Matrix3x3 | null;
 export declare function parse_lammps_trajectory(content: string, filename?: string, atom_type_mapping?: AtomTypeMapping): TrajectoryType;

package/dist/trajectory/parse/lammps.js

@@ -1,11 +1,13 @@
 import { ELEM_SYMBOLS } from '../../labels';
 import * as math from '../../math';
-import { coerce_element_symbol, create_trajectory_frame } from '../helpers';
+import { coerce_elem_symbol } from '../../element/helpers';
+import { count_elements, create_trajectory_frame } from '../helpers';
+import { traj_warn } from './diagnostics';
 const is_periodic = (token) => token.toLowerCase().startsWith(`p`);
 // Parse LAMMPS box bounds → lattice matrix. Handles orthogonal and triclinic boxes.
 // Triclinic: converts bounding box to actual dims per https://docs.lammps.org/Howto_triclinic.html
 // Lattice vectors: a=(lx,0,0), b=(xy,ly,0), c=(xz,yz,lz)
-export function parse_lammps_box(box_lines, is_triclinic) {
+function parse_lammps_box(box_lines, is_triclinic) {
     if (box_lines.length !== 3)
         return null;
     const bounds = box_lines.map((line) => line.split(/\s+/).map(Number));
@@ -58,11 +60,11 @@ export function parse_lammps_trajectory(content, filename, atom_type_mapping) {
         if (!skip_to(`ITEM: TIMESTEP`))
             break;
         idx++;
-        const timestep = parseInt(read_line(), 10) || 0;
+        const timestep = Math.trunc(Number(read_line())) || 0;
         if (!skip_to(`ITEM: NUMBER OF ATOMS`))
             break;
         idx++;
-        const num_atoms = parseInt(read_line(), 10);
+        const num_atoms = Math.trunc(Number(read_line()));
         if (!num_atoms || num_atoms <= 0)
             continue;
         // BOX BOUNDS: orthogonal="pp pp pp", triclinic="xy xz yz pp pp pp"
@@ -100,7 +102,7 @@ export function parse_lammps_trajectory(content, filename, atom_type_mapping) {
         if (pos_cols.some((col_idx) => col_idx === undefined))
             continue;
         if (type_col === undefined && element_col === undefined && id_col === undefined) {
-            console.warn(`Skipping LAMMPS frame at timestep ${timestep}: missing type/element/id column`);
+            traj_warn(`Skipping LAMMPS frame at timestep ${timestep}: missing type/element/id column`);
             continue;
         }
         // Parse atom data
@@ -109,7 +111,7 @@ export function parse_lammps_trajectory(content, filename, atom_type_mapping) {
         const frac_to_cart = use_scaled ? math.create_frac_to_cart(lattice_matrix) : null;
         for (let atom = 0; atom < num_atoms && idx < lines.length; atom++) {
             const parts = read_line().split(/\s+/);
-            const coords = pos_cols.map((col_idx) => parseFloat(parts[col_idx]));
+            const coords = pos_cols.map((col_idx) => Number(parts[col_idx]));
             if (coords.some(isNaN) || parts.length <= max_col_idx)
                 continue;
             // Convert scaled coordinates to Cartesian if needed
@@ -117,7 +119,7 @@ export function parse_lammps_trajectory(content, filename, atom_type_mapping) {
             let element_symbol;
             if (type_col !== undefined) {
                 // Map atom type to element using custom mapping or default (type 1 -> H, etc.)
-                const atom_type = parseInt(parts[type_col], 10) || 1;
+                const atom_type = Math.trunc(Number(parts[type_col])) || 1;
                 atom_types_found.add(atom_type);
                 element_symbol = get_element(atom_type);
             }
@@ -125,17 +127,17 @@ export function parse_lammps_trajectory(content, filename, atom_type_mapping) {
                 const raw_symbol = parts[element_col];
                 if (!raw_symbol)
                     continue;
-                element_symbol = coerce_element_symbol(raw_symbol);
+                element_symbol = coerce_elem_symbol(raw_symbol);
                 if (!element_symbol) {
-                    console.warn(`Skipping LAMMPS atom with unknown element symbol "${raw_symbol}" at timestep ${timestep}`);
+                    traj_warn(`Skipping LAMMPS atom with unknown element symbol "${raw_symbol}" at timestep ${timestep}`);
                     continue;
                 }
             }
             else if (id_col !== undefined) {
-                const atom_id = parseInt(parts[id_col], 10) || 1;
+                const atom_id = Math.trunc(Number(parts[id_col])) || 1;
                 atom_types_found.add(atom_id);
                 if (!id_fallback_warning_emitted) {
-                    console.warn(`LAMMPS parser fallback: mapping atom IDs to elements from ID column; this may be incorrect for large or sequential IDs. Prefer a TYPE column when available.`);
+                    traj_warn(`LAMMPS parser fallback: mapping atom IDs to elements from ID column; this may be incorrect for large or sequential IDs. Prefer a TYPE column when available.`);
                     id_fallback_warning_emitted = true;
                 }
                 element_symbol = get_element(atom_id);
@@ -157,11 +159,7 @@ export function parse_lammps_trajectory(content, filename, atom_type_mapping) {
         throw new Error(`No valid frames found in LAMMPS trajectory`);
     }
     const first_frame = frames[0];
-    const element_counts = first_frame.structure.sites.reduce((counts, site) => {
-        const elem = site.species[0].element;
-        counts[elem] = (counts[elem] || 0) + 1;
-        return counts;
-    }, {});
+    const element_counts = count_elements(first_frame.structure.sites.map((site) => site.species[0].element));
     return {
         frames,
         metadata: {

package/dist/trajectory/parse/pymatgen.d.ts

@@ -0,0 +1,2 @@
+import type { TrajectoryType } from '../index';
+export declare function parse_pymatgen_trajectory(obj: Record<string, unknown>, filename?: string): TrajectoryType;