matterviz 0.3.7 → 0.4.1

package/dist/trajectory/helpers.js

@@ -1,16 +1,14 @@
 // Shared utilities for trajectory parsing
 import { ATOMIC_NUMBER_TO_SYMBOL } from '../composition/parse';
-import { ELEM_SYMBOLS } from '../labels';
+import { is_elem_symbol } from '../element';
 import * as math from '../math';
-const element_symbol_set = new Set(ELEM_SYMBOLS);
+import { make_site } from '../structure/site';
 const is_valid_row = (row) => {
     if (!(Array.isArray(row) || (ArrayBuffer.isView(row) && `length` in row)))
         return false;
     return math.is_finite_vec3_like(row);
 };
 const is_valid_vec3 = (coords) => Array.isArray(coords) && math.is_finite_vec3_like(coords);
-export const is_valid_element_symbol = (symbol) => element_symbol_set.has(symbol);
-export const coerce_element_symbol = (symbol) => is_valid_element_symbol(symbol) ? symbol : undefined;
 // Validate that data is a proper 3x3 matrix
 // Accepts both regular arrays and typed arrays (Float32Array, Float64Array, etc.)
 export function validate_3x3_matrix(data) {
@@ -24,7 +22,7 @@ export function validate_3x3_matrix(data) {
 }
 export const convert_atomic_numbers = (numbers) => numbers.map((num) => {
     const symbol = ATOMIC_NUMBER_TO_SYMBOL[num];
-    if (!symbol || !is_valid_element_symbol(symbol)) {
+    if (!symbol || !is_elem_symbol(symbol)) {
         throw new Error(`Unknown atomic number in trajectory data: ${num}`);
     }
     return symbol;
@@ -42,13 +40,7 @@ export const create_structure = (positions, elements, lattice_matrix, pbc, force
         const abc = cart_to_frac ? cart_to_frac(xyz) : [0, 0, 0];
         const force = force_data?.[idx];
         const properties = is_valid_vec3(force) ? { force } : {};
-        return {
-            species: [{ element: elements[idx], occu: 1, oxidation_state: 0 }],
-            abc,
-            xyz,
-            label: `${elements[idx]}${idx + 1}`,
-            properties,
-        };
+        return make_site(elements[idx], abc, xyz, `${elements[idx]}${idx + 1}`, properties);
     });
     return lattice_matrix
         ? {
@@ -126,39 +118,67 @@ export const read_ndarray_from_view = (view, ref) => {
                 throw new Error(`Unsupported shape`);
             })();
 };
-// Unified frame counting for XYZ
-export function count_xyz_frames(data) {
-    if (!data || typeof data !== `string`)
-        return 0;
-    const lines = data.trim().split(/\r?\n/);
-    let frame_count = 0;
+// Copy listed fields from source to target when they hold numbers
+export const copy_numeric_fields = (target, source, fields) => {
+    for (const field of fields) {
+        if (field in source && typeof source[field] === `number`)
+            target[field] = source[field];
+    }
+};
+// Max and RMS of per-atom force magnitudes, or null when no forces present. Loop-based
+// rather than Math.max(...spread) to avoid call-stack overflow on very large frames.
+export function calc_force_stats(forces) {
+    if (forces.length === 0)
+        return null;
+    let force_max = -Infinity;
+    let sum_sq = 0;
+    for (const force of forces) {
+        const magnitude = Math.hypot(...force);
+        if (magnitude > force_max)
+            force_max = magnitude;
+        sum_sq += magnitude ** 2;
+    }
+    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
+// 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
+// (e.g. VASP XDATCAR) aren't misread as frames, and keeps count_xyz_frames consistent with
+// the actual parse/index walk (both go through this single source of truth).
+export function* iter_xyz_frames(lines) {
     let line_idx = 0;
     while (line_idx < lines.length) {
-        if (!lines[line_idx]?.trim()) {
-            line_idx++;
-            continue;
-        }
-        const num_atoms = parseInt(lines[line_idx].trim(), 10);
+        const num_atoms = parseInt(lines[line_idx]?.trim(), 10);
         if (isNaN(num_atoms) || num_atoms <= 0 || line_idx + num_atoms + 2 > lines.length) {
-            line_idx++;
+            line_idx++; // skip blank/invalid lines until the next frame's atom-count line
             continue;
         }
-        // Quick validation of first few atom lines
         let valid_coords = 0;
-        for (let idx = 0; idx < Math.min(num_atoms, 3); idx++) {
+        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])) && parts[0].length <= 3) {
-                if (parts.slice(1, 4).every((coord) => !isNaN(parseFloat(coord))))
-                    valid_coords++;
-            }
-        }
-        if (valid_coords >= Math.min(num_atoms, 3)) {
-            frame_count++;
-            line_idx += 2 + num_atoms;
+            if (parts?.length >= 4 &&
+                isNaN(parseInt(parts[0], 10)) &&
+                parts[0].length <= 3 &&
+                parts.slice(1, 4).every((coord) => !isNaN(parseFloat(coord))))
+                valid_coords++;
         }
-        else {
-            line_idx++;
+        if (valid_coords < sample) {
+            line_idx++; // count line looks valid but atom lines don't — likely non-XYZ content
+            continue;
         }
+        yield { start: line_idx, num_atoms, comment: lines[line_idx + 1] || `` };
+        line_idx += num_atoms + 2;
     }
+}
+// Count XYZ frames via iter_xyz_frames so total_frames matches what gets indexed/loaded
+export function count_xyz_frames(data) {
+    if (!data || typeof data !== `string`)
+        return 0;
+    const frames = iter_xyz_frames(data.trim().split(/\r?\n/));
+    let frame_count = 0;
+    while (!frames.next().done)
+        frame_count += 1;
     return frame_count;
 }

package/dist/trajectory/index.js

@@ -77,7 +77,7 @@ export function validate_trajectory(trajectory) {
 }
 export function get_trajectory_stats(trajectory) {
     const { frames, total_frames, indexed_frames, plot_metadata } = trajectory;
-    const frame_count = total_frames || frames.length;
+    const frame_count = total_frames ?? frames.length;
     const stats = {
         frame_count,
         is_indexed: trajectory.is_indexed ?? false,

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

@@ -1,2 +1,10 @@
-import type { TrajectoryType } from '../index';
+import type { TrajectoryFrame, TrajectoryType } from '../index';
+export declare const read_ase_header: (view: DataView) => {
+    n_items: number;
+    offsets_pos: number;
+};
+export declare function decode_ase_frame(view: DataView, buffer: ArrayBuffer, frame_offset: number, step: number, fallback_numbers?: number[], max_json_length?: number): {
+    frame: TrajectoryFrame;
+    numbers: number[];
+};
 export declare function parse_ase_trajectory(buffer: ArrayBuffer, filename?: string): TrajectoryType;

package/dist/trajectory/parse/ase.js

@@ -1,18 +1,55 @@
 // ASE trajectory (.traj) parsing - binary format
+import * as math from '../../math';
 import { MAX_SAFE_STRING_LENGTH } from '../constants';
 import { convert_atomic_numbers, create_trajectory_frame, read_ndarray_from_view, validate_3x3_matrix, } from '../helpers';
+// ULM header: frame count lives at byte 32, frame-offsets table position at byte 40
+export const read_ase_header = (view) => ({
+    n_items: Number(view.getBigInt64(32, true)),
+    offsets_pos: Number(view.getBigInt64(40, true)),
+});
+// Decode a single ASE/ULM frame (JSON header + optional ndarray payloads) into a
+// TrajectoryFrame. Returns the atomic numbers actually used so callers can cache them
+// as fallback for later frames that omit `numbers` (ASE stores them only once).
+export function decode_ase_frame(view, buffer, frame_offset, step, fallback_numbers, max_json_length) {
+    const json_length = Number(view.getBigInt64(frame_offset, true));
+    if (max_json_length !== undefined && json_length > max_json_length) {
+        throw new Error(`frame JSON too large: ${json_length} bytes`);
+    }
+    const frame_data = JSON.parse(new TextDecoder().decode(new Uint8Array(buffer, frame_offset + 8, json_length)));
+    const positions_ref = frame_data[`positions.`] ?? frame_data.positions;
+    const positions = positions_ref?.ndarray
+        ? read_ndarray_from_view(view, positions_ref)
+        : positions_ref;
+    const numbers_ref = frame_data[`numbers.`] ?? frame_data.numbers ?? fallback_numbers;
+    const numbers = numbers_ref?.ndarray
+        ? read_ndarray_from_view(view, numbers_ref).flat()
+        : numbers_ref;
+    if (!numbers || !positions) {
+        throw new Error(`missing ${!numbers ? `numbers` : `positions`}`);
+    }
+    const cell = frame_data.cell ? validate_3x3_matrix(frame_data.cell) : undefined;
+    const metadata = {
+        step,
+        ...frame_data.calculator,
+        ...frame_data.info,
+    };
+    if (cell) {
+        try {
+            metadata.volume = Math.abs(math.det_3x3(cell));
+        }
+        catch (error) {
+            console.warn(`Failed to calculate volume for frame ${step}:`, error);
+        }
+    }
+    const frame = create_trajectory_frame(positions, convert_atomic_numbers(numbers), cell, frame_data.pbc ?? [true, true, true], step, metadata);
+    return { frame, numbers };
+}
 export function parse_ase_trajectory(buffer, filename) {
     const view = new DataView(buffer);
-    let offset = 0;
     const signature = new TextDecoder().decode(new Uint8Array(buffer, 0, 8));
     if (signature !== `- of Ulm`)
         throw new Error(`Invalid ASE trajectory`);
-    offset += 24;
-    // Skip ASE/Ulm version field; current parsing logic is version-independent.
-    offset += 8;
-    const n_items = Number(view.getBigInt64(offset, true));
-    offset += 8;
-    const offsets_pos = Number(view.getBigInt64(offset, true));
+    const { n_items, offsets_pos } = read_ase_header(view);
     if (n_items <= 0)
         throw new Error(`Invalid frame count`);
     if (offsets_pos < 0 || offsets_pos + n_items * 8 > buffer.byteLength) {
@@ -23,31 +60,9 @@ export function parse_ase_trajectory(buffer, filename) {
     let global_numbers;
     for (let idx = 0; idx < n_items; idx++) {
         try {
-            offset = frame_offsets[idx];
-            const json_length = Number(view.getBigInt64(offset, true));
-            offset += 8;
-            if (json_length > MAX_SAFE_STRING_LENGTH) {
-                console.warn(`Skipping frame ${idx + 1}/${n_items}: too large`);
-                continue;
-            }
-            const frame_data = JSON.parse(new TextDecoder().decode(new Uint8Array(buffer, offset, json_length)));
-            const positions_ref = frame_data[`positions.`] ?? frame_data.positions;
-            const positions = positions_ref?.ndarray
-                ? read_ndarray_from_view(view, positions_ref)
-                : positions_ref;
-            const numbers_ref = frame_data[`numbers.`] ?? frame_data.numbers ?? global_numbers;
-            const numbers = numbers_ref?.ndarray
-                ? read_ndarray_from_view(view, numbers_ref).flat()
-                : numbers_ref;
-            if (numbers)
-                global_numbers = numbers;
-            if (!numbers || !positions) {
-                console.warn(`Skipping ASE frame ${idx + 1}/${n_items}: missing ${!numbers ? `numbers` : `positions`}`);
-                continue;
-            }
-            const elements = convert_atomic_numbers(numbers);
-            const metadata = { step: idx, ...frame_data.calculator, ...frame_data.info };
-            frames.push(create_trajectory_frame(positions, elements, frame_data.cell ? validate_3x3_matrix(frame_data.cell) : undefined, frame_data.pbc ?? [true, true, true], idx, metadata));
+            const { frame, numbers } = decode_ase_frame(view, buffer, frame_offsets[idx], idx, global_numbers, MAX_SAFE_STRING_LENGTH);
+            global_numbers = numbers;
+            frames.push(frame);
         }
         catch (error) {
             console.warn(`Error processing frame ${idx + 1}/${n_items}:`, error);

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

@@ -0,0 +1,3 @@
+export declare const get_traj_parse_warnings: () => string[];
+export declare const reset_traj_parse_warnings: () => void;
+export declare const traj_warn: (message: string, error?: unknown) => void;

package/dist/trajectory/parse/diagnostics.js

@@ -0,0 +1,14 @@
+import { to_error } from '../../utils';
+// Collector for non-fatal trajectory parse warnings (skipped atoms, dropped frames, plot-metadata extraction failures, ...) so they reach the UI not just the console. Reset at the start of each top-level parse call; format parsers append via traj_warn (mirrored to console.warn). Fatal failures throw — see parse_trajectory_data.
+let traj_parse_warnings = [];
+// Read-only snapshot of warnings since the last top-level parse (attached to trajectory metadata by parse/index.ts for UI surfacing)
+export const get_traj_parse_warnings = () => [...traj_parse_warnings];
+export const reset_traj_parse_warnings = () => void (traj_parse_warnings = []);
+export const traj_warn = (message, error) => {
+    const detail = error === undefined ? `` : `: ${to_error(error).message}`;
+    traj_parse_warnings.push(`${message}${detail}`);
+    if (error === undefined)
+        console.warn(message);
+    else
+        console.warn(`${message}:`, error);
+};

package/dist/trajectory/parse/hdf5.js

@@ -9,7 +9,7 @@ export async function parse_torch_sim_hdf5(buffer, filename) {
     const file_basename = filename
         ?.split(`/`)
         .at(-1)
-        ?.replace(/[^\w.-]/g, `_`) || `temp`;
+        ?.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));

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

@@ -2,7 +2,7 @@ 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 declare function parse_trajectory_data(data: unknown, filename?: string, atom_type_mapping?: AtomTypeMapping): Promise<TrajectoryType>;

package/dist/trajectory/parse/index.js

@@ -1,21 +1,31 @@
+// 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 { FORMAT_PATTERNS, is_trajectory_file, strip_compression_extensions, } from '../format-detect';
+import { strip_compression_extensions } from '../../io';
+import { ext_hint, FORMAT_PATTERNS, is_trajectory_file } from '../format-detect';
 import { TrajFrameReader } from '../frame-reader';
-import { create_trajectory_frame, validate_3x3_matrix } from '../helpers';
+import { count_xyz_frames } from '../helpers';
 import { parse_ase_trajectory } from './ase';
+import { get_traj_parse_warnings, reset_traj_parse_warnings, traj_warn } from './diagnostics';
 import { parse_torch_sim_hdf5 } 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 { LARGE_FILE_THRESHOLD, MAX_BIN_FILE_SIZE, MAX_TEXT_FILE_SIZE, } from '../constants';
 export { is_trajectory_file, TrajFrameReader };
 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);
@@ -33,8 +43,10 @@ export async function parse_trajectory_data(data, filename, atom_type_mapping) {
         if (FORMAT_PATTERNS.lammpstrj(content, filename)) {
             return parse_lammps_trajectory(content, filename, atom_type_mapping);
         }
-        // Single XYZ fallback
-        if (filename?.toLowerCase().match(/\.(?:xyz|extxyz)$/)) {
+        // 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)$/);
+        if (xyz_hint || (xyz_hint === null && count_xyz_frames(content) === 1)) {
             try {
                 const structure = parse_xyz(content);
                 if (structure) {
@@ -44,127 +56,62 @@ export async function parse_trajectory_data(data, filename, atom_type_mapping) {
                     };
                 }
             }
-            catch (error) {
+            catch {
                 // Single-frame XYZ parsing failed, continue to JSON parsing.
-                log_parse_debug(`Single XYZ parse fallback failed for ${filename ?? `unknown file`}:`, error);
             }
         }
         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`;
         }
@@ -185,10 +132,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;
@@ -198,18 +155,21 @@ export async function parse_trajectory_async(data, filename, on_progress, option
             update_progress(5, `Large file detected (${Math.round(data_size / 1024 / 1024)}MB)`);
         }
         // Use indexed loading for supported large files (including compressed names).
+        // 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);
-        if (should_use_indexing && /\.(xyz|extxyz|traj)$/.test(base_filename)) {
-            return await parse_with_unified_loader(data, filename, {
-                index_sample_rate,
-                extract_plot_metadata,
-            }, on_progress);
+        const can_index = /\.(xyz|extxyz|traj)$/.test(base_filename) ||
+            (typeof data === `string` &&
+                ext_hint(filename, /\.(xyz|extxyz)$/) === null &&
+                count_xyz_frames(data.slice(0, 2 ** 20)) >= 1);
+        if (should_use_indexing && can_index) {
+            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`;
@@ -251,7 +211,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`;

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';
+import { 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));
@@ -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
@@ -125,9 +127,9 @@ 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;
                 }
             }
@@ -135,7 +137,7 @@ export function parse_lammps_trajectory(content, filename, atom_type_mapping) {
                 const atom_id = parseInt(parts[id_col], 10) || 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);

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;