@molcrafts/molrs 0.1.3 → 0.6.0

package/README.md

@@ -4,8 +4,8 @@
 
 WebAssembly bindings for the [molrs](https://github.com/MolCrafts/molrs) molecular modeling toolkit.
 
-Full documentation lives at <https://molcrafts.github.io/molrs/>. The WASM
-reference is published at <https://molcrafts.github.io/molrs/reference/wasm/>.
+Full documentation lives at <https://molrs.molcrafts.org/>. The WASM
+reference is published at <https://molrs.molcrafts.org/reference/wasm/>.
 
 ## Install
 

package/molrs.d.ts

@@ -1726,6 +1726,39 @@ export class FrameIndexEntry {
     readonly byteOffset: number;
 }
 
+/**
+ * GROMACS GRO structure / trajectory reader.
+ *
+ * GRO is a fixed-column text format for GROMACS structures and
+ * single-precision trajectories. Multi-frame files expose each frame via
+ * `read(step)`. Coordinates and box are GROMACS-native nm in the file and
+ * are converted to angstrom on read (x10), matching every other molvis
+ * reader. Each frame produces an `"atoms"` block (`resid`, `resname`,
+ * `atom_name`, `atom_id`, `x`/`y`/`z`, optional `vx`/`vy`/`vz`) and a
+ * `simbox` from the box-vector line.
+ */
+export class GROReader {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Check whether the file contains no frames.
+     */
+    isEmpty(): boolean;
+    /**
+     * Return the number of frames in the GRO file.
+     */
+    len(): number;
+    /**
+     * Create a new GRO reader from a string containing the file content.
+     */
+    constructor(content: string);
+    /**
+     * Read the frame at the given step index (0-based). Coordinates are
+     * converted nm -> angstrom before the frame is returned.
+     */
+    read(step: number): Frame | undefined;
+}
+
 /**
  * Gyration tensor per cluster.
  *
@@ -1980,6 +2013,37 @@ export class LinkedCell {
     query(ref_frame: Frame, query_frame: Frame): NeighborList;
 }
 
+/**
+ * Tripos MOL2 reader.
+ *
+ * MOL2 is a section-delimited (`@<TRIPOS>...`) text format. Multi-molecule
+ * files expose each `MOLECULE` record as a frame via `read(step)`.
+ * Coordinates are already in angstrom. Produces an `"atoms"` block (`id`,
+ * `name`, `x`/`y`/`z`, `atom_type`, optional `subst_id`/`subst_name`/
+ * `charge`) and, when present, a `"bonds"` block (`atomi`/`atomj` 0-based,
+ * `bond_type`).
+ */
+export class MOL2Reader {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Check whether the file contains no records.
+     */
+    isEmpty(): boolean;
+    /**
+     * Return the number of molecule records in the MOL2 file.
+     */
+    len(): number;
+    /**
+     * Create a new MOL2 reader from a string containing the file content.
+     */
+    constructor(content: string);
+    /**
+     * Read the molecule record at the given step index (0-based).
+     */
+    read(step: number): Frame | undefined;
+}
+
 /**
  * Mean squared displacement (MSD) analysis.
  *
@@ -2097,19 +2161,6 @@ export class MSDResult {
     readonly mean: number;
 }
 
-/**
- * Reader for MolRec Zarr v3 archives.
- */
-export class MolRecReader {
-    free(): void;
-    [Symbol.dispose](): void;
-    countAtoms(): number;
-    countFrames(): number;
-    free(): void;
-    constructor(files: Map<any, any>);
-    readFrame(t: number): Frame | undefined;
-}
-
 /**
  * Result of a neighbor search: all atom pairs within a distance cutoff.
  *
@@ -2264,6 +2315,37 @@ export class PDBReader {
     read(step: number): Frame | undefined;
 }
 
+/**
+ * VASP POSCAR / CONTCAR structure reader.
+ *
+ * POSCAR describes a single crystalline cell. Coordinates are returned as
+ * Cartesian angstrom (`Direct` files are converted on read by molrs).
+ * Produces an `"atoms"` block (`x`/`y`/`z`, optional `symbol`,
+ * selective-dynamics flags, velocities) and a periodic `simbox`.
+ * Single-frame: any `step != 0` returns `undefined`.
+ */
+export class POSCARReader {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Check whether the file contains no valid frame.
+     */
+    isEmpty(): boolean;
+    /**
+     * Return the number of frames (always 0 or 1 for POSCAR files).
+     */
+    len(): number;
+    /**
+     * Create a new POSCAR reader from a string containing the file content.
+     */
+    constructor(content: string);
+    /**
+     * Read the frame at `step`. POSCAR is single-frame, so any `step != 0`
+     * returns `undefined`.
+     */
+    read(step: number): Frame | undefined;
+}
+
 /**
  * Radial distribution function g(r) analysis.
  *
@@ -2427,6 +2509,19 @@ export class RadiusOfGyration {
     constructor(masses?: Float64Array | null);
 }
 
+/**
+ * Reader for frame-sequence Zarr v3 archives.
+ */
+export class RecordReader {
+    free(): void;
+    [Symbol.dispose](): void;
+    countAtoms(): number;
+    countFrames(): number;
+    free(): void;
+    constructor(files: Map<any, any>);
+    readFrame(t: number): Frame | undefined;
+}
+
 /**
  * MDL molfile / SDF (V2000 CTAB) reader.
  *
@@ -2545,6 +2640,37 @@ export class SmilesIR {
     readonly nComponents: number;
 }
 
+/**
+ * GROMACS TRR binary trajectory reader.
+ *
+ * TRR is the full-precision GROMACS trajectory (XDR, big-endian). Accepts the
+ * file as raw bytes (`Uint8Array`). Each frame produces an `"atoms"` block
+ * (`id`, `x`/`y`/`z`, optional `vx`/`vy`/`vz` and `fx`/`fy`/`fz`);
+ * coordinates and box are converted nm -> angstrom on read. Box is attached
+ * as `simbox` when the frame carries one.
+ */
+export class TRRReader {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Check whether the file contains no frames.
+     */
+    isEmpty(): boolean;
+    /**
+     * Return the number of frames in the TRR file.
+     */
+    len(): number;
+    /**
+     * Create a new TRR reader from the file's raw bytes.
+     */
+    constructor(bytes: Uint8Array);
+    /**
+     * Read a frame at the given step index (0-based). Coordinates are
+     * converted nm -> angstrom before the frame is returned.
+     */
+    read(step: number): Frame | undefined;
+}
+
 /**
  * Graph-based molecular topology with automated detection of angles,
  * dihedrals, impropers, connected components, and rings (SSSR).
@@ -2884,7 +3010,7 @@ export class WasmArray {
 }
 
 /**
- * Wrapper for [`molrs::compute::kmeans::KMeans`].
+ * Wrapper for [`molrs::compute::ml::kmeans::KMeans`].
  *
  * # Example (JavaScript)
  *
@@ -3210,7 +3336,7 @@ export class WasmLammpsDumpStream {
 }
 
 /**
- * Stateless wrapper for [`molrs::compute::pca::Pca2`].
+ * Stateless wrapper for [`molrs::compute::ml::pca::Pca2`].
  *
  * All configuration lives on [`fitTransform`](Self::fit_transform).
  *
@@ -3696,6 +3822,36 @@ export class WasmXyzStream {
     simboxPbc(): Uint8Array | undefined;
 }
 
+/**
+ * GROMACS XTC binary trajectory reader.
+ *
+ * XTC is the compressed GROMACS trajectory (XDR, big-endian, lossy
+ * coordinate compression). Accepts the file as raw bytes (`Uint8Array`).
+ * Each frame produces an `"atoms"` block (`id`, `x`/`y`/`z`); coordinates
+ * and box are converted nm -> angstrom on read. Box is attached as `simbox`.
+ */
+export class XTCReader {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Check whether the file contains no frames.
+     */
+    isEmpty(): boolean;
+    /**
+     * Return the number of frames in the XTC file.
+     */
+    len(): number;
+    /**
+     * Create a new XTC reader from the file's raw bytes.
+     */
+    constructor(bytes: Uint8Array);
+    /**
+     * Read a frame at the given step index (0-based). Coordinates are
+     * converted nm -> angstrom before the frame is returned.
+     */
+    read(step: number): Frame | undefined;
+}
+
 /**
  * XYZ / Extended XYZ file reader.
  *
@@ -3944,3 +4100,18 @@ export function wasmMemory(): WebAssembly.Memory;
  * ```
  */
 export function writeFrame(frame: Frame, format: string): string;
+
+/**
+ * Serialize a [`Frame`] to bytes in a binary trajectory format.
+ *
+ * Mirrors [`write_frame_export`] for the formats whose output is not valid
+ * UTF-8: `"dcd"`, `"trr"`, `"xtc"` (case-insensitive). Returns a
+ * `Uint8Array` to JavaScript. The GROMACS formats (`trr`/`xtc`) are written
+ * in nm — coordinates and box are scaled Å → nm on a throwaway clone first.
+ *
+ * # Errors
+ *
+ * Throws a `JsValue` string if the format is not a known binary format, the
+ * frame is missing required columns, or the writer encounters an error.
+ */
+export function writeFrameBytes(frame: Frame, format: string): Uint8Array;

package/molrs.js

@@ -5,5 +5,5 @@ import { __wbg_set_wasm } from "./molrs_bg.js";
 __wbg_set_wasm(wasm);
 wasm.__wbindgen_start();
 export {
-    Block, Box, CHGCARReader, CIFReader, CenterOfMass, CenterOfMassResult, Cluster, ClusterCenters, ClusterResult, CubeReader, DCDReader, Frame, FrameIndexEntry, GyrationTensor, InertiaTensor, LAMMPSReader, LAMMPSTrajReader, LinkedCell, MSD, MSDResult, MolRecReader, NeighborList, PDBReader, RDF, RDFResult, RadiusOfGyration, SDFReader, SmilesIR, Topology, TopologyRingInfo, WasmArray, WasmKMeans, WasmLammpsDataStream, WasmLammpsDumpStream, WasmPca2, WasmPcaResult, WasmPdbStream, WasmSdfStream, WasmXyzStream, XYZReader, covalentRadius, generate3D, parseSMILES, start, wasmMemory, writeFrame
+    Block, Box, CHGCARReader, CIFReader, CenterOfMass, CenterOfMassResult, Cluster, ClusterCenters, ClusterResult, CubeReader, DCDReader, Frame, FrameIndexEntry, GROReader, GyrationTensor, InertiaTensor, LAMMPSReader, LAMMPSTrajReader, LinkedCell, MOL2Reader, MSD, MSDResult, NeighborList, PDBReader, POSCARReader, RDF, RDFResult, RadiusOfGyration, RecordReader, SDFReader, SmilesIR, TRRReader, Topology, TopologyRingInfo, WasmArray, WasmKMeans, WasmLammpsDataStream, WasmLammpsDumpStream, WasmPca2, WasmPcaResult, WasmPdbStream, WasmSdfStream, WasmXyzStream, XTCReader, XYZReader, covalentRadius, generate3D, parseSMILES, start, wasmMemory, writeFrame, writeFrameBytes
 } from "./molrs_bg.js";

package/molrs_bg.js

@@ -2587,6 +2587,78 @@ export class FrameIndexEntry {
 }
 if (Symbol.dispose) FrameIndexEntry.prototype[Symbol.dispose] = FrameIndexEntry.prototype.free;
 
+/**
+ * GROMACS GRO structure / trajectory reader.
+ *
+ * GRO is a fixed-column text format for GROMACS structures and
+ * single-precision trajectories. Multi-frame files expose each frame via
+ * `read(step)`. Coordinates and box are GROMACS-native nm in the file and
+ * are converted to angstrom on read (x10), matching every other molvis
+ * reader. Each frame produces an `"atoms"` block (`resid`, `resname`,
+ * `atom_name`, `atom_id`, `x`/`y`/`z`, optional `vx`/`vy`/`vz`) and a
+ * `simbox` from the box-vector line.
+ */
+export class GROReader {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        GROReaderFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_groreader_free(ptr, 0);
+    }
+    /**
+     * Check whether the file contains no frames.
+     * @returns {boolean}
+     */
+    isEmpty() {
+        const ret = wasm.groreader_isEmpty(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Return the number of frames in the GRO file.
+     * @returns {number}
+     */
+    len() {
+        const ret = wasm.groreader_len(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * Create a new GRO reader from a string containing the file content.
+     * @param {string} content
+     */
+    constructor(content) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.groreader_new(ptr0, len0);
+        this.__wbg_ptr = ret;
+        GROReaderFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Read the frame at the given step index (0-based). Coordinates are
+     * converted nm -> angstrom before the frame is returned.
+     * @param {number} step
+     * @returns {Frame | undefined}
+     */
+    read(step) {
+        const ret = wasm.groreader_read(this.__wbg_ptr, step);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] === 0 ? undefined : Frame.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) GROReader.prototype[Symbol.dispose] = GROReader.prototype.free;
+
 /**
  * Gyration tensor per cluster.
  *
@@ -3013,6 +3085,76 @@ export class LinkedCell {
 }
 if (Symbol.dispose) LinkedCell.prototype[Symbol.dispose] = LinkedCell.prototype.free;
 
+/**
+ * Tripos MOL2 reader.
+ *
+ * MOL2 is a section-delimited (`@<TRIPOS>...`) text format. Multi-molecule
+ * files expose each `MOLECULE` record as a frame via `read(step)`.
+ * Coordinates are already in angstrom. Produces an `"atoms"` block (`id`,
+ * `name`, `x`/`y`/`z`, `atom_type`, optional `subst_id`/`subst_name`/
+ * `charge`) and, when present, a `"bonds"` block (`atomi`/`atomj` 0-based,
+ * `bond_type`).
+ */
+export class MOL2Reader {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MOL2ReaderFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_mol2reader_free(ptr, 0);
+    }
+    /**
+     * Check whether the file contains no records.
+     * @returns {boolean}
+     */
+    isEmpty() {
+        const ret = wasm.mol2reader_isEmpty(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Return the number of molecule records in the MOL2 file.
+     * @returns {number}
+     */
+    len() {
+        const ret = wasm.mol2reader_len(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * Create a new MOL2 reader from a string containing the file content.
+     * @param {string} content
+     */
+    constructor(content) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.mol2reader_new(ptr0, len0);
+        this.__wbg_ptr = ret;
+        MOL2ReaderFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Read the molecule record at the given step index (0-based).
+     * @param {number} step
+     * @returns {Frame | undefined}
+     */
+    read(step) {
+        const ret = wasm.mol2reader_read(this.__wbg_ptr, step);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] === 0 ? undefined : Frame.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) MOL2Reader.prototype[Symbol.dispose] = MOL2Reader.prototype.free;
+
 /**
  * Mean squared displacement (MSD) analysis.
  *
@@ -3188,66 +3330,6 @@ export class MSDResult {
 }
 if (Symbol.dispose) MSDResult.prototype[Symbol.dispose] = MSDResult.prototype.free;
 
-/**
- * Reader for MolRec Zarr v3 archives.
- */
-export class MolRecReader {
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        MolRecReaderFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_molrecreader_free(ptr, 0);
-    }
-    /**
-     * @returns {number}
-     */
-    countAtoms() {
-        const ret = wasm.molrecreader_countAtoms(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * @returns {number}
-     */
-    countFrames() {
-        const ret = wasm.molrecreader_countFrames(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return ret[0] >>> 0;
-    }
-    free() {
-        wasm.molrecreader_free(this.__wbg_ptr);
-    }
-    /**
-     * @param {Map<any, any>} files
-     */
-    constructor(files) {
-        const ret = wasm.molrecreader_new(files);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        this.__wbg_ptr = ret[0];
-        MolRecReaderFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * @param {number} t
-     * @returns {Frame | undefined}
-     */
-    readFrame(t) {
-        const ret = wasm.molrecreader_readFrame(this.__wbg_ptr, t);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return ret[0] === 0 ? undefined : Frame.__wrap(ret[0]);
-    }
-}
-if (Symbol.dispose) MolRecReader.prototype[Symbol.dispose] = MolRecReader.prototype.free;
-
 /**
  * Result of a neighbor search: all atom pairs within a distance cutoff.
  *
@@ -3489,6 +3571,76 @@ export class PDBReader {
 }
 if (Symbol.dispose) PDBReader.prototype[Symbol.dispose] = PDBReader.prototype.free;
 
+/**
+ * VASP POSCAR / CONTCAR structure reader.
+ *
+ * POSCAR describes a single crystalline cell. Coordinates are returned as
+ * Cartesian angstrom (`Direct` files are converted on read by molrs).
+ * Produces an `"atoms"` block (`x`/`y`/`z`, optional `symbol`,
+ * selective-dynamics flags, velocities) and a periodic `simbox`.
+ * Single-frame: any `step != 0` returns `undefined`.
+ */
+export class POSCARReader {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        POSCARReaderFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_poscarreader_free(ptr, 0);
+    }
+    /**
+     * Check whether the file contains no valid frame.
+     * @returns {boolean}
+     */
+    isEmpty() {
+        const ret = wasm.poscarreader_isEmpty(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Return the number of frames (always 0 or 1 for POSCAR files).
+     * @returns {number}
+     */
+    len() {
+        const ret = wasm.poscarreader_len(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * Create a new POSCAR reader from a string containing the file content.
+     * @param {string} content
+     */
+    constructor(content) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.poscarreader_new(ptr0, len0);
+        this.__wbg_ptr = ret;
+        POSCARReaderFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Read the frame at `step`. POSCAR is single-frame, so any `step != 0`
+     * returns `undefined`.
+     * @param {number} step
+     * @returns {Frame | undefined}
+     */
+    read(step) {
+        const ret = wasm.poscarreader_read(this.__wbg_ptr, step);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] === 0 ? undefined : Frame.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) POSCARReader.prototype[Symbol.dispose] = POSCARReader.prototype.free;
+
 /**
  * Radial distribution function g(r) analysis.
  *
@@ -3767,6 +3919,66 @@ export class RadiusOfGyration {
 }
 if (Symbol.dispose) RadiusOfGyration.prototype[Symbol.dispose] = RadiusOfGyration.prototype.free;
 
+/**
+ * Reader for frame-sequence Zarr v3 archives.
+ */
+export class RecordReader {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RecordReaderFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_recordreader_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    countAtoms() {
+        const ret = wasm.recordreader_countAtoms(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    countFrames() {
+        const ret = wasm.recordreader_countFrames(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    free() {
+        wasm.recordreader_free(this.__wbg_ptr);
+    }
+    /**
+     * @param {Map<any, any>} files
+     */
+    constructor(files) {
+        const ret = wasm.recordreader_new(files);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        RecordReaderFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {number} t
+     * @returns {Frame | undefined}
+     */
+    readFrame(t) {
+        const ret = wasm.recordreader_readFrame(this.__wbg_ptr, t);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] === 0 ? undefined : Frame.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) RecordReader.prototype[Symbol.dispose] = RecordReader.prototype.free;
+
 /**
  * MDL molfile / SDF (V2000 CTAB) reader.
  *
@@ -3949,6 +4161,76 @@ export class SmilesIR {
 }
 if (Symbol.dispose) SmilesIR.prototype[Symbol.dispose] = SmilesIR.prototype.free;
 
+/**
+ * GROMACS TRR binary trajectory reader.
+ *
+ * TRR is the full-precision GROMACS trajectory (XDR, big-endian). Accepts the
+ * file as raw bytes (`Uint8Array`). Each frame produces an `"atoms"` block
+ * (`id`, `x`/`y`/`z`, optional `vx`/`vy`/`vz` and `fx`/`fy`/`fz`);
+ * coordinates and box are converted nm -> angstrom on read. Box is attached
+ * as `simbox` when the frame carries one.
+ */
+export class TRRReader {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TRRReaderFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_trrreader_free(ptr, 0);
+    }
+    /**
+     * Check whether the file contains no frames.
+     * @returns {boolean}
+     */
+    isEmpty() {
+        const ret = wasm.trrreader_isEmpty(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Return the number of frames in the TRR file.
+     * @returns {number}
+     */
+    len() {
+        const ret = wasm.trrreader_len(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * Create a new TRR reader from the file's raw bytes.
+     * @param {Uint8Array} bytes
+     */
+    constructor(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc_command_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.trrreader_new(ptr0, len0);
+        this.__wbg_ptr = ret;
+        TRRReaderFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Read a frame at the given step index (0-based). Coordinates are
+     * converted nm -> angstrom before the frame is returned.
+     * @param {number} step
+     * @returns {Frame | undefined}
+     */
+    read(step) {
+        const ret = wasm.trrreader_read(this.__wbg_ptr, step);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] === 0 ? undefined : Frame.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) TRRReader.prototype[Symbol.dispose] = TRRReader.prototype.free;
+
 /**
  * Graph-based molecular topology with automated detection of angles,
  * dihedrals, impropers, connected components, and rings (SSSR).
@@ -4531,7 +4813,7 @@ export class WasmArray {
 if (Symbol.dispose) WasmArray.prototype[Symbol.dispose] = WasmArray.prototype.free;
 
 /**
- * Wrapper for [`molrs::compute::kmeans::KMeans`].
+ * Wrapper for [`molrs::compute::ml::kmeans::KMeans`].
  *
  * # Example (JavaScript)
  *
@@ -5211,7 +5493,7 @@ export class WasmLammpsDumpStream {
 if (Symbol.dispose) WasmLammpsDumpStream.prototype[Symbol.dispose] = WasmLammpsDumpStream.prototype.free;
 
 /**
- * Stateless wrapper for [`molrs::compute::pca::Pca2`].
+ * Stateless wrapper for [`molrs::compute::ml::pca::Pca2`].
  *
  * All configuration lives on [`fitTransform`](Self::fit_transform).
  *
@@ -6228,6 +6510,75 @@ export class WasmXyzStream {
 }
 if (Symbol.dispose) WasmXyzStream.prototype[Symbol.dispose] = WasmXyzStream.prototype.free;
 
+/**
+ * GROMACS XTC binary trajectory reader.
+ *
+ * XTC is the compressed GROMACS trajectory (XDR, big-endian, lossy
+ * coordinate compression). Accepts the file as raw bytes (`Uint8Array`).
+ * Each frame produces an `"atoms"` block (`id`, `x`/`y`/`z`); coordinates
+ * and box are converted nm -> angstrom on read. Box is attached as `simbox`.
+ */
+export class XTCReader {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        XTCReaderFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_xtcreader_free(ptr, 0);
+    }
+    /**
+     * Check whether the file contains no frames.
+     * @returns {boolean}
+     */
+    isEmpty() {
+        const ret = wasm.xtcreader_isEmpty(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Return the number of frames in the XTC file.
+     * @returns {number}
+     */
+    len() {
+        const ret = wasm.xtcreader_len(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * Create a new XTC reader from the file's raw bytes.
+     * @param {Uint8Array} bytes
+     */
+    constructor(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc_command_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.xtcreader_new(ptr0, len0);
+        this.__wbg_ptr = ret;
+        XTCReaderFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Read a frame at the given step index (0-based). Coordinates are
+     * converted nm -> angstrom before the frame is returned.
+     * @param {number} step
+     * @returns {Frame | undefined}
+     */
+    read(step) {
+        const ret = wasm.xtcreader_read(this.__wbg_ptr, step);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] === 0 ? undefined : Frame.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) XTCReader.prototype[Symbol.dispose] = XTCReader.prototype.free;
+
 /**
  * XYZ / Extended XYZ file reader.
  *
@@ -6574,18 +6925,47 @@ export function writeFrame(frame, format) {
         wasm.__wbindgen_free_command_export(deferred3_0, deferred3_1, 1);
     }
 }
-export function __wbg___wbindgen_debug_string_8a447059637473e2(arg0, arg1) {
+
+/**
+ * Serialize a [`Frame`] to bytes in a binary trajectory format.
+ *
+ * Mirrors [`write_frame_export`] for the formats whose output is not valid
+ * UTF-8: `"dcd"`, `"trr"`, `"xtc"` (case-insensitive). Returns a
+ * `Uint8Array` to JavaScript. The GROMACS formats (`trr`/`xtc`) are written
+ * in nm — coordinates and box are scaled Å → nm on a throwaway clone first.
+ *
+ * # Errors
+ *
+ * Throws a `JsValue` string if the format is not a known binary format, the
+ * frame is missing required columns, or the writer encounters an error.
+ * @param {Frame} frame
+ * @param {string} format
+ * @returns {Uint8Array}
+ */
+export function writeFrameBytes(frame, format) {
+    _assertClass(frame, Frame);
+    const ptr0 = passStringToWasm0(format, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.writeFrameBytes(frame.__wbg_ptr, ptr0, len0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free_command_export(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+export function __wbg___wbindgen_debug_string_c25d447a39f5578f(arg0, arg1) {
     const ret = debugString(arg1);
     const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
     const len1 = WASM_VECTOR_LEN;
     getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 }
-export function __wbg___wbindgen_memory_9751d9a3017e7c25() {
+export function __wbg___wbindgen_memory_de265df8aadd6273() {
     const ret = wasm.memory;
     return ret;
 }
-export function __wbg___wbindgen_string_get_71bb4348194e31f0(arg0, arg1) {
+export function __wbg___wbindgen_string_get_b0ca35b86a603356(arg0, arg1) {
     const obj = arg1;
     const ret = typeof(obj) === 'string' ? obj : undefined;
     var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
@@ -6593,10 +6973,10 @@ export function __wbg___wbindgen_string_get_71bb4348194e31f0(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 }
-export function __wbg___wbindgen_throw_ea4887a5f8f9a9db(arg0, arg1) {
+export function __wbg___wbindgen_throw_344f42d3211c4765(arg0, arg1) {
     throw new Error(getStringFromWasm0(arg0, arg1));
 }
-export function __wbg_done_b62d4a7d2286852a(arg0) {
+export function __wbg_done_89b2b13e91a60321(arg0) {
     const ret = arg0.done;
     return ret;
 }
@@ -6615,38 +6995,38 @@ export function __wbg_frameindexentry_new(arg0) {
     const ret = FrameIndexEntry.__wrap(arg0);
     return ret;
 }
-export function __wbg_getRandomValues_76dfc69825c9c552() { return handleError(function (arg0, arg1) {
+export function __wbg_getRandomValues_cc7f052a444bb2ce() { return handleError(function (arg0, arg1) {
     globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
 }, arguments); }
-export function __wbg_get_f6f94ffcaf26eed1(arg0, arg1) {
+export function __wbg_get_53202602c459bfb1(arg0, arg1) {
     const ret = arg0.get(arg1);
     return ret;
 }
-export function __wbg_get_unchecked_54a4374c38e08460(arg0, arg1) {
+export function __wbg_get_unchecked_6e0ad6d2a41b06f6(arg0, arg1) {
     const ret = arg0[arg1 >>> 0];
     return ret;
 }
-export function __wbg_keys_8c9f7da46ee76e8d(arg0) {
+export function __wbg_keys_8e08ab7a3c20df35(arg0) {
     const ret = arg0.keys();
     return ret;
 }
-export function __wbg_length_4875795b8939c6b6(arg0) {
+export function __wbg_length_0133fa10e3234c57(arg0) {
     const ret = arg0.length;
     return ret;
 }
-export function __wbg_length_589238bdcf171f0e(arg0) {
+export function __wbg_length_1f0964f4a5e2c6d8(arg0) {
     const ret = arg0.length;
     return ret;
 }
-export function __wbg_length_750ab89c52b42479(arg0) {
+export function __wbg_length_370319915dc99107(arg0) {
     const ret = arg0.length;
     return ret;
 }
-export function __wbg_length_bf9e65fd7019a3f2(arg0) {
+export function __wbg_length_381d540857ec99e8(arg0) {
     const ret = arg0.length;
     return ret;
 }
-export function __wbg_length_c6054974c0a6cdb9(arg0) {
+export function __wbg_length_a6f0e2586a65d524(arg0) {
     const ret = arg0.length;
     return ret;
 }
@@ -6658,74 +7038,74 @@ export function __wbg_new_227d7c05414eb861() {
     const ret = new Error();
     return ret;
 }
-export function __wbg_new_36e147a8ced3c6e0() {
+export function __wbg_new_32b398fb48b6d94a() {
     const ret = new Array();
     return ret;
 }
-export function __wbg_new_81880fb5002cb255(arg0) {
+export function __wbg_new_cd45aabdf6073e84(arg0) {
     const ret = new Uint8Array(arg0);
     return ret;
 }
-export function __wbg_new_from_slice_3f5658f83d8d0725(arg0, arg1) {
+export function __wbg_new_from_slice_7568ba55b4a7e81f(arg0, arg1) {
     const ret = new Uint32Array(getArrayU32FromWasm0(arg0, arg1));
     return ret;
 }
-export function __wbg_new_from_slice_7b8c5f56d6f4bffc(arg0, arg1) {
-    const ret = new Int32Array(getArrayI32FromWasm0(arg0, arg1));
+export function __wbg_new_from_slice_7e254b47c77fb8cc(arg0, arg1) {
+    const ret = new Float64Array(getArrayF64FromWasm0(arg0, arg1));
     return ret;
 }
-export function __wbg_new_from_slice_98e57cb2fe2e6a5d(arg0, arg1) {
-    const ret = new Float64Array(getArrayF64FromWasm0(arg0, arg1));
+export function __wbg_new_from_slice_adc482e0820cc439(arg0, arg1) {
+    const ret = new Int32Array(getArrayI32FromWasm0(arg0, arg1));
     return ret;
 }
-export function __wbg_new_with_length_3f188e379a8c6a4d(arg0) {
+export function __wbg_new_with_length_112583d83d0cb73c(arg0) {
     const ret = new Float64Array(arg0 >>> 0);
     return ret;
 }
-export function __wbg_new_with_length_793583df958b3ae2(arg0) {
+export function __wbg_new_with_length_664ae1da061c56fa(arg0) {
     const ret = new Int32Array(arg0 >>> 0);
     return ret;
 }
-export function __wbg_new_with_length_9b650f44b5c44a4e(arg0) {
+export function __wbg_new_with_length_e6785c33c8e4cce8(arg0) {
     const ret = new Uint8Array(arg0 >>> 0);
     return ret;
 }
-export function __wbg_new_with_length_ecf42de9ee25651c(arg0) {
+export function __wbg_new_with_length_f048f86e32f1515e(arg0) {
     const ret = new Uint32Array(arg0 >>> 0);
     return ret;
 }
-export function __wbg_next_0c4066e251d2eff9() { return handleError(function (arg0) {
+export function __wbg_next_71f2aa1cb3d1e37e() { return handleError(function (arg0) {
     const ret = arg0.next();
     return ret;
 }, arguments); }
-export function __wbg_prototypesetcall_1f31756936f35af0(arg0, arg1, arg2) {
+export function __wbg_prototypesetcall_18a0f7bcf4a5652d(arg0, arg1, arg2) {
     Int32Array.prototype.set.call(getArrayI32FromWasm0(arg0, arg1), arg2);
 }
-export function __wbg_prototypesetcall_26a86dd8c73de125(arg0, arg1, arg2) {
-    Uint32Array.prototype.set.call(getArrayU32FromWasm0(arg0, arg1), arg2);
-}
-export function __wbg_prototypesetcall_83f8c8d8e36faf9f(arg0, arg1, arg2) {
+export function __wbg_prototypesetcall_21a175a0a8157491(arg0, arg1, arg2) {
     Float64Array.prototype.set.call(getArrayF64FromWasm0(arg0, arg1), arg2);
 }
-export function __wbg_prototypesetcall_d721637c7ca66eb8(arg0, arg1, arg2) {
+export function __wbg_prototypesetcall_4770620bbe4688a0(arg0, arg1, arg2) {
     Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
 }
-export function __wbg_push_f724b5db8acf89d2(arg0, arg1) {
+export function __wbg_prototypesetcall_62396032bc038599(arg0, arg1, arg2) {
+    Uint32Array.prototype.set.call(getArrayU32FromWasm0(arg0, arg1), arg2);
+}
+export function __wbg_push_d2ae3af0c1217ae6(arg0, arg1) {
     const ret = arg0.push(arg1);
     return ret;
 }
-export function __wbg_set_404b02690d27a687(arg0, arg1, arg2) {
+export function __wbg_set_29967298e530d279(arg0, arg1, arg2) {
     arg0.set(getArrayF64FromWasm0(arg1, arg2));
 }
-export function __wbg_set_699bda357d38bc49(arg0, arg1, arg2) {
+export function __wbg_set_d07b6d94c9c97f43(arg0, arg1, arg2) {
     arg0.set(getArrayI32FromWasm0(arg1, arg2));
 }
-export function __wbg_set_index_4cab6f2df9ae8120(arg0, arg1, arg2) {
-    arg0[arg1 >>> 0] = arg2 >>> 0;
-}
-export function __wbg_set_index_dd52456a7aef02bf(arg0, arg1, arg2) {
+export function __wbg_set_index_0a2d916cd3658df4(arg0, arg1, arg2) {
     arg0[arg1 >>> 0] = arg2;
 }
+export function __wbg_set_index_1edd196294cd6dbf(arg0, arg1, arg2) {
+    arg0[arg1 >>> 0] = arg2 >>> 0;
+}
 export function __wbg_stack_3b0d974bbf31e44f(arg0, arg1) {
     const ret = arg1.stack;
     const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
@@ -6733,7 +7113,7 @@ export function __wbg_stack_3b0d974bbf31e44f(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 }
-export function __wbg_value_49f783bb59765962(arg0) {
+export function __wbg_value_a5d5488a9589444a(arg0) {
     const ret = arg0.value;
     return ret;
 }
@@ -6805,6 +7185,9 @@ const FrameFinalization = (typeof FinalizationRegistry === 'undefined')
 const FrameIndexEntryFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_frameindexentry_free(ptr, 1));
+const GROReaderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_groreader_free(ptr, 1));
 const GyrationTensorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_gyrationtensor_free(ptr, 1));
@@ -6820,21 +7203,24 @@ const LAMMPSTrajReaderFinalization = (typeof FinalizationRegistry === 'undefined
 const LinkedCellFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_linkedcell_free(ptr, 1));
+const MOL2ReaderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_mol2reader_free(ptr, 1));
 const MSDFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_msd_free(ptr, 1));
 const MSDResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_msdresult_free(ptr, 1));
-const MolRecReaderFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_molrecreader_free(ptr, 1));
 const NeighborListFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_neighborlist_free(ptr, 1));
 const PDBReaderFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_pdbreader_free(ptr, 1));
+const POSCARReaderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_poscarreader_free(ptr, 1));
 const RDFFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_rdf_free(ptr, 1));
@@ -6844,12 +7230,18 @@ const RDFResultFinalization = (typeof FinalizationRegistry === 'undefined')
 const RadiusOfGyrationFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_radiusofgyration_free(ptr, 1));
+const RecordReaderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_recordreader_free(ptr, 1));
 const SDFReaderFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_sdfreader_free(ptr, 1));
 const SmilesIRFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_smilesir_free(ptr, 1));
+const TRRReaderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_trrreader_free(ptr, 1));
 const TopologyFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_topology_free(ptr, 1));
@@ -6883,6 +7275,9 @@ const WasmSdfStreamFinalization = (typeof FinalizationRegistry === 'undefined')
 const WasmXyzStreamFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmxyzstream_free(ptr, 1));
+const XTCReaderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_xtcreader_free(ptr, 1));
 const XYZReaderFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_xyzreader_free(ptr, 1));

package/package.json

@@ -5,7 +5,7 @@
     "MolCrafts"
   ],
   "description": "WASM bindings for molrs",
-  "version": "0.1.3",
+  "version": "0.6.0",
   "license": "BSD-3-Clause",
   "repository": {
     "type": "git",