@molcrafts/molrs 0.0.7 → 0.0.12

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
      *
@@ -1181,11 +1182,11 @@ export class CenterOfMass {
     /**
      * Create a center-of-mass calculator.
      *
-     * Pass `null` for uniform masses, or a `Float32Array` of per-particle masses.
-     * @param {Float32Array | null} [masses]
+     * 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 : passArrayF32ToWasm0(masses, wasm.__wbindgen_malloc_command_export);
+        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;
@@ -1202,8 +1203,8 @@ if (Symbol.dispose) CenterOfMass.prototype[Symbol.dispose] = CenterOfMass.protot
  *
  * ```js
  * const com = new CenterOfMass().compute(frame, clusterResult);
- * com.centersOfMass();   // Float32Array [x0,y0,z0, ...]
- * com.clusterMasses();   // Float32Array
+ * com.centersOfMass();   // Float32Array or Float64Array [x0,y0,z0, ...]
+ * com.clusterMasses();   // Float32Array or Float64Array
  * ```
  */
 export class CenterOfMassResult {
@@ -1225,24 +1226,22 @@ export class CenterOfMassResult {
         wasm.__wbg_centerofmassresult_free(ptr, 0);
     }
     /**
-     * Mass-weighted centers, flat `[x0,y0,z0, x1,y1,z1, ...]`.
-     * @returns {Float32Array}
+     * 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);
-        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
-        return v1;
+        return ret;
     }
     /**
-     * Total mass per cluster.
-     * @returns {Float32Array}
+     * 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);
-        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 clusters.
@@ -1354,7 +1353,7 @@ if (Symbol.dispose) Cluster.prototype[Symbol.dispose] = Cluster.prototype.free;
  *
  * ```js
  * const centers = new ClusterCenters().compute(frame, clusterResult);
- * // Float32Array [x0,y0,z0, x1,y1,z1, ...]
+ * // Float32Array or Float64Array [x0,y0,z0, x1,y1,z1, ...]
  * ```
  */
 export class ClusterCenters {
@@ -1369,10 +1368,10 @@ export class ClusterCenters {
         wasm.__wbg_clustercenters_free(ptr, 0);
     }
     /**
-     * Compute geometric centers. Returns flat `Float32Array` `[x0,y0,z0, ...]`.
+     * Compute geometric centers. Returns a flat float typed array `[x0,y0,z0, ...]`.
      * @param {Frame} frame
      * @param {ClusterResult} cluster_result
-     * @returns {Float32Array}
+     * @returns {Float64Array}
      */
     compute(frame, cluster_result) {
         _assertClass(frame, Frame);
@@ -1381,8 +1380,8 @@ export class ClusterCenters {
         if (ret[3]) {
             throw takeFromExternrefTable0(ret[2]);
         }
-        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;
     }
     constructor() {
@@ -1480,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)
@@ -1491,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 {
@@ -1553,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}
@@ -1608,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
@@ -1620,6 +1619,111 @@ 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]);
+    }
+    /**
+     * Read a per-frame metadata value as a numeric scalar.
+     *
+     * Returns `Some(v)` if the meta key exists AND its string value parses
+     * as an `f64`. Returns `None` if the key is missing or the value is
+     * non-numeric (e.g., `config="trans"`).
+     *
+     * `frame.meta` is a `HashMap<String, String>`; the ExtXYZ parser stores
+     * all comment-line values as strings. This accessor reads numeric ones
+     * via `str::parse::<f64>`.
+     *
+     * # Arguments
+     *
+     * * `name` — Meta key to look up (e.g., `"energy"`, `"temp"`).
+     *
+     * # Example (JavaScript)
+     *
+     * ```js
+     * const energy = frame.getMetaScalar("energy");
+     * if (energy !== undefined) {
+     *   console.log("Energy:", energy);
+     * }
+     * ```
+     * @param {string} name
+     * @returns {number | undefined}
+     */
+    getMetaScalar(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.frame_getMetaScalar(this.__wbg_ptr, ptr0, len0);
+        return ret[0] === 0 ? undefined : ret[1];
+    }
+    /**
+     * 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.
      *
@@ -1658,6 +1762,62 @@ 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]);
+        }
+    }
+    /**
+     * Return the names of all metadata keys on this frame.
+     *
+     * Includes all keys regardless of whether their values are numeric
+     * or categorical. To filter to numeric keys, iterate and call
+     * [`getMetaScalar`](Self::get_meta_scalar) on each.
+     *
+     * # Example (JavaScript)
+     *
+     * ```js
+     * const names = frame.metaNames(); // e.g. ["energy", "config", "temp"]
+     * ```
+     * @returns {string[]}
+     */
+    metaNames() {
+        const ret = wasm.frame_metaNames(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
     /**
      * Create a new, empty `Frame` with no blocks and no simulation box.
      *
@@ -1700,6 +1860,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`.
      *
@@ -1778,6 +1964,44 @@ export class Frame {
         }
         return ret[0] !== 0;
     }
+    /**
+     * Set a per-frame metadata value.
+     *
+     * Stores `value` as the string backing for `name` on `frame.meta`.
+     * Numeric values are read back via
+     * [`getMetaScalar`](Self::get_meta_scalar) by parsing the string
+     * form. `frame.meta` is the single source of truth for per-frame
+     * scalars — no separate aggregation layer is needed on the JS side.
+     *
+     * # Arguments
+     *
+     * * `name` — Meta key (e.g., `"energy"`, `"temp"`).
+     * * `value` — String value. For numeric labels, the caller is
+     *   responsible for converting (e.g., `num.toString()`).
+     *
+     * # Errors
+     *
+     * Throws a `JsValue` string if the frame has been dropped.
+     *
+     * # Example (JavaScript)
+     *
+     * ```js
+     * frame.setMeta("energy", "-3.14");
+     * frame.setMeta("note", "run-42");
+     * ```
+     * @param {string} name
+     * @param {string} value
+     */
+    setMeta(name, value) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(value, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.frame_setMeta(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * Attach or detach a simulation box.
      *
@@ -1795,7 +2019,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]
@@ -1836,6 +2060,306 @@ export class Frame {
 }
 if (Symbol.dispose) Frame.prototype[Symbol.dispose] = Frame.prototype.free;
 
+/**
+ * A uniform spatial grid storing multiple named scalar arrays.
+ *
+ * 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
+ * // 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 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;
+        GridFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_grid_free(ptr, 0);
+    }
+    /**
+     * Names of all scalar arrays stored in this grid.
+     *
+     * # Example (JavaScript)
+     *
+     * ```js
+     * const names = grid.arrayNames(); // e.g. ["rho", "spin"]
+     * ```
+     * @returns {Array<any>}
+     */
+    arrayNames() {
+        const ret = wasm.grid_arrayNames(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Cell matrix in Ångström as a flat array of length 9 in column-major
+     * order (columns are lattice vectors, matching VASP/molrs convention).
+     *
+     * Layout: `[col0_x, col0_y, col0_z, col1_x, col1_y, col1_z, col2_x, col2_y, col2_z]`
+     *
+     * # Example (JavaScript)
+     *
+     * ```js
+     * const c = grid.cell();
+     * const flat = c.toCopy(); // Float32Array of length 9
+     * ```
+     * @returns {WasmArray}
+     */
+    cell() {
+        const ret = wasm.grid_cell(this.__wbg_ptr);
+        return WasmArray.__wrap(ret);
+    }
+    /**
+     * Grid dimensions `[nx, ny, nz]`.
+     *
+     * # Example (JavaScript)
+     *
+     * ```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 view = grid.getArray("rho");          // zero-copy
+     * const copy = new Float64Array(view);        // owned copy if needed
+     * ```
+     * @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.
  *
@@ -1853,10 +2377,14 @@ export class GyrationTensor {
         wasm.__wbg_gyrationtensor_free(ptr, 0);
     }
     /**
-     * Compute gyration tensors. Returns flat `Float32Array` (9 values per cluster).
+     * Compute gyration tensors. Returns a flat float typed array (9 values per cluster).
+     *
+     * Internally computes the cluster geometric centers (via
+     * [`RsClusterCenters`]) since the new compute trait exposes them as a
+     * required upstream — the old single-frame wasm API hides this detail.
      * @param {Frame} frame
      * @param {ClusterResult} cluster_result
-     * @returns {Float32Array}
+     * @returns {Float64Array}
      */
     compute(frame, cluster_result) {
         _assertClass(frame, Frame);
@@ -1865,8 +2393,8 @@ export class GyrationTensor {
         if (ret[3]) {
             throw takeFromExternrefTable0(ret[2]);
         }
-        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;
     }
     constructor() {
@@ -1893,10 +2421,14 @@ export class InertiaTensor {
         wasm.__wbg_inertiatensor_free(ptr, 0);
     }
     /**
-     * Compute inertia tensors. Returns flat `Float32Array` (9 values per cluster).
+     * Compute inertia tensors. Returns a flat float typed array (9 values per cluster).
+     *
+     * Internally computes the cluster centers of mass (via
+     * [`RsCenterOfMass`]) since the new compute trait consumes them as a
+     * required upstream — the old single-frame wasm API hides this detail.
      * @param {Frame} frame
      * @param {ClusterResult} cluster_result
-     * @returns {Float32Array}
+     * @returns {Float64Array}
      */
     compute(frame, cluster_result) {
         _assertClass(frame, Frame);
@@ -1905,15 +2437,15 @@ export class InertiaTensor {
         if (ret[3]) {
             throw takeFromExternrefTable0(ret[2]);
         }
-        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;
     }
     /**
-     * @param {Float32Array | null} [masses]
+     * @param {Float64Array | null} [masses]
      */
     constructor(masses) {
-        var ptr0 = isLikeNone(masses) ? 0 : passArrayF32ToWasm0(masses, wasm.__wbindgen_malloc_command_export);
+        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;
@@ -2006,8 +2538,8 @@ if (Symbol.dispose) LAMMPSDumpReader.prototype[Symbol.dispose] = LAMMPSDumpReade
  * Reads LAMMPS data files (the format written by `write_data`). The
  * reader produces a [`Frame`] containing:
  *
- * - `"atoms"` block: `type` (i32), `x`, `y`, `z` (f32, angstrom),
- *   and optionally `charge` (f32)
+ * - `"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
  *
@@ -2158,7 +2690,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.
      *
@@ -2179,7 +2711,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}
@@ -2300,25 +2832,23 @@ export class MSD {
     /**
      * Feed a frame into the MSD analysis.
      *
-     * The first frame sets the reference configuration.
-     * Subsequent frames compute MSD relative to that reference.
+     * Internally clones the frame's core data so subsequent mutations on
+     * the JS side (e.g. trajectory playback overwriting buffers) do not
+     * race against pending [`results`](Self::results) calls. The first
+     * frame sets the reference configuration.
      *
      * # Arguments
      *
      * * `frame` - Frame with `"atoms"` block containing
-     *   `x`, `y`, `z` (f32) columns
-     *
-     * # Errors
-     *
-     * Throws if the frame is missing required columns or has a
-     * different number of atoms than the reference.
+     *   `x`, `y`, `z` (F) columns
      *
      * # Example (JavaScript)
      *
      * ```js
      * const msd = new MSD();
      * msd.feed(frame0);  // sets reference
-     * msd.feed(frame1);  // computes MSD vs frame0
+     * msd.feed(frame1);  // added to trajectory
+     * const series = msd.results();
      * ```
      * @param {Frame} frame
      */
@@ -2348,16 +2878,16 @@ export class MSD {
         return this;
     }
     /**
-     * Reset the analysis, clearing reference and all results.
+     * Reset the analysis, clearing the trajectory buffer.
      */
     reset() {
         wasm.msd_reset(this.__wbg_ptr);
     }
     /**
-     * Return all accumulated MSD results as an array.
+     * Run the stateless [`molrs_compute::MSD`] over every fed frame and
+     * return the per-frame time series.
      *
-     * Returns one [`MSDResult`] per frame fed (including the
-     * reference frame, which has MSD = 0).
+     * The first frame is always the reference, so `results()[0].mean ≈ 0`.
      *
      * # Example (JavaScript)
      *
@@ -2369,6 +2899,9 @@ export class MSD {
      */
     results() {
         const ret = wasm.msd_results(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
         var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
         return v1;
@@ -2384,7 +2917,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 {
@@ -2417,21 +2950,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.
  *
@@ -2456,7 +3046,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 {
@@ -2478,29 +3068,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;
     }
     /**
@@ -2540,27 +3126,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;
@@ -2570,8 +3152,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)
  *
@@ -2580,7 +3162,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 {
@@ -2685,15 +3267,16 @@ if (Symbol.dispose) PDBReader.prototype[Symbol.dispose] = PDBReader.prototype.fr
 /**
  * Radial distribution function g(r) analysis.
  *
- * Computes the pair correlation function by binning neighbor-pair
- * distances into a histogram and normalizing by the ideal-gas
- * density (spherical shell volume normalization).
+ * Bins neighbor-pair distances in `[rMin, rMax]` and normalizes by the
+ * ideal-gas pair density. Defaults follow freud (`rMin = 0`). Periodic
+ * systems take their normalization volume from `frame.simbox`; non-periodic
+ * systems must supply it explicitly via [`computeWithVolume`].
  *
  * # Algorithm
  *
  * g(r) = n(r) / (rho * V_shell(r) * N_ref)
  *
- * where `n(r)` is the pair count in bin `r`, `rho` is the number
+ * where `n(r)` is the pair count in bin `r`, `rho = N/V` is the number
  * density, and `V_shell(r)` is the shell volume for that bin.
  *
  * # Example (JavaScript)
@@ -2702,11 +3285,14 @@ if (Symbol.dispose) PDBReader.prototype[Symbol.dispose] = PDBReader.prototype.fr
  * const lc = new LinkedCell(5.0);
  * const nlist = lc.build(frame);
  *
- * const rdf = new RDF(100, 5.0);
+ * const rdf = new RDF(100, 5.0);          // rMin defaults to 0
  * const result = rdf.compute(frame, nlist);
  *
- * const r  = result.binCenters();  // Float32Array, bin centers in A
- * const gr = result.rdf();         // Float32Array, g(r) values
+ * // Non-periodic frame: supply the normalization volume.
+ * const resultFree = rdf.computeWithVolume(nlist, volumeA3);
+ *
+ * const r  = result.binCenters();
+ * const gr = result.rdf();
  * ```
  */
 export class RDF {
@@ -2721,64 +3307,88 @@ export class RDF {
         wasm.__wbg_rdf_free(ptr, 0);
     }
     /**
-     * Compute the RDF from a pre-built neighbor list.
+     * Compute g(r) using the simulation-box volume from `frame.simbox`.
+     *
+     * # Arguments
+     *
+     * * `frame` - Frame with a `simbox` set (used only for volume)
+     * * `neighbors` - Pre-built [`NeighborList`] from [`LinkedCell`]
+     *
+     * # Errors
+     *
+     * Throws if the frame has no `simbox` — use
+     * [`computeWithVolume`](Self::compute_with_volume) for non-periodic frames.
+     * @param {Frame} frame
+     * @param {NeighborList} neighbors
+     * @returns {RDFResult}
+     */
+    compute(frame, neighbors) {
+        _assertClass(frame, Frame);
+        _assertClass(neighbors, NeighborList);
+        const ret = wasm.rdf_compute(this.__wbg_ptr, frame.__wbg_ptr, neighbors.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return RDFResult.__wrap(ret[0]);
+    }
+    /**
+     * Compute g(r) using an explicit normalization volume (A^3).
      *
-     * The frame is needed to read the simulation box volume for
-     * normalization.
+     * Use this for non-periodic systems or to override the box volume.
+     * Internally wraps the supplied volume as a cubic SimBox since the
+     * underlying [`molrs_compute::RDF`] pulls its normalization volume from
+     * `frame.simbox`.
      *
      * # Arguments
      *
-     * * `frame` - Frame with a `simbox` set (for volume normalization)
-     * * `neighbors` - Pre-built [`NeighborList`] from [`LinkedCell`]
-     *
-     * # Returns
-     *
-     * An [`RDFResult`] containing bin centers, g(r) values, and raw
-     * pair counts.
-     *
-     * # Errors
-     *
-     * Throws if the frame cannot be cloned or the computation fails.
+     * * `neighbors` - Pre-built [`NeighborList`]
+     * * `volume` - Normalization volume in A^3 (must be finite and > 0)
      *
      * # Example (JavaScript)
      *
      * ```js
-     * const result = rdf.compute(frame, nlist);
-     * const gr = result.rdf(); // Float32Array
+     * const result = rdf.computeWithVolume(nlist, 1000.0);
      * ```
-     * @param {Frame} frame
      * @param {NeighborList} neighbors
+     * @param {number} volume
      * @returns {RDFResult}
      */
-    compute(frame, neighbors) {
-        _assertClass(frame, Frame);
+    computeWithVolume(neighbors, volume) {
         _assertClass(neighbors, NeighborList);
-        const ret = wasm.rdf_compute(this.__wbg_ptr, frame.__wbg_ptr, neighbors.__wbg_ptr);
+        const ret = wasm.rdf_computeWithVolume(this.__wbg_ptr, neighbors.__wbg_ptr, volume);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return RDFResult.__wrap(ret[0]);
     }
     /**
-     * Create a new RDF analysis with specified binning.
+     * Create a new RDF analysis.
      *
      * # Arguments
      *
      * * `n_bins` - Number of histogram bins
-     * * `r_max` - Maximum radial distance in angstrom (A). Should
-     *   match or be less than the neighbor-search cutoff.
+     * * `r_max` - Upper radial cutoff in angstrom (A). Should be ≤ the
+     *   neighbor-search cutoff.
+     * * `r_min` - Lower radial cutoff in angstrom (A). Optional, defaults
+     *   to 0 (freud convention). Pairs with `d < rMin` or `d == 0` are
+     *   excluded from the histogram.
      *
      * # Example (JavaScript)
      *
      * ```js
-     * const rdf = new RDF(100, 5.0); // 100 bins up to 5 A
+     * const rdf = new RDF(100, 5.0);       // rMin = 0
+     * const rdf2 = new RDF(100, 5.0, 0.5); // exclude d < 0.5 A
      * ```
      * @param {number} n_bins
      * @param {number} r_max
+     * @param {number | null} [r_min]
      */
-    constructor(n_bins, r_max) {
-        const ret = wasm.rdf_new(n_bins, r_max);
-        this.__wbg_ptr = ret >>> 0;
+    constructor(n_bins, r_max, r_min) {
+        const ret = wasm.rdf_new(n_bins, r_max, !isLikeNone(r_min), isLikeNone(r_min) ? 0 : r_min);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
         RDFFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
@@ -2795,9 +3405,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);
  * ```
@@ -2821,28 +3431,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.
@@ -2853,30 +3458,33 @@ 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}
+     * Inner cutoff in A (lower edge of bin 0).
+     * @returns {number}
+     */
+    get rMin() {
+        const ret = wasm.rdfresult_rMin(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * 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.
+     * Normalization volume in A^3 (from the SimBox or the explicit caller value).
      * @returns {number}
      */
     get volume() {
@@ -2901,10 +3509,14 @@ export class RadiusOfGyration {
         wasm.__wbg_radiusofgyration_free(ptr, 0);
     }
     /**
-     * Compute radii of gyration. Returns `Float32Array` of length `numClusters`.
+     * Compute radii of gyration. Returns a float typed array of length `numClusters`.
+     *
+     * Internally computes the cluster centers of mass so the single-frame
+     * wasm signature `(frame, cluster)` stays stable despite the new
+     * compute trait needing explicit COM upstream.
      * @param {Frame} frame
      * @param {ClusterResult} cluster_result
-     * @returns {Float32Array}
+     * @returns {Float64Array}
      */
     compute(frame, cluster_result) {
         _assertClass(frame, Frame);
@@ -2913,15 +3525,15 @@ export class RadiusOfGyration {
         if (ret[3]) {
             throw takeFromExternrefTable0(ret[2]);
         }
-        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;
     }
     /**
-     * @param {Float32Array | null} [masses]
+     * @param {Float64Array | null} [masses]
      */
     constructor(masses) {
-        var ptr0 = isLikeNone(masses) ? 0 : passArrayF32ToWasm0(masses, wasm.__wbindgen_malloc_command_export);
+        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;
@@ -2932,150 +3544,90 @@ export class RadiusOfGyration {
 if (Symbol.dispose) RadiusOfGyration.prototype[Symbol.dispose] = RadiusOfGyration.prototype.free;
 
 /**
- * Reader for Zarr V3 simulation archives.
+ * MDL molfile / SDF (V2000 CTAB) reader.
+ *
+ * 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)
  *
- * 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.
+ * 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}
+     * Check whether the file contains no records.
+     * @returns {boolean}
      */
-    countAtoms() {
-        const ret = wasm.simulationreader_countAtoms(this.__wbg_ptr);
-        return ret >>> 0;
+    isEmpty() {
+        const ret = wasm.sdfreader_isEmpty(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 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
-     * ```
+     * Return the total number of records in the SDF file.
      * @returns {number}
      */
-    countFrames() {
-        const ret = wasm.simulationreader_countFrames(this.__wbg_ptr);
+    len() {
+        const ret = wasm.sdfreader_len(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
+     * Create a new SDF reader from a string containing the file content.
+     * @param {string} content
      */
-    constructor(files) {
-        const ret = wasm.simulationreader_new(files);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        this.__wbg_ptr = ret[0] >>> 0;
-        SimulationReaderFinalization.register(this, this.__wbg_ptr, this);
+    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.
@@ -3095,7 +3647,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 {
@@ -3143,7 +3695,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
@@ -3160,7 +3712,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}
      */
@@ -3495,26 +4047,26 @@ export class TopologyRingInfo {
 if (Symbol.dispose) TopologyRingInfo.prototype[Symbol.dispose] = TopologyRingInfo.prototype.free;
 
 /**
- * Owned f32 array with ndarray-compatible shape metadata.
+ * 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
@@ -3540,7 +4092,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() {
@@ -3556,11 +4108,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
@@ -3574,10 +4126,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}
      */
@@ -3675,7 +4227,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}
@@ -3685,7 +4237,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.
@@ -3695,14 +4247,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)
@@ -3710,7 +4262,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.
      *
@@ -3720,21 +4273,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
      *
@@ -3744,9 +4297,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);
@@ -3757,12 +4310,201 @@ export class WasmArray {
 }
 if (Symbol.dispose) WasmArray.prototype[Symbol.dispose] = WasmArray.prototype.free;
 
+/**
+ * Wrapper for [`molrs_compute::kmeans::KMeans`].
+ *
+ * # Example (JavaScript)
+ *
+ * ```js
+ * const km = new WasmKMeans(3, 100, 42);
+ * const labels = km.fit(coords, nRows, 2);   // Int32Array
+ * ```
+ */
+export class WasmKMeans {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmKMeansFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmkmeans_free(ptr, 0);
+    }
+    /**
+     * Cluster a row-major `n_rows × n_dims` coordinate matrix.
+     *
+     * # Returns
+     *
+     * Cluster labels in `0..k` as an owned `Int32Array`, one per row.
+     *
+     * # Errors
+     *
+     * Throws if `k > n_rows`, `n_dims == 0`, the length does not match
+     * `n_rows * n_dims`, or any element is non-finite.
+     * @param {Float64Array} coords
+     * @param {number} n_rows
+     * @param {number} n_dims
+     * @returns {Int32Array}
+     */
+    fit(coords, n_rows, n_dims) {
+        const ptr0 = passArrayF64ToWasm0(coords, wasm.__wbindgen_malloc_command_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmkmeans_fit(this.__wbg_ptr, ptr0, len0, n_rows, n_dims);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Create a new k-means configuration.
+     *
+     * # Arguments
+     *
+     * * `k` — number of clusters (>= 1).
+     * * `max_iter` — maximum Lloyd iterations (>= 1).
+     * * `seed` — RNG seed for k-means++ initialization. Cast to `u64`
+     *   internally (JS numbers are `f64`; integers up to 2^53 pass
+     *   through losslessly).
+     *
+     * # Errors
+     *
+     * Throws if `k == 0` or `max_iter == 0`.
+     * @param {number} k
+     * @param {number} max_iter
+     * @param {number} seed
+     */
+    constructor(k, max_iter, seed) {
+        const ret = wasm.wasmkmeans_new(k, max_iter, seed);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        WasmKMeansFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) WasmKMeans.prototype[Symbol.dispose] = WasmKMeans.prototype.free;
+
+/**
+ * Stateless wrapper for [`molrs_compute::pca::Pca2`].
+ *
+ * All configuration lives on [`fitTransform`](Self::fit_transform).
+ *
+ * # Example (JavaScript)
+ *
+ * ```js
+ * const pca = new WasmPca2();
+ * const result = pca.fitTransform(matrix, nRows, nCols);
+ * const coords   = result.coords();    // Float64Array, length 2 * nRows
+ * const variance = result.variance();  // Float64Array, length 2
+ * ```
+ */
+export class WasmPca2 {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmPca2Finalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmpca2_free(ptr, 0);
+    }
+    /**
+     * Fit 2-component PCA on a row-major observation matrix and return the
+     * projected coordinates + per-component variance.
+     *
+     * # Arguments
+     *
+     * * `matrix` — row-major `n_rows × n_cols` observation matrix.
+     * * `n_rows` — number of observations.
+     * * `n_cols` — number of features.
+     *
+     * # Errors
+     *
+     * Throws if `n_rows < 3`, `n_cols < 2`, the length does not match
+     * `n_rows * n_cols`, any element is non-finite, or any column has
+     * zero variance.
+     * @param {Float64Array} matrix
+     * @param {number} n_rows
+     * @param {number} n_cols
+     * @returns {WasmPcaResult}
+     */
+    fitTransform(matrix, n_rows, n_cols) {
+        const ptr0 = passArrayF64ToWasm0(matrix, wasm.__wbindgen_malloc_command_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmpca2_fitTransform(this.__wbg_ptr, ptr0, len0, n_rows, n_cols);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmPcaResult.__wrap(ret[0]);
+    }
+    /**
+     * Create a new PCA calculator. The struct carries no state — all
+     * parameters are supplied on [`fitTransform`](Self::fit_transform).
+     */
+    constructor() {
+        const ret = wasm.wasmpca2_new();
+        this.__wbg_ptr = ret >>> 0;
+        WasmPca2Finalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) WasmPca2.prototype[Symbol.dispose] = WasmPca2.prototype.free;
+
+/**
+ * Result of a [`WasmPca2::fit_transform`] call.
+ *
+ * Each accessor returns an **owned** `Float64Array` (copy of the underlying
+ * `Vec`) so JS is free to let this wrapper be GC'd without dangling views.
+ */
+export class WasmPcaResult {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmPcaResult.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmPcaResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmPcaResultFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmpcaresult_free(ptr, 0);
+    }
+    /**
+     * Projected 2D coordinates as a row-major `Float64Array` of length
+     * `2 * n_rows`. `coords[2 * i + 0]` is the PC1 score for row `i`,
+     * `coords[2 * i + 1]` is PC2.
+     * @returns {Float64Array}
+     */
+    coords() {
+        const ret = wasm.wasmpcaresult_coords(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Explained variance per component as `Float64Array` of length 2.
+     * `variance[0] >= variance[1]` by construction.
+     * @returns {Float64Array}
+     */
+    variance() {
+        const ret = wasm.wasmpcaresult_variance(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) WasmPcaResult.prototype[Symbol.dispose] = WasmPcaResult.prototype.free;
+
 /**
  * XYZ / Extended XYZ file reader.
  *
  * 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)
  *
@@ -3773,7 +4515,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 {
@@ -3889,13 +4631,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
  *
@@ -3928,9 +4670,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]
@@ -4007,7 +4749,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}
  */
@@ -4078,18 +4820,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);
@@ -4097,10 +4839,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;
 }
@@ -4118,35 +4860,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;
 }
@@ -4154,50 +4896,64 @@ 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) {
+export function __wbg_new_from_slice_3115b094b1002246(arg0, arg1) {
+    const ret = new Float64Array(getArrayF64FromWasm0(arg0, arg1));
+    return ret;
+}
+export function __wbg_new_from_slice_ede497d29b90a4ad(arg0, arg1) {
     const ret = new Int32Array(getArrayI32FromWasm0(arg0, arg1));
     return ret;
 }
-export function __wbg_new_from_slice_ff2c15e8e05ffdfc(arg0, arg1) {
-    const ret = new Float32Array(getArrayF32FromWasm0(arg0, arg1));
+export function __wbg_new_with_length_33f0a4c41f7ce2fc(arg0) {
+    const ret = new Int32Array(arg0 >>> 0);
     return ret;
 }
-export function __wbg_next_11b99ee6237339e3() { return handleError(function (arg0) {
+export function __wbg_new_with_length_5cfd777b51078805(arg0) {
+    const ret = new Float64Array(arg0 >>> 0);
+    return ret;
+}
+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;
 }
+export function __wbg_set_5637e648df81c8e5(arg0, arg1, arg2) {
+    arg0.set(getArrayF64FromWasm0(arg1, arg2));
+}
+export function __wbg_set_6c7215e0274bbbf2(arg0, arg1, arg2) {
+    arg0.set(getArrayI32FromWasm0(arg1, arg2));
+}
 export function __wbg_stack_3b0d974bbf31e44f(arg0, arg1) {
     const ret = arg1.stack;
     const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
@@ -4205,13 +4961,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) {
@@ -4262,6 +5018,9 @@ const ClusterResultFinalization = (typeof FinalizationRegistry === 'undefined')
 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));
@@ -4283,6 +5042,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));
@@ -4298,15 +5060,24 @@ const RDFResultFinalization = (typeof FinalizationRegistry === 'undefined')
 const RadiusOfGyrationFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_radiusofgyration_free(ptr >>> 0, 1));
-const SimulationReaderFinalization = (typeof FinalizationRegistry === 'undefined')
+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 WasmKMeansFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmkmeans_free(ptr >>> 0, 1));
+const WasmPca2Finalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmpca2_free(ptr >>> 0, 1));
+const WasmPcaResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmpcaresult_free(ptr >>> 0, 1));
 const SmilesIRFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_smilesir_free(ptr >>> 0, 1));
@@ -4394,9 +5165,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) {
@@ -4433,12 +5204,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;
@@ -4490,9 +5261,9 @@ function passArray32ToWasm0(arg, malloc) {
     return ptr;
 }
 
-function passArrayF32ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 4, 4) >>> 0;
-    getFloat32ArrayMemory0().set(arg, ptr / 4);
+function passArrayF64ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 8, 8) >>> 0;
+    getFloat64ArrayMemory0().set(arg, ptr / 8);
     WASM_VECTOR_LEN = arg.length;
     return ptr;
 }