matterviz 0.4.2 → 0.4.3

package/dist/trajectory/TrajectoryInfoPane.svelte

@@ -8,11 +8,12 @@
   import { SETTINGS_CONFIG } from '../settings'
   import type { AnyStructure } from '../structure'
   import type { ComponentProps } from 'svelte'
-  import type { TrajectoryType } from './index'
+  import type { TrajectoryFrame, TrajectoryType } from './index'
 
   let {
     trajectory,
     current_step_idx,
+    current_frame = null,
     current_filename,
     current_file_path,
     file_size,
@@ -24,6 +25,7 @@
   }: Omit<ComponentProps<typeof DraggablePane>, `children`> & {
     trajectory: TrajectoryType
     current_step_idx: number
+    current_frame?: TrajectoryFrame | null
     current_filename?: string | null
     current_file_path?: string | null
     file_size?: number | null
@@ -76,14 +78,18 @@
     )
       return []
 
-    // For indexed trajectories, we might not have the current frame loaded
-    const current_frame = trajectory.frames?.[current_step_idx]
+    // For indexed trajectories, the resolved frame may live outside sparse frame arrays.
+    const displayed_frame = current_frame ?? trajectory.frames?.[current_step_idx]
     const total_frames = trajectory.total_frames ?? trajectory.frames?.length ?? 0
 
     const sections: { title: string; items: InfoItem[] }[] = []
+    // Append a section unless every item filtered out as falsy
+    const push_section = (title: string, items: unknown[]) => {
+      const valid_items = items.filter(is_info_item)
+      if (valid_items.length > 0) sections.push({ title, items: valid_items })
+    }
 
-    // File info section
-    const file_items = [
+    push_section(`File`, [
       current_filename &&
         safe_item(`Name`, current_filename, `file-name`, current_file_path || undefined),
       file_size &&
@@ -97,14 +103,9 @@
         ),
       trajectory.metadata?.source_format &&
         safe_item(`Format`, String(trajectory.metadata.source_format), `file-format`),
-    ].filter(is_info_item)
-
-    if (file_items.length > 0) {
-      sections.push({ title: `File`, items: file_items })
-    }
+    ])
 
-    // Trajectory info section (always show this)
-    const traj_items = [
+    push_section(`Trajectory`, [
       safe_item(
         `Total Frames`,
         `${format_num(total_frames, `.3~s`)} (current: ${format_num(
@@ -134,20 +135,16 @@
           `plot-metadata`,
           `Pre-extracted metadata for plotting`,
         ),
-    ].filter(is_info_item)
-
-    if (traj_items.length > 0) {
-      sections.push({ title: `Trajectory`, items: traj_items })
-    }
+    ])
 
     // Structure info section (only if we have the current frame)
-    if (current_frame?.structure?.sites) {
-      const { structure } = current_frame
+    if (displayed_frame?.structure?.sites) {
+      const { structure } = displayed_frame
       const lattice = `lattice` in structure ? structure.lattice : null
       const { volume, a, b, c, alpha, beta, gamma } = lattice || {}
       const formula = safe_formula(structure)
 
-      const structure_items = [
+      push_section(`Structure`, [
         safe_item(`Atoms`, `${structure.sites.length}`, `atoms`),
         formula && safe_item(`Formula`, String(formula), `formula`),
         is_valid_number(volume) &&
@@ -158,7 +155,7 @@
           structure.sites.length > 0 &&
           safe_item(
             `Density`,
-            `${format_num(structure.sites.length / volume, `.4~s`)} atoms/ų`,
+            `${format_num(structure.sites.length / volume, `.3~s`)} atoms/ų`,
             `density`,
           ),
         [a, b, c].every(is_valid_number) &&
@@ -179,77 +176,59 @@
             )}°, ${format_num(gamma as number, `.2~f`)}°`,
             `cell-angles`,
           ),
-      ].filter(is_info_item)
-
-      if (structure_items.length > 0) {
-        sections.push({ title: `Structure`, items: structure_items })
-      }
+      ])
     } else if (trajectory.is_indexed) {
       // For indexed trajectories, show a note that frame data is loaded on demand
-      const structure_items = [
+      push_section(`Structure`, [
         safe_item(
           `Frame Loading`,
           `On-demand`,
           `frame-loading`,
           `Structure data loaded when frame is accessed`,
         ),
-      ].filter(is_info_item)
-
-      if (structure_items.length > 0) {
-        sections.push({ title: `Structure`, items: structure_items })
-      }
-    }
-
-    // Energy section (only for regular trajectories with multiple frames)
-    if (!trajectory.is_indexed && trajectory.frames.length > 1) {
-      const energies = extract_numeric_array(trajectory.frames, `energy`)
-      if (energies.length > 1) {
-        const current_energy = current_frame?.metadata?.energy
-        const energy_range = format_range(energies, `eV`, `.3~s`)
-
-        const energy_items = [
-          is_valid_number(current_energy) &&
-            safe_item(
-              `Current Energy`,
-              `${format_num(current_energy, `.3~s`)} eV`,
-              `energy-current`,
-            ),
-          energy_range && safe_item(`Energy Range`, energy_range, `energy-range`),
-        ].filter(is_info_item)
-
-        if (energy_items.length > 0) {
-          sections.push({ title: `Energy`, items: energy_items })
-        }
-      }
+      ])
     }
 
-    // Forces section (only for regular trajectories with multiple frames)
+    // Energy/Forces sections (only for regular trajectories with multiple frames)
     if (!trajectory.is_indexed && trajectory.frames.length > 1) {
-      const forces = extract_numeric_array(trajectory.frames, `force_max`)
-      if (forces.length > 1) {
-        const current_force = current_frame?.metadata?.force_max
-        const force_range = format_range(forces, `eV/Å`, `.3~s`)
-
-        const force_items = [
-          is_valid_number(current_force) &&
+      const range_sections = [
+        {
+          title: `Energy`,
+          prop: `energy`,
+          unit: `eV`,
+          key: `energy`,
+          current_label: `Current Energy`,
+          range_label: `Energy Range`,
+        },
+        {
+          title: `Forces`,
+          prop: `force_max`,
+          unit: `eV/Å`,
+          key: `force`,
+          current_label: `Max Force`,
+          range_label: `Force Range`,
+        },
+      ] as const
+      for (const { title, prop, unit, key, current_label, range_label } of range_sections) {
+        const values = extract_numeric_array(trajectory.frames, prop)
+        if (values.length <= 1) continue
+        const current = displayed_frame?.metadata?.[prop]
+        push_section(title, [
+          is_valid_number(current) &&
             safe_item(
-              `Max Force`,
-              `${format_num(current_force, `.3~s`)} eV/Å`,
-              `force-current`,
+              current_label,
+              `${format_num(current, `.3~s`)} ${unit}`,
+              `${key}-current`,
             ),
-          force_range && safe_item(`Force Range`, force_range, `force-range`),
-        ].filter(is_info_item)
-
-        if (force_items.length > 0) {
-          sections.push({ title: `Forces`, items: force_items })
-        }
+          safe_item(range_label, format_range(values, unit, `.3~s`), `${key}-range`),
+        ])
       }
     }
 
     // Volume change section (only for regular trajectories)
-    if (!trajectory.is_indexed && current_frame?.structure && trajectory.frames.length > 1) {
+    if (!trajectory.is_indexed && displayed_frame?.structure && trajectory.frames.length > 1) {
       const lattice =
-        `lattice` in current_frame.structure ? current_frame.structure.lattice : null
+        `lattice` in displayed_frame.structure ? displayed_frame.structure.lattice : null
       if (lattice) {
         const volumes = trajectory.frames
           .map(({ structure }) => `lattice` in structure && structure.lattice?.volume)
@@ -260,13 +239,9 @@
           const vol_change =
             (Math.max(...volumes) - Math.min(...volumes)) / Math.min(...volumes)
           if (Math.abs(vol_change) > 0.1 && is_valid_number(vol_change)) {
-            const vol_items = [
+            push_section(`Volume`, [
               safe_item(`Volume Change`, `${format_num(vol_change, `.2~%`)}`, `vol-change`),
-            ].filter(is_info_item)
-
-            if (vol_items.length > 0) {
-              sections.push({ title: `Volume`, items: vol_items })
-            }
+            ])
           }
         }
       }

package/dist/trajectory/TrajectoryInfoPane.svelte.d.ts

@@ -1,10 +1,11 @@
 import type { PaneProps, PaneToggleProps } from '../overlays';
 import DraggablePane from '../overlays/DraggablePane.svelte';
 import type { ComponentProps } from 'svelte';
-import type { TrajectoryType } from './index';
+import type { TrajectoryFrame, TrajectoryType } from './index';
 type $$ComponentProps = Omit<ComponentProps<typeof DraggablePane>, `children`> & {
     trajectory: TrajectoryType;
     current_step_idx: number;
+    current_frame?: TrajectoryFrame | null;
     current_filename?: string | null;
     current_file_path?: string | null;
     file_size?: number | null;

package/dist/trajectory/extract.js

@@ -1,23 +1,21 @@
 // Data extraction functions for trajectory analysis and plotting
 import { get_density } from '../structure/index';
 import { calc_force_stats, copy_numeric_fields } from './helpers';
-// Common data extractor that extracts energy and structural properties
-export const energy_data_extractor = (frame) => {
-    const data = {
-        Step: frame.step,
-    };
-    if (frame.metadata) {
-        // Extract energy-related properties
-        copy_numeric_fields(data, frame.metadata, [
-            `energy`,
-            `energy_per_atom`,
-            `potential_energy`,
-            `kinetic_energy`,
-            `total_energy`,
-        ]);
-    }
+// Build an extractor that copies the listed numeric metadata fields (plus Step)
+const make_metadata_extractor = (fields) => (frame) => {
+    const data = { Step: frame.step };
+    if (frame.metadata)
+        copy_numeric_fields(data, frame.metadata, fields);
     return data;
 };
+// Common data extractor that extracts energy-related properties
+export const energy_data_extractor = make_metadata_extractor([
+    `energy`,
+    `energy_per_atom`,
+    `potential_energy`,
+    `kinetic_energy`,
+    `total_energy`,
+]);
 // Data extractor for forces and stresses
 export const force_stress_data_extractor = (frame) => {
     const data = {
@@ -55,20 +53,12 @@ export const force_stress_data_extractor = (frame) => {
 // Data extractor for SCF/electronic-convergence properties. Parsers emit these
 // per frame (per ionic step, or per SCF step for static single-point runs) —
 // e.g. the vaspout.h5 parser fills them from VASP's OSZICAR data.
-const scf_data_extractor = (frame) => {
-    const data = {
-        Step: frame.step,
-    };
-    if (frame.metadata) {
-        copy_numeric_fields(data, frame.metadata, [
-            `n_scf_steps`,
-            `scf_energy_delta`,
-            `scf_rms`,
-            `scf_charge_rms`,
-        ]);
-    }
-    return data;
-};
+const scf_data_extractor = make_metadata_extractor([
+    `n_scf_steps`,
+    `scf_energy_delta`,
+    `scf_rms`,
+    `scf_charge_rms`,
+]);
 // Data extractor for structural properties
 export const structural_data_extractor = (frame) => {
     const data = {

package/dist/trajectory/format-detect.d.ts

@@ -1,4 +1,6 @@
 export declare function ext_hint(filename: string | undefined, ext_regex: RegExp): boolean | null;
+export declare const indexed_trajectory_format: (filename: string) => `ase` | `xyz`;
+export declare const is_indexable_trajectory_filename: (filename: string) => boolean;
 export declare const FORMAT_PATTERNS: {
     readonly ase: (data: unknown, filename?: string) => boolean;
     readonly hdf5: (data: unknown, filename?: string) => boolean;

package/dist/trajectory/format-detect.js

@@ -1,5 +1,5 @@
 // Format detection for trajectory files
-import { CONFIG_DIRS_REGEX, MD_SIM_EXCLUDE_REGEX, TRAJ_EXTENSIONS_REGEX, TRAJ_FALLBACK_EXTENSIONS_REGEX, TRAJ_KEYWORDS_SIMPLE_REGEX, XDATCAR_REGEX, } from '../constants';
+import { CONFIG_DIRS_REGEX, MD_SIM_EXCLUDE_REGEX, TRAJ_EXTENSIONS_REGEX, TRAJ_FALLBACK_EXTENSIONS_REGEX, TRAJ_KEYWORDS_REGEX, XDATCAR_REGEX, } from '../constants';
 import { strip_compression_extensions } from '../io/decompress';
 import { parse_leading_num } from '../utils';
 import { count_xyz_frames } from './helpers';
@@ -18,6 +18,9 @@ export function ext_hint(filename, ext_regex) {
         return true;
     return KNOWN_FORMAT_EXT_REGEX.test(base) ? false : null;
 }
+// Large-file frame indexing currently supports text XYZ/EXTXYZ and binary ASE .traj.
+export const indexed_trajectory_format = (filename) => strip_compression_extensions(filename).endsWith(`.traj`) ? `ase` : `xyz`;
+export const is_indexable_trajectory_filename = (filename) => /\.(?:xyz|extxyz|traj)$/i.test(strip_compression_extensions(filename));
 // Unified format detection. Each pattern trusts a matching file extension when present
 // but falls back to content/magic-byte detection when the filename gives no hint
 // (e.g. blob: object URLs, extensionless API endpoints).
@@ -67,7 +70,7 @@ export function is_trajectory_file(filename, content) {
     if (/\.(?:xyz|extxyz)$/i.test(base_name)) {
         if (content)
             return count_xyz_frames(content) >= 2;
-        return TRAJ_KEYWORDS_SIMPLE_REGEX.test(base_name);
+        return TRAJ_KEYWORDS_REGEX.test(base_name);
     }
     // Always detect these specific trajectory formats
     if (TRAJ_EXTENSIONS_REGEX.test(base_name) || XDATCAR_REGEX.test(base_name))
@@ -78,9 +81,8 @@ export function is_trajectory_file(filename, content) {
     // For .h5/.hdf5 files, require trajectory keywords. vaspout.h5 (VASP's
     // HDF5 output) is always trajectory-shaped regardless of keywords.
     if (/\.(?:h5|hdf5)$/i.test(base_name)) {
-        return /vaspout/i.test(base_name) || TRAJ_KEYWORDS_SIMPLE_REGEX.test(base_name);
+        return /vaspout/i.test(base_name) || TRAJ_KEYWORDS_REGEX.test(base_name);
     }
     // For other extensions, require both keywords and specific extensions
-    return (TRAJ_KEYWORDS_SIMPLE_REGEX.test(base_name) &&
-        TRAJ_FALLBACK_EXTENSIONS_REGEX.test(base_name));
+    return TRAJ_KEYWORDS_REGEX.test(base_name) && TRAJ_FALLBACK_EXTENSIONS_REGEX.test(base_name);
 }

package/dist/trajectory/frame-reader.js

@@ -1,10 +1,10 @@
 // Unified frame loader for XYZ and ASE trajectories (large file indexing)
 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/decompress';
+import { indexed_trajectory_format } from './format-detect';
 import { decode_ase_frame, read_ase_header } from './parse/ase';
 import { build_xyz_frame, parse_xyz_comment_metadata } from './parse/xyz';
+const MAX_METADATA_SIZE = 50 * 1024 * 1024; // 50MB limit for metadata
 // Restrict frame metadata to the requested property keys (no-op when unset)
 const filter_properties = (metadata, properties) => {
     if (!properties)
@@ -18,8 +18,7 @@ export class TrajFrameReader {
     // 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`;
+        this.format = indexed_trajectory_format(filename);
     }
     async get_total_frames(data) {
         if (this.format === `xyz`) {

package/dist/trajectory/helpers.js

@@ -3,11 +3,6 @@ import { ATOMIC_NUMBER_TO_SYMBOL } from '../composition/parse';
 import { is_elem_symbol } from '../element/helpers';
 import * as math from '../math';
 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);
 // Validate that data is a proper 3x3 matrix
 // Accepts both regular arrays and typed arrays (Float32Array, Float64Array, etc.)
@@ -15,7 +10,8 @@ export function validate_3x3_matrix(data) {
     if (!Array.isArray(data) || data.length !== 3) {
         throw new Error(`Expected 3x3 matrix, got array of length ${Array.isArray(data) ? data.length : `non-array`}`);
     }
-    if (!data.every(is_valid_row)) {
+    if (!data.every((row) => (Array.isArray(row) || (ArrayBuffer.isView(row) && `length` in row)) &&
+        math.is_finite_vec3_like(row))) {
         throw new Error(`Invalid 3x3 matrix structure`);
     }
     return data;
@@ -69,54 +65,25 @@ export const create_trajectory_frame = (positions, elements, lattice_matrix, pbc
 export const read_ndarray_from_view = (view, ref) => {
     const [shape, dtype, array_offset] = ref.ndarray;
     const total = shape.reduce((product, dim_size) => product * dim_size, 1);
-    const data = [];
-    let pos = array_offset;
     const readers = {
-        int64: {
-            bytes_per_element: 8,
-            read: () => {
-                const value = Number(view.getBigInt64(pos, true));
-                pos += 8;
-                return value;
-            },
-        },
-        int32: {
-            bytes_per_element: 4,
-            read: () => {
-                const value = view.getInt32(pos, true);
-                pos += 4;
-                return value;
-            },
-        },
-        float64: {
-            bytes_per_element: 8,
-            read: () => {
-                const value = view.getFloat64(pos, true);
-                pos += 8;
-                return value;
-            },
-        },
-        float32: {
-            bytes_per_element: 4,
-            read: () => {
-                const value = view.getFloat32(pos, true);
-                pos += 4;
-                return value;
-            },
-        },
+        int64: { bytes: 8, read: (pos) => Number(view.getBigInt64(pos, true)) },
+        int32: { bytes: 4, read: (pos) => view.getInt32(pos, true) },
+        float64: { bytes: 8, read: (pos) => view.getFloat64(pos, true) },
+        float32: { bytes: 4, read: (pos) => view.getFloat32(pos, true) },
     };
-    const reader_config = readers[dtype];
-    if (!reader_config)
+    const reader = readers[dtype];
+    if (!reader)
         throw new Error(`Unsupported dtype: ${dtype}`);
     if (!Number.isInteger(array_offset) || array_offset < 0) {
         throw new Error(`Invalid array_offset: expected non-negative integer, got ${array_offset}`);
     }
-    const bytes_needed = total * reader_config.bytes_per_element;
-    if (array_offset + bytes_needed > view.byteLength) {
+    if (array_offset + total * reader.bytes > view.byteLength) {
         throw new Error(`Out-of-bounds read: array_offset + bytesNeeded exceeds view.byteLength`);
     }
-    for (let idx = 0; idx < total; idx++)
-        data.push(reader_config.read());
+    const data = [];
+    for (let idx = 0; idx < total; idx++) {
+        data.push(reader.read(array_offset + idx * reader.bytes));
+    }
     return shape.length === 1
         ? [data]
         : shape.length === 2
@@ -147,7 +114,6 @@ 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.
@@ -156,7 +122,8 @@ export const is_xyz_atom_line = (parts) => parts !== undefined &&
     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
+// Walk concatenated (ext)XYZ frames in `lines`, yielding each frame's start 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
@@ -185,7 +152,7 @@ export function* iter_xyz_frames(lines) {
 }
 // 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`)
+    if (!data)
         return 0;
     const frames = iter_xyz_frames(data.trim().split(/\r?\n/));
     let frame_count = 0;

package/dist/trajectory/index.js

@@ -6,7 +6,6 @@ export { default as TrajectoryInfoPane } from './TrajectoryInfoPane.svelte';
 // 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 = [];
     const { frames, total_frames, indexed_frames, plot_metadata, is_indexed } = trajectory;
     if (!frames?.length)
@@ -113,13 +112,8 @@ export function get_trajectory_stats(trajectory) {
         else
             stats.atom_count_range = [Math.min(...all_counts), Math.max(...all_counts)];
     }
-    else {
-        // Handle empty trajectory case
-        stats.steps = [];
-        stats.step_range = undefined;
-        stats.constant_atom_count = undefined;
-        stats.total_atoms = undefined;
-    }
+    else
+        stats.steps = []; // empty trajectory
     // Additional metadata for large files
     if (indexed_frames)
         stats.indexed_frame_count = indexed_frames.length;

package/dist/trajectory/parse/ase.js

@@ -1,7 +1,7 @@
 // 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';
+const MAX_SAFE_STRING_LENGTH = 0x1fffffe8 * 0.5; // 50% of JS max string length as safety
 // 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)),

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

@@ -1,11 +1,12 @@
-import type { FrameLoader, ParseProgress, TrajectoryType } from '../index';
+import type { 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 declare const LARGE_FILE_THRESHOLD: number;
+export declare const MAX_BIN_FILE_SIZE: number;
+export declare const MAX_TEXT_FILE_SIZE: number;
 export type { AtomTypeMapping, LoadingOptions } from '../types';
 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>;
-export declare function create_frame_loader(filename: string): FrameLoader;
 export declare function load_binary_traj(resp: Response, type: string, fallback?: boolean): Promise<ArrayBuffer | string>;

package/dist/trajectory/parse/index.js

@@ -1,10 +1,9 @@
 // Parsing functions for trajectory data from various formats
 import { is_binary } from '../../io/is-binary';
 import { is_plain_object } from '../../utils';
+import { DEFAULTS } from '../../settings';
 import { is_parsed_structure, parse_xyz } from '../../structure/parse';
-import { INDEX_SAMPLE_RATE, LARGE_FILE_THRESHOLD } from '../constants';
-import { strip_compression_extensions } from '../../io/decompress';
-import { ext_hint, FORMAT_PATTERNS } from '../format-detect';
+import { ext_hint, FORMAT_PATTERNS, indexed_trajectory_format, is_indexable_trajectory_filename, } from '../format-detect';
 import { TrajFrameReader } from '../frame-reader';
 import { count_xyz_frames } from '../helpers';
 import { parse_ase_trajectory } from './ase';
@@ -21,8 +20,14 @@ const assert_frame_structure = (structure, 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 { LARGE_FILE_THRESHOLD, MAX_BIN_FILE_SIZE, MAX_TEXT_FILE_SIZE, } from '../constants';
+// Constants for trajectory parsing and large file handling
+export const LARGE_FILE_THRESHOLD = 400 * 1024 * 1024; // 400MB
+const INDEX_SAMPLE_RATE = 100; // Default sample rate for frame indexing
+// Fallback thresholds for component usage without loading_options, derived from the
+// settings schema so settings-driven contexts (e.g. the VSCode extension) and direct
+// component use agree on when large-file/indexed loading kicks in.
+export const MAX_BIN_FILE_SIZE = DEFAULTS.trajectory.bin_file_threshold; // 50MB
+export const MAX_TEXT_FILE_SIZE = DEFAULTS.trajectory.text_file_threshold; // 25MB
 export { is_trajectory_file } from '../format-detect';
 export { TrajFrameReader } from '../frame-reader';
 export async function parse_trajectory_data(data, filename, atom_type_mapping) {
@@ -154,8 +159,7 @@ export async function parse_trajectory_async(data, filename, on_progress, option
         // 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);
-        const can_index = /\.(?:xyz|extxyz|traj)$/.test(base_filename) ||
+        const can_index = is_indexable_trajectory_filename(filename) ||
             (typeof data === `string` &&
                 ext_hint(filename, /\.(?:xyz|extxyz)$/) === null &&
                 count_xyz_frames(data.slice(0, 2 ** 20)) >= 1);
@@ -213,9 +217,7 @@ async function parse_with_unified_loader(data, filename, options, on_progress) {
     }
     const stage = `Ready: ${total_frames} frames indexed`;
     on_progress?.({ current: 100, total: 100, stage });
-    const source_format = filename.toLowerCase().endsWith(`.traj`)
-        ? `ase_trajectory`
-        : `xyz_trajectory`;
+    const source_format = `${indexed_trajectory_format(filename)}_trajectory`;
     return {
         frames,
         metadata: { source_format, frame_count: total_frames },
@@ -226,13 +228,6 @@ async function parse_with_unified_loader(data, filename, options, on_progress) {
         frame_loader: loader,
     };
 }
-// Factory function for frame loader (simplified)
-export function create_frame_loader(filename) {
-    if (!/\.(?:xyz|extxyz|traj)$/.test(filename.toLowerCase())) {
-        throw new Error(`Unsupported format for frame loading: ${filename}`);
-    }
-    return new TrajFrameReader(filename);
-}
 export async function load_binary_traj(resp, type, fallback = false) {
     try {
         // Read binary from a clone so the original can be used for text fallback

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

@@ -2,4 +2,3 @@ import type * as h5wasm from 'h5wasm';
 import type { TrajectoryType } from '../index';
 export declare const is_vaspout_h5_file: (h5_file: h5wasm.File) => boolean;
 export declare function parse_vaspout_h5_file(h5_file: h5wasm.File): TrajectoryType;
-export declare function parse_vaspout_h5(buffer: ArrayBuffer, filename?: string): Promise<TrajectoryType>;

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

@@ -17,7 +17,7 @@
 // VASP 6.x schema definitions).
 import { calc_lattice_params, create_frac_to_cart } from '../../math';
 import { count_elements, create_trajectory_frame, validate_3x3_matrix, } from '../helpers';
-import { expand_ion_types, is_hdf5_group, read_dataset, scale_matrix, to_number_array, to_scalar_number, to_string_array, with_h5_file, } from './h5-utils';
+import { expand_ion_types, is_hdf5_group, read_dataset, scale_matrix, to_number_array, to_scalar_number, to_string_array, } from './h5-utils';
 import { read_vaspout_dos, read_vaspout_electronic } from './vaspout-electronic';
 const FINAL_ION_TYPES = `results/positions/ion_types`;
 const FINAL_ION_COUNTS = `results/positions/number_ion_types`;
@@ -279,6 +279,3 @@ export function parse_vaspout_h5_file(h5_file) {
         },
     };
 }
-export async function parse_vaspout_h5(buffer, filename) {
-    return with_h5_file(buffer, filename, parse_vaspout_h5_file);
-}