@molcrafts/molrs 0.0.14 → 0.0.16

package/molrs_bg.js

@@ -28,7 +28,6 @@
  */
 export class Block {
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(Block.prototype);
         obj.__wbg_ptr = ptr;
         BlockFinalization.register(obj, obj.__wbg_ptr, obj);
@@ -368,7 +367,7 @@ export class Block {
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        this.__wbg_ptr = ret[0] >>> 0;
+        this.__wbg_ptr = ret[0];
         BlockFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
@@ -555,6 +554,71 @@ export class Block {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
+    /**
+     * Declare this block as N-dimensional with the given `shape`.
+     *
+     * `shape.iter().product()` must equal the block's current `nrows`
+     * when the block has columns. Pass an empty array to clear the
+     * shape and revert to plain row-table semantics.
+     *
+     * This does **not** reshape column storage — columns remain
+     * row-major 1D buffers of length `product(shape)`. `shape` is
+     * structural metadata; consumers (e.g. the volumetric renderer in
+     * MolVis) use it to unflatten the row index back into N-D
+     * coordinates.
+     *
+     * # Errors
+     *
+     * Throws if `shape.iter().product()` does not match the block's
+     * existing `nrows`, or if the block handle has been invalidated.
+     *
+     * # Example (JavaScript)
+     *
+     * ```js
+     * const grid = frame.createBlock("grid");
+     * grid.setColF("electron_density", values);  // values.length === 32*32*32
+     * grid.setShape(new Uint32Array([32, 32, 32]));
+     * ```
+     * @param {Uint32Array} shape
+     */
+    setShape(shape) {
+        const ret = wasm.block_setShape(this.__wbg_ptr, shape);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Return the structural shape of the block as a `Uint32Array`.
+     *
+     * - Plain row tables (atoms, bonds): `[nrows]` — single-axis.
+     * - Volumetric grids: `[Nx, Ny, Nz]` — explicitly declared via
+     *   [`setShape`](Self::set_shape).
+     * - Empty blocks: `[]`.
+     *
+     * `block.shape()` is uniform across all block kinds — the rank of
+     * the returned array is what distinguishes a plain table from a
+     * volumetric grid. The product of the shape always equals
+     * `block.nrows()`.
+     *
+     * # Errors
+     *
+     * Throws if the block handle has been invalidated.
+     *
+     * # Example (JavaScript)
+     *
+     * ```js
+     * const atomsShape = atoms.shape();   // Uint32Array([1000])
+     * const gridShape  = grid.shape();    // Uint32Array([32, 32, 32])
+     * ```
+     * @returns {Uint32Array}
+     */
+    shape() {
+        const ret = wasm.block_shape(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * Zero-copy JS float typed-array view into WASM linear memory.
      *
@@ -681,7 +745,6 @@ if (Symbol.dispose) Block.prototype[Symbol.dispose] = Block.prototype.free;
  */
 export class Box {
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(Box.prototype);
         obj.__wbg_ptr = ptr;
         BoxFinalization.register(obj, obj.__wbg_ptr, obj);
@@ -845,22 +908,32 @@ export class Box {
         return WasmArray.__wrap(ret);
     }
     /**
-     * Return the box edge lengths as a `WasmArray` with shape `[3]`.
-     *
-     * For orthorhombic boxes these are `[lx, ly, lz]`. For triclinic
-     * boxes these are the lengths of the three cell vectors.
+     * Return the box's 3×3 cell matrix `h` as a `WasmArray` with shape
+     * `[9]`, **column-major** (column j of `h` is the j-th lattice
+     * vector). Suitable for direct consumption by `marchingCubes` and
+     * other code that expects the cell as a flat 3×3 column-major
+     * `Float64Array`.
      *
      * # Returns
      *
-     * `WasmArray` containing `[lx, ly, lz]` in angstrom (A).
+     * `WasmArray` of length 9: `[h00, h10, h20, h01, h11, h21, h02, h12, h22]`,
+     * in angstrom (A).
      *
      * # Example (JavaScript)
      *
      * ```js
-     * const L = box.lengths().toCopy(); // Float32Array or Float64Array [10, 10, 10]
+     * const cell = box.hMatrix().toCopy(); // Float64Array, length 9
+     * // col0 = a-vector = cell[0..3]
      * ```
      * @returns {WasmArray}
      */
+    hMatrix() {
+        const ret = wasm.box_hMatrix(this.__wbg_ptr);
+        return WasmArray.__wrap(ret);
+    }
+    /**
+     * @returns {WasmArray}
+     */
     lengths() {
         const ret = wasm.box_lengths(this.__wbg_ptr);
         return WasmArray.__wrap(ret);
@@ -907,7 +980,7 @@ export class Box {
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        this.__wbg_ptr = ret[0] >>> 0;
+        this.__wbg_ptr = ret[0];
         BoxFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
@@ -973,6 +1046,40 @@ export class Box {
         }
         return Box.__wrap(ret[0]);
     }
+    /**
+     * Return the box edge lengths as a `WasmArray` with shape `[3]`.
+     *
+     * For orthorhombic boxes these are `[lx, ly, lz]`. For triclinic
+     * boxes these are the lengths of the three cell vectors.
+     *
+     * # Returns
+     *
+     * `WasmArray` containing `[lx, ly, lz]` in angstrom (A).
+     *
+     * # Example (JavaScript)
+     *
+     * ```js
+     * const L = box.lengths().toCopy(); // Float32Array or Float64Array [10, 10, 10]
+     * ```
+     * Return the per-axis periodic boundary flags as a `Uint8Array`
+     * of length 3 (`[px, py, pz]`, 1 = periodic, 0 = open).
+     *
+     * Renderers that respect PBC (isosurface marching cubes,
+     * bond minimum-image, atom wrap-around) need this to decide
+     * whether to wrap coordinates across the cell.
+     *
+     * # Example (JavaScript)
+     *
+     * ```js
+     * const pbc = box.pbc(); // Uint8Array [1, 1, 1] for fully periodic
+     * const fullyPeriodic = pbc[0] === 1 && pbc[1] === 1 && pbc[2] === 1;
+     * ```
+     * @returns {Uint8Array}
+     */
+    pbc() {
+        const ret = wasm.box_pbc(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * Return the box tilt factors as a `WasmArray` with shape `[3]`.
      *
@@ -1227,6 +1334,212 @@ export class Box {
 }
 if (Symbol.dispose) Box.prototype[Symbol.dispose] = Box.prototype.free;
 
+/**
+ * VASP CHGCAR / CHGDIF volumetric data reader.
+ *
+ * Reads VASP-format charge density files (extension-less canonical name
+ * `CHGCAR` or `CHGCAR_*`). Produces a [`Frame`] with:
+ * - `"atoms"` block: `element` (string), `x`/`y`/`z` (F, Cartesian Å).
+ * - `"grid"` block: structural shape `[nx, ny, nz]`, columns
+ *   `total` (always) and `diff` (when ISPIN=2).
+ * - `simbox`: triclinic POSCAR lattice in Å, fully periodic.
+ *
+ * CHGCAR is single-frame; only `step = 0` is valid.
+ *
+ * # Example (JavaScript)
+ *
+ * ```js
+ * const content = await file.text();
+ * const reader  = new CHGCARReader(content);
+ * const frame   = reader.read(0);
+ * const grid    = frame.getBlock("grid");
+ * const total   = grid.copyColF("total");
+ * ```
+ */
+export class CHGCARReader {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CHGCARReaderFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_chgcarreader_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isEmpty() {
+        const ret = wasm.chgcarreader_isEmpty(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * @returns {number}
+     */
+    len() {
+        const ret = wasm.chgcarreader_len(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * Create a new CHGCAR reader from the file's text content.
+     * @param {string} content
+     */
+    constructor(content) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.chgcarreader_new(ptr0, len0);
+        this.__wbg_ptr = ret;
+        CHGCARReaderFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Read the frame at `step`. CHGCAR is single-frame.
+     *
+     * # Errors
+     *
+     * Throws a `JsValue` string on parse errors.
+     * @param {number} step
+     * @returns {Frame | undefined}
+     */
+    read(step) {
+        const ret = wasm.chgcarreader_read(this.__wbg_ptr, step);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] === 0 ? undefined : Frame.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) CHGCARReader.prototype[Symbol.dispose] = CHGCARReader.prototype.free;
+
+/**
+ * Crystallographic Information File (CIF / mmCIF) reader.
+ *
+ * Each `data_*` block in the file becomes one [`Frame`]. Most CIF files
+ * contain a single block (one structure), but multi-block files (e.g.
+ * polymorphs of the same compound) are also supported and are exposed
+ * as a multi-frame sequence. The unit cell parameters
+ * (`_cell_length_a`, `_b`, `_c`, `_cell_angle_alpha`, `_beta`,
+ * `_gamma`) are converted to a 3x3 h-matrix on the Rust side and
+ * surface on the JS side as `frame.simbox`.
+ *
+ * Produces a [`Frame`] with an `"atoms"` block containing
+ * `element` (string), `x`, `y`, `z` (F, angstrom in Cartesian
+ * coordinates) and (when present in the file) `label`, `occupancy`,
+ * `bfactor` columns.
+ *
+ * CIF parsing reads the entire file on each `read(step)` call --
+ * random access is therefore O(file_size), but typical CIF files are
+ * small (< 1 MB) and the molvis lazy trajectory caches frames at the
+ * JS level, so this is rarely a bottleneck.
+ *
+ * # Example (JavaScript)
+ *
+ * ```js
+ * const content = await file.text();
+ * const reader = new CIFReader(content);
+ * const frame  = reader.read(0);
+ * const atoms  = frame.getBlock("atoms");
+ * const box    = frame.simbox;        // populated from the unit cell
+ * ```
+ */
+export class CIFReader {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CIFReaderFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_cifreader_free(ptr, 0);
+    }
+    /**
+     * Check whether the file contains no valid blocks.
+     *
+     * # Errors
+     *
+     * Throws a `JsValue` string on parse errors.
+     * @returns {boolean}
+     */
+    isEmpty() {
+        const ret = wasm.cifreader_isEmpty(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Return the number of `data_*` blocks in the file.
+     *
+     * # Errors
+     *
+     * Throws a `JsValue` string on parse errors.
+     * @returns {number}
+     */
+    len() {
+        const ret = wasm.cifreader_len(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * Create a new CIF reader from a string containing the file content.
+     *
+     * # Arguments
+     *
+     * * `content` - The full text content of a CIF file
+     *
+     * # Example (JavaScript)
+     *
+     * ```js
+     * const reader = new CIFReader(cifString);
+     * ```
+     * @param {string} content
+     */
+    constructor(content) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.cifreader_new(ptr0, len0);
+        this.__wbg_ptr = ret;
+        CIFReaderFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Read the frame at the given block index.
+     *
+     * # Arguments
+     *
+     * * `step` - 0-based index of the `data_*` block to return
+     *
+     * # Returns
+     *
+     * A [`Frame`] for the requested block, or `undefined` when
+     * `step >= len()`.
+     *
+     * # Errors
+     *
+     * Throws a `JsValue` string on parse errors.
+     * @param {number} step
+     * @returns {Frame | undefined}
+     */
+    read(step) {
+        const ret = wasm.cifreader_read(this.__wbg_ptr, step);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] === 0 ? undefined : Frame.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) CIFReader.prototype[Symbol.dispose] = CIFReader.prototype.free;
+
 /**
  * Mass-weighted cluster center calculator.
  */
@@ -1266,7 +1579,7 @@ export class CenterOfMass {
         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;
+        this.__wbg_ptr = ret;
         CenterOfMassFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
@@ -1286,7 +1599,6 @@ if (Symbol.dispose) CenterOfMass.prototype[Symbol.dispose] = CenterOfMass.protot
  */
 export class CenterOfMassResult {
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(CenterOfMassResult.prototype);
         obj.__wbg_ptr = ptr;
         CenterOfMassResultFinalization.register(obj, obj.__wbg_ptr, obj);
@@ -1416,7 +1728,7 @@ export class Cluster {
      */
     constructor(min_cluster_size) {
         const ret = wasm.cluster_new(min_cluster_size);
-        this.__wbg_ptr = ret >>> 0;
+        this.__wbg_ptr = ret;
         ClusterFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
@@ -1463,7 +1775,7 @@ export class ClusterCenters {
     }
     constructor() {
         const ret = wasm.clustercenters_new();
-        this.__wbg_ptr = ret >>> 0;
+        this.__wbg_ptr = ret;
         ClusterCentersFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
@@ -1490,7 +1802,6 @@ if (Symbol.dispose) ClusterCenters.prototype[Symbol.dispose] = ClusterCenters.pr
  */
 export class ClusterResult {
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(ClusterResult.prototype);
         obj.__wbg_ptr = ptr;
         ClusterResultFinalization.register(obj, obj.__wbg_ptr, obj);
@@ -1547,64 +1858,293 @@ export class ClusterResult {
 if (Symbol.dispose) ClusterResult.prototype[Symbol.dispose] = ClusterResult.prototype.free;
 
 /**
- * Hierarchical data container mapping string keys to typed [`Block`]s.
- *
- * A `Frame` owns a set of named blocks (column stores) and an optional
- * simulation box ([`Box`](super::region::simbox::Box)). This is the
- * primary interchange type for molecular data in the WASM API.
+ * Gaussian Cube file reader.
  *
- * # Conventions
+ * Cube files describe a single voxel grid with embedded atom geometry.
+ * The reader produces a [`Frame`] with:
+ * - `"atoms"` block: `element` (string), `atomic_number` (i32),
+ *   `charge` (F), `x`/`y`/`z` (F, **always Å** — Bohr files are converted
+ *   on read).
+ * - `"grid"` block: structural shape `[nx, ny, nz]` and one f64 column
+ *   per scalar field — `density` for single-density files,
+ *   `mo_<idx>` for negative-natoms multi-orbital files.
+ * - `simbox`: voxel cell × dims in Å.
  *
- * - The `"atoms"` block should contain per-atom properties: `symbol`
- *   (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` (F, bond order: 1.0 = single,
- *   1.5 = aromatic, 2.0 = double, 3.0 = triple).
+ * Cube is inherently single-frame (only `step = 0` is valid).
  *
  * # Example (JavaScript)
  *
  * ```js
- * const frame = new Frame();
- * const atoms = frame.createBlock("atoms");
- * atoms.setColF("x", xCoords);
+ * const content = await file.text();
+ * const reader  = new CubeReader(content);
+ * const frame   = reader.read(0);
+ * const grid    = frame.getBlock("grid");   // shape [nx, ny, nz]
+ * const density = grid.copyColF("density"); // owned Float64Array
  * ```
  */
-export class Frame {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(Frame.prototype);
-        obj.__wbg_ptr = ptr;
-        FrameFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
+export class CubeReader {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        FrameFinalization.unregister(this);
+        CubeReaderFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_frame_free(ptr, 0);
+        wasm.__wbg_cubereader_free(ptr, 0);
     }
     /**
-     * Remove all blocks from this frame (but keep the frame alive).
-     *
-     * # Errors
-     *
-     * Throws a `JsValue` string if the frame has already been dropped.
-     *
-     * # Example (JavaScript)
-     *
-     * ```js
-     * frame.clear();
-     * ```
+     * @returns {boolean}
      */
-    clear() {
-        const ret = wasm.frame_clear(this.__wbg_ptr);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
+    isEmpty() {
+        const ret = wasm.cubereader_isEmpty(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Return the number of frames (always 0 or 1).
+     * @returns {number}
+     */
+    len() {
+        const ret = wasm.cubereader_len(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * Create a new Cube reader from the file's text content.
+     * @param {string} content
+     */
+    constructor(content) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.cubereader_new(ptr0, len0);
+        this.__wbg_ptr = ret;
+        CubeReaderFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Read the frame at `step`. Cube files are single-frame, so any
+     * `step != 0` returns `undefined`.
+     *
+     * # Errors
+     *
+     * Throws a `JsValue` string on parse errors.
+     * @param {number} step
+     * @returns {Frame | undefined}
+     */
+    read(step) {
+        const ret = wasm.cubereader_read(this.__wbg_ptr, step);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] === 0 ? undefined : Frame.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) CubeReader.prototype[Symbol.dispose] = CubeReader.prototype.free;
+
+/**
+ * DCD trajectory file reader.
+ *
+ * DCD is a binary multi-frame trajectory format originally used by
+ * CHARMM and now widely produced by NAMD / OpenMM / GROMACS-via-VMD.
+ * This wrapper accepts the file as raw bytes (`Uint8Array`) since
+ * DCD is not text-encoded — passing a JS string would corrupt the
+ * fixed-width Fortran record markers.
+ *
+ * Each frame produces a [`Frame`] with an `"atoms"` block carrying
+ * `x`, `y`, `z` (F, angstrom). Box/cell information, when the DCD
+ * header declares it present, is attached as the frame's `simbox`.
+ *
+ * # Example (JavaScript)
+ *
+ * ```js
+ * const bytes = new Uint8Array(await blob.arrayBuffer());
+ * const reader = new DCDReader(bytes);
+ * console.log(reader.len()); // number of frames
+ *
+ * const frame = reader.read(0); // first frame
+ * const atoms = frame.getBlock("atoms");
+ * const x = atoms.copyColF("x");
+ * ```
+ */
+export class DCDReader {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DCDReaderFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_dcdreader_free(ptr, 0);
+    }
+    /**
+     * Check whether the file contains no frames.
+     *
+     * # Errors
+     *
+     * Throws a `JsValue` string if the header cannot be parsed.
+     * @returns {boolean}
+     */
+    isEmpty() {
+        const ret = wasm.dcdreader_isEmpty(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Return the number of frames in the DCD file.
+     *
+     * # Errors
+     *
+     * Throws a `JsValue` string if the header cannot be parsed.
+     * @returns {number}
+     */
+    len() {
+        const ret = wasm.dcdreader_len(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * Create a new DCD reader from the file's raw bytes.
+     *
+     * # Arguments
+     *
+     * * `bytes` - The full binary content of a DCD file. The reader
+     *   takes ownership of an internal copy, so the caller is free
+     *   to discard the buffer immediately after this returns.
+     *
+     * # Example (JavaScript)
+     *
+     * ```js
+     * const bytes = new Uint8Array(await file.arrayBuffer());
+     * const reader = new DCDReader(bytes);
+     * ```
+     * @param {Uint8Array} bytes
+     */
+    constructor(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc_command_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.dcdreader_new(ptr0, len0);
+        this.__wbg_ptr = ret;
+        DCDReaderFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Read a frame at the given step index.
+     *
+     * # Arguments
+     *
+     * * `step` - Zero-based frame index
+     *
+     * # Returns
+     *
+     * A [`Frame`] if the step exists, or `undefined` if `step` is
+     * out of range.
+     *
+     * # Errors
+     *
+     * Throws a `JsValue` string on parse errors (truncated record,
+     * malformed header, byte-order mismatch).
+     * @param {number} step
+     * @returns {Frame | undefined}
+     */
+    read(step) {
+        const ret = wasm.dcdreader_read(this.__wbg_ptr, step);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] === 0 ? undefined : Frame.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) DCDReader.prototype[Symbol.dispose] = DCDReader.prototype.free;
+
+/**
+ * Hierarchical data container mapping string keys to typed [`Block`]s.
+ *
+ * A `Frame` owns a set of named blocks (column stores) and an optional
+ * simulation box ([`Box`](super::region::simbox::Box)). This is the
+ * primary interchange type for molecular data in the WASM API.
+ *
+ * # Conventions
+ *
+ * - The `"atoms"` block should contain per-atom properties: `symbol`
+ *   (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` (F, bond order: 1.0 = single,
+ *   1.5 = aromatic, 2.0 = double, 3.0 = triple).
+ *
+ * # Example (JavaScript)
+ *
+ * ```js
+ * const frame = new Frame();
+ * const atoms = frame.createBlock("atoms");
+ * atoms.setColF("x", xCoords);
+ * ```
+ */
+export class Frame {
+    static __wrap(ptr) {
+        const obj = Object.create(Frame.prototype);
+        obj.__wbg_ptr = ptr;
+        FrameFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        FrameFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_frame_free(ptr, 0);
+    }
+    /**
+     * Return the names of all blocks attached to this frame.
+     *
+     * Iteration order matches the underlying `HashMap` and is therefore
+     * not stable across runs — callers that need a deterministic order
+     * must sort on the JS side. Returns an empty array if the frame
+     * has been dropped.
+     *
+     * # Example (JavaScript)
+     *
+     * ```js
+     * const names = frame.blockNames(); // e.g. ["atoms", "bonds"]
+     * ```
+     * @returns {string[]}
+     */
+    blockNames() {
+        const ret = wasm.frame_blockNames(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Remove all blocks from this frame (but keep the frame alive).
+     *
+     * # Errors
+     *
+     * Throws a `JsValue` string if the frame has already been dropped.
+     *
+     * # Example (JavaScript)
+     *
+     * ```js
+     * frame.clear();
+     * ```
+     */
+    clear() {
+        const ret = wasm.frame_clear(this.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
         }
     }
     /**
@@ -1696,38 +2236,6 @@ 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.
      *
@@ -1760,47 +2268,6 @@ export class Frame {
         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.
      *
@@ -1840,52 +2307,16 @@ export class Frame {
         }
     }
     /**
-     * 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
+     * Return the names of all metadata keys on this frame.
      *
-     * Throws a `JsValue` string if the frame has been dropped.
+     * 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 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"]
+     * const names = frame.metaNames(); // e.g. ["energy", "config", "temp"]
      * ```
      * @returns {string[]}
      */
@@ -1906,7 +2337,7 @@ export class Frame {
      */
     constructor() {
         const ret = wasm.frame_new();
-        this.__wbg_ptr = ret >>> 0;
+        this.__wbg_ptr = ret;
         FrameFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
@@ -1937,32 +2368,6 @@ 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`.
      *
@@ -2138,304 +2543,49 @@ export class Frame {
 if (Symbol.dispose) Frame.prototype[Symbol.dispose] = Frame.prototype.free;
 
 /**
- * A uniform spatial grid storing multiple named scalar arrays.
+ * One frame's location inside the source byte stream.
  *
- * 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());
- * ```
+ * `byteOffset` is the absolute byte position of the frame's first byte
+ * inside the source (round-tripped through `f64`; the spec caps source
+ * size at 1 TB which is well within `Number.MAX_SAFE_INTEGER`).
+ * `byteLen` is `u32` — per-frame size never exceeds the worker chunk
+ * size plus a small slack.
  */
-export class Grid {
+export class FrameIndexEntry {
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(Grid.prototype);
+        const obj = Object.create(FrameIndexEntry.prototype);
         obj.__wbg_ptr = ptr;
-        GridFinalization.register(obj, obj.__wbg_ptr, obj);
+        FrameIndexEntryFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        GridFinalization.unregister(this);
+        FrameIndexEntryFinalization.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;
+        wasm.__wbg_frameindexentry_free(ptr, 0);
     }
     /**
-     * Number of named arrays stored in this grid.
-     *
-     * # Example (JavaScript)
-     *
-     * ```js
-     * console.log(grid.len()); // e.g. 2
-     * ```
+     * Size of this frame's encoded byte range, in bytes.
      * @returns {number}
      */
-    len() {
-        const ret = wasm.grid_len(this.__wbg_ptr);
+    get byteLen() {
+        const ret = wasm.frameindexentry_byteLen(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
-     * ```
+     * Absolute byte offset of this frame inside the source (in bytes).
      * @returns {number}
      */
-    total() {
-        const ret = wasm.grid_total(this.__wbg_ptr);
-        return ret >>> 0;
+    get byteOffset() {
+        const ret = wasm.frameindexentry_byteOffset(this.__wbg_ptr);
+        return ret;
     }
 }
-if (Symbol.dispose) Grid.prototype[Symbol.dispose] = Grid.prototype.free;
+if (Symbol.dispose) FrameIndexEntry.prototype[Symbol.dispose] = FrameIndexEntry.prototype.free;
 
 /**
  * Gyration tensor per cluster.
@@ -2476,7 +2626,7 @@ export class GyrationTensor {
     }
     constructor() {
         const ret = wasm.gyrationtensor_new();
-        this.__wbg_ptr = ret >>> 0;
+        this.__wbg_ptr = ret;
         GyrationTensorFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
@@ -2525,7 +2675,7 @@ export class InertiaTensor {
         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;
+        this.__wbg_ptr = ret;
         InertiaTensorFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
@@ -2614,7 +2764,7 @@ export class LAMMPSReader {
         const ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.lammpsreader_new(ptr0, len0);
-        this.__wbg_ptr = ret >>> 0;
+        this.__wbg_ptr = ret;
         LAMMPSReaderFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
@@ -2712,7 +2862,7 @@ export class LAMMPSTrajReader {
         const ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.lammpstrajreader_new(ptr0, len0);
-        this.__wbg_ptr = ret >>> 0;
+        this.__wbg_ptr = ret;
         LAMMPSTrajReaderFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
@@ -2817,7 +2967,7 @@ export class LinkedCell {
      */
     constructor(cutoff) {
         const ret = wasm.linkedcell_new(cutoff);
-        this.__wbg_ptr = ret >>> 0;
+        this.__wbg_ptr = ret;
         LinkedCellFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
@@ -2950,7 +3100,7 @@ export class MSD {
      */
     constructor() {
         const ret = wasm.msd_new();
-        this.__wbg_ptr = ret >>> 0;
+        this.__wbg_ptr = ret;
         MSDFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
@@ -2999,7 +3149,6 @@ if (Symbol.dispose) MSD.prototype[Symbol.dispose] = MSD.prototype.free;
  */
 export class MSDResult {
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(MSDResult.prototype);
         obj.__wbg_ptr = ptr;
         MSDResultFinalization.register(obj, obj.__wbg_ptr, obj);
@@ -3081,7 +3230,7 @@ export class MolRecReader {
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        this.__wbg_ptr = ret[0] >>> 0;
+        this.__wbg_ptr = ret[0];
         MolRecReaderFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
@@ -3128,7 +3277,6 @@ if (Symbol.dispose) MolRecReader.prototype[Symbol.dispose] = MolRecReader.protot
  */
 export class NeighborList {
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(NeighborList.prototype);
         obj.__wbg_ptr = ptr;
         NeighborListFinalization.register(obj, obj.__wbg_ptr, obj);
@@ -3301,7 +3449,7 @@ export class PDBReader {
         const ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.pdbreader_new(ptr0, len0);
-        this.__wbg_ptr = ret >>> 0;
+        this.__wbg_ptr = ret;
         PDBReaderFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
@@ -3465,7 +3613,7 @@ export class RDF {
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        this.__wbg_ptr = ret[0] >>> 0;
+        this.__wbg_ptr = ret[0];
         RDFFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
@@ -3491,7 +3639,6 @@ if (Symbol.dispose) RDF.prototype[Symbol.dispose] = RDF.prototype.free;
  */
 export class RDFResult {
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(RDFResult.prototype);
         obj.__wbg_ptr = ptr;
         RDFResultFinalization.register(obj, obj.__wbg_ptr, obj);
@@ -3613,7 +3760,7 @@ export class RadiusOfGyration {
         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;
+        this.__wbg_ptr = ret;
         RadiusOfGyrationFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
@@ -3687,7 +3834,7 @@ export class SDFReader {
         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;
+        this.__wbg_ptr = ret;
         SDFReaderFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
@@ -3729,7 +3876,6 @@ if (Symbol.dispose) SDFReader.prototype[Symbol.dispose] = SDFReader.prototype.fr
  */
 export class SmilesIR {
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(SmilesIR.prototype);
         obj.__wbg_ptr = ptr;
         SmilesIRFinalization.register(obj, obj.__wbg_ptr, obj);
@@ -3825,7 +3971,6 @@ if (Symbol.dispose) SmilesIR.prototype[Symbol.dispose] = SmilesIR.prototype.free
  */
 export class Topology {
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(Topology.prototype);
         obj.__wbg_ptr = ptr;
         TopologyFinalization.register(obj, obj.__wbg_ptr, obj);
@@ -4022,7 +4167,7 @@ export class Topology {
      */
     constructor(n_atoms) {
         const ret = wasm.topology_new(n_atoms);
-        this.__wbg_ptr = ret >>> 0;
+        this.__wbg_ptr = ret;
         TopologyFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
@@ -4046,7 +4191,6 @@ if (Symbol.dispose) Topology.prototype[Symbol.dispose] = Topology.prototype.free
  */
 export class TopologyRingInfo {
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(TopologyRingInfo.prototype);
         obj.__wbg_ptr = ptr;
         TopologyRingInfoFinalization.register(obj, obj.__wbg_ptr, obj);
@@ -4152,7 +4296,6 @@ if (Symbol.dispose) TopologyRingInfo.prototype[Symbol.dispose] = TopologyRingInf
  */
 export class WasmArray {
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(WasmArray.prototype);
         obj.__wbg_ptr = ptr;
         WasmArrayFinalization.register(obj, obj.__wbg_ptr, obj);
@@ -4263,7 +4406,7 @@ export class WasmArray {
         const ptr0 = passArray32ToWasm0(shape, wasm.__wbindgen_malloc_command_export);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.wasmarray_new(ptr0, len0);
-        this.__wbg_ptr = ret >>> 0;
+        this.__wbg_ptr = ret;
         WasmArrayFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
@@ -4446,135 +4589,1644 @@ export class WasmKMeans {
      *
      * # Errors
      *
-     * Throws if `k == 0` or `max_iter == 0`.
-     * @param {number} k
-     * @param {number} max_iter
-     * @param {number} seed
+     * 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];
+        WasmKMeansFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) WasmKMeans.prototype[Symbol.dispose] = WasmKMeans.prototype.free;
+
+export class WasmLammpsDataStream {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmLammpsDataStreamFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmlammpsdatastream_free(ptr, 0);
+    }
+    /**
+     * Resize the reusable input buffer so it can hold at least
+     * `len` bytes, and return the WASM linear-memory pointer to
+     * its first byte.
+     *
+     * CALLER MUST RE-DERIVE THIS POINTER AFTER ANY OTHER WASM CALL —
+     * `wasm.memory.buffer` may have been detached by a `memory.grow`.
+     * @param {number} len
+     * @returns {number}
+     */
+    allocInputBuffer(len) {
+        const ret = wasm.wasmlammpsdatastream_allocInputBuffer(this.__wbg_ptr, len);
+        return ret >>> 0;
+    }
+    /**
+     * Number of blocks in the most recently parsed frame.
+     * @returns {number}
+     */
+    blockCount() {
+        const ret = wasm.wasmlammpsdatastream_blockCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Name of block `blockIdx`, or empty string if out of range.
+     * @param {number} block_idx
+     * @returns {string}
+     */
+    blockName(block_idx) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmlammpsdatastream_blockName(this.__wbg_ptr, block_idx);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free_command_export(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Number of columns in block `blockIdx`.
+     * @param {number} block_idx
+     * @returns {number}
+     */
+    columnCount(block_idx) {
+        const ret = wasm.wasmlammpsdatastream_columnCount(this.__wbg_ptr, block_idx);
+        return ret >>> 0;
+    }
+    /**
+     * Column dtype string at `(blockIdx, colIdx)`. One of `"f64"`,
+     * `"u32"`, `"i32"`, `"string"` — or `"bool"` / `"u8"` if a
+     * future parser emits those (current streaming formats do not).
+     * Empty string if the index is out of range.
+     * @param {number} block_idx
+     * @param {number} col_idx
+     * @returns {string}
+     */
+    columnDtype(block_idx, col_idx) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmlammpsdatastream_columnDtype(this.__wbg_ptr, block_idx, col_idx);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free_command_export(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Total flat element count of the column. For multi-dimensional
+     * columns (e.g. an Nx3 positions array) this is the product of
+     * all axes — i.e. the length of the slice the matching
+     * `columnPtr*` points at.
+     * @param {number} block_idx
+     * @param {number} col_idx
+     * @returns {number}
+     */
+    columnLen(block_idx, col_idx) {
+        const ret = wasm.wasmlammpsdatastream_columnLen(this.__wbg_ptr, block_idx, col_idx);
+        return ret >>> 0;
+    }
+    /**
+     * Column name at `(blockIdx, colIdx)`, or empty string if
+     * either index is out of range.
+     * @param {number} block_idx
+     * @param {number} col_idx
+     * @returns {string}
+     */
+    columnName(block_idx, col_idx) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmlammpsdatastream_columnName(this.__wbg_ptr, block_idx, col_idx);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free_command_export(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Pointer to the contiguous `f64` slice backing this column,
+     * or 0 (null) if the column is missing or has the wrong
+     * dtype.
+     *
+     * **Lifetime**: valid only until the next non-trivial wasm
+     * call. See the module-level memory-grow contract.
+     * @param {number} block_idx
+     * @param {number} col_idx
+     * @returns {number}
+     */
+    columnPtrF64(block_idx, col_idx) {
+        const ret = wasm.wasmlammpsdatastream_columnPtrF64(this.__wbg_ptr, block_idx, col_idx);
+        return ret >>> 0;
+    }
+    /**
+     * Pointer to the contiguous `i32` slice backing this column,
+     * or 0 (null) if the column is missing or has the wrong
+     * dtype.
+     *
+     * **Lifetime**: valid only until the next non-trivial wasm
+     * call. See the module-level memory-grow contract.
+     * @param {number} block_idx
+     * @param {number} col_idx
+     * @returns {number}
+     */
+    columnPtrI32(block_idx, col_idx) {
+        const ret = wasm.wasmlammpsdatastream_columnPtrI32(this.__wbg_ptr, block_idx, col_idx);
+        return ret >>> 0;
+    }
+    /**
+     * Pointer to the contiguous `u32` slice backing this column,
+     * or 0 (null) if the column is missing or has the wrong
+     * dtype.
+     *
+     * **Lifetime**: valid only until the next non-trivial wasm
+     * call. See the module-level memory-grow contract.
+     * @param {number} block_idx
+     * @param {number} col_idx
+     * @returns {number}
+     */
+    columnPtrU32(block_idx, col_idx) {
+        const ret = wasm.wasmlammpsdatastream_columnPtrU32(this.__wbg_ptr, block_idx, col_idx);
+        return ret >>> 0;
+    }
+    /**
+     * Copy a string column out by value. Returns an empty array
+     * if the column is missing or not a string column.
+     * @param {number} block_idx
+     * @param {number} col_idx
+     * @returns {string[]}
+     */
+    columnStrings(block_idx, col_idx) {
+        const ret = wasm.wasmlammpsdatastream_columnStrings(this.__wbg_ptr, block_idx, col_idx);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Feed the first `len` bytes of the input buffer into the
+     * indexer at absolute source offset `globalOffset`. Returns
+     * any frame entries that became finalized as a result.
+     *
+     * `globalOffset` is round-tripped through `f64`; per the
+     * streaming protocol the source size is capped at 1 TB
+     * (well within `Number.MAX_SAFE_INTEGER`).
+     * @param {number} global_offset
+     * @param {number} len
+     * @returns {FrameIndexEntry[]}
+     */
+    feedIndexChunk(global_offset, len) {
+        const ret = wasm.wasmlammpsdatastream_feedIndexChunk(this.__wbg_ptr, global_offset, len);
+        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;
+    }
+    /**
+     * Signal end-of-stream; return any trailing frame entry. The
+     * indexer is consumed and further `feedIndexChunk` calls
+     * throw.
+     * @returns {FrameIndexEntry[]}
+     */
+    finishIndex() {
+        const ret = wasm.wasmlammpsdatastream_finishIndex(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;
+    }
+    /**
+     * Current capacity (in bytes) of the reusable input buffer.
+     * @returns {number}
+     */
+    inputCapacity() {
+        const ret = wasm.wasmlammpsdatastream_inputCapacity(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Create a new streaming reader. The reusable input buffer
+     * starts empty; call [`allocInputBuffer`] before feeding data.
+     */
+    constructor() {
+        const ret = wasm.wasmlammpsdatastream_new();
+        this.__wbg_ptr = ret;
+        WasmLammpsDataStreamFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Decode the byte range `[offset, offset + len)` from the
+     * reusable input buffer as a single frame. Replaces any
+     * previously cached output; the caller must extract data
+     * before the next `parseRangeInInput` (the same buffer can
+     * be overwritten in between).
+     * @param {number} offset
+     * @param {number} len
+     */
+    parseRangeInInput(offset, len) {
+        const ret = wasm.wasmlammpsdatastream_parseRangeInInput(this.__wbg_ptr, offset, len);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Drop the cached output frame, releasing its memory and
+     * invalidating any outstanding `columnPtr*` pointers.
+     * pointers. Subsequent extraction calls return 0 / empty
+     * until the next `parseRangeInInput`.
+     */
+    releaseFrame() {
+        wasm.wasmlammpsdatastream_releaseFrame(this.__wbg_ptr);
+    }
+    /**
+     * Box H-matrix as a length-9 `Float64Array` (column-major:
+     * `[col0_x, col0_y, col0_z, col1_x, col1_y, col1_z, col2_x, col2_y, col2_z]`),
+     * or `undefined` if the frame has no simbox.
+     *
+     * Returned by VALUE — the typed array is owned by JS and is
+     * stable across subsequent wasm calls.
+     * @returns {Float64Array | undefined}
+     */
+    simboxH() {
+        const ret = wasm.wasmlammpsdatastream_simboxH(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free_command_export(ret[0], ret[1] * 8, 8);
+        }
+        return v1;
+    }
+    /**
+     * Box origin as a length-3 `Float64Array`, or `undefined` if
+     * the frame has no simbox.
+     * @returns {Float64Array | undefined}
+     */
+    simboxOrigin() {
+        const ret = wasm.wasmlammpsdatastream_simboxOrigin(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free_command_export(ret[0], ret[1] * 8, 8);
+        }
+        return v1;
+    }
+    /**
+     * Per-axis PBC flags as a length-3 `Uint8Array` (`1` = periodic,
+     * `0` = open), or `undefined` if the frame has no simbox.
+     *
+     * (wasm-bindgen does not support `[bool; 3]` returns natively,
+     * hence the `Uint8Array` wire format. The spec calls for
+     * `[boolean, boolean, boolean]`; the JS side is expected to
+     * `Boolean(arr[i])` each entry.)
+     * @returns {Uint8Array | undefined}
+     */
+    simboxPbc() {
+        const ret = wasm.wasmlammpsdatastream_simboxPbc(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free_command_export(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+}
+if (Symbol.dispose) WasmLammpsDataStream.prototype[Symbol.dispose] = WasmLammpsDataStream.prototype.free;
+
+export class WasmLammpsDumpStream {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmLammpsDumpStreamFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmlammpsdumpstream_free(ptr, 0);
+    }
+    /**
+     * Resize the reusable input buffer so it can hold at least
+     * `len` bytes, and return the WASM linear-memory pointer to
+     * its first byte.
+     *
+     * CALLER MUST RE-DERIVE THIS POINTER AFTER ANY OTHER WASM CALL —
+     * `wasm.memory.buffer` may have been detached by a `memory.grow`.
+     * @param {number} len
+     * @returns {number}
+     */
+    allocInputBuffer(len) {
+        const ret = wasm.wasmlammpsdumpstream_allocInputBuffer(this.__wbg_ptr, len);
+        return ret >>> 0;
+    }
+    /**
+     * Number of blocks in the most recently parsed frame.
+     * @returns {number}
+     */
+    blockCount() {
+        const ret = wasm.wasmlammpsdumpstream_blockCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Name of block `blockIdx`, or empty string if out of range.
+     * @param {number} block_idx
+     * @returns {string}
+     */
+    blockName(block_idx) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmlammpsdumpstream_blockName(this.__wbg_ptr, block_idx);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free_command_export(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Number of columns in block `blockIdx`.
+     * @param {number} block_idx
+     * @returns {number}
+     */
+    columnCount(block_idx) {
+        const ret = wasm.wasmlammpsdumpstream_columnCount(this.__wbg_ptr, block_idx);
+        return ret >>> 0;
+    }
+    /**
+     * Column dtype string at `(blockIdx, colIdx)`. One of `"f64"`,
+     * `"u32"`, `"i32"`, `"string"` — or `"bool"` / `"u8"` if a
+     * future parser emits those (current streaming formats do not).
+     * Empty string if the index is out of range.
+     * @param {number} block_idx
+     * @param {number} col_idx
+     * @returns {string}
+     */
+    columnDtype(block_idx, col_idx) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmlammpsdumpstream_columnDtype(this.__wbg_ptr, block_idx, col_idx);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free_command_export(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Total flat element count of the column. For multi-dimensional
+     * columns (e.g. an Nx3 positions array) this is the product of
+     * all axes — i.e. the length of the slice the matching
+     * `columnPtr*` points at.
+     * @param {number} block_idx
+     * @param {number} col_idx
+     * @returns {number}
+     */
+    columnLen(block_idx, col_idx) {
+        const ret = wasm.wasmlammpsdumpstream_columnLen(this.__wbg_ptr, block_idx, col_idx);
+        return ret >>> 0;
+    }
+    /**
+     * Column name at `(blockIdx, colIdx)`, or empty string if
+     * either index is out of range.
+     * @param {number} block_idx
+     * @param {number} col_idx
+     * @returns {string}
+     */
+    columnName(block_idx, col_idx) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmlammpsdumpstream_columnName(this.__wbg_ptr, block_idx, col_idx);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free_command_export(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Pointer to the contiguous `f64` slice backing this column,
+     * or 0 (null) if the column is missing or has the wrong
+     * dtype.
+     *
+     * **Lifetime**: valid only until the next non-trivial wasm
+     * call. See the module-level memory-grow contract.
+     * @param {number} block_idx
+     * @param {number} col_idx
+     * @returns {number}
+     */
+    columnPtrF64(block_idx, col_idx) {
+        const ret = wasm.wasmlammpsdumpstream_columnPtrF64(this.__wbg_ptr, block_idx, col_idx);
+        return ret >>> 0;
+    }
+    /**
+     * Pointer to the contiguous `i32` slice backing this column,
+     * or 0 (null) if the column is missing or has the wrong
+     * dtype.
+     *
+     * **Lifetime**: valid only until the next non-trivial wasm
+     * call. See the module-level memory-grow contract.
+     * @param {number} block_idx
+     * @param {number} col_idx
+     * @returns {number}
+     */
+    columnPtrI32(block_idx, col_idx) {
+        const ret = wasm.wasmlammpsdumpstream_columnPtrI32(this.__wbg_ptr, block_idx, col_idx);
+        return ret >>> 0;
+    }
+    /**
+     * Pointer to the contiguous `u32` slice backing this column,
+     * or 0 (null) if the column is missing or has the wrong
+     * dtype.
+     *
+     * **Lifetime**: valid only until the next non-trivial wasm
+     * call. See the module-level memory-grow contract.
+     * @param {number} block_idx
+     * @param {number} col_idx
+     * @returns {number}
+     */
+    columnPtrU32(block_idx, col_idx) {
+        const ret = wasm.wasmlammpsdumpstream_columnPtrU32(this.__wbg_ptr, block_idx, col_idx);
+        return ret >>> 0;
+    }
+    /**
+     * Copy a string column out by value. Returns an empty array
+     * if the column is missing or not a string column.
+     * @param {number} block_idx
+     * @param {number} col_idx
+     * @returns {string[]}
+     */
+    columnStrings(block_idx, col_idx) {
+        const ret = wasm.wasmlammpsdumpstream_columnStrings(this.__wbg_ptr, block_idx, col_idx);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Feed the first `len` bytes of the input buffer into the
+     * indexer at absolute source offset `globalOffset`. Returns
+     * any frame entries that became finalized as a result.
+     *
+     * `globalOffset` is round-tripped through `f64`; per the
+     * streaming protocol the source size is capped at 1 TB
+     * (well within `Number.MAX_SAFE_INTEGER`).
+     * @param {number} global_offset
+     * @param {number} len
+     * @returns {FrameIndexEntry[]}
+     */
+    feedIndexChunk(global_offset, len) {
+        const ret = wasm.wasmlammpsdumpstream_feedIndexChunk(this.__wbg_ptr, global_offset, len);
+        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;
+    }
+    /**
+     * Signal end-of-stream; return any trailing frame entry. The
+     * indexer is consumed and further `feedIndexChunk` calls
+     * throw.
+     * @returns {FrameIndexEntry[]}
+     */
+    finishIndex() {
+        const ret = wasm.wasmlammpsdumpstream_finishIndex(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;
+    }
+    /**
+     * Current capacity (in bytes) of the reusable input buffer.
+     * @returns {number}
+     */
+    inputCapacity() {
+        const ret = wasm.wasmlammpsdumpstream_inputCapacity(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Create a new streaming reader. The reusable input buffer
+     * starts empty; call [`allocInputBuffer`] before feeding data.
+     */
+    constructor() {
+        const ret = wasm.wasmlammpsdumpstream_new();
+        this.__wbg_ptr = ret;
+        WasmLammpsDumpStreamFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Decode the byte range `[offset, offset + len)` from the
+     * reusable input buffer as a single frame. Replaces any
+     * previously cached output; the caller must extract data
+     * before the next `parseRangeInInput` (the same buffer can
+     * be overwritten in between).
+     * @param {number} offset
+     * @param {number} len
+     */
+    parseRangeInInput(offset, len) {
+        const ret = wasm.wasmlammpsdumpstream_parseRangeInInput(this.__wbg_ptr, offset, len);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Drop the cached output frame, releasing its memory and
+     * invalidating any outstanding `columnPtr*` pointers.
+     * pointers. Subsequent extraction calls return 0 / empty
+     * until the next `parseRangeInInput`.
+     */
+    releaseFrame() {
+        wasm.wasmlammpsdumpstream_releaseFrame(this.__wbg_ptr);
+    }
+    /**
+     * Box H-matrix as a length-9 `Float64Array` (column-major:
+     * `[col0_x, col0_y, col0_z, col1_x, col1_y, col1_z, col2_x, col2_y, col2_z]`),
+     * or `undefined` if the frame has no simbox.
+     *
+     * Returned by VALUE — the typed array is owned by JS and is
+     * stable across subsequent wasm calls.
+     * @returns {Float64Array | undefined}
+     */
+    simboxH() {
+        const ret = wasm.wasmlammpsdumpstream_simboxH(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free_command_export(ret[0], ret[1] * 8, 8);
+        }
+        return v1;
+    }
+    /**
+     * Box origin as a length-3 `Float64Array`, or `undefined` if
+     * the frame has no simbox.
+     * @returns {Float64Array | undefined}
+     */
+    simboxOrigin() {
+        const ret = wasm.wasmlammpsdumpstream_simboxOrigin(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free_command_export(ret[0], ret[1] * 8, 8);
+        }
+        return v1;
+    }
+    /**
+     * Per-axis PBC flags as a length-3 `Uint8Array` (`1` = periodic,
+     * `0` = open), or `undefined` if the frame has no simbox.
+     *
+     * (wasm-bindgen does not support `[bool; 3]` returns natively,
+     * hence the `Uint8Array` wire format. The spec calls for
+     * `[boolean, boolean, boolean]`; the JS side is expected to
+     * `Boolean(arr[i])` each entry.)
+     * @returns {Uint8Array | undefined}
+     */
+    simboxPbc() {
+        const ret = wasm.wasmlammpsdumpstream_simboxPbc(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free_command_export(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+}
+if (Symbol.dispose) WasmLammpsDumpStream.prototype[Symbol.dispose] = WasmLammpsDumpStream.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;
+        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) {
+        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;
+
+export class WasmPdbStream {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmPdbStreamFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmpdbstream_free(ptr, 0);
+    }
+    /**
+     * Resize the reusable input buffer so it can hold at least
+     * `len` bytes, and return the WASM linear-memory pointer to
+     * its first byte.
+     *
+     * CALLER MUST RE-DERIVE THIS POINTER AFTER ANY OTHER WASM CALL —
+     * `wasm.memory.buffer` may have been detached by a `memory.grow`.
+     * @param {number} len
+     * @returns {number}
+     */
+    allocInputBuffer(len) {
+        const ret = wasm.wasmpdbstream_allocInputBuffer(this.__wbg_ptr, len);
+        return ret >>> 0;
+    }
+    /**
+     * Number of blocks in the most recently parsed frame.
+     * @returns {number}
+     */
+    blockCount() {
+        const ret = wasm.wasmpdbstream_blockCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Name of block `blockIdx`, or empty string if out of range.
+     * @param {number} block_idx
+     * @returns {string}
+     */
+    blockName(block_idx) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmpdbstream_blockName(this.__wbg_ptr, block_idx);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free_command_export(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Number of columns in block `blockIdx`.
+     * @param {number} block_idx
+     * @returns {number}
+     */
+    columnCount(block_idx) {
+        const ret = wasm.wasmpdbstream_columnCount(this.__wbg_ptr, block_idx);
+        return ret >>> 0;
+    }
+    /**
+     * Column dtype string at `(blockIdx, colIdx)`. One of `"f64"`,
+     * `"u32"`, `"i32"`, `"string"` — or `"bool"` / `"u8"` if a
+     * future parser emits those (current streaming formats do not).
+     * Empty string if the index is out of range.
+     * @param {number} block_idx
+     * @param {number} col_idx
+     * @returns {string}
+     */
+    columnDtype(block_idx, col_idx) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmpdbstream_columnDtype(this.__wbg_ptr, block_idx, col_idx);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free_command_export(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Total flat element count of the column. For multi-dimensional
+     * columns (e.g. an Nx3 positions array) this is the product of
+     * all axes — i.e. the length of the slice the matching
+     * `columnPtr*` points at.
+     * @param {number} block_idx
+     * @param {number} col_idx
+     * @returns {number}
+     */
+    columnLen(block_idx, col_idx) {
+        const ret = wasm.wasmpdbstream_columnLen(this.__wbg_ptr, block_idx, col_idx);
+        return ret >>> 0;
+    }
+    /**
+     * Column name at `(blockIdx, colIdx)`, or empty string if
+     * either index is out of range.
+     * @param {number} block_idx
+     * @param {number} col_idx
+     * @returns {string}
+     */
+    columnName(block_idx, col_idx) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmpdbstream_columnName(this.__wbg_ptr, block_idx, col_idx);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free_command_export(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Pointer to the contiguous `f64` slice backing this column,
+     * or 0 (null) if the column is missing or has the wrong
+     * dtype.
+     *
+     * **Lifetime**: valid only until the next non-trivial wasm
+     * call. See the module-level memory-grow contract.
+     * @param {number} block_idx
+     * @param {number} col_idx
+     * @returns {number}
+     */
+    columnPtrF64(block_idx, col_idx) {
+        const ret = wasm.wasmpdbstream_columnPtrF64(this.__wbg_ptr, block_idx, col_idx);
+        return ret >>> 0;
+    }
+    /**
+     * Pointer to the contiguous `i32` slice backing this column,
+     * or 0 (null) if the column is missing or has the wrong
+     * dtype.
+     *
+     * **Lifetime**: valid only until the next non-trivial wasm
+     * call. See the module-level memory-grow contract.
+     * @param {number} block_idx
+     * @param {number} col_idx
+     * @returns {number}
+     */
+    columnPtrI32(block_idx, col_idx) {
+        const ret = wasm.wasmpdbstream_columnPtrI32(this.__wbg_ptr, block_idx, col_idx);
+        return ret >>> 0;
+    }
+    /**
+     * Pointer to the contiguous `u32` slice backing this column,
+     * or 0 (null) if the column is missing or has the wrong
+     * dtype.
+     *
+     * **Lifetime**: valid only until the next non-trivial wasm
+     * call. See the module-level memory-grow contract.
+     * @param {number} block_idx
+     * @param {number} col_idx
+     * @returns {number}
+     */
+    columnPtrU32(block_idx, col_idx) {
+        const ret = wasm.wasmpdbstream_columnPtrU32(this.__wbg_ptr, block_idx, col_idx);
+        return ret >>> 0;
+    }
+    /**
+     * Copy a string column out by value. Returns an empty array
+     * if the column is missing or not a string column.
+     * @param {number} block_idx
+     * @param {number} col_idx
+     * @returns {string[]}
+     */
+    columnStrings(block_idx, col_idx) {
+        const ret = wasm.wasmpdbstream_columnStrings(this.__wbg_ptr, block_idx, col_idx);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Feed the first `len` bytes of the input buffer into the
+     * indexer at absolute source offset `globalOffset`. Returns
+     * any frame entries that became finalized as a result.
+     *
+     * `globalOffset` is round-tripped through `f64`; per the
+     * streaming protocol the source size is capped at 1 TB
+     * (well within `Number.MAX_SAFE_INTEGER`).
+     * @param {number} global_offset
+     * @param {number} len
+     * @returns {FrameIndexEntry[]}
+     */
+    feedIndexChunk(global_offset, len) {
+        const ret = wasm.wasmpdbstream_feedIndexChunk(this.__wbg_ptr, global_offset, len);
+        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;
+    }
+    /**
+     * Signal end-of-stream; return any trailing frame entry. The
+     * indexer is consumed and further `feedIndexChunk` calls
+     * throw.
+     * @returns {FrameIndexEntry[]}
+     */
+    finishIndex() {
+        const ret = wasm.wasmpdbstream_finishIndex(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;
+    }
+    /**
+     * Current capacity (in bytes) of the reusable input buffer.
+     * @returns {number}
+     */
+    inputCapacity() {
+        const ret = wasm.wasmpdbstream_inputCapacity(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Create a new streaming reader. The reusable input buffer
+     * starts empty; call [`allocInputBuffer`] before feeding data.
+     */
+    constructor() {
+        const ret = wasm.wasmpdbstream_new();
+        this.__wbg_ptr = ret;
+        WasmPdbStreamFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Decode the byte range `[offset, offset + len)` from the
+     * reusable input buffer as a single frame. Replaces any
+     * previously cached output; the caller must extract data
+     * before the next `parseRangeInInput` (the same buffer can
+     * be overwritten in between).
+     * @param {number} offset
+     * @param {number} len
+     */
+    parseRangeInInput(offset, len) {
+        const ret = wasm.wasmpdbstream_parseRangeInInput(this.__wbg_ptr, offset, len);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Drop the cached output frame, releasing its memory and
+     * invalidating any outstanding `columnPtr*` pointers.
+     * pointers. Subsequent extraction calls return 0 / empty
+     * until the next `parseRangeInInput`.
+     */
+    releaseFrame() {
+        wasm.wasmpdbstream_releaseFrame(this.__wbg_ptr);
+    }
+    /**
+     * Box H-matrix as a length-9 `Float64Array` (column-major:
+     * `[col0_x, col0_y, col0_z, col1_x, col1_y, col1_z, col2_x, col2_y, col2_z]`),
+     * or `undefined` if the frame has no simbox.
+     *
+     * Returned by VALUE — the typed array is owned by JS and is
+     * stable across subsequent wasm calls.
+     * @returns {Float64Array | undefined}
+     */
+    simboxH() {
+        const ret = wasm.wasmpdbstream_simboxH(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free_command_export(ret[0], ret[1] * 8, 8);
+        }
+        return v1;
+    }
+    /**
+     * Box origin as a length-3 `Float64Array`, or `undefined` if
+     * the frame has no simbox.
+     * @returns {Float64Array | undefined}
+     */
+    simboxOrigin() {
+        const ret = wasm.wasmpdbstream_simboxOrigin(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free_command_export(ret[0], ret[1] * 8, 8);
+        }
+        return v1;
+    }
+    /**
+     * Per-axis PBC flags as a length-3 `Uint8Array` (`1` = periodic,
+     * `0` = open), or `undefined` if the frame has no simbox.
+     *
+     * (wasm-bindgen does not support `[bool; 3]` returns natively,
+     * hence the `Uint8Array` wire format. The spec calls for
+     * `[boolean, boolean, boolean]`; the JS side is expected to
+     * `Boolean(arr[i])` each entry.)
+     * @returns {Uint8Array | undefined}
+     */
+    simboxPbc() {
+        const ret = wasm.wasmpdbstream_simboxPbc(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free_command_export(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+}
+if (Symbol.dispose) WasmPdbStream.prototype[Symbol.dispose] = WasmPdbStream.prototype.free;
+
+export class WasmSdfStream {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmSdfStreamFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmsdfstream_free(ptr, 0);
+    }
+    /**
+     * Resize the reusable input buffer so it can hold at least
+     * `len` bytes, and return the WASM linear-memory pointer to
+     * its first byte.
+     *
+     * CALLER MUST RE-DERIVE THIS POINTER AFTER ANY OTHER WASM CALL —
+     * `wasm.memory.buffer` may have been detached by a `memory.grow`.
+     * @param {number} len
+     * @returns {number}
+     */
+    allocInputBuffer(len) {
+        const ret = wasm.wasmsdfstream_allocInputBuffer(this.__wbg_ptr, len);
+        return ret >>> 0;
+    }
+    /**
+     * Number of blocks in the most recently parsed frame.
+     * @returns {number}
+     */
+    blockCount() {
+        const ret = wasm.wasmsdfstream_blockCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Name of block `blockIdx`, or empty string if out of range.
+     * @param {number} block_idx
+     * @returns {string}
+     */
+    blockName(block_idx) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmsdfstream_blockName(this.__wbg_ptr, block_idx);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free_command_export(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Number of columns in block `blockIdx`.
+     * @param {number} block_idx
+     * @returns {number}
+     */
+    columnCount(block_idx) {
+        const ret = wasm.wasmsdfstream_columnCount(this.__wbg_ptr, block_idx);
+        return ret >>> 0;
+    }
+    /**
+     * Column dtype string at `(blockIdx, colIdx)`. One of `"f64"`,
+     * `"u32"`, `"i32"`, `"string"` — or `"bool"` / `"u8"` if a
+     * future parser emits those (current streaming formats do not).
+     * Empty string if the index is out of range.
+     * @param {number} block_idx
+     * @param {number} col_idx
+     * @returns {string}
+     */
+    columnDtype(block_idx, col_idx) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmsdfstream_columnDtype(this.__wbg_ptr, block_idx, col_idx);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free_command_export(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Total flat element count of the column. For multi-dimensional
+     * columns (e.g. an Nx3 positions array) this is the product of
+     * all axes — i.e. the length of the slice the matching
+     * `columnPtr*` points at.
+     * @param {number} block_idx
+     * @param {number} col_idx
+     * @returns {number}
+     */
+    columnLen(block_idx, col_idx) {
+        const ret = wasm.wasmsdfstream_columnLen(this.__wbg_ptr, block_idx, col_idx);
+        return ret >>> 0;
+    }
+    /**
+     * Column name at `(blockIdx, colIdx)`, or empty string if
+     * either index is out of range.
+     * @param {number} block_idx
+     * @param {number} col_idx
+     * @returns {string}
+     */
+    columnName(block_idx, col_idx) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmsdfstream_columnName(this.__wbg_ptr, block_idx, col_idx);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free_command_export(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Pointer to the contiguous `f64` slice backing this column,
+     * or 0 (null) if the column is missing or has the wrong
+     * dtype.
+     *
+     * **Lifetime**: valid only until the next non-trivial wasm
+     * call. See the module-level memory-grow contract.
+     * @param {number} block_idx
+     * @param {number} col_idx
+     * @returns {number}
+     */
+    columnPtrF64(block_idx, col_idx) {
+        const ret = wasm.wasmsdfstream_columnPtrF64(this.__wbg_ptr, block_idx, col_idx);
+        return ret >>> 0;
+    }
+    /**
+     * Pointer to the contiguous `i32` slice backing this column,
+     * or 0 (null) if the column is missing or has the wrong
+     * dtype.
+     *
+     * **Lifetime**: valid only until the next non-trivial wasm
+     * call. See the module-level memory-grow contract.
+     * @param {number} block_idx
+     * @param {number} col_idx
+     * @returns {number}
+     */
+    columnPtrI32(block_idx, col_idx) {
+        const ret = wasm.wasmsdfstream_columnPtrI32(this.__wbg_ptr, block_idx, col_idx);
+        return ret >>> 0;
+    }
+    /**
+     * Pointer to the contiguous `u32` slice backing this column,
+     * or 0 (null) if the column is missing or has the wrong
+     * dtype.
+     *
+     * **Lifetime**: valid only until the next non-trivial wasm
+     * call. See the module-level memory-grow contract.
+     * @param {number} block_idx
+     * @param {number} col_idx
+     * @returns {number}
+     */
+    columnPtrU32(block_idx, col_idx) {
+        const ret = wasm.wasmsdfstream_columnPtrU32(this.__wbg_ptr, block_idx, col_idx);
+        return ret >>> 0;
+    }
+    /**
+     * Copy a string column out by value. Returns an empty array
+     * if the column is missing or not a string column.
+     * @param {number} block_idx
+     * @param {number} col_idx
+     * @returns {string[]}
+     */
+    columnStrings(block_idx, col_idx) {
+        const ret = wasm.wasmsdfstream_columnStrings(this.__wbg_ptr, block_idx, col_idx);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Feed the first `len` bytes of the input buffer into the
+     * indexer at absolute source offset `globalOffset`. Returns
+     * any frame entries that became finalized as a result.
+     *
+     * `globalOffset` is round-tripped through `f64`; per the
+     * streaming protocol the source size is capped at 1 TB
+     * (well within `Number.MAX_SAFE_INTEGER`).
+     * @param {number} global_offset
+     * @param {number} len
+     * @returns {FrameIndexEntry[]}
+     */
+    feedIndexChunk(global_offset, len) {
+        const ret = wasm.wasmsdfstream_feedIndexChunk(this.__wbg_ptr, global_offset, len);
+        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;
+    }
+    /**
+     * Signal end-of-stream; return any trailing frame entry. The
+     * indexer is consumed and further `feedIndexChunk` calls
+     * throw.
+     * @returns {FrameIndexEntry[]}
+     */
+    finishIndex() {
+        const ret = wasm.wasmsdfstream_finishIndex(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;
+    }
+    /**
+     * Current capacity (in bytes) of the reusable input buffer.
+     * @returns {number}
+     */
+    inputCapacity() {
+        const ret = wasm.wasmsdfstream_inputCapacity(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Create a new streaming reader. The reusable input buffer
+     * starts empty; call [`allocInputBuffer`] before feeding data.
+     */
+    constructor() {
+        const ret = wasm.wasmsdfstream_new();
+        this.__wbg_ptr = ret;
+        WasmSdfStreamFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Decode the byte range `[offset, offset + len)` from the
+     * reusable input buffer as a single frame. Replaces any
+     * previously cached output; the caller must extract data
+     * before the next `parseRangeInInput` (the same buffer can
+     * be overwritten in between).
+     * @param {number} offset
+     * @param {number} len
+     */
+    parseRangeInInput(offset, len) {
+        const ret = wasm.wasmsdfstream_parseRangeInInput(this.__wbg_ptr, offset, len);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Drop the cached output frame, releasing its memory and
+     * invalidating any outstanding `columnPtr*` pointers.
+     * pointers. Subsequent extraction calls return 0 / empty
+     * until the next `parseRangeInInput`.
+     */
+    releaseFrame() {
+        wasm.wasmsdfstream_releaseFrame(this.__wbg_ptr);
+    }
+    /**
+     * Box H-matrix as a length-9 `Float64Array` (column-major:
+     * `[col0_x, col0_y, col0_z, col1_x, col1_y, col1_z, col2_x, col2_y, col2_z]`),
+     * or `undefined` if the frame has no simbox.
+     *
+     * Returned by VALUE — the typed array is owned by JS and is
+     * stable across subsequent wasm calls.
+     * @returns {Float64Array | undefined}
+     */
+    simboxH() {
+        const ret = wasm.wasmsdfstream_simboxH(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free_command_export(ret[0], ret[1] * 8, 8);
+        }
+        return v1;
+    }
+    /**
+     * Box origin as a length-3 `Float64Array`, or `undefined` if
+     * the frame has no simbox.
+     * @returns {Float64Array | undefined}
+     */
+    simboxOrigin() {
+        const ret = wasm.wasmsdfstream_simboxOrigin(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free_command_export(ret[0], ret[1] * 8, 8);
+        }
+        return v1;
+    }
+    /**
+     * Per-axis PBC flags as a length-3 `Uint8Array` (`1` = periodic,
+     * `0` = open), or `undefined` if the frame has no simbox.
+     *
+     * (wasm-bindgen does not support `[bool; 3]` returns natively,
+     * hence the `Uint8Array` wire format. The spec calls for
+     * `[boolean, boolean, boolean]`; the JS side is expected to
+     * `Boolean(arr[i])` each entry.)
+     * @returns {Uint8Array | undefined}
      */
-    constructor(k, max_iter, seed) {
-        const ret = wasm.wasmkmeans_new(k, max_iter, seed);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
+    simboxPbc() {
+        const ret = wasm.wasmsdfstream_simboxPbc(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free_command_export(ret[0], ret[1] * 1, 1);
         }
-        this.__wbg_ptr = ret[0] >>> 0;
-        WasmKMeansFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+        return v1;
     }
 }
-if (Symbol.dispose) WasmKMeans.prototype[Symbol.dispose] = WasmKMeans.prototype.free;
+if (Symbol.dispose) WasmSdfStream.prototype[Symbol.dispose] = WasmSdfStream.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 {
+export class WasmXyzStream {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        WasmPca2Finalization.unregister(this);
+        WasmXyzStreamFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmpca2_free(ptr, 0);
+        wasm.__wbg_wasmxyzstream_free(ptr, 0);
     }
     /**
-     * Fit 2-component PCA on a row-major observation matrix and return the
-     * projected coordinates + per-component variance.
+     * Resize the reusable input buffer so it can hold at least
+     * `len` bytes, and return the WASM linear-memory pointer to
+     * its first byte.
      *
-     * # Arguments
+     * CALLER MUST RE-DERIVE THIS POINTER AFTER ANY OTHER WASM CALL —
+     * `wasm.memory.buffer` may have been detached by a `memory.grow`.
+     * @param {number} len
+     * @returns {number}
+     */
+    allocInputBuffer(len) {
+        const ret = wasm.wasmxyzstream_allocInputBuffer(this.__wbg_ptr, len);
+        return ret >>> 0;
+    }
+    /**
+     * Number of blocks in the most recently parsed frame.
+     * @returns {number}
+     */
+    blockCount() {
+        const ret = wasm.wasmxyzstream_blockCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Name of block `blockIdx`, or empty string if out of range.
+     * @param {number} block_idx
+     * @returns {string}
+     */
+    blockName(block_idx) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmxyzstream_blockName(this.__wbg_ptr, block_idx);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free_command_export(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Number of columns in block `blockIdx`.
+     * @param {number} block_idx
+     * @returns {number}
+     */
+    columnCount(block_idx) {
+        const ret = wasm.wasmxyzstream_columnCount(this.__wbg_ptr, block_idx);
+        return ret >>> 0;
+    }
+    /**
+     * Column dtype string at `(blockIdx, colIdx)`. One of `"f64"`,
+     * `"u32"`, `"i32"`, `"string"` — or `"bool"` / `"u8"` if a
+     * future parser emits those (current streaming formats do not).
+     * Empty string if the index is out of range.
+     * @param {number} block_idx
+     * @param {number} col_idx
+     * @returns {string}
+     */
+    columnDtype(block_idx, col_idx) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmxyzstream_columnDtype(this.__wbg_ptr, block_idx, col_idx);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free_command_export(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Total flat element count of the column. For multi-dimensional
+     * columns (e.g. an Nx3 positions array) this is the product of
+     * all axes — i.e. the length of the slice the matching
+     * `columnPtr*` points at.
+     * @param {number} block_idx
+     * @param {number} col_idx
+     * @returns {number}
+     */
+    columnLen(block_idx, col_idx) {
+        const ret = wasm.wasmxyzstream_columnLen(this.__wbg_ptr, block_idx, col_idx);
+        return ret >>> 0;
+    }
+    /**
+     * Column name at `(blockIdx, colIdx)`, or empty string if
+     * either index is out of range.
+     * @param {number} block_idx
+     * @param {number} col_idx
+     * @returns {string}
+     */
+    columnName(block_idx, col_idx) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmxyzstream_columnName(this.__wbg_ptr, block_idx, col_idx);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free_command_export(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Pointer to the contiguous `f64` slice backing this column,
+     * or 0 (null) if the column is missing or has the wrong
+     * dtype.
      *
-     * * `matrix` — row-major `n_rows × n_cols` observation matrix.
-     * * `n_rows` — number of observations.
-     * * `n_cols` — number of features.
+     * **Lifetime**: valid only until the next non-trivial wasm
+     * call. See the module-level memory-grow contract.
+     * @param {number} block_idx
+     * @param {number} col_idx
+     * @returns {number}
+     */
+    columnPtrF64(block_idx, col_idx) {
+        const ret = wasm.wasmxyzstream_columnPtrF64(this.__wbg_ptr, block_idx, col_idx);
+        return ret >>> 0;
+    }
+    /**
+     * Pointer to the contiguous `i32` slice backing this column,
+     * or 0 (null) if the column is missing or has the wrong
+     * dtype.
      *
-     * # Errors
+     * **Lifetime**: valid only until the next non-trivial wasm
+     * call. See the module-level memory-grow contract.
+     * @param {number} block_idx
+     * @param {number} col_idx
+     * @returns {number}
+     */
+    columnPtrI32(block_idx, col_idx) {
+        const ret = wasm.wasmxyzstream_columnPtrI32(this.__wbg_ptr, block_idx, col_idx);
+        return ret >>> 0;
+    }
+    /**
+     * Pointer to the contiguous `u32` slice backing this column,
+     * or 0 (null) if the column is missing or has the wrong
+     * dtype.
      *
-     * 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}
+     * **Lifetime**: valid only until the next non-trivial wasm
+     * call. See the module-level memory-grow contract.
+     * @param {number} block_idx
+     * @param {number} col_idx
+     * @returns {number}
      */
-    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]);
+    columnPtrU32(block_idx, col_idx) {
+        const ret = wasm.wasmxyzstream_columnPtrU32(this.__wbg_ptr, block_idx, col_idx);
+        return ret >>> 0;
+    }
+    /**
+     * Copy a string column out by value. Returns an empty array
+     * if the column is missing or not a string column.
+     * @param {number} block_idx
+     * @param {number} col_idx
+     * @returns {string[]}
+     */
+    columnStrings(block_idx, col_idx) {
+        const ret = wasm.wasmxyzstream_columnStrings(this.__wbg_ptr, block_idx, col_idx);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Feed the first `len` bytes of the input buffer into the
+     * indexer at absolute source offset `globalOffset`. Returns
+     * any frame entries that became finalized as a result.
+     *
+     * `globalOffset` is round-tripped through `f64`; per the
+     * streaming protocol the source size is capped at 1 TB
+     * (well within `Number.MAX_SAFE_INTEGER`).
+     * @param {number} global_offset
+     * @param {number} len
+     * @returns {FrameIndexEntry[]}
+     */
+    feedIndexChunk(global_offset, len) {
+        const ret = wasm.wasmxyzstream_feedIndexChunk(this.__wbg_ptr, global_offset, len);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
         }
-        return WasmPcaResult.__wrap(ret[0]);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
+        return v1;
     }
     /**
-     * Create a new PCA calculator. The struct carries no state — all
-     * parameters are supplied on [`fitTransform`](Self::fit_transform).
+     * Signal end-of-stream; return any trailing frame entry. The
+     * indexer is consumed and further `feedIndexChunk` calls
+     * throw.
+     * @returns {FrameIndexEntry[]}
+     */
+    finishIndex() {
+        const ret = wasm.wasmxyzstream_finishIndex(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;
+    }
+    /**
+     * Current capacity (in bytes) of the reusable input buffer.
+     * @returns {number}
+     */
+    inputCapacity() {
+        const ret = wasm.wasmxyzstream_inputCapacity(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Create a new streaming reader. The reusable input buffer
+     * starts empty; call [`allocInputBuffer`] before feeding data.
      */
     constructor() {
-        const ret = wasm.wasmpca2_new();
-        this.__wbg_ptr = ret >>> 0;
-        WasmPca2Finalization.register(this, this.__wbg_ptr, this);
+        const ret = wasm.wasmxyzstream_new();
+        this.__wbg_ptr = ret;
+        WasmXyzStreamFinalization.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;
+    /**
+     * Decode the byte range `[offset, offset + len)` from the
+     * reusable input buffer as a single frame. Replaces any
+     * previously cached output; the caller must extract data
+     * before the next `parseRangeInInput` (the same buffer can
+     * be overwritten in between).
+     * @param {number} offset
+     * @param {number} len
+     */
+    parseRangeInInput(offset, len) {
+        const ret = wasm.wasmxyzstream_parseRangeInInput(this.__wbg_ptr, offset, len);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
     }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        WasmPcaResultFinalization.unregister(this);
-        return ptr;
+    /**
+     * Drop the cached output frame, releasing its memory and
+     * invalidating any outstanding `columnPtr*` pointers.
+     * pointers. Subsequent extraction calls return 0 / empty
+     * until the next `parseRangeInInput`.
+     */
+    releaseFrame() {
+        wasm.wasmxyzstream_releaseFrame(this.__wbg_ptr);
     }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmpcaresult_free(ptr, 0);
+    /**
+     * Box H-matrix as a length-9 `Float64Array` (column-major:
+     * `[col0_x, col0_y, col0_z, col1_x, col1_y, col1_z, col2_x, col2_y, col2_z]`),
+     * or `undefined` if the frame has no simbox.
+     *
+     * Returned by VALUE — the typed array is owned by JS and is
+     * stable across subsequent wasm calls.
+     * @returns {Float64Array | undefined}
+     */
+    simboxH() {
+        const ret = wasm.wasmxyzstream_simboxH(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free_command_export(ret[0], ret[1] * 8, 8);
+        }
+        return v1;
     }
     /**
-     * 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}
+     * Box origin as a length-3 `Float64Array`, or `undefined` if
+     * the frame has no simbox.
+     * @returns {Float64Array | undefined}
      */
-    coords() {
-        const ret = wasm.wasmpcaresult_coords(this.__wbg_ptr);
-        return ret;
+    simboxOrigin() {
+        const ret = wasm.wasmxyzstream_simboxOrigin(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free_command_export(ret[0], ret[1] * 8, 8);
+        }
+        return v1;
     }
     /**
-     * Explained variance per component as `Float64Array` of length 2.
-     * `variance[0] >= variance[1]` by construction.
-     * @returns {Float64Array}
+     * Per-axis PBC flags as a length-3 `Uint8Array` (`1` = periodic,
+     * `0` = open), or `undefined` if the frame has no simbox.
+     *
+     * (wasm-bindgen does not support `[bool; 3]` returns natively,
+     * hence the `Uint8Array` wire format. The spec calls for
+     * `[boolean, boolean, boolean]`; the JS side is expected to
+     * `Boolean(arr[i])` each entry.)
+     * @returns {Uint8Array | undefined}
      */
-    variance() {
-        const ret = wasm.wasmpcaresult_variance(this.__wbg_ptr);
-        return ret;
+    simboxPbc() {
+        const ret = wasm.wasmxyzstream_simboxPbc(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free_command_export(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
     }
 }
-if (Symbol.dispose) WasmPcaResult.prototype[Symbol.dispose] = WasmPcaResult.prototype.free;
+if (Symbol.dispose) WasmXyzStream.prototype[Symbol.dispose] = WasmXyzStream.prototype.free;
 
 /**
  * XYZ / Extended XYZ file reader.
@@ -4664,7 +6316,7 @@ export class XYZReader {
         const ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.xyzreader_new(ptr0, len0);
-        this.__wbg_ptr = ret >>> 0;
+        this.__wbg_ptr = ret;
         XYZReaderFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
@@ -4760,7 +6412,7 @@ export function generate3D(frame, speed, seed) {
     _assertClass(frame, Frame);
     var ptr0 = isLikeNone(speed) ? 0 : passStringToWasm0(speed, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
     var len0 = WASM_VECTOR_LEN;
-    const ret = wasm.generate3D(frame.__wbg_ptr, ptr0, len0, isLikeNone(seed) ? 0x100000001 : (seed) >>> 0);
+    const ret = wasm.generate3D(frame.__wbg_ptr, ptr0, len0, isLikeNone(seed) ? Number.MAX_SAFE_INTEGER : (seed) >>> 0);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -4897,18 +6549,18 @@ export function writeFrame(frame, format) {
         wasm.__wbindgen_free_command_export(deferred3_0, deferred3_1, 1);
     }
 }
-export function __wbg___wbindgen_debug_string_ab4b34d23d6778bd(arg0, arg1) {
+export function __wbg___wbindgen_debug_string_edece8177ad01481(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_dfa12096f400c9bd() {
+export function __wbg___wbindgen_memory_9544558992fc5400() {
     const ret = wasm.memory;
     return ret;
 }
-export function __wbg___wbindgen_string_get_7ed5322991caaec5(arg0, arg1) {
+export function __wbg___wbindgen_string_get_d109740c0d18f4d7(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);
@@ -4916,10 +6568,10 @@ export function __wbg___wbindgen_string_get_7ed5322991caaec5(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 }
-export function __wbg___wbindgen_throw_6b64449b9b9ed33c(arg0, arg1) {
+export function __wbg___wbindgen_throw_9c31b086c2b26051(arg0, arg1) {
     throw new Error(getStringFromWasm0(arg0, arg1));
 }
-export function __wbg_done_9158f7cc8751ba32(arg0) {
+export function __wbg_done_54b8da57023b7ed2(arg0) {
     const ret = arg0.done;
     return ret;
 }
@@ -4934,38 +6586,42 @@ export function __wbg_error_a6fa202b58aa1cd3(arg0, arg1) {
         wasm.__wbindgen_free_command_export(deferred0_0, deferred0_1, 1);
     }
 }
+export function __wbg_frameindexentry_new(arg0) {
+    const ret = FrameIndexEntry.__wrap(arg0);
+    return ret;
+}
 export function __wbg_getRandomValues_3f44b700395062e5() { return handleError(function (arg0, arg1) {
     globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
 }, arguments); }
-export function __wbg_get_ef70f6ce70a05af6(arg0, arg1) {
+export function __wbg_get_9573a5d891e60573(arg0, arg1) {
     const ret = arg0.get(arg1);
     return ret;
 }
-export function __wbg_get_unchecked_17f53dad852b9588(arg0, arg1) {
+export function __wbg_get_unchecked_1dfe6d05ad91d9b7(arg0, arg1) {
     const ret = arg0[arg1 >>> 0];
     return ret;
 }
-export function __wbg_keys_7fc58fd5f4899356(arg0) {
+export function __wbg_keys_3905d699258a1ee0(arg0) {
     const ret = arg0.keys();
     return ret;
 }
-export function __wbg_length_3d4ecd04bd8d22f1(arg0) {
+export function __wbg_length_2591a0f4f659a55c(arg0) {
     const ret = arg0.length;
     return ret;
 }
-export function __wbg_length_7da87610a31a2ef9(arg0) {
+export function __wbg_length_3a1b902b6cde9e2c(arg0) {
     const ret = arg0.length;
     return ret;
 }
-export function __wbg_length_9f1775224cf1d815(arg0) {
+export function __wbg_length_56fcd3e2b7e0299d(arg0) {
     const ret = arg0.length;
     return ret;
 }
-export function __wbg_length_d807629e96c741b8(arg0) {
+export function __wbg_length_911750a64e2f4f88(arg0) {
     const ret = arg0.length;
     return ret;
 }
-export function __wbg_length_fab29957ea6bdb8c(arg0) {
+export function __wbg_length_c7ce929623e7a230(arg0) {
     const ret = arg0.length;
     return ret;
 }
@@ -4973,64 +6629,78 @@ export function __wbg_msdresult_new(arg0) {
     const ret = MSDResult.__wrap(arg0);
     return ret;
 }
-export function __wbg_new_0c7403db6e782f19(arg0) {
-    const ret = new Uint8Array(arg0);
-    return ret;
-}
 export function __wbg_new_227d7c05414eb861() {
     const ret = new Error();
     return ret;
 }
-export function __wbg_new_682678e2f47e32bc() {
+export function __wbg_new_310879b66b6e95e1() {
     const ret = new Array();
     return ret;
 }
-export function __wbg_new_from_slice_01793f7edd3b321a(arg0, arg1) {
-    const ret = new Uint32Array(getArrayU32FromWasm0(arg0, arg1));
+export function __wbg_new_7ddec6de44ff8f5d(arg0) {
+    const ret = new Uint8Array(arg0);
     return ret;
 }
-export function __wbg_new_from_slice_3115b094b1002246(arg0, arg1) {
+export function __wbg_new_from_slice_02962bf7778cf945(arg0, arg1) {
     const ret = new Float64Array(getArrayF64FromWasm0(arg0, arg1));
     return ret;
 }
-export function __wbg_new_from_slice_ede497d29b90a4ad(arg0, arg1) {
+export function __wbg_new_from_slice_53b9575cecde0d9e(arg0, arg1) {
     const ret = new Int32Array(getArrayI32FromWasm0(arg0, arg1));
     return ret;
 }
-export function __wbg_new_with_length_33f0a4c41f7ce2fc(arg0) {
-    const ret = new Int32Array(arg0 >>> 0);
+export function __wbg_new_from_slice_f92bf65e9a895613(arg0, arg1) {
+    const ret = new Uint32Array(getArrayU32FromWasm0(arg0, arg1));
     return ret;
 }
-export function __wbg_new_with_length_5cfd777b51078805(arg0) {
+export function __wbg_new_with_length_1278c16a5c5b497f(arg0) {
     const ret = new Float64Array(arg0 >>> 0);
     return ret;
 }
-export function __wbg_next_0340c4ae324393c3() { return handleError(function (arg0) {
+export function __wbg_new_with_length_78398b95fa59feae(arg0) {
+    const ret = new Int32Array(arg0 >>> 0);
+    return ret;
+}
+export function __wbg_new_with_length_99887c91eae4abab(arg0) {
+    const ret = new Uint8Array(arg0 >>> 0);
+    return ret;
+}
+export function __wbg_new_with_length_f128f2c16ad4f906(arg0) {
+    const ret = new Uint32Array(arg0 >>> 0);
+    return ret;
+}
+export function __wbg_next_6429a146bf756f93() { return handleError(function (arg0) {
     const ret = arg0.next();
     return ret;
 }, arguments); }
-export function __wbg_prototypesetcall_a6b02eb00b0f4ce2(arg0, arg1, arg2) {
-    Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
-}
-export function __wbg_prototypesetcall_c5875dab42ff6b97(arg0, arg1, arg2) {
+export function __wbg_prototypesetcall_272875b350b1e49b(arg0, arg1, arg2) {
     Float64Array.prototype.set.call(getArrayF64FromWasm0(arg0, arg1), arg2);
 }
-export function __wbg_prototypesetcall_d412f763861ea165(arg0, arg1, arg2) {
+export function __wbg_prototypesetcall_303283bf37c9f014(arg0, arg1, arg2) {
     Uint32Array.prototype.set.call(getArrayU32FromWasm0(arg0, arg1), arg2);
 }
-export function __wbg_prototypesetcall_db677c7a1d7d3039(arg0, arg1, arg2) {
+export function __wbg_prototypesetcall_5f9bdc8d75e07276(arg0, arg1, arg2) {
+    Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+}
+export function __wbg_prototypesetcall_e8325bfb1e498d1c(arg0, arg1, arg2) {
     Int32Array.prototype.set.call(getArrayI32FromWasm0(arg0, arg1), arg2);
 }
-export function __wbg_push_471a5b068a5295f6(arg0, arg1) {
+export function __wbg_push_b77c476b01548d0a(arg0, arg1) {
     const ret = arg0.push(arg1);
     return ret;
 }
-export function __wbg_set_5637e648df81c8e5(arg0, arg1, arg2) {
+export function __wbg_set_5bffd0c00e65c280(arg0, arg1, arg2) {
     arg0.set(getArrayF64FromWasm0(arg1, arg2));
 }
-export function __wbg_set_6c7215e0274bbbf2(arg0, arg1, arg2) {
+export function __wbg_set_943e5a384dda27eb(arg0, arg1, arg2) {
     arg0.set(getArrayI32FromWasm0(arg1, arg2));
 }
+export function __wbg_set_index_6216eb6926d2fbc6(arg0, arg1, arg2) {
+    arg0[arg1 >>> 0] = arg2;
+}
+export function __wbg_set_index_b93fd9d797d1ff98(arg0, arg1, arg2) {
+    arg0[arg1 >>> 0] = arg2 >>> 0;
+}
 export function __wbg_stack_3b0d974bbf31e44f(arg0, arg1) {
     const ret = arg1.stack;
     const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
@@ -5038,7 +6708,7 @@ export function __wbg_stack_3b0d974bbf31e44f(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 }
-export function __wbg_value_ee3a06f4579184fa(arg0) {
+export function __wbg_value_9cc0518af87a489c(arg0) {
     const ret = arg0.value;
     return ret;
 }
@@ -5073,97 +6743,124 @@ export function __wbindgen_init_externref_table() {
 }
 const BlockFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_block_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_block_free(ptr, 1));
 const BoxFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_box_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_box_free(ptr, 1));
 const CenterOfMassFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_centerofmass_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_centerofmass_free(ptr, 1));
 const CenterOfMassResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_centerofmassresult_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_centerofmassresult_free(ptr, 1));
+const CHGCARReaderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_chgcarreader_free(ptr, 1));
+const CIFReaderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_cifreader_free(ptr, 1));
 const ClusterFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_cluster_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_cluster_free(ptr, 1));
 const ClusterCentersFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_clustercenters_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_clustercenters_free(ptr, 1));
 const ClusterResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_clusterresult_free(ptr >>> 0, 1));
-const FrameFinalization = (typeof FinalizationRegistry === 'undefined')
+    : new FinalizationRegistry(ptr => wasm.__wbg_clusterresult_free(ptr, 1));
+const CubeReaderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_cubereader_free(ptr, 1));
+const DCDReaderFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_frame_free(ptr >>> 0, 1));
-const GridFinalization = (typeof FinalizationRegistry === 'undefined')
+    : new FinalizationRegistry(ptr => wasm.__wbg_dcdreader_free(ptr, 1));
+const FrameFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_grid_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_frame_free(ptr, 1));
 const GyrationTensorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_gyrationtensor_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_gyrationtensor_free(ptr, 1));
 const InertiaTensorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_inertiatensor_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_inertiatensor_free(ptr, 1));
 const LAMMPSTrajReaderFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_lammpstrajreader_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_lammpstrajreader_free(ptr, 1));
 const LAMMPSReaderFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_lammpsreader_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_lammpsreader_free(ptr, 1));
 const LinkedCellFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_linkedcell_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_linkedcell_free(ptr, 1));
 const MSDFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_msd_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_msd_free(ptr, 1));
 const MSDResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_msdresult_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_msdresult_free(ptr, 1));
 const MolRecReaderFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_molrecreader_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_molrecreader_free(ptr, 1));
 const NeighborListFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_neighborlist_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_neighborlist_free(ptr, 1));
 const PDBReaderFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_pdbreader_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_pdbreader_free(ptr, 1));
 const RDFFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_rdf_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_rdf_free(ptr, 1));
 const RDFResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_rdfresult_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_rdfresult_free(ptr, 1));
 const RadiusOfGyrationFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_radiusofgyration_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_radiusofgyration_free(ptr, 1));
 const SDFReaderFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_sdfreader_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_sdfreader_free(ptr, 1));
 const TopologyRingInfoFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_topologyringinfo_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_topologyringinfo_free(ptr, 1));
 const WasmArrayFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmarray_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmarray_free(ptr, 1));
+const FrameIndexEntryFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_frameindexentry_free(ptr, 1));
 const WasmKMeansFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmkmeans_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmkmeans_free(ptr, 1));
+const WasmLammpsDataStreamFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmlammpsdatastream_free(ptr, 1));
+const WasmLammpsDumpStreamFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmlammpsdumpstream_free(ptr, 1));
 const WasmPca2Finalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmpca2_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmpca2_free(ptr, 1));
 const WasmPcaResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmpcaresult_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmpcaresult_free(ptr, 1));
+const WasmPdbStreamFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmpdbstream_free(ptr, 1));
+const WasmSdfStreamFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmsdfstream_free(ptr, 1));
 const SmilesIRFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_smilesir_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_smilesir_free(ptr, 1));
 const TopologyFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_topology_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_topology_free(ptr, 1));
+const WasmXyzStreamFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmxyzstream_free(ptr, 1));
 const XYZReaderFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_xyzreader_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_xyzreader_free(ptr, 1));
 
 function addToExternrefTable0(obj) {
     const idx = wasm.__externref_table_alloc_command_export();
@@ -5298,8 +6995,7 @@ function getInt32ArrayMemory0() {
 }
 
 function getStringFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return decodeText(ptr, len);
+    return decodeText(ptr >>> 0, len);
 }
 
 let cachedUint32ArrayMemory0 = null;
@@ -5338,6 +7034,13 @@ function passArray32ToWasm0(arg, malloc) {
     return ptr;
 }
 
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
 function passArrayF64ToWasm0(arg, malloc) {
     const ptr = malloc(arg.length * 8, 8) >>> 0;
     getFloat64ArrayMemory0().set(arg, ptr / 8);