@molcrafts/molrs 0.0.6 → 0.0.8

package/molrs_bg.js

@@ -2,14 +2,14 @@
  * Column-oriented data store with typed arrays.
  *
  * Each column is identified by a string key and has a fixed data type
- * (`f32`, `i32`, `u32`, `string`). All columns in a block must have
+ * (`F`, `i32`, `u32`, `string`). All columns in a block must have
  * the same number of rows.
  *
  * # Supported column types
  *
  * | JS type | Rust type | dtype string | Setter | Getter (copy) | Getter (view) |
  * |---------|-----------|-------------|--------|---------------|---------------|
- * | `Float32Array` | `f32` | `"f32"` | `setColF32` | `copyColF32` | `viewColF32` |
+ * | `Float32Array` / `Float64Array` | `F` | `"f32"` / `"f64"` | `setColF` | `copyColF` | `viewColF` |
  * | `Int32Array` | `i32` | `"i32"` | `setColI32` | `copyColI32` | `viewColI32` |
  * | `Uint32Array` | `u32` | `"u32"` | `setColU32` | `copyColU32` | `viewColU32` |
  * | `string[]` | `String` | `"string"` | `setColStr` | `copyColStr` | -- |
@@ -18,12 +18,12 @@
  *
  * ```js
  * const block = new Block();
- * block.setColF32("x", new Float32Array([1.0, 2.0, 3.0]));
- * block.setColF32("y", new Float32Array([0.0, 0.0, 0.0]));
+ * block.setColF("x", coordsX);
+ * block.setColF("y", coordsY);
  * console.log(block.nrows()); // 3
  * console.log(block.keys());  // ["x", "y"]
  *
- * const x = block.copyColF32("x"); // owned copy, safe to keep
+ * const x = block.copyColF("x"); // owned copy, safe to keep
  * ```
  */
 export class Block {
@@ -45,9 +45,9 @@ export class Block {
         wasm.__wbg_block_free(ptr, 0);
     }
     /**
-     * Owned `Float32Array` copy of a column.
+     * Owned JS float typed-array copy of a column.
      *
-     * Returns a new JS `Float32Array` that is an independent copy of
+     * Returns a new JS float typed array that is an independent copy of
      * the column data. Safe to store and use across allocations.
      *
      * # Arguments
@@ -56,25 +56,25 @@ export class Block {
      *
      * # Returns
      *
-     * An owned `Float32Array` copy of the column.
+     * An owned JS float typed-array copy of the column.
      *
      * # Errors
      *
-     * Throws if the column does not exist or is not of type `f32`.
+     * Throws if the column does not exist or is not of the active float type.
      *
      * # Example (JavaScript)
      *
      * ```js
-     * const x = block.copyColF32("x");
+     * const x = block.copyColF("x");
      * console.log(x[0]); // 1.0
      * ```
      * @param {string} key
-     * @returns {Float32Array}
+     * @returns {Float64Array}
      */
-    copyColF32(key) {
+    copyColF(key) {
         const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.block_copyColF32(this.__wbg_ptr, ptr0, len0);
+        const ret = wasm.block_copyColF(this.__wbg_ptr, ptr0, len0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -172,7 +172,8 @@ export class Block {
     /**
      * Return the data type string for a column.
      *
-     * Possible return values: `"f32"`, `"i32"`, `"u32"`, `"bool"`,
+     * Possible return values: `"f32"` or `"f64"` for float columns,
+     * plus `"i32"`, `"u32"`, `"bool"`,
      * `"string"`, `"u8"`. Returns `undefined` if the column does
      * not exist.
      *
@@ -187,7 +188,7 @@ export class Block {
      * # Example (JavaScript)
      *
      * ```js
-     * console.log(block.dtype("x"));      // "f32"
+     * console.log(block.dtype("x"));      // "f32" or "f64"
      * console.log(block.dtype("symbol")); // "string"
      * ```
      * @param {string} key
@@ -282,7 +283,7 @@ export class Block {
      *
      * ```js
      * const block = new Block();
-     * block.setColF32("values", new Float32Array([1, 2, 3]));
+     * block.setColF("values", values);
      * ```
      */
     constructor() {
@@ -354,12 +355,12 @@ export class Block {
         return ret[0] !== 0;
     }
     /**
-     * Set a float column from a `Float32Array`.
+     * Set a float column from a JS float typed array.
      *
      * # Arguments
      *
      * * `key` - Column name (e.g., `"x"`, `"mass"`, `"charge"`)
-     * * `data` - `Float32Array` with the column values
+     * * `data` - JS float typed array with the column values
      * * `shape` - Optional shape array for multi-dimensional data
      *   (e.g., `[N, 3]` for an Nx3 matrix stored flat). If omitted,
      *   the data is stored as a 1D column.
@@ -372,20 +373,20 @@ export class Block {
      * # Example (JavaScript)
      *
      * ```js
-     * block.setColF32("x", new Float32Array([1.0, 2.0, 3.0]));
+     * block.setColF("x", xCoords);
      * // Multi-dimensional: 2 rows x 3 columns
-     * block.setColF32("pos", new Float32Array([1,2,3, 4,5,6]), [2, 3]);
+     * block.setColF("pos", positions, [2, 3]);
      * ```
      * @param {string} key
-     * @param {Float32Array} data
+     * @param {Float64Array} data
      * @param {Uint32Array | null} [shape]
      */
-    setColF32(key, data, shape) {
+    setColF(key, data, shape) {
         const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
         const len0 = WASM_VECTOR_LEN;
         var ptr1 = isLikeNone(shape) ? 0 : passArray32ToWasm0(shape, wasm.__wbindgen_malloc_command_export);
         var len1 = WASM_VECTOR_LEN;
-        const ret = wasm.block_setColF32(this.__wbg_ptr, ptr0, len0, data, ptr1, len1);
+        const ret = wasm.block_setColF(this.__wbg_ptr, ptr0, len0, data, ptr1, len1);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
@@ -478,13 +479,13 @@ export class Block {
         }
     }
     /**
-     * Zero-copy `Float32Array` view into WASM linear memory.
+     * Zero-copy JS float typed-array view into WASM linear memory.
      *
      * Returns a view backed directly by the block's storage in WASM
      * memory. This avoids copying but the view becomes **invalid**
      * if WASM linear memory grows (due to any allocation).
      *
-     * Use [`copyColF32`](Block::copy_col_f32) for a safe, long-lived copy.
+     * Use [`copyColF`](Block::copy_col_f) for a safe, long-lived copy.
      *
      * # Arguments
      *
@@ -492,25 +493,25 @@ export class Block {
      *
      * # Returns
      *
-     * A `Float32Array` view into WASM memory.
+     * A JS float typed-array view into WASM memory.
      *
      * # Errors
      *
-     * Throws if the column does not exist or is not of type `f32`.
+     * Throws if the column does not exist or is not of the active float type.
      *
      * # Example (JavaScript)
      *
      * ```js
-     * const view = block.viewColF32("x"); // zero-copy, use immediately
-     * const copy = block.copyColF32("x"); // safe to keep
+     * const view = block.viewColF("x"); // zero-copy, use immediately
+     * const copy = block.copyColF("x"); // safe to keep
      * ```
      * @param {string} key
-     * @returns {Float32Array}
+     * @returns {Float64Array}
      */
-    viewColF32(key) {
+    viewColF(key) {
         const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.block_viewColF32(this.__wbg_ptr, ptr0, len0);
+        const ret = wasm.block_viewColF(this.__wbg_ptr, ptr0, len0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -594,8 +595,8 @@ if (Symbol.dispose) Block.prototype[Symbol.dispose] = Block.prototype.free;
  * # Example (JavaScript)
  *
  * ```js
- * const h = new Float32Array([10, 0, 0, 0, 10, 0, 0, 0, 10]);
- * const origin = new Float32Array([0, 0, 0]);
+ * const h = floatArrayH;
+ * const origin = floatArrayOrigin;
  * const box = new Box(h, origin, true, true, true);
  * console.log(box.volume()); // 1000.0
  * console.log(box.lengths().toCopy()); // [10, 10, 10]
@@ -625,7 +626,7 @@ export class Box {
      * # Arguments
      *
      * * `a` - Side length of the cube in angstrom (A)
-     * * `origin` - 3D origin vector as `Float32Array` with 3 elements
+     * * `origin` - 3D origin vector as a float typed array with 3 elements
      *   `[x, y, z]` in angstrom
      * * `pbc_x` - Enable periodic boundary in x direction
      * * `pbc_y` - Enable periodic boundary in y direction
@@ -642,12 +643,12 @@ export class Box {
      * # Example (JavaScript)
      *
      * ```js
-     * const origin = new Float32Array([0, 0, 0]);
+     * const origin = originVec;
      * const box = Box.cube(10.0, origin, true, true, true);
      * console.log(box.volume()); // 1000.0
      * ```
      * @param {number} a
-     * @param {Float32Array} origin
+     * @param {Float64Array} origin
      * @param {boolean} pbc_x
      * @param {boolean} pbc_y
      * @param {boolean} pbc_z
@@ -688,8 +689,8 @@ export class Box {
      * # Example (JavaScript)
      *
      * ```js
-     * const a = WasmArray.from(new Float32Array([1,1,1]), [1,3]);
-     * const b = WasmArray.from(new Float32Array([9,9,9]), [1,3]);
+     * const a = WasmArray.from(aCoords, [1, 3]);
+     * const b = WasmArray.from(bCoords, [1, 3]);
      * const d = box.delta(a, b, true); // minimum-image displacement
      * ```
      * @param {WasmArray} a
@@ -718,7 +719,7 @@ export class Box {
      * * `b` - `WasmArray` with shape `[N, 3]` (target positions in A)
      * * `minimum_image` - If `true`, apply minimum image convention
      * * `out_block` - Target [`Block`] to write the result into
-     * * `out_key` - Column name for the result (f32, shape `[N, 3]`)
+     * * `out_key` - Column name for the result (float, shape `[N, 3]`)
      *
      * # Errors
      *
@@ -779,7 +780,7 @@ export class Box {
      * # Example (JavaScript)
      *
      * ```js
-     * const L = box.lengths().toCopy(); // Float32Array [10, 10, 10]
+     * const L = box.lengths().toCopy(); // Float32Array or Float64Array [10, 10, 10]
      * ```
      * @returns {WasmArray}
      */
@@ -792,10 +793,10 @@ export class Box {
      *
      * # Arguments
      *
-     * * `h` - 3x3 cell matrix as `Float32Array` with 9 elements in
+     * * `h` - 3x3 cell matrix as a float typed array with 9 elements in
      *   row-major order: `[h00, h01, h02, h10, h11, h12, h20, h21, h22]`.
      *   All values in angstrom (A).
-     * * `origin` - 3D origin vector as `Float32Array` with 3 elements
+     * * `origin` - 3D origin vector as a float typed array with 3 elements
      *   `[x, y, z]` in angstrom.
      * * `pbc_x` - Enable periodic boundary in x direction
      * * `pbc_y` - Enable periodic boundary in y direction
@@ -814,12 +815,12 @@ export class Box {
      *
      * ```js
      * // Triclinic box
-     * const h = new Float32Array([10, 2, 0, 0, 10, 0, 0, 0, 10]);
-     * const origin = new Float32Array([0, 0, 0]);
+     * const h = hMatrix;
+     * const origin = originVec;
      * const box = new Box(h, origin, true, true, true);
      * ```
-     * @param {Float32Array} h
-     * @param {Float32Array} origin
+     * @param {Float64Array} h
+     * @param {Float64Array} origin
      * @param {boolean} pbc_x
      * @param {boolean} pbc_y
      * @param {boolean} pbc_z
@@ -845,7 +846,7 @@ export class Box {
      * # Example (JavaScript)
      *
      * ```js
-     * const o = box.origin().toCopy(); // Float32Array [0, 0, 0]
+     * const o = box.origin().toCopy(); // Float32Array or Float64Array [0, 0, 0]
      * ```
      * @returns {WasmArray}
      */
@@ -858,9 +859,9 @@ export class Box {
      *
      * # Arguments
      *
-     * * `lengths` - Box dimensions as `Float32Array` with 3 elements
+     * * `lengths` - Box dimensions as a float typed array with 3 elements
      *   `[lx, ly, lz]` in angstrom (A)
-     * * `origin` - 3D origin vector as `Float32Array` with 3 elements
+     * * `origin` - 3D origin vector as a float typed array with 3 elements
      *   `[x, y, z]` in angstrom
      * * `pbc_x` - Enable periodic boundary in x direction
      * * `pbc_y` - Enable periodic boundary in y direction
@@ -877,12 +878,12 @@ export class Box {
      * # Example (JavaScript)
      *
      * ```js
-     * const origin = new Float32Array([0, 0, 0]);
-     * const box = Box.ortho(new Float32Array([10, 20, 30]), origin, true, true, true);
+     * const origin = originVec;
+     * const box = Box.ortho(lengthsVec, origin, true, true, true);
      * console.log(box.volume()); // 6000.0
      * ```
-     * @param {Float32Array} lengths
-     * @param {Float32Array} origin
+     * @param {Float64Array} lengths
+     * @param {Float64Array} origin
      * @param {boolean} pbc_x
      * @param {boolean} pbc_y
      * @param {boolean} pbc_z
@@ -910,7 +911,7 @@ export class Box {
      * # Example (JavaScript)
      *
      * ```js
-     * const t = box.tilts().toCopy(); // Float32Array [0, 0, 0]
+     * const t = box.tilts().toCopy(); // Float32Array or Float64Array [0, 0, 0]
      * ```
      * @returns {WasmArray}
      */
@@ -926,7 +927,7 @@ export class Box {
      *
      * * `coords` - `WasmArray` with shape `[N, 3]` (fractional, dimensionless)
      * * `out_block` - Target [`Block`]
-     * * `out_key` - Column name for the result (f32, shape `[N, 3]`)
+     * * `out_key` - Column name for the result (float, shape `[N, 3]`)
      *
      * # Errors
      *
@@ -959,7 +960,7 @@ export class Box {
      *
      * * `coords` - `WasmArray` with shape `[N, 3]` (Cartesian, A)
      * * `out_block` - Target [`Block`]
-     * * `out_key` - Column name for the result (f32, shape `[N, 3]`)
+     * * `out_key` - Column name for the result (float, shape `[N, 3]`)
      *
      * # Errors
      *
@@ -1004,7 +1005,7 @@ export class Box {
      * # Example (JavaScript)
      *
      * ```js
-     * const frac = WasmArray.from(new Float32Array([0.5, 0.5, 0.5]), [1, 3]);
+     * const frac = WasmArray.from(fracCoords, [1, 3]);
      * const cart = box.toCart(frac);
      * console.log(cart.toCopy()); // [5, 5, 5] for a 10x10x10 box
      * ```
@@ -1042,7 +1043,7 @@ export class Box {
      * # Example (JavaScript)
      *
      * ```js
-     * const cart = WasmArray.from(new Float32Array([5, 5, 5]), [1, 3]);
+     * const cart = WasmArray.from(coords, [1, 3]);
      * const frac = box.toFrac(cart);
      * console.log(frac.toCopy()); // [0.5, 0.5, 0.5] for a 10x10x10 box
      * ```
@@ -1095,7 +1096,7 @@ export class Box {
      * # Example (JavaScript)
      *
      * ```js
-     * const pos = WasmArray.from(new Float32Array([12, -1, 5]), [1, 3]);
+     * const pos = WasmArray.from(positions, [1, 3]);
      * const wrapped = box.wrap(pos); // wraps into [0, lx) x [0, ly) x [0, lz)
      * ```
      * @param {WasmArray} coords
@@ -1120,7 +1121,7 @@ export class Box {
      * * `coords` - `WasmArray` with shape `[N, 3]` containing
      *   Cartesian coordinates in angstrom (A)
      * * `out_block` - Target [`Block`] to write the result into
-     * * `out_key` - Column name for the result (f32, shape `[N, 3]`)
+     * * `out_key` - Column name for the result (float, shape `[N, 3]`)
      *
      * # Errors
      *
@@ -1149,6 +1150,110 @@ export class Box {
 }
 if (Symbol.dispose) Box.prototype[Symbol.dispose] = Box.prototype.free;
 
+/**
+ * Mass-weighted cluster center calculator.
+ */
+export class CenterOfMass {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CenterOfMassFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_centerofmass_free(ptr, 0);
+    }
+    /**
+     * Compute centers of mass.
+     * @param {Frame} frame
+     * @param {ClusterResult} cluster_result
+     * @returns {CenterOfMassResult}
+     */
+    compute(frame, cluster_result) {
+        _assertClass(frame, Frame);
+        _assertClass(cluster_result, ClusterResult);
+        const ret = wasm.centerofmass_compute(this.__wbg_ptr, frame.__wbg_ptr, cluster_result.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return CenterOfMassResult.__wrap(ret[0]);
+    }
+    /**
+     * Create a center-of-mass calculator.
+     *
+     * Pass `null` for uniform masses, or a float typed array of per-particle masses.
+     * @param {Float64Array | null} [masses]
+     */
+    constructor(masses) {
+        var ptr0 = isLikeNone(masses) ? 0 : passArrayF64ToWasm0(masses, wasm.__wbindgen_malloc_command_export);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.centerofmass_new(ptr0, len0);
+        this.__wbg_ptr = ret >>> 0;
+        CenterOfMassFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) CenterOfMass.prototype[Symbol.dispose] = CenterOfMass.prototype.free;
+
+/**
+ * Result of center-of-mass computation.
+ *
+ * # Example (JavaScript)
+ *
+ * ```js
+ * const com = new CenterOfMass().compute(frame, clusterResult);
+ * com.centersOfMass();   // Float32Array or Float64Array [x0,y0,z0, ...]
+ * com.clusterMasses();   // Float32Array or Float64Array
+ * ```
+ */
+export class CenterOfMassResult {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(CenterOfMassResult.prototype);
+        obj.__wbg_ptr = ptr;
+        CenterOfMassResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CenterOfMassResultFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_centerofmassresult_free(ptr, 0);
+    }
+    /**
+     * Zero-copy `Float64Array` view of mass-weighted centers, flat
+     * `[x0,y0,z0, x1,y1,z1, ...]`. **Invalidated** on WASM memory growth.
+     * @returns {Float64Array}
+     */
+    centersOfMass() {
+        const ret = wasm.centerofmassresult_centersOfMass(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Zero-copy `Float64Array` view of total mass per cluster.
+     * **Invalidated** on WASM memory growth.
+     * @returns {Float64Array}
+     */
+    clusterMasses() {
+        const ret = wasm.centerofmassresult_clusterMasses(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Number of clusters.
+     * @returns {number}
+     */
+    get numClusters() {
+        const ret = wasm.centerofmassresult_numClusters(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) CenterOfMassResult.prototype[Symbol.dispose] = CenterOfMassResult.prototype.free;
+
 /**
  * Distance-based cluster analysis using BFS on the neighbor graph.
  *
@@ -1241,6 +1346,53 @@ export class Cluster {
 }
 if (Symbol.dispose) Cluster.prototype[Symbol.dispose] = Cluster.prototype.free;
 
+/**
+ * Geometric cluster centers with minimum image convention.
+ *
+ * # Example (JavaScript)
+ *
+ * ```js
+ * const centers = new ClusterCenters().compute(frame, clusterResult);
+ * // Float32Array or Float64Array [x0,y0,z0, x1,y1,z1, ...]
+ * ```
+ */
+export class ClusterCenters {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ClusterCentersFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_clustercenters_free(ptr, 0);
+    }
+    /**
+     * Compute geometric centers. Returns a flat float typed array `[x0,y0,z0, ...]`.
+     * @param {Frame} frame
+     * @param {ClusterResult} cluster_result
+     * @returns {Float64Array}
+     */
+    compute(frame, cluster_result) {
+        _assertClass(frame, Frame);
+        _assertClass(cluster_result, ClusterResult);
+        const ret = wasm.clustercenters_compute(this.__wbg_ptr, frame.__wbg_ptr, cluster_result.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    constructor() {
+        const ret = wasm.clustercenters_new();
+        this.__wbg_ptr = ret >>> 0;
+        ClusterCentersFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) ClusterCenters.prototype[Symbol.dispose] = ClusterCenters.prototype.free;
+
 /**
  * Result of a distance-based cluster analysis.
  *
@@ -1327,10 +1479,10 @@ if (Symbol.dispose) ClusterResult.prototype[Symbol.dispose] = ClusterResult.prot
  * # Conventions
  *
  * - The `"atoms"` block should contain per-atom properties: `symbol`
- *   (string), `x`/`y`/`z` (f32, coordinates in angstrom), and optionally
- *   `mass` (f32, atomic mass units) and `charge` (f32, elementary charges).
+ *   (string), `x`/`y`/`z` (F, coordinates in angstrom), and optionally
+ *   `mass` (F, atomic mass units) and `charge` (F, elementary charges).
  * - The `"bonds"` block should contain bond topology: `i`/`j` (u32,
- *   zero-based atom indices) and `order` (f32, bond order: 1.0 = single,
+ *   zero-based atom indices) and `order` (F, bond order: 1.0 = single,
  *   1.5 = aromatic, 2.0 = double, 3.0 = triple).
  *
  * # Example (JavaScript)
@@ -1338,7 +1490,7 @@ if (Symbol.dispose) ClusterResult.prototype[Symbol.dispose] = ClusterResult.prot
  * ```js
  * const frame = new Frame();
  * const atoms = frame.createBlock("atoms");
- * atoms.setColF32("x", new Float32Array([0.0, 1.54]));
+ * atoms.setColF("x", xCoords);
  * ```
  */
 export class Frame {
@@ -1400,7 +1552,7 @@ export class Frame {
      *
      * ```js
      * const atoms = frame.createBlock("atoms");
-     * atoms.setColF32("x", new Float32Array([1.0, 2.0]));
+     * atoms.setColF("x", xCoords);
      * ```
      * @param {string} key
      * @returns {Block}
@@ -1455,7 +1607,7 @@ export class Frame {
      * ```js
      * const atoms = frame.getBlock("atoms");
      * if (atoms) {
-     *   const x = atoms.copyColF32("x");
+     *   const x = atoms.copyColF("x");
      * }
      * ```
      * @param {string} key
@@ -1467,6 +1619,79 @@ export class Frame {
         const ret = wasm.frame_getBlock(this.__wbg_ptr, ptr0, len0);
         return ret === 0 ? undefined : Block.__wrap(ret);
     }
+    /**
+     * Retrieve a named grid attached to this frame.
+     *
+     * Returns a cloned [`Grid`] wrapper, or `undefined` if the grid does
+     * not exist. The returned object is independent of the frame — mutations
+     * to it are not reflected in the frame without a subsequent
+     * [`insertGrid`](Frame::insert_grid) call.
+     *
+     * # Arguments
+     *
+     * * `name` — Grid name to retrieve.
+     *
+     * # Example (JavaScript)
+     *
+     * ```js
+     * const g = frame.getGrid("chgcar");
+     * if (g) {
+     *   const arr = g.getArray("rho");
+     * }
+     * ```
+     * @param {string} name
+     * @returns {Grid | undefined}
+     */
+    getGrid(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.frame_getGrid(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] === 0 ? undefined : Grid.__wrap(ret[0]);
+    }
+    /**
+     * Return the names of all grids attached to this frame.
+     *
+     * # Example (JavaScript)
+     *
+     * ```js
+     * const names = frame.gridNames(); // e.g. ["chgcar", "spin"]
+     * ```
+     * @returns {Array<any>}
+     */
+    gridNames() {
+        const ret = wasm.frame_gridNames(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Returns `true` if a named grid is attached to this frame.
+     *
+     * # Arguments
+     *
+     * * `name` — Grid name to look up.
+     *
+     * # Example (JavaScript)
+     *
+     * ```js
+     * frame.hasGrid("chgcar"); // true or false
+     * ```
+     * @param {string} name
+     * @returns {boolean}
+     */
+    hasGrid(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.frame_hasGrid(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
     /**
      * Insert a block by deep-copying its data into this frame's store.
      *
@@ -1505,6 +1730,42 @@ export class Frame {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
+    /**
+     * Attach a grid to this frame under the given name.
+     *
+     * If a grid with the same name already exists it is replaced. The grid
+     * data is moved into the frame; the JS `Grid` object becomes empty after
+     * this call and should not be reused.
+     *
+     * # Arguments
+     *
+     * * `name` — Name to store the grid under (e.g., `"chgcar"`).
+     * * `grid` — The [`Grid`] to attach.
+     *
+     * # Errors
+     *
+     * Throws a `JsValue` string if the frame has been dropped.
+     *
+     * # Example (JavaScript)
+     *
+     * ```js
+     * const grid = new Grid(10, 10, 10, origin, cell, true, true, true);
+     * grid.insertArray("rho", rhoData);
+     * frame.insertGrid("chgcar", grid);
+     * ```
+     * @param {string} name
+     * @param {Grid} grid
+     */
+    insertGrid(name, grid) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
+        const len0 = WASM_VECTOR_LEN;
+        _assertClass(grid, Grid);
+        var ptr1 = grid.__destroy_into_raw();
+        const ret = wasm.frame_insertGrid(this.__wbg_ptr, ptr0, len0, ptr1);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * Create a new, empty `Frame` with no blocks and no simulation box.
      *
@@ -1547,6 +1808,32 @@ export class Frame {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
+    /**
+     * Remove a named grid from this frame.
+     *
+     * # Arguments
+     *
+     * * `name` — Grid name to remove.
+     *
+     * # Errors
+     *
+     * Throws a `JsValue` string if the frame has been dropped.
+     *
+     * # Example (JavaScript)
+     *
+     * ```js
+     * frame.removeGrid("chgcar");
+     * ```
+     * @param {string} name
+     */
+    removeGrid(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.frame_removeGrid(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * Rename a block from `old_key` to `new_key`.
      *
@@ -1642,7 +1929,7 @@ export class Frame {
      * # Example (JavaScript)
      *
      * ```js
-     * const origin = new Float32Array([0, 0, 0]);
+     * const origin = originVec;
      * frame.simbox = Box.cube(10.0, origin, true, true, true);
      * ```
      * @param {Box | null} [simbox]
@@ -1684,82 +1971,546 @@ export class Frame {
 if (Symbol.dispose) Frame.prototype[Symbol.dispose] = Frame.prototype.free;
 
 /**
- * LAMMPS data file reader.
- *
- * Reads LAMMPS data files (the format written by `write_data`). The
- * reader produces a [`Frame`] containing:
+ * A uniform spatial grid storing multiple named scalar arrays.
  *
- * - `"atoms"` block: `type` (i32), `x`, `y`, `z` (f32, angstrom),
- *   and optionally `charge` (f32)
- * - `"bonds"` block (if present): `i`, `j` (u32), `type` (i32)
- * - Simulation box (`simbox`) with PBC
- *
- * Only a single frame is supported (`step = 0`).
+ * All arrays in a `Grid` share the same spatial definition: dimensions
+ * (`[nx, ny, nz]`), Cartesian origin, cell matrix (columns are lattice
+ * vectors, matching VASP/molrs convention), and periodic boundary flags.
  *
  * # Example (JavaScript)
  *
  * ```js
- * const reader = new LAMMPSReader(dataFileContent);
- * const frame = reader.read(0);
- * const atoms = frame.getBlock("atoms");
- * const bonds = frame.getBlock("bonds");
- * const box   = frame.simbox;
+ * // Create a 10×10×10 cubic grid
+ * const origin = new Float32Array([0, 0, 0]);
+ * const cell = new Float32Array([
+ *   10, 0, 0,   // first column (a vector)
+ *    0,10, 0,   // second column (b vector)
+ *    0, 0,10,   // third column (c vector)
+ * ]);
+ * const grid = new Grid(10, 10, 10, origin, cell, true, true, true);
+ *
+ * // Insert a density array (must have length = 10*10*10 = 1000)
+ * const rho = new Float32Array(1000).fill(1.0);
+ * grid.insertArray("rho", rho);
+ *
+ * // Retrieve it
+ * const arr = grid.getArray("rho");
+ * console.log(arr.toCopy());
  * ```
  */
-export class LAMMPSReader {
+export class Grid {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Grid.prototype);
+        obj.__wbg_ptr = ptr;
+        GridFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        LAMMPSReaderFinalization.unregister(this);
+        GridFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_lammpsreader_free(ptr, 0);
+        wasm.__wbg_grid_free(ptr, 0);
     }
     /**
-     * Check whether the file contains no valid frames.
+     * Names of all scalar arrays stored in this grid.
      *
-     * # Errors
+     * # Example (JavaScript)
      *
-     * Throws a `JsValue` string on parse errors.
-     * @returns {boolean}
+     * ```js
+     * const names = grid.arrayNames(); // e.g. ["rho", "spin"]
+     * ```
+     * @returns {Array<any>}
      */
-    isEmpty() {
-        const ret = wasm.lammpsreader_isEmpty(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return ret[0] !== 0;
+    arrayNames() {
+        const ret = wasm.grid_arrayNames(this.__wbg_ptr);
+        return ret;
     }
     /**
-     * Return the number of frames (always 0 or 1 for LAMMPS data files).
+     * Cell matrix in Ångström as a flat array of length 9 in column-major
+     * order (columns are lattice vectors, matching VASP/molrs convention).
      *
-     * # Errors
+     * Layout: `[col0_x, col0_y, col0_z, col1_x, col1_y, col1_z, col2_x, col2_y, col2_z]`
      *
-     * Throws a `JsValue` string on parse errors.
-     * @returns {number}
+     * # Example (JavaScript)
+     *
+     * ```js
+     * const c = grid.cell();
+     * const flat = c.toCopy(); // Float32Array of length 9
+     * ```
+     * @returns {WasmArray}
      */
-    len() {
-        const ret = wasm.lammpsreader_len(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return ret[0] >>> 0;
+    cell() {
+        const ret = wasm.grid_cell(this.__wbg_ptr);
+        return WasmArray.__wrap(ret);
     }
     /**
-     * Create a new LAMMPS data file reader from string content.
+     * Grid dimensions `[nx, ny, nz]`.
      *
-     * # Arguments
+     * # Example (JavaScript)
      *
-     * * `content` - The full text content of a LAMMPS data file
+     * ```js
+     * console.log(grid.dim()); // [10, 10, 10]
+     * ```
+     * @returns {Uint32Array}
+     */
+    dim() {
+        const ret = wasm.grid_dim(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Retrieve a named scalar array as a zero-copy `Float64Array` view
+     * over the underlying WASM memory. Flat row-major order, length
+     * `nx * ny * nz`. Use [`Grid::dim`] for shape.
+     *
+     * **Warning**: the view is invalidated on any WASM memory growth.
+     * Copy it in JS (`new Float64Array(view)`) if it needs to outlive
+     * subsequent allocations.
+     *
+     * Returns `undefined` if the named array does not exist.
      *
      * # Example (JavaScript)
      *
      * ```js
-     * const reader = new LAMMPSReader(dataFileString);
+     * const view = grid.getArray("rho");          // zero-copy
+     * const copy = new Float64Array(view);        // owned copy if needed
      * ```
-     * @param {string} content
+     * @param {string} name
+     * @returns {Float64Array | undefined}
+     */
+    getArray(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.grid_getArray(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * Returns `true` if a named array is present in this grid.
+     *
+     * # Arguments
+     *
+     * * `name` — Array name to look up.
+     *
+     * # Example (JavaScript)
+     *
+     * ```js
+     * grid.hasArray("rho"); // true or false
+     * ```
+     * @param {string} name
+     * @returns {boolean}
+     */
+    hasArray(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.grid_hasArray(this.__wbg_ptr, ptr0, len0);
+        return ret !== 0;
+    }
+    /**
+     * Insert (or replace) a named scalar array.
+     *
+     * The provided `data` must have exactly `nx * ny * nz` elements in
+     * row-major `(ix, iy, iz)` order.
+     *
+     * # Arguments
+     *
+     * * `name` — Array name.
+     * * `data` — Float32Array with length equal to `grid.total()`.
+     *
+     * # Errors
+     *
+     * Throws if `data.length != nx * ny * nz`.
+     *
+     * # Example (JavaScript)
+     *
+     * ```js
+     * const rho = new Float32Array(grid.total()).fill(0.5);
+     * grid.insertArray("rho", rho);
+     * ```
+     * @param {string} name
+     * @param {Float64Array} data
+     */
+    insertArray(name, data) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc_command_export);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.grid_insertArray(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Returns `true` if no arrays are stored.
+     *
+     * # Example (JavaScript)
+     *
+     * ```js
+     * console.log(grid.isEmpty()); // true for a freshly created grid
+     * ```
+     * @returns {boolean}
+     */
+    isEmpty() {
+        const ret = wasm.grid_isEmpty(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Number of named arrays stored in this grid.
+     *
+     * # Example (JavaScript)
+     *
+     * ```js
+     * console.log(grid.len()); // e.g. 2
+     * ```
+     * @returns {number}
+     */
+    len() {
+        const ret = wasm.grid_len(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Create a new empty grid with the given spatial definition.
+     *
+     * # Arguments
+     *
+     * * `dim_x`, `dim_y`, `dim_z` — Number of grid points along each axis.
+     * * `origin` — Float32Array of length 3: Cartesian origin in Ångström.
+     * * `cell` — Float32Array of length 9: cell matrix in column-major order.
+     *   `cell[0..3]` is the first lattice vector (a), `cell[3..6]` is b,
+     *   `cell[6..9]` is c (matching VASP/molrs convention where columns are
+     *   lattice vectors).
+     * * `pbc_x`, `pbc_y`, `pbc_z` — Periodic boundary flags for each axis.
+     *
+     * # Errors
+     *
+     * Throws if `origin` does not have length 3, or `cell` does not have
+     * length 9.
+     *
+     * # Example (JavaScript)
+     *
+     * ```js
+     * const origin = new Float32Array([0, 0, 0]);
+     * const cell = new Float32Array([10,0,0, 0,10,0, 0,0,10]);
+     * const grid = new Grid(10, 10, 10, origin, cell, true, true, true);
+     * ```
+     * @param {number} dim_x
+     * @param {number} dim_y
+     * @param {number} dim_z
+     * @param {Float64Array} origin
+     * @param {Float64Array} cell
+     * @param {boolean} pbc_x
+     * @param {boolean} pbc_y
+     * @param {boolean} pbc_z
+     */
+    constructor(dim_x, dim_y, dim_z, origin, cell, pbc_x, pbc_y, pbc_z) {
+        const ptr0 = passArrayF64ToWasm0(origin, wasm.__wbindgen_malloc_command_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(cell, wasm.__wbindgen_malloc_command_export);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.grid_new(dim_x, dim_y, dim_z, ptr0, len0, ptr1, len1, pbc_x, pbc_y, pbc_z);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        GridFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Cartesian origin in Ångström as a 1-D array of length 3.
+     *
+     * # Example (JavaScript)
+     *
+     * ```js
+     * const o = grid.origin();
+     * const arr = o.toCopy(); // Float32Array [ox, oy, oz]
+     * ```
+     * @returns {WasmArray}
+     */
+    origin() {
+        const ret = wasm.grid_origin(this.__wbg_ptr);
+        return WasmArray.__wrap(ret);
+    }
+    /**
+     * Periodic boundary flags as a `Uint8Array`-compatible slice.
+     *
+     * Each element is `1` (periodic) or `0` (not periodic).
+     *
+     * # Example (JavaScript)
+     *
+     * ```js
+     * console.log(grid.pbc()); // [1, 1, 1]
+     * ```
+     * @returns {Uint8Array}
+     */
+    pbc() {
+        const ret = wasm.grid_pbc(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * Total number of voxels: `nx * ny * nz`.
+     *
+     * # Example (JavaScript)
+     *
+     * ```js
+     * console.log(grid.total()); // 1000 for a 10×10×10 grid
+     * ```
+     * @returns {number}
+     */
+    total() {
+        const ret = wasm.grid_total(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) Grid.prototype[Symbol.dispose] = Grid.prototype.free;
+
+/**
+ * Gyration tensor per cluster.
+ *
+ * Returns flat array: `[g00,g01,g02, g10,g11,g12, g20,g21,g22, ...]` per cluster.
+ */
+export class GyrationTensor {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        GyrationTensorFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_gyrationtensor_free(ptr, 0);
+    }
+    /**
+     * Compute gyration tensors. Returns a flat float typed array (9 values per cluster).
+     * @param {Frame} frame
+     * @param {ClusterResult} cluster_result
+     * @returns {Float64Array}
+     */
+    compute(frame, cluster_result) {
+        _assertClass(frame, Frame);
+        _assertClass(cluster_result, ClusterResult);
+        const ret = wasm.gyrationtensor_compute(this.__wbg_ptr, frame.__wbg_ptr, cluster_result.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    constructor() {
+        const ret = wasm.gyrationtensor_new();
+        this.__wbg_ptr = ret >>> 0;
+        GyrationTensorFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) GyrationTensor.prototype[Symbol.dispose] = GyrationTensor.prototype.free;
+
+/**
+ * Moment of inertia tensor per cluster.
+ */
+export class InertiaTensor {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        InertiaTensorFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_inertiatensor_free(ptr, 0);
+    }
+    /**
+     * Compute inertia tensors. Returns a flat float typed array (9 values per cluster).
+     * @param {Frame} frame
+     * @param {ClusterResult} cluster_result
+     * @returns {Float64Array}
+     */
+    compute(frame, cluster_result) {
+        _assertClass(frame, Frame);
+        _assertClass(cluster_result, ClusterResult);
+        const ret = wasm.inertiatensor_compute(this.__wbg_ptr, frame.__wbg_ptr, cluster_result.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * @param {Float64Array | null} [masses]
+     */
+    constructor(masses) {
+        var ptr0 = isLikeNone(masses) ? 0 : passArrayF64ToWasm0(masses, wasm.__wbindgen_malloc_command_export);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.inertiatensor_new(ptr0, len0);
+        this.__wbg_ptr = ret >>> 0;
+        InertiaTensorFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) InertiaTensor.prototype[Symbol.dispose] = InertiaTensor.prototype.free;
+
+/**
+ * LAMMPS dump trajectory file reader.
+ *
+ * Reads multi-frame LAMMPS dump files (the format produced by the
+ * `dump` command). Each frame produces a [`Frame`] containing an
+ * `"atoms"` block with columns matching the dump header (e.g.
+ * `id`, `type`, `x`, `y`, `z`, `vx`, `vy`, `vz`).
+ *
+ * # Example (JavaScript)
+ *
+ * ```js
+ * const reader = new LAMMPSDumpReader(dumpContent);
+ * console.log(reader.len()); // number of timesteps
+ * const frame = reader.read(0);
+ * const atoms = frame.getBlock("atoms");
+ * ```
+ */
+export class LAMMPSDumpReader {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        LAMMPSDumpReaderFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_lammpsdumpreader_free(ptr, 0);
+    }
+    /**
+     * Check whether the file contains no frames.
+     * @returns {boolean}
+     */
+    isEmpty() {
+        const ret = wasm.lammpsdumpreader_isEmpty(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Return the number of frames in the dump file.
+     * @returns {number}
+     */
+    len() {
+        const ret = wasm.lammpsdumpreader_len(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * Create a new LAMMPS dump reader from string 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.lammpsdumpreader_new(ptr0, len0);
+        this.__wbg_ptr = ret >>> 0;
+        LAMMPSDumpReaderFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Read a frame at the given step index.
+     * @param {number} step
+     * @returns {Frame | undefined}
+     */
+    read(step) {
+        const ret = wasm.lammpsdumpreader_read(this.__wbg_ptr, step);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] === 0 ? undefined : Frame.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) LAMMPSDumpReader.prototype[Symbol.dispose] = LAMMPSDumpReader.prototype.free;
+
+/**
+ * LAMMPS data file reader.
+ *
+ * Reads LAMMPS data files (the format written by `write_data`). The
+ * reader produces a [`Frame`] containing:
+ *
+ * - `"atoms"` block: `type` (i32), `x`, `y`, `z` (F, angstrom),
+ *   and optionally `charge` (F)
+ * - `"bonds"` block (if present): `i`, `j` (u32), `type` (i32)
+ * - Simulation box (`simbox`) with PBC
+ *
+ * Only a single frame is supported (`step = 0`).
+ *
+ * # Example (JavaScript)
+ *
+ * ```js
+ * const reader = new LAMMPSReader(dataFileContent);
+ * const frame = reader.read(0);
+ * const atoms = frame.getBlock("atoms");
+ * const bonds = frame.getBlock("bonds");
+ * const box   = frame.simbox;
+ * ```
+ */
+export class LAMMPSReader {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        LAMMPSReaderFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_lammpsreader_free(ptr, 0);
+    }
+    /**
+     * Check whether the file contains no valid frames.
+     *
+     * # Errors
+     *
+     * Throws a `JsValue` string on parse errors.
+     * @returns {boolean}
+     */
+    isEmpty() {
+        const ret = wasm.lammpsreader_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 LAMMPS data files).
+     *
+     * # Errors
+     *
+     * Throws a `JsValue` string on parse errors.
+     * @returns {number}
+     */
+    len() {
+        const ret = wasm.lammpsreader_len(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * Create a new LAMMPS data file reader from string content.
+     *
+     * # Arguments
+     *
+     * * `content` - The full text content of a LAMMPS data file
+     *
+     * # Example (JavaScript)
+     *
+     * ```js
+     * const reader = new LAMMPSReader(dataFileString);
+     * ```
+     * @param {string} content
      */
     constructor(content) {
         const ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
@@ -1841,7 +2592,7 @@ export class LinkedCell {
      * Finds all unique pairs `(i < j)` of atoms within the cutoff
      * distance using the cell-list algorithm.
      *
-     * The frame must have an `"atoms"` block with `x`, `y`, `z` (f32) columns.
+     * The frame must have an `"atoms"` block with `x`, `y`, `z` (F) columns.
      * If the frame has a `simbox`, periodic boundary conditions are used.
      * Otherwise, a free-boundary bounding box is auto-generated.
      *
@@ -1862,7 +2613,7 @@ export class LinkedCell {
      * ```js
      * const lc = new LinkedCell(3.0);
      * const nlist = lc.build(frame);
-     * const dists = nlist.distances(); // Float32Array
+     * const dists = nlist.distances(); // Float32Array or Float64Array
      * ```
      * @param {Frame} frame
      * @returns {NeighborList}
@@ -1989,7 +2740,7 @@ export class MSD {
      * # Arguments
      *
      * * `frame` - Frame with `"atoms"` block containing
-     *   `x`, `y`, `z` (f32) columns
+     *   `x`, `y`, `z` (F) columns
      *
      * # Errors
      *
@@ -2067,7 +2818,7 @@ if (Symbol.dispose) MSD.prototype[Symbol.dispose] = MSD.prototype.free;
  * ```js
  * const result = msd.compute(frame);
  * console.log(result.mean);              // number (A^2)
- * console.log(result.perParticle());     // Float32Array (A^2)
+ * console.log(result.perParticle());     // Float32Array or Float64Array (A^2)
  * ```
  */
 export class MSDResult {
@@ -2100,21 +2851,78 @@ export class MSDResult {
         return ret;
     }
     /**
-     * Per-particle squared displacements as `Float32Array` in A^2.
-     *
-     * `perParticle()[i]` is `|r_i(t) - r_i(0)|^2` for particle `i`.
-     * Length equals the number of atoms.
-     * @returns {Float32Array}
+     * Zero-copy `Float64Array` view of per-particle squared displacements
+     * in A². `perParticle()[i]` is `|r_i(t) - r_i(0)|²` for particle `i`.
+     * **Invalidated** on WASM memory growth; copy in JS if needed.
+     * @returns {Float64Array}
      */
     perParticle() {
         const ret = wasm.msdresult_perParticle(this.__wbg_ptr);
-        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
-        return v1;
+        return ret;
     }
 }
 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] >>> 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.
  *
@@ -2139,7 +2947,7 @@ if (Symbol.dispose) MSDResult.prototype[Symbol.dispose] = MSDResult.prototype.fr
  *
  * const i = nlist.queryPointIndices(); // Uint32Array
  * const j = nlist.pointIndices();      // Uint32Array
- * const d = nlist.distances();         // Float32Array (in A)
+ * const d = nlist.distances();         // Float32Array or Float64Array (in A)
  * ```
  */
 export class NeighborList {
@@ -2161,29 +2969,25 @@ export class NeighborList {
         wasm.__wbg_neighborlist_free(ptr, 0);
     }
     /**
-     * Squared pairwise distances in A^2, as a `Float32Array`.
-     *
-     * More efficient than `distances()` when you only need to
-     * compare or threshold distances.
-     * @returns {Float32Array}
+     * Zero-copy `Float64Array` view of squared pairwise distances in A^2.
+     * Same invalidation caveat as [`queryPointIndices`](Self::query_point_indices).
+     * @returns {Float64Array}
      */
     distSq() {
         const ret = wasm.neighborlist_distSq(this.__wbg_ptr);
-        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
-        return v1;
+        return ret;
     }
     /**
-     * Pairwise distances in angstrom (A), as a `Float32Array`.
+     * Pairwise distances in angstrom (A). Computed lazily from `distSq`.
      *
-     * `distances()[k]` is the distance between query point
-     * `queryPointIndices()[k]` and reference point `pointIndices()[k]`.
-     * @returns {Float32Array}
+     * Returns an owned copy because distances are derived on the fly
+     * (`sqrt` per pair) rather than stored.
+     * @returns {Float64Array}
      */
     distances() {
         const ret = wasm.neighborlist_distances(this.__wbg_ptr);
-        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 8, 8);
         return v1;
     }
     /**
@@ -2223,27 +3027,23 @@ export class NeighborList {
         return ret >>> 0;
     }
     /**
-     * Reference point indices (`j`) for each pair, as a `Uint32Array`.
+     * Zero-copy `Uint32Array` view of reference point indices (`j`).
+     * Same invalidation caveat as [`queryPointIndices`](Self::query_point_indices).
      * @returns {Uint32Array}
      */
     pointIndices() {
         const ret = wasm.neighborlist_pointIndices(this.__wbg_ptr);
-        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
-        return v1;
+        return ret;
     }
     /**
-     * Query point indices (`i`) for each pair, as a `Uint32Array`.
-     *
-     * The `k`-th pair connects query point `queryPointIndices()[k]`
-     * to reference point `pointIndices()[k]`.
+     * Zero-copy `Uint32Array` view of query point indices (`i`) over
+     * WASM memory. **Invalidated** on any WASM memory growth — copy
+     * in JS (`new Uint32Array(view)`) if it needs to outlive later calls.
      * @returns {Uint32Array}
      */
     queryPointIndices() {
         const ret = wasm.neighborlist_queryPointIndices(this.__wbg_ptr);
-        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
-        return v1;
+        return ret;
     }
 }
 if (Symbol.dispose) NeighborList.prototype[Symbol.dispose] = NeighborList.prototype.free;
@@ -2253,8 +3053,8 @@ if (Symbol.dispose) NeighborList.prototype[Symbol.dispose] = NeighborList.protot
  *
  * PDB files contain a single molecular structure. The reader produces
  * a [`Frame`] with an `"atoms"` block containing columns such as
- * `name` (string), `resname` (string), `x`, `y`, `z` (f32, angstrom),
- * and optionally `occupancy` and `bfactor` (f32).
+ * `name` (string), `resname` (string), `x`, `y`, `z` (F, angstrom),
+ * and optionally `occupancy` and `bfactor` (F).
  *
  * # Example (JavaScript)
  *
@@ -2263,7 +3063,7 @@ if (Symbol.dispose) NeighborList.prototype[Symbol.dispose] = NeighborList.protot
  * const frame = reader.read(0);
  * const atoms = frame.getBlock("atoms");
  * const names = atoms.copyColStr("name"); // ["CA", "CB", ...]
- * const x = atoms.copyColF32("x");
+ * const x = atoms.copyColF("x");
  * ```
  */
 export class PDBReader {
@@ -2388,8 +3188,8 @@ if (Symbol.dispose) PDBReader.prototype[Symbol.dispose] = PDBReader.prototype.fr
  * const rdf = new RDF(100, 5.0);
  * const result = rdf.compute(frame, nlist);
  *
- * const r  = result.binCenters();  // Float32Array, bin centers in A
- * const gr = result.rdf();         // Float32Array, g(r) values
+ * const r  = result.binCenters();  // Float32Array or Float64Array, bin centers in A
+ * const gr = result.rdf();         // Float32Array or Float64Array, g(r) values
  * ```
  */
 export class RDF {
@@ -2427,7 +3227,7 @@ export class RDF {
      *
      * ```js
      * const result = rdf.compute(frame, nlist);
-     * const gr = result.rdf(); // Float32Array
+     * const gr = result.rdf(); // Float32Array or Float64Array
      * ```
      * @param {Frame} frame
      * @param {NeighborList} neighbors
@@ -2478,9 +3278,9 @@ if (Symbol.dispose) RDF.prototype[Symbol.dispose] = RDF.prototype.free;
  *
  * ```js
  * const result = rdf.compute(frame, nlist);
- * const r  = result.binCenters();  // Float32Array [0.025, 0.075, ...]
- * const gr = result.rdf();         // Float32Array, normalized g(r)
- * const nr = result.pairCounts();  // Float32Array, raw counts
+ * const r  = result.binCenters();  // Float32Array or Float64Array [0.025, 0.075, ...]
+ * const gr = result.rdf();         // Float32Array or Float64Array, normalized g(r)
+ * const nr = result.pairCounts();  // Float32Array or Float64Array, raw counts
  * console.log("Volume:", result.volume, "A^3");
  * console.log("N_ref:", result.numPoints);
  * ```
@@ -2504,28 +3304,23 @@ export class RDFResult {
         wasm.__wbg_rdfresult_free(ptr, 0);
     }
     /**
-     * Bin center positions as `Float32Array` in angstrom (A).
-     *
-     * Length equals `n_bins` (the value passed to the `RDF` constructor).
-     * @returns {Float32Array}
+     * Zero-copy `Float64Array` view of bin center positions in A.
+     * Length equals `n_bins`. **Invalidated** on WASM memory growth;
+     * copy in JS if it needs to outlive later calls.
+     * @returns {Float64Array}
      */
     binCenters() {
         const ret = wasm.rdfresult_binCenters(this.__wbg_ptr);
-        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
-        return v1;
+        return ret;
     }
     /**
-     * Bin edge positions as `Float32Array` in angstrom (A).
-     *
-     * Length is `n_bins + 1` (one more than bin centers).
-     * @returns {Float32Array}
+     * Zero-copy `Float64Array` view of bin edge positions in A.
+     * Length is `n_bins + 1`. Same invalidation caveat.
+     * @returns {Float64Array}
      */
     binEdges() {
         const ret = wasm.rdfresult_binEdges(this.__wbg_ptr);
-        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
-        return v1;
+        return ret;
     }
     /**
      * Number of reference points used in the normalization.
@@ -2536,27 +3331,22 @@ export class RDFResult {
         return ret >>> 0;
     }
     /**
-     * Raw (un-normalized) pair counts per bin as `Float32Array`.
-     * @returns {Float32Array}
+     * Zero-copy `Float64Array` view of raw (un-normalized) pair counts
+     * per bin. Same invalidation caveat.
+     * @returns {Float64Array}
      */
     pairCounts() {
         const ret = wasm.rdfresult_pairCounts(this.__wbg_ptr);
-        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
-        return v1;
+        return ret;
     }
     /**
-     * Normalized g(r) values as `Float32Array` (dimensionless).
-     *
-     * A uniform ideal gas has g(r) = 1.0 everywhere. Peaks indicate
-     * preferred interatomic distances (coordination shells).
-     * @returns {Float32Array}
+     * Zero-copy `Float64Array` view of normalized g(r). Same invalidation
+     * caveat.
+     * @returns {Float64Array}
      */
     rdf() {
         const ret = wasm.rdfresult_rdf(this.__wbg_ptr);
-        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
-        return v1;
+        return ret;
     }
     /**
      * Simulation box volume used in the normalization, in A^3.
@@ -2570,150 +3360,135 @@ export class RDFResult {
 if (Symbol.dispose) RDFResult.prototype[Symbol.dispose] = RDFResult.prototype.free;
 
 /**
- * Reader for Zarr V3 simulation archives.
+ * Radius of gyration per cluster.
+ */
+export class RadiusOfGyration {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RadiusOfGyrationFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_radiusofgyration_free(ptr, 0);
+    }
+    /**
+     * Compute radii of gyration. Returns a float typed array of length `numClusters`.
+     * @param {Frame} frame
+     * @param {ClusterResult} cluster_result
+     * @returns {Float64Array}
+     */
+    compute(frame, cluster_result) {
+        _assertClass(frame, Frame);
+        _assertClass(cluster_result, ClusterResult);
+        const ret = wasm.radiusofgyration_compute(this.__wbg_ptr, frame.__wbg_ptr, cluster_result.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * @param {Float64Array | null} [masses]
+     */
+    constructor(masses) {
+        var ptr0 = isLikeNone(masses) ? 0 : passArrayF64ToWasm0(masses, wasm.__wbindgen_malloc_command_export);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.radiusofgyration_new(ptr0, len0);
+        this.__wbg_ptr = ret >>> 0;
+        RadiusOfGyrationFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) RadiusOfGyration.prototype[Symbol.dispose] = RadiusOfGyration.prototype.free;
+
+/**
+ * MDL molfile / SDF (V2000 CTAB) reader.
  *
- * Wraps [`SimulationStore`] from `molrs-core` for reading trajectory
- * frames and system metadata from an in-memory Zarr store. The store
- * is populated from a `Map<string, Uint8Array>` of file paths to
- * binary content.
+ * Parses the connection table found in `.mol` files and the record
+ * blocks of `.sdf` files. Coordinates come directly from the file —
+ * no 3D generation is performed. Only V2000 is supported; V3000
+ * records throw on read.
+ *
+ * Produces a [`Frame`] with:
+ * - `"atoms"` block: `element` (string), `id` (u32, 1-based),
+ *   `x`, `y`, `z` (F, angstrom)
+ * - `"bonds"` block (if present): `atomi`, `atomj` (u32, 0-based),
+ *   `order` (u32)
+ *
+ * Multi-record SDF files expose each record as a separate frame via
+ * `read(step)`.
  *
  * # Example (JavaScript)
  *
  * ```js
- * const files = new Map();
- * files.set("zarr.json", new Uint8Array([...]));
- * files.set("system/.zarray", new Uint8Array([...]));
- * // ... etc.
- *
- * const reader = new SimulationReader(files);
- * const frame = reader.readFrame(0);
+ * const reader = new SDFReader(sdfContent);
+ * const frame = reader.read(0);
+ * const atoms = frame.getBlock("atoms");
+ * const x = atoms.copyColF("x");
  * ```
  */
-export class SimulationReader {
+export class SDFReader {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        SimulationReaderFinalization.unregister(this);
+        SDFReaderFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_simulationreader_free(ptr, 0);
+        wasm.__wbg_sdfreader_free(ptr, 0);
     }
     /**
-     * Return the number of atoms in the system topology.
-     *
-     * # Example (JavaScript)
-     *
-     * ```js
-     * console.log(reader.countAtoms()); // e.g., 256
-     * ```
-     * @returns {number}
-     */
-    countAtoms() {
-        const ret = wasm.simulationreader_countAtoms(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * Return the number of trajectory frames in the archive.
-     *
-     * Returns `0` if no trajectory data is present.
-     *
-     * # Errors
-     *
-     * Throws a `JsValue` string on I/O errors.
-     *
-     * # Example (JavaScript)
-     *
-     * ```js
-     * console.log(reader.countFrames()); // e.g., 1000
-     * ```
-     * @returns {number}
+     * Check whether the file contains no records.
+     * @returns {boolean}
      */
-    countFrames() {
-        const ret = wasm.simulationreader_countFrames(this.__wbg_ptr);
+    isEmpty() {
+        const ret = wasm.sdfreader_isEmpty(this.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
-        }
-        return ret[0] >>> 0;
-    }
-    /**
-     * Create a reader from a map of file paths to binary content.
-     *
-     * The map keys are relative paths within the Zarr archive
-     * (e.g., `"zarr.json"`, `"system/.zarray"`). Values are the
-     * raw bytes of each file as `Uint8Array`.
-     *
-     * # Arguments
-     *
-     * * `files` - `Map<string, Uint8Array>` mapping archive paths
-     *   to their binary content
-     *
-     * # Returns
-     *
-     * A new `SimulationReader` ready to read frames.
-     *
-     * # Errors
-     *
-     * Throws a `JsValue` string if the archive cannot be opened
-     * (e.g., missing required metadata files).
-     *
-     * # Example (JavaScript)
-     *
-     * ```js
-     * const reader = new SimulationReader(filesMap);
-     * ```
-     * @param {Map<any, any>} files
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Return the total number of records in the SDF file.
+     * @returns {number}
      */
-    constructor(files) {
-        const ret = wasm.simulationreader_new(files);
+    len() {
+        const ret = wasm.sdfreader_len(this.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        this.__wbg_ptr = ret[0] >>> 0;
-        SimulationReaderFinalization.register(this, this.__wbg_ptr, this);
+        return ret[0] >>> 0;
+    }
+    /**
+     * Create a new SDF 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.sdfreader_new(ptr0, len0);
+        this.__wbg_ptr = ret >>> 0;
+        SDFReaderFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
     /**
-     * Read a trajectory frame at the given time index.
-     *
-     * The returned [`Frame`] merges the static system topology
-     * (atoms, bonds) with the per-frame trajectory data (positions,
-     * velocities, etc.) at time step `t`.
-     *
-     * # Arguments
-     *
-     * * `t` - Zero-based time step index
-     *
-     * # Returns
-     *
-     * A [`Frame`] with merged system + trajectory data, or `undefined`
-     * if no trajectory is present.
-     *
-     * # Errors
-     *
-     * Throws a `JsValue` string on I/O or deserialization errors.
-     *
-     * # Example (JavaScript)
-     *
-     * ```js
-     * const frame = reader.readFrame(0);
-     * if (frame) {
-     *   const x = frame.getBlock("atoms").copyColF32("x");
-     * }
-     * ```
-     * @param {number} t
+     * Read the frame (SDF record) at the given step index.
+     * @param {number} step
      * @returns {Frame | undefined}
      */
-    readFrame(t) {
-        const ret = wasm.simulationreader_readFrame(this.__wbg_ptr, t);
+    read(step) {
+        const ret = wasm.sdfreader_read(this.__wbg_ptr, step);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return ret[0] === 0 ? undefined : Frame.__wrap(ret[0]);
     }
 }
-if (Symbol.dispose) SimulationReader.prototype[Symbol.dispose] = SimulationReader.prototype.free;
+if (Symbol.dispose) SDFReader.prototype[Symbol.dispose] = SDFReader.prototype.free;
 
 /**
  * Intermediate representation of a parsed SMILES string.
@@ -2733,7 +3508,7 @@ if (Symbol.dispose) SimulationReader.prototype[Symbol.dispose] = SimulationReade
  *
  * const frame = ir.toFrame();
  * const atoms = frame.getBlock("atoms");
- * console.log(atoms.copyColStr("symbol")); // ["C", "C", "O", "H", ...]
+ * console.log(atoms.copyColStr("element")); // ["C", "C", "O", "H", ...]
  * ```
  */
 export class SmilesIR {
@@ -2781,7 +3556,7 @@ export class SmilesIR {
      *   are added. No 3D coordinates are present -- use
      *   [`generate3D`](crate::generate_3d_wasm) to embed coordinates.
      * - `"bonds"` block: `i`, `j` (u32, zero-based atom indices),
-     *   `order` (f32, bond order: 1.0 = single, 1.5 = aromatic,
+     *   `order` (F, bond order: 1.0 = single, 1.5 = aromatic,
      *   2.0 = double, 3.0 = triple).
      *
      * # Returns
@@ -2798,7 +3573,7 @@ export class SmilesIR {
      * ```js
      * const frame = ir.toFrame();
      * const bonds = frame.getBlock("bonds");
-     * const order = bonds.copyColF32("order");
+     * const order = bonds.copyColF("order");
      * ```
      * @returns {Frame}
      */
@@ -2813,26 +3588,346 @@ export class SmilesIR {
 if (Symbol.dispose) SmilesIR.prototype[Symbol.dispose] = SmilesIR.prototype.free;
 
 /**
- * Owned f32 array with ndarray-compatible shape metadata.
+ * Graph-based molecular topology with automated detection of angles,
+ * dihedrals, impropers, connected components, and rings (SSSR).
+ *
+ * API mirrors igraph / molpy conventions.
+ *
+ * # Example (JavaScript)
+ *
+ * ```js
+ * const topo = Topology.fromFrame(frame);
+ * console.log(topo.nAtoms, topo.nBonds);
+ *
+ * const angles = topo.angles();       // Uint32Array [i,j,k, ...]
+ * const dihedrals = topo.dihedrals(); // Uint32Array [i,j,k,l, ...]
+ * const cc = topo.connectedComponents(); // Int32Array per-atom labels
+ *
+ * const rings = topo.findRings();
+ * console.log(rings.numRings);
+ * ```
+ */
+export class Topology {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Topology.prototype);
+        obj.__wbg_ptr = ptr;
+        TopologyFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TopologyFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_topology_free(ptr, 0);
+    }
+    /**
+     * Add a single atom.
+     */
+    addAtom() {
+        wasm.topology_addAtom(this.__wbg_ptr);
+    }
+    /**
+     * Add a bond between atoms `i` and `j`.
+     * @param {number} i
+     * @param {number} j
+     */
+    addBond(i, j) {
+        wasm.topology_addBond(this.__wbg_ptr, i, j);
+    }
+    /**
+     * All angle triplets as flat `Uint32Array` `[i,j,k, ...]`.
+     * @returns {Uint32Array}
+     */
+    angles() {
+        const ret = wasm.topology_angles(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Whether atoms `i` and `j` are directly bonded.
+     * @param {number} i
+     * @param {number} j
+     * @returns {boolean}
+     */
+    areBonded(i, j) {
+        const ret = wasm.topology_areBonded(this.__wbg_ptr, i, j);
+        return ret !== 0;
+    }
+    /**
+     * All bond pairs as flat `Uint32Array` `[i0,j0, i1,j1, ...]`.
+     * @returns {Uint32Array}
+     */
+    bonds() {
+        const ret = wasm.topology_bonds(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Per-atom connected component labels as `Int32Array`.
+     *
+     * Labels are 0-based and contiguous. Each atom gets a component ID.
+     * Atoms in the same connected subgraph share the same label.
+     * @returns {Int32Array}
+     */
+    connectedComponents() {
+        const ret = wasm.topology_connectedComponents(this.__wbg_ptr);
+        var v1 = getArrayI32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Degree (number of bonds) of atom `idx`.
+     * @param {number} idx
+     * @returns {number}
+     */
+    degree(idx) {
+        const ret = wasm.topology_degree(this.__wbg_ptr, idx);
+        return ret >>> 0;
+    }
+    /**
+     * Delete an atom by index.
+     * @param {number} idx
+     */
+    deleteAtom(idx) {
+        wasm.topology_deleteAtom(this.__wbg_ptr, idx);
+    }
+    /**
+     * Delete a bond by edge index.
+     * @param {number} idx
+     */
+    deleteBond(idx) {
+        wasm.topology_deleteBond(this.__wbg_ptr, idx);
+    }
+    /**
+     * All proper dihedral quartets as flat `Uint32Array` `[i,j,k,l, ...]`.
+     * @returns {Uint32Array}
+     */
+    dihedrals() {
+        const ret = wasm.topology_dihedrals(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Compute the Smallest Set of Smallest Rings (SSSR).
+     * @returns {TopologyRingInfo}
+     */
+    findRings() {
+        const ret = wasm.topology_findRings(this.__wbg_ptr);
+        return TopologyRingInfo.__wrap(ret);
+    }
+    /**
+     * Build a topology from a Frame's `bonds` block.
+     *
+     * Reads the `atoms` block for atom count and `bonds` block for
+     * `i`, `j` columns (Uint32).
+     * @param {Frame} frame
+     * @returns {Topology}
+     */
+    static fromFrame(frame) {
+        _assertClass(frame, Frame);
+        const ret = wasm.topology_fromFrame(frame.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Topology.__wrap(ret[0]);
+    }
+    /**
+     * All improper dihedral quartets as flat `Uint32Array` `[center,i,j,k, ...]`.
+     * @returns {Uint32Array}
+     */
+    impropers() {
+        const ret = wasm.topology_impropers(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Number of unique angles.
+     * @returns {number}
+     */
+    get nAngles() {
+        const ret = wasm.topology_nAngles(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Number of atoms (vertices).
+     * @returns {number}
+     */
+    get nAtoms() {
+        const ret = wasm.topology_nAtoms(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Number of bonds (edges).
+     * @returns {number}
+     */
+    get nBonds() {
+        const ret = wasm.topology_nBonds(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Number of connected components.
+     * @returns {number}
+     */
+    get nComponents() {
+        const ret = wasm.topology_nComponents(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Number of unique proper dihedrals.
+     * @returns {number}
+     */
+    get nDihedrals() {
+        const ret = wasm.topology_nDihedrals(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Neighbor atom indices of atom `idx` as `Uint32Array`.
+     * @param {number} idx
+     * @returns {Uint32Array}
+     */
+    neighbors(idx) {
+        const ret = wasm.topology_neighbors(this.__wbg_ptr, idx);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Create a topology with `n` atoms and no bonds.
+     * @param {number} n_atoms
+     */
+    constructor(n_atoms) {
+        const ret = wasm.topology_new(n_atoms);
+        this.__wbg_ptr = ret >>> 0;
+        TopologyFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) Topology.prototype[Symbol.dispose] = Topology.prototype.free;
+
+/**
+ * Result of ring detection (SSSR) on a topology graph.
+ *
+ * # Example (JavaScript)
+ *
+ * ```js
+ * const rings = topo.findRings();
+ * console.log(rings.numRings);
+ * console.log(rings.ringSizes());   // Uint32Array
+ * console.log(rings.isAtomInRing(0));
+ *
+ * // Get all rings as flat array [size0, idx0_0, idx0_1, ..., size1, ...]
+ * const data = rings.rings();
+ * ```
+ */
+export class TopologyRingInfo {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(TopologyRingInfo.prototype);
+        obj.__wbg_ptr = ptr;
+        TopologyRingInfoFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TopologyRingInfoFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_topologyringinfo_free(ptr, 0);
+    }
+    /**
+     * Per-atom boolean mask as `Uint8Array` (0 or 1). 1 if atom is in any ring.
+     * @param {number} n_atoms
+     * @returns {Uint8Array}
+     */
+    atomRingMask(n_atoms) {
+        const ret = wasm.topologyringinfo_atomRingMask(this.__wbg_ptr, n_atoms);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * Whether atom `idx` belongs to any ring.
+     * @param {number} idx
+     * @returns {boolean}
+     */
+    isAtomInRing(idx) {
+        const ret = wasm.topologyringinfo_isAtomInRing(this.__wbg_ptr, idx);
+        return ret !== 0;
+    }
+    /**
+     * Number of rings containing atom `idx`.
+     * @param {number} idx
+     * @returns {number}
+     */
+    numAtomRings(idx) {
+        const ret = wasm.topologyringinfo_numAtomRings(this.__wbg_ptr, idx);
+        return ret >>> 0;
+    }
+    /**
+     * Total number of rings detected.
+     * @returns {number}
+     */
+    get numRings() {
+        const ret = wasm.topologyringinfo_numRings(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Size of each ring as `Uint32Array`.
+     * @returns {Uint32Array}
+     */
+    ringSizes() {
+        const ret = wasm.topologyringinfo_ringSizes(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * All rings as flat `Uint32Array` with length-prefixed encoding:
+     * `[size0, atom0, atom1, ..., size1, atom0, atom1, ...]`.
+     * @returns {Uint32Array}
+     */
+    rings() {
+        const ret = wasm.topologyringinfo_rings(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+}
+if (Symbol.dispose) TopologyRingInfo.prototype[Symbol.dispose] = TopologyRingInfo.prototype.free;
+
+/**
+ * Owned float array with ndarray-compatible shape metadata.
  *
- * Stores a flat `Vec<f32>` together with a shape descriptor (e.g.,
+ * Stores a flat `Vec<F>` together with a shape descriptor (e.g.,
  * `[N, 3]` for an Nx3 coordinate matrix). Used for passing
  * multi-dimensional numeric data across the WASM boundary.
  *
  * # Memory layout
  *
  * Data is stored in row-major (C) order, matching ndarray's default
- * and JavaScript's `Float32Array` convention.
+ * and JavaScript's float typed-array convention.
  *
  * # Example (JavaScript)
  *
  * ```js
  * // Create a 2x3 zero array
  * const arr = new WasmArray([2, 3]);
- * arr.writeFrom(new Float32Array([1,2,3, 4,5,6]));
+ * arr.writeFrom(floatArray);
  *
  * // Or from existing data
- * const arr2 = WasmArray.from(new Float32Array([1,2,3]), [1, 3]);
+ * const arr2 = WasmArray.from(floatArray, [1, 3]);
  *
  * // Get data back
  * const copy = arr.toCopy();       // safe owned copy
@@ -2858,7 +3953,7 @@ export class WasmArray {
         wasm.__wbg_wasmarray_free(ptr, 0);
     }
     /**
-     * Return the data type string. Always `"float"` for `WasmArray`.
+     * Return the concrete float dtype string for this build.
      * @returns {string}
      */
     dtype() {
@@ -2874,11 +3969,11 @@ export class WasmArray {
         }
     }
     /**
-     * Create a `WasmArray` from an existing JS `Float32Array`.
+     * Create a `WasmArray` from an existing JS float typed array.
      *
      * # Arguments
      *
-     * * `data` - Source `Float32Array`
+     * * `data` - Source float typed array (`Float32Array` or `Float64Array`)
      * * `shape` - Optional shape. If omitted, defaults to `[data.length]` (1D).
      *
      * # Returns
@@ -2892,10 +3987,10 @@ export class WasmArray {
      * # Example (JavaScript)
      *
      * ```js
-     * const arr = WasmArray.from(new Float32Array([1,2,3,4,5,6]), [2, 3]);
+     * const arr = WasmArray.from(floatArray, [2, 3]);
      * console.log(arr.shape()); // [2, 3]
      * ```
-     * @param {Float32Array} data
+     * @param {Float64Array} data
      * @param {Uint32Array | null} [shape]
      * @returns {WasmArray}
      */
@@ -2993,7 +4088,7 @@ export class WasmArray {
      * # Example (JavaScript)
      *
      * ```js
-     * const arr = WasmArray.from(new Float32Array([1, 2, 3]));
+     * const arr = WasmArray.from(floatArray);
      * console.log(arr.sum()); // 6.0
      * ```
      * @returns {number}
@@ -3003,7 +4098,7 @@ export class WasmArray {
         return ret;
     }
     /**
-     * Create an owned JS `Float32Array` copy of the data.
+     * Create an owned JS float typed-array copy of the data.
      *
      * The returned array is an independent copy that is safe to store
      * and use regardless of subsequent WASM memory operations.
@@ -3013,14 +4108,14 @@ export class WasmArray {
      * ```js
      * const copy = arr.toCopy(); // safe to keep indefinitely
      * ```
-     * @returns {Float32Array}
+     * @returns {Float64Array}
      */
     toCopy() {
         const ret = wasm.wasmarray_toCopy(this.__wbg_ptr);
         return ret;
     }
     /**
-     * Zero-copy `Float32Array` view over this array's backing storage.
+     * Zero-copy float typed-array view over this array's backing storage.
      *
      * **Warning**: The returned view becomes **invalid** if WASM linear
      * memory grows (due to any allocation). Use [`toCopy`](WasmArray::to_copy)
@@ -3028,7 +4123,8 @@ export class WasmArray {
      *
      * # Safety (internal)
      *
-     * Uses `Float32Array::view` which creates an unowned view into
+     * Uses the corresponding JS float typed-array `view` constructor,
+     * which creates an unowned view into
      * WASM memory. The view must not outlive the `WasmArray` and must
      * not be used after any allocation that could trigger memory growth.
      *
@@ -3038,21 +4134,21 @@ export class WasmArray {
      * const view = arr.toTypedArray(); // use immediately
      * // Do NOT allocate between view creation and use
      * ```
-     * @returns {Float32Array}
+     * @returns {Float64Array}
      */
     toTypedArray() {
         const ret = wasm.wasmarray_toTypedArray(this.__wbg_ptr);
         return ret;
     }
     /**
-     * Overwrite the array contents from a JS `Float32Array`.
+     * Overwrite the array contents from a JS float typed array.
      *
      * The source array must have exactly the same number of elements
      * as this `WasmArray` (i.e., the shape is preserved).
      *
      * # Arguments
      *
-     * * `arr` - Source `Float32Array` with matching length
+     * * `arr` - Source float typed array with matching length
      *
      * # Errors
      *
@@ -3062,9 +4158,9 @@ export class WasmArray {
      *
      * ```js
      * const wa = new WasmArray([3]);
-     * wa.writeFrom(new Float32Array([1.0, 2.0, 3.0]));
+     * wa.writeFrom(floatArray);
      * ```
-     * @param {Float32Array} arr
+     * @param {Float64Array} arr
      */
     write_from(arr) {
         const ret = wasm.wasmarray_write_from(this.__wbg_ptr, arr);
@@ -3080,7 +4176,7 @@ if (Symbol.dispose) WasmArray.prototype[Symbol.dispose] = WasmArray.prototype.fr
  *
  * Supports multi-frame trajectory files. Each frame produces a
  * [`Frame`] with an `"atoms"` block containing `element` (string)
- * and `x`, `y`, `z` (f32, coordinates in angstrom) columns.
+ * and `x`, `y`, `z` (F, coordinates in angstrom) columns.
  *
  * # Example (JavaScript)
  *
@@ -3091,7 +4187,7 @@ if (Symbol.dispose) WasmArray.prototype[Symbol.dispose] = WasmArray.prototype.fr
  *
  * const frame = reader.read(0); // first frame
  * const atoms = frame.getBlock("atoms");
- * const x = atoms.copyColF32("x");
+ * const x = atoms.copyColF("x");
  * ```
  */
 export class XYZReader {
@@ -3207,13 +4303,13 @@ if (Symbol.dispose) XYZReader.prototype[Symbol.dispose] = XYZReader.prototype.fr
 /**
  * Generate 3D coordinates for a molecular [`Frame`].
  *
- * The input frame must have an `"atoms"` block with a `"symbol"`
+ * The input frame must have an `"atoms"` block with a `"element"`
  * string column (element symbols like `"C"`, `"N"`, `"O"`). A
- * `"bonds"` block with `i`, `j` (u32) and `order` (f32) columns
+ * `"bonds"` block with `i`, `j` (u32) and `order` (F) columns
  * is required for correct geometry.
  *
  * Returns a **new** [`Frame`] with 3D coordinates added as `x`, `y`,
- * `z` (f32, angstrom) columns in the `"atoms"` block.
+ * `z` (F, angstrom) columns in the `"atoms"` block.
  *
  * # Arguments
  *
@@ -3246,9 +4342,9 @@ if (Symbol.dispose) XYZReader.prototype[Symbol.dispose] = XYZReader.prototype.fr
  * const frame3d = generate3D(frame2d, "fast", 42);
  *
  * const atoms = frame3d.getBlock("atoms");
- * const x = atoms.copyColF32("x"); // Float32Array with 3D x-coords
- * const y = atoms.copyColF32("y");
- * const z = atoms.copyColF32("z");
+ * const x = atoms.copyColF("x"); // Float32Array or Float64Array with 3D x-coords
+ * const y = atoms.copyColF("y");
+ * const z = atoms.copyColF("z");
  * ```
  * @param {Frame} frame
  * @param {string | null} [speed]
@@ -3325,7 +4421,7 @@ export function start() {
  *
  * ```js
  * const mem = wasmMemory();
- * const buf = new Float32Array(mem.buffer, ptr, len);
+ * const buf = new Float64Array(mem.buffer, ptr, len); // or Float32Array in default builds
  * ```
  * @returns {WebAssembly.Memory}
  */
@@ -3396,18 +4492,18 @@ export function writeFrame(frame, format) {
         wasm.__wbindgen_free_command_export(deferred3_0, deferred3_1, 1);
     }
 }
-export function __wbg___wbindgen_debug_string_5398f5bb970e0daa(arg0, arg1) {
+export function __wbg___wbindgen_debug_string_ab4b34d23d6778bd(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_edb3f01e3930bbf6() {
+export function __wbg___wbindgen_memory_dfa12096f400c9bd() {
     const ret = wasm.memory;
     return ret;
 }
-export function __wbg___wbindgen_string_get_395e606bd0ee4427(arg0, arg1) {
+export function __wbg___wbindgen_string_get_7ed5322991caaec5(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);
@@ -3415,10 +4511,10 @@ export function __wbg___wbindgen_string_get_395e606bd0ee4427(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 }
-export function __wbg___wbindgen_throw_6ddd609b62940d55(arg0, arg1) {
+export function __wbg___wbindgen_throw_6b64449b9b9ed33c(arg0, arg1) {
     throw new Error(getStringFromWasm0(arg0, arg1));
 }
-export function __wbg_done_08ce71ee07e3bd17(arg0) {
+export function __wbg_done_9158f7cc8751ba32(arg0) {
     const ret = arg0.done;
     return ret;
 }
@@ -3436,35 +4532,35 @@ export function __wbg_error_a6fa202b58aa1cd3(arg0, arg1) {
 export function __wbg_getRandomValues_3f44b700395062e5() { return handleError(function (arg0, arg1) {
     globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
 }, arguments); }
-export function __wbg_get_10ee87d86a58fb49(arg0, arg1) {
+export function __wbg_get_ef70f6ce70a05af6(arg0, arg1) {
     const ret = arg0.get(arg1);
     return ret;
 }
-export function __wbg_get_unchecked_329cfe50afab7352(arg0, arg1) {
+export function __wbg_get_unchecked_17f53dad852b9588(arg0, arg1) {
     const ret = arg0[arg1 >>> 0];
     return ret;
 }
-export function __wbg_keys_3fff7686656d707e(arg0) {
+export function __wbg_keys_7fc58fd5f4899356(arg0) {
     const ret = arg0.keys();
     return ret;
 }
-export function __wbg_length_259ee9d041e381ad(arg0) {
+export function __wbg_length_3d4ecd04bd8d22f1(arg0) {
     const ret = arg0.length;
     return ret;
 }
-export function __wbg_length_27280eca2d70010e(arg0) {
+export function __wbg_length_7da87610a31a2ef9(arg0) {
     const ret = arg0.length;
     return ret;
 }
-export function __wbg_length_76eefdd571f24b00(arg0) {
+export function __wbg_length_9f1775224cf1d815(arg0) {
     const ret = arg0.length;
     return ret;
 }
-export function __wbg_length_b3416cf66a5452c8(arg0) {
+export function __wbg_length_d807629e96c741b8(arg0) {
     const ret = arg0.length;
     return ret;
 }
-export function __wbg_length_ea16607d7b61445b(arg0) {
+export function __wbg_length_fab29957ea6bdb8c(arg0) {
     const ret = arg0.length;
     return ret;
 }
@@ -3472,47 +4568,47 @@ export function __wbg_msdresult_new(arg0) {
     const ret = MSDResult.__wrap(arg0);
     return ret;
 }
-export function __wbg_new_227d7c05414eb861() {
-    const ret = new Error();
+export function __wbg_new_0c7403db6e782f19(arg0) {
+    const ret = new Uint8Array(arg0);
     return ret;
 }
-export function __wbg_new_5f486cdf45a04d78(arg0) {
-    const ret = new Uint8Array(arg0);
+export function __wbg_new_227d7c05414eb861() {
+    const ret = new Error();
     return ret;
 }
-export function __wbg_new_a70fbab9066b301f() {
+export function __wbg_new_682678e2f47e32bc() {
     const ret = new Array();
     return ret;
 }
-export function __wbg_new_from_slice_898ac63cbd46f332(arg0, arg1) {
+export function __wbg_new_from_slice_01793f7edd3b321a(arg0, arg1) {
     const ret = new Uint32Array(getArrayU32FromWasm0(arg0, arg1));
     return ret;
 }
-export function __wbg_new_from_slice_c62f8165d6102476(arg0, arg1) {
-    const ret = new Int32Array(getArrayI32FromWasm0(arg0, arg1));
+export function __wbg_new_from_slice_3115b094b1002246(arg0, arg1) {
+    const ret = new Float64Array(getArrayF64FromWasm0(arg0, arg1));
     return ret;
 }
-export function __wbg_new_from_slice_ff2c15e8e05ffdfc(arg0, arg1) {
-    const ret = new Float32Array(getArrayF32FromWasm0(arg0, arg1));
+export function __wbg_new_from_slice_ede497d29b90a4ad(arg0, arg1) {
+    const ret = new Int32Array(getArrayI32FromWasm0(arg0, arg1));
     return ret;
 }
-export function __wbg_next_11b99ee6237339e3() { return handleError(function (arg0) {
+export function __wbg_next_0340c4ae324393c3() { return handleError(function (arg0) {
     const ret = arg0.next();
     return ret;
 }, arguments); }
-export function __wbg_prototypesetcall_247ac4333d4d3cb4(arg0, arg1, arg2) {
-    Float32Array.prototype.set.call(getArrayF32FromWasm0(arg0, arg1), arg2);
-}
-export function __wbg_prototypesetcall_52ca14fb142bc37b(arg0, arg1, arg2) {
-    Int32Array.prototype.set.call(getArrayI32FromWasm0(arg0, arg1), arg2);
-}
-export function __wbg_prototypesetcall_d62e5099504357e6(arg0, arg1, arg2) {
+export function __wbg_prototypesetcall_a6b02eb00b0f4ce2(arg0, arg1, arg2) {
     Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
 }
-export function __wbg_prototypesetcall_f04613188bde902d(arg0, arg1, arg2) {
+export function __wbg_prototypesetcall_c5875dab42ff6b97(arg0, arg1, arg2) {
+    Float64Array.prototype.set.call(getArrayF64FromWasm0(arg0, arg1), arg2);
+}
+export function __wbg_prototypesetcall_d412f763861ea165(arg0, arg1, arg2) {
     Uint32Array.prototype.set.call(getArrayU32FromWasm0(arg0, arg1), arg2);
 }
-export function __wbg_push_e87b0e732085a946(arg0, arg1) {
+export function __wbg_prototypesetcall_db677c7a1d7d3039(arg0, arg1, arg2) {
+    Int32Array.prototype.set.call(getArrayI32FromWasm0(arg0, arg1), arg2);
+}
+export function __wbg_push_471a5b068a5295f6(arg0, arg1) {
     const ret = arg0.push(arg1);
     return ret;
 }
@@ -3523,13 +4619,13 @@ 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_21fc78aab0322612(arg0) {
+export function __wbg_value_ee3a06f4579184fa(arg0) {
     const ret = arg0.value;
     return ret;
 }
 export function __wbindgen_cast_0000000000000001(arg0, arg1) {
-    // Cast intrinsic for `Ref(Slice(F32)) -> NamedExternref("Float32Array")`.
-    const ret = getArrayF32FromWasm0(arg0, arg1);
+    // Cast intrinsic for `Ref(Slice(F64)) -> NamedExternref("Float64Array")`.
+    const ret = getArrayF64FromWasm0(arg0, arg1);
     return ret;
 }
 export function __wbindgen_cast_0000000000000002(arg0, arg1) {
@@ -3562,15 +4658,36 @@ const BlockFinalization = (typeof FinalizationRegistry === 'undefined')
 const BoxFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_box_free(ptr >>> 0, 1));
+const CenterOfMassFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_centerofmass_free(ptr >>> 0, 1));
+const CenterOfMassResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_centerofmassresult_free(ptr >>> 0, 1));
 const ClusterFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_cluster_free(ptr >>> 0, 1));
+const ClusterCentersFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_clustercenters_free(ptr >>> 0, 1));
 const ClusterResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_clusterresult_free(ptr >>> 0, 1));
 const FrameFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_frame_free(ptr >>> 0, 1));
+const GridFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_grid_free(ptr >>> 0, 1));
+const GyrationTensorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_gyrationtensor_free(ptr >>> 0, 1));
+const InertiaTensorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_inertiatensor_free(ptr >>> 0, 1));
+const LAMMPSDumpReaderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_lammpsdumpreader_free(ptr >>> 0, 1));
 const LAMMPSReaderFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_lammpsreader_free(ptr >>> 0, 1));
@@ -3583,6 +4700,9 @@ const MSDFinalization = (typeof FinalizationRegistry === 'undefined')
 const MSDResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_msdresult_free(ptr >>> 0, 1));
+const MolRecReaderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_molrecreader_free(ptr >>> 0, 1));
 const NeighborListFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_neighborlist_free(ptr >>> 0, 1));
@@ -3595,15 +4715,24 @@ const RDFFinalization = (typeof FinalizationRegistry === 'undefined')
 const RDFResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_rdfresult_free(ptr >>> 0, 1));
-const SimulationReaderFinalization = (typeof FinalizationRegistry === 'undefined')
+const RadiusOfGyrationFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_radiusofgyration_free(ptr >>> 0, 1));
+const SDFReaderFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_simulationreader_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_sdfreader_free(ptr >>> 0, 1));
+const TopologyRingInfoFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_topologyringinfo_free(ptr >>> 0, 1));
 const WasmArrayFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmarray_free(ptr >>> 0, 1));
 const SmilesIRFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_smilesir_free(ptr >>> 0, 1));
+const TopologyFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_topology_free(ptr >>> 0, 1));
 const XYZReaderFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_xyzreader_free(ptr >>> 0, 1));
@@ -3685,9 +4814,9 @@ function debugString(val) {
     return className;
 }
 
-function getArrayF32FromWasm0(ptr, len) {
+function getArrayF64FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
-    return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+    return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
 }
 
 function getArrayI32FromWasm0(ptr, len) {
@@ -3724,12 +4853,12 @@ function getDataViewMemory0() {
     return cachedDataViewMemory0;
 }
 
-let cachedFloat32ArrayMemory0 = null;
-function getFloat32ArrayMemory0() {
-    if (cachedFloat32ArrayMemory0 === null || cachedFloat32ArrayMemory0.byteLength === 0) {
-        cachedFloat32ArrayMemory0 = new Float32Array(wasm.memory.buffer);
+let cachedFloat64ArrayMemory0 = null;
+function getFloat64ArrayMemory0() {
+    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
+        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
     }
-    return cachedFloat32ArrayMemory0;
+    return cachedFloat64ArrayMemory0;
 }
 
 let cachedInt32ArrayMemory0 = null;
@@ -3781,6 +4910,13 @@ function passArray32ToWasm0(arg, malloc) {
     return ptr;
 }
 
+function passArrayF64ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 8, 8) >>> 0;
+    getFloat64ArrayMemory0().set(arg, ptr / 8);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);