matterviz 0.4.1 → 0.4.2

package/dist/trajectory/frame-reader.js

@@ -2,7 +2,7 @@
 import * as math from '../math';
 import { MAX_METADATA_SIZE } from './constants';
 import { copy_numeric_fields, count_xyz_frames, iter_xyz_frames, validate_3x3_matrix, } from './helpers';
-import { strip_compression_extensions } from '../io';
+import { strip_compression_extensions } from '../io/decompress';
 import { decode_ase_frame, read_ase_header } from './parse/ase';
 import { build_xyz_frame, parse_xyz_comment_metadata } from './parse/xyz';
 // Restrict frame metadata to the requested property keys (no-op when unset)
@@ -14,6 +14,9 @@ const filter_properties = (metadata, properties) => {
 export class TrajFrameReader {
     format;
     global_numbers;
+    // Split lines + per-frame start indices for the last XYZ payload, so repeat seeks are
+    // O(1) lookup instead of re-splitting + rescanning from line 0 (was O(n²) over playback)
+    xyz_cache;
     constructor(filename) {
         const base_filename = strip_compression_extensions(filename);
         this.format = base_filename.endsWith(`.traj`) ? `ase` : `xyz`;
@@ -108,26 +111,19 @@ export class TrajFrameReader {
         if (this.format === `xyz`) {
             const lines = data.trim().split(/\r?\n/);
             let current_frame = 0;
-            for (const { start, comment } of iter_xyz_frames(lines)) {
+            for (const { comment } of iter_xyz_frames(lines)) {
                 if (current_frame >= total_frames)
                     break;
                 if (current_frame % sample_rate === 0) {
-                    let frame_metadata = null;
-                    try {
-                        const { step, properties: props } = parse_xyz_comment_metadata(comment);
-                        frame_metadata = {
-                            frame_number: current_frame,
-                            step: step ?? current_frame,
-                            properties: props,
-                        };
-                    }
-                    catch (error) {
-                        console.warn(`Failed to parse XYZ metadata for frame ${current_frame} at line ${start + 1}:`, error);
-                    }
-                    if (frame_metadata) {
-                        filter_properties(frame_metadata, properties);
-                        metadata_list.push(frame_metadata);
-                    }
+                    // parse_xyz_comment_metadata is pure regex/parseFloat and never throws
+                    const { step, properties: props } = parse_xyz_comment_metadata(comment);
+                    const frame_metadata = {
+                        frame_number: current_frame,
+                        step: step ?? current_frame,
+                        properties: props,
+                    };
+                    filter_properties(frame_metadata, properties);
+                    metadata_list.push(frame_metadata);
                 }
                 current_frame++;
                 if (on_progress && current_frame % 5000 === 0) {
@@ -169,18 +165,26 @@ export class TrajFrameReader {
         }
         return metadata_list;
     }
-    load_xyz_frame(data, frame_number) {
+    // Build + cache the line array and per-frame start indices once per payload
+    get_xyz_cache(data) {
+        if (this.xyz_cache?.data === data)
+            return this.xyz_cache;
         const lines = data.trim().split(/\r?\n/);
-        let current_frame = 0;
-        for (const frame of iter_xyz_frames(lines)) {
-            if (current_frame++ < frame_number)
-                continue; // skip frames before the target
-            return build_xyz_frame(lines, frame, {
-                frame_label: `indexed frame ${frame_number}`,
-                default_step: frame_number,
-            });
-        }
-        return null;
+        const frame_starts = Array.from(iter_xyz_frames(lines), ({ start }) => start);
+        this.xyz_cache = { data, lines, frame_starts };
+        return this.xyz_cache;
+    }
+    load_xyz_frame(data, frame_number) {
+        const { lines, frame_starts } = this.get_xyz_cache(data);
+        const start = frame_starts[frame_number];
+        if (start === undefined)
+            return null; // out-of-range frame
+        const num_atoms = Math.trunc(Number(lines[start]?.trim()));
+        const comment = lines[start + 1] ?? ``;
+        return build_xyz_frame(lines, { start, num_atoms, comment }, {
+            frame_label: `indexed frame ${frame_number}`,
+            default_step: frame_number,
+        });
     }
     load_ase_frame(data, frame_number) {
         try {

package/dist/trajectory/helpers.d.ts

@@ -5,6 +5,7 @@ import type { Pbc } from '../structure/pbc';
 import type { TrajectoryFrame } from './index';
 export declare function validate_3x3_matrix(data: unknown): math.Matrix3x3;
 export declare const convert_atomic_numbers: (numbers: number[]) => ElementSymbol[];
+export declare const count_elements: (elements: readonly string[]) => Record<string, number>;
 export declare const create_structure: (positions: number[][], elements: ElementSymbol[], lattice_matrix?: math.Matrix3x3, pbc?: Pbc, force_data?: number[][]) => AnyStructure;
 export declare const create_trajectory_frame: (positions: number[][], elements: ElementSymbol[], lattice_matrix: math.Matrix3x3 | undefined, pbc: Pbc | undefined, step: number, metadata?: Record<string, unknown>) => TrajectoryFrame;
 export declare const read_ndarray_from_view: (view: DataView, ref: {
@@ -15,6 +16,7 @@ export declare function calc_force_stats(forces: number[][]): {
     force_max: number;
     force_norm: number;
 } | null;
+export declare const is_xyz_atom_line: (parts: string[] | undefined) => boolean;
 export declare function iter_xyz_frames(lines: string[]): Generator<{
     start: number;
     num_atoms: number;

package/dist/trajectory/helpers.js

@@ -1,6 +1,6 @@
 // Shared utilities for trajectory parsing
 import { ATOMIC_NUMBER_TO_SYMBOL } from '../composition/parse';
-import { is_elem_symbol } from '../element';
+import { is_elem_symbol } from '../element/helpers';
 import * as math from '../math';
 import { make_site } from '../structure/site';
 const is_valid_row = (row) => {
@@ -27,6 +27,13 @@ export const convert_atomic_numbers = (numbers) => numbers.map((num) => {
     }
     return symbol;
 });
+// Tally per-element atom counts for trajectory metadata.element_counts
+export const count_elements = (elements) => {
+    const counts = {};
+    for (const element of elements)
+        counts[element] = (counts[element] || 0) + 1;
+    return counts;
+};
 export const create_structure = (positions, elements, lattice_matrix, pbc, force_data) => {
     if (positions.length !== elements.length) {
         throw new Error(`create_structure requires matching positions and elements lengths, got positions=${positions.length}, elements=${elements.length}`);
@@ -141,6 +148,14 @@ export function calc_force_stats(forces) {
     return { force_max, force_norm: Math.sqrt(sum_sq / forces.length) };
 }
 // Walk concatenated (ext)XYZ frames in `lines`, yielding each frame's atom-count line
+// True when a whitespace-split line looks like an XYZ atom line: a short
+// non-numeric element token followed by three numeric coordinates. Shared by
+// trajectory frame iteration and structure-format sniffing so both stay in sync.
+export const is_xyz_atom_line = (parts) => parts !== undefined &&
+    parts.length >= 4 &&
+    isNaN(Number(parts[0])) &&
+    parts[0].length <= 3 &&
+    parts.slice(1, 4).every((coord) => coord !== `` && !isNaN(Number(coord)));
 // index, parsed atom count, and comment line. A candidate frame is accepted only when its
 // first few atom lines look like "<element> <x> <y> <z>"; otherwise we advance one line and
 // rescan. That validation doubles as content sniffing so numeric-leading non-XYZ formats
@@ -149,7 +164,7 @@ export function calc_force_stats(forces) {
 export function* iter_xyz_frames(lines) {
     let line_idx = 0;
     while (line_idx < lines.length) {
-        const num_atoms = parseInt(lines[line_idx]?.trim(), 10);
+        const num_atoms = Math.trunc(Number(lines[line_idx]?.trim()));
         if (isNaN(num_atoms) || num_atoms <= 0 || line_idx + num_atoms + 2 > lines.length) {
             line_idx++; // skip blank/invalid lines until the next frame's atom-count line
             continue;
@@ -157,11 +172,7 @@ export function* iter_xyz_frames(lines) {
         let valid_coords = 0;
         const sample = Math.min(num_atoms, 3);
         for (let idx = 0; idx < sample; idx++) {
-            const parts = lines[line_idx + 2 + idx]?.trim().split(/\s+/);
-            if (parts?.length >= 4 &&
-                isNaN(parseInt(parts[0], 10)) &&
-                parts[0].length <= 3 &&
-                parts.slice(1, 4).every((coord) => !isNaN(parseFloat(coord))))
+            if (is_xyz_atom_line(lines[line_idx + 2 + idx]?.trim().split(/\s+/)))
                 valid_coords++;
         }
         if (valid_coords < sample) {

package/dist/trajectory/index.d.ts

@@ -7,6 +7,7 @@ export { default as TrajectoryExportPane } from './TrajectoryExportPane.svelte';
 export { default as TrajectoryInfoPane } from './TrajectoryInfoPane.svelte';
 export type TrajectoryFormat = `hdf5` | `json` | `xyz` | `xdatcar` | `traj` | `unknown`;
 export type { AtomTypeMapping } from './types';
+export declare const FRAME_LOAD_DEBOUNCE_MS = 75;
 export interface ParseProgress {
     current: number;
     total: number;

package/dist/trajectory/index.js

@@ -2,6 +2,9 @@ export { default as Trajectory } from './Trajectory.svelte';
 export { default as TrajectoryError } from './TrajectoryError.svelte';
 export { default as TrajectoryExportPane } from './TrajectoryExportPane.svelte';
 export { default as TrajectoryInfoPane } from './TrajectoryInfoPane.svelte';
+// Debounce for on-demand frame loads while scrubbing: skips fetches for steps
+// the user slides past. Exported so tests stay in sync with the real delay.
+export const FRAME_LOAD_DEBOUNCE_MS = 75;
 export function validate_trajectory(trajectory) {
     // with detailed error reporting
     const errors = [];

package/dist/trajectory/parse/h5-utils.d.ts

@@ -0,0 +1,13 @@
+import type { ElementSymbol } from '../../element/types';
+import type { Matrix3x3 } from '../../math';
+import type { Dataset, Entity, Group } from 'h5wasm';
+import * as h5wasm from 'h5wasm';
+export declare const is_hdf5_dataset: (entity: Entity | null) => entity is Dataset;
+export declare const is_hdf5_group: (entity: Entity | null) => entity is Group;
+export declare const read_dataset: (h5_file: h5wasm.File, path: string) => unknown;
+export declare const to_string_array: (data: unknown) => string[] | null;
+export declare const to_number_array: (data: unknown) => number[] | null;
+export declare const to_scalar_number: (data: unknown) => number | null;
+export declare const scale_matrix: (matrix: Matrix3x3, scale: number) => Matrix3x3;
+export declare const expand_ion_types: (ion_types: string[], ion_counts: number[]) => ElementSymbol[];
+export declare function with_h5_file<T>(buffer: ArrayBuffer, filename: string | undefined, callback: (h5_file: h5wasm.File) => T | Promise<T>): Promise<T>;

package/dist/trajectory/parse/h5-utils.js

@@ -0,0 +1,109 @@
+// Shared h5wasm plumbing for HDF5 trajectory parsers: type guards plus the
+// write-to-in-memory-FS/open/cleanup lifecycle both torch-sim and vaspout
+// parsing need (the FS write is the expensive part, so parsers share one open
+// file handle instead of re-opening per format probe).
+import { is_elem_symbol } from '../../element/helpers';
+import * as h5wasm from 'h5wasm';
+export const is_hdf5_dataset = (entity) => entity !== null && `to_array` in entity && entity instanceof h5wasm.Dataset;
+export const is_hdf5_group = (entity) => entity !== null && `keys` in entity && entity instanceof h5wasm.Group;
+// Datasets in interrupted files can be torn mid-chunk, making to_array throw —
+// treat unreadable datasets like missing ones so callers keep what parsed so far.
+export const read_dataset = (h5_file, path) => {
+    try {
+        const entity = h5_file.get(path);
+        return is_hdf5_dataset(entity) ? entity.to_array() : null;
+    }
+    catch {
+        return null;
+    }
+};
+// h5wasm returns JS strings for variable-length UTF-8 but may hand back byte
+// arrays for fixed-length string datasets (like VASP's |S2 ion_types).
+export const to_string_array = (data) => {
+    if (!Array.isArray(data))
+        return null;
+    const decoder = new TextDecoder();
+    const strings = [];
+    for (const item of data) {
+        if (typeof item === `string`)
+            strings.push(item.trim());
+        else if (item instanceof Uint8Array)
+            strings.push(decoder.decode(item).trim());
+        else
+            return null;
+    }
+    return strings;
+};
+// Integer datasets (like int64 number_ion_types) can surface as BigInt
+// values or typed arrays depending on dtype; normalize to plain numbers.
+export const to_number_array = (data) => {
+    const values = Array.isArray(data)
+        ? data
+        : ArrayBuffer.isView(data)
+            ? Array.from(data)
+            : null;
+    if (!values)
+        return null;
+    const numbers = values.map((item) => (typeof item === `bigint` ? Number(item) : item));
+    return numbers.every((item) => typeof item === `number` && Number.isFinite(item))
+        ? numbers
+        : null;
+};
+// Scalar datasets surface as plain numbers, 1-element arrays, or BigInt
+// depending on dtype; normalize to a finite number or null.
+export const to_scalar_number = (data) => {
+    const value = Array.isArray(data) ? data[0] : data;
+    if (typeof value === `bigint`)
+        return Number(value);
+    return typeof value === `number` && Number.isFinite(value) ? value : null;
+};
+// Apply VASP's POSCAR-style universal scaling factor to lattice vectors
+export const scale_matrix = (matrix, scale) => scale === 1 ? matrix : matrix.map((row) => row.map((val) => val * scale));
+// Expand VASP's (ion_types, number_ion_types) pair into per-atom symbols,
+// e.g. ([Ga, Sb], [1, 1]) -> [Ga, Sb]. Throws on unknown symbols and
+// malformed counts so torn/corrupt HDF5 input fails loudly, not by dropping atoms.
+export const expand_ion_types = (ion_types, ion_counts) => {
+    if (ion_types.length !== ion_counts.length) {
+        throw new Error(`ion_types (${ion_types.length}) and ion_counts (${ion_counts.length}) length mismatch`);
+    }
+    const elements = [];
+    for (const [type_idx, symbol] of ion_types.entries()) {
+        if (!is_elem_symbol(symbol)) {
+            throw new Error(`Unknown element symbol in ion_types: ${symbol}`);
+        }
+        const ion_count = ion_counts[type_idx];
+        if (!Number.isFinite(ion_count) || !Number.isInteger(ion_count) || ion_count < 0) {
+            throw new Error(`Invalid ion count for ${symbol}: ${ion_count}`);
+        }
+        for (let count = 0; count < ion_count; count++)
+            elements.push(symbol);
+    }
+    return elements;
+};
+// Writes the buffer to h5wasm's in-memory FS under a unique temp name, opens
+// it, runs the callback (awaiting async ones so cleanup can't race reads),
+// and always closes + unlinks afterwards.
+export async function with_h5_file(buffer, filename, callback) {
+    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`);
+        return await callback(h5_file);
+    }
+    finally {
+        h5_file?.close();
+        try {
+            FS.unlink(temp_filename);
+        }
+        catch {
+            /* temp file cleanup is best-effort */
+        }
+    }
+}

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

@@ -1,2 +1,2 @@
 import type { TrajectoryType } from '../index';
-export declare function parse_torch_sim_hdf5(buffer: ArrayBuffer, filename?: string): Promise<TrajectoryType>;
+export declare function parse_hdf5_trajectory(buffer: ArrayBuffer, filename?: string): Promise<TrajectoryType>;

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 { 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>;