@molcrafts/molrs 0.0.6 → 0.0.7

package/README.md

@@ -75,10 +75,13 @@ Frames without a simulation box are supported — a non-periodic bounding box is
 | `bonds` | `i`, `j` | `u32` | Atom indices |
 | `bonds` | `order` | `f32` | Bond order (1.0, 1.5, 2.0, 3.0) |
 
-## Build from source
+## Build from source and use it for development
 
 ```bash
 wasm-pack build --target bundler --scope molcrafts --out-name molrs
+npm link
+cd ../my-app
+npm link @molcrafts/molrs
 ```
 
 ## License

package/molrs.d.ts

@@ -803,6 +803,53 @@ export class Box {
     wrapToBlock(coords: WasmArray, out_block: Block, out_key: string): void;
 }
 
+/**
+ * Mass-weighted cluster center calculator.
+ */
+export class CenterOfMass {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Compute centers of mass.
+     */
+    compute(frame: Frame, cluster_result: ClusterResult): CenterOfMassResult;
+    /**
+     * Create a center-of-mass calculator.
+     *
+     * Pass `null` for uniform masses, or a `Float32Array` of per-particle masses.
+     */
+    constructor(masses?: Float32Array | null);
+}
+
+/**
+ * Result of center-of-mass computation.
+ *
+ * # Example (JavaScript)
+ *
+ * ```js
+ * const com = new CenterOfMass().compute(frame, clusterResult);
+ * com.centersOfMass();   // Float32Array [x0,y0,z0, ...]
+ * com.clusterMasses();   // Float32Array
+ * ```
+ */
+export class CenterOfMassResult {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Mass-weighted centers, flat `[x0,y0,z0, x1,y1,z1, ...]`.
+     */
+    centersOfMass(): Float32Array;
+    /**
+     * Total mass per cluster.
+     */
+    clusterMasses(): Float32Array;
+    /**
+     * Number of clusters.
+     */
+    readonly numClusters: number;
+}
+
 /**
  * Distance-based cluster analysis using BFS on the neighbor graph.
  *
@@ -869,6 +916,26 @@ export class Cluster {
     constructor(min_cluster_size: number);
 }
 
+/**
+ * Geometric cluster centers with minimum image convention.
+ *
+ * # Example (JavaScript)
+ *
+ * ```js
+ * const centers = new ClusterCenters().compute(frame, clusterResult);
+ * // Float32Array [x0,y0,z0, x1,y1,z1, ...]
+ * ```
+ */
+export class ClusterCenters {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Compute geometric centers. Returns flat `Float32Array` `[x0,y0,z0, ...]`.
+     */
+    compute(frame: Frame, cluster_result: ClusterResult): Float32Array;
+    constructor();
+}
+
 /**
  * Result of a distance-based cluster analysis.
  *
@@ -1169,6 +1236,72 @@ export class Frame {
     set simbox(value: Box | null | undefined);
 }
 
+/**
+ * Gyration tensor per cluster.
+ *
+ * Returns flat array: `[g00,g01,g02, g10,g11,g12, g20,g21,g22, ...]` per cluster.
+ */
+export class GyrationTensor {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Compute gyration tensors. Returns flat `Float32Array` (9 values per cluster).
+     */
+    compute(frame: Frame, cluster_result: ClusterResult): Float32Array;
+    constructor();
+}
+
+/**
+ * Moment of inertia tensor per cluster.
+ */
+export class InertiaTensor {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Compute inertia tensors. Returns flat `Float32Array` (9 values per cluster).
+     */
+    compute(frame: Frame, cluster_result: ClusterResult): Float32Array;
+    constructor(masses?: Float32Array | null);
+}
+
+/**
+ * LAMMPS dump trajectory file reader.
+ *
+ * Reads multi-frame LAMMPS dump files (the format produced by the
+ * `dump` command). Each frame produces a [`Frame`] containing an
+ * `"atoms"` block with columns matching the dump header (e.g.
+ * `id`, `type`, `x`, `y`, `z`, `vx`, `vy`, `vz`).
+ *
+ * # Example (JavaScript)
+ *
+ * ```js
+ * const reader = new LAMMPSDumpReader(dumpContent);
+ * console.log(reader.len()); // number of timesteps
+ * const frame = reader.read(0);
+ * const atoms = frame.getBlock("atoms");
+ * ```
+ */
+export class LAMMPSDumpReader {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Check whether the file contains no frames.
+     */
+    isEmpty(): boolean;
+    /**
+     * Return the number of frames in the dump file.
+     */
+    len(): number;
+    /**
+     * Create a new LAMMPS dump reader from string content.
+     */
+    constructor(content: string);
+    /**
+     * Read a frame at the given step index.
+     */
+    read(step: number): Frame | undefined;
+}
+
 /**
  * LAMMPS data file reader.
  *
@@ -1755,6 +1888,19 @@ export class RDFResult {
     readonly volume: number;
 }
 
+/**
+ * Radius of gyration per cluster.
+ */
+export class RadiusOfGyration {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Compute radii of gyration. Returns `Float32Array` of length `numClusters`.
+     */
+    compute(frame: Frame, cluster_result: ClusterResult): Float32Array;
+    constructor(masses?: Float32Array | null);
+}
+
 /**
  * Reader for Zarr V3 simulation archives.
  *
@@ -1935,6 +2081,163 @@ export class SmilesIR {
     readonly nComponents: number;
 }
 
+/**
+ * Graph-based molecular topology with automated detection of angles,
+ * dihedrals, impropers, connected components, and rings (SSSR).
+ *
+ * API mirrors igraph / molpy conventions.
+ *
+ * # Example (JavaScript)
+ *
+ * ```js
+ * const topo = Topology.fromFrame(frame);
+ * console.log(topo.nAtoms, topo.nBonds);
+ *
+ * const angles = topo.angles();       // Uint32Array [i,j,k, ...]
+ * const dihedrals = topo.dihedrals(); // Uint32Array [i,j,k,l, ...]
+ * const cc = topo.connectedComponents(); // Int32Array per-atom labels
+ *
+ * const rings = topo.findRings();
+ * console.log(rings.numRings);
+ * ```
+ */
+export class Topology {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Add a single atom.
+     */
+    addAtom(): void;
+    /**
+     * Add a bond between atoms `i` and `j`.
+     */
+    addBond(i: number, j: number): void;
+    /**
+     * All angle triplets as flat `Uint32Array` `[i,j,k, ...]`.
+     */
+    angles(): Uint32Array;
+    /**
+     * Whether atoms `i` and `j` are directly bonded.
+     */
+    areBonded(i: number, j: number): boolean;
+    /**
+     * All bond pairs as flat `Uint32Array` `[i0,j0, i1,j1, ...]`.
+     */
+    bonds(): Uint32Array;
+    /**
+     * Per-atom connected component labels as `Int32Array`.
+     *
+     * Labels are 0-based and contiguous. Each atom gets a component ID.
+     * Atoms in the same connected subgraph share the same label.
+     */
+    connectedComponents(): Int32Array;
+    /**
+     * Degree (number of bonds) of atom `idx`.
+     */
+    degree(idx: number): number;
+    /**
+     * Delete an atom by index.
+     */
+    deleteAtom(idx: number): void;
+    /**
+     * Delete a bond by edge index.
+     */
+    deleteBond(idx: number): void;
+    /**
+     * All proper dihedral quartets as flat `Uint32Array` `[i,j,k,l, ...]`.
+     */
+    dihedrals(): Uint32Array;
+    /**
+     * Compute the Smallest Set of Smallest Rings (SSSR).
+     */
+    findRings(): TopologyRingInfo;
+    /**
+     * Build a topology from a Frame's `bonds` block.
+     *
+     * Reads the `atoms` block for atom count and `bonds` block for
+     * `i`, `j` columns (Uint32).
+     */
+    static fromFrame(frame: Frame): Topology;
+    /**
+     * All improper dihedral quartets as flat `Uint32Array` `[center,i,j,k, ...]`.
+     */
+    impropers(): Uint32Array;
+    /**
+     * Neighbor atom indices of atom `idx` as `Uint32Array`.
+     */
+    neighbors(idx: number): Uint32Array;
+    /**
+     * Create a topology with `n` atoms and no bonds.
+     */
+    constructor(n_atoms: number);
+    /**
+     * Number of unique angles.
+     */
+    readonly nAngles: number;
+    /**
+     * Number of atoms (vertices).
+     */
+    readonly nAtoms: number;
+    /**
+     * Number of bonds (edges).
+     */
+    readonly nBonds: number;
+    /**
+     * Number of connected components.
+     */
+    readonly nComponents: number;
+    /**
+     * Number of unique proper dihedrals.
+     */
+    readonly nDihedrals: number;
+}
+
+/**
+ * Result of ring detection (SSSR) on a topology graph.
+ *
+ * # Example (JavaScript)
+ *
+ * ```js
+ * const rings = topo.findRings();
+ * console.log(rings.numRings);
+ * console.log(rings.ringSizes());   // Uint32Array
+ * console.log(rings.isAtomInRing(0));
+ *
+ * // Get all rings as flat array [size0, idx0_0, idx0_1, ..., size1, ...]
+ * const data = rings.rings();
+ * ```
+ */
+export class TopologyRingInfo {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Per-atom boolean mask as `Uint8Array` (0 or 1). 1 if atom is in any ring.
+     */
+    atomRingMask(n_atoms: number): Uint8Array;
+    /**
+     * Whether atom `idx` belongs to any ring.
+     */
+    isAtomInRing(idx: number): boolean;
+    /**
+     * Number of rings containing atom `idx`.
+     */
+    numAtomRings(idx: number): number;
+    /**
+     * Size of each ring as `Uint32Array`.
+     */
+    ringSizes(): Uint32Array;
+    /**
+     * All rings as flat `Uint32Array` with length-prefixed encoding:
+     * `[size0, atom0, atom1, ..., size1, atom0, atom1, ...]`.
+     */
+    rings(): Uint32Array;
+    /**
+     * Total number of rings detected.
+     */
+    readonly numRings: number;
+}
+
 /**
  * Owned f32 array with ndarray-compatible shape metadata.
  *

package/molrs.js

@@ -5,5 +5,5 @@ import { __wbg_set_wasm } from "./molrs_bg.js";
 __wbg_set_wasm(wasm);
 wasm.__wbindgen_start();
 export {
-    Block, Box, Cluster, ClusterResult, Frame, LAMMPSReader, LinkedCell, MSD, MSDResult, NeighborList, PDBReader, RDF, RDFResult, SimulationReader, SmilesIR, WasmArray, XYZReader, generate3D, parseSMILES, start, wasmMemory, writeFrame
+    Block, Box, CenterOfMass, CenterOfMassResult, Cluster, ClusterCenters, ClusterResult, Frame, GyrationTensor, InertiaTensor, LAMMPSDumpReader, LAMMPSReader, LinkedCell, MSD, MSDResult, NeighborList, PDBReader, RDF, RDFResult, RadiusOfGyration, SimulationReader, SmilesIR, Topology, TopologyRingInfo, WasmArray, XYZReader, generate3D, parseSMILES, start, wasmMemory, writeFrame
 } from "./molrs_bg.js";

package/molrs_bg.js

@@ -1149,6 +1149,112 @@ export class Box {
 }
 if (Symbol.dispose) Box.prototype[Symbol.dispose] = Box.prototype.free;
 
+/**
+ * Mass-weighted cluster center calculator.
+ */
+export class CenterOfMass {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CenterOfMassFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_centerofmass_free(ptr, 0);
+    }
+    /**
+     * Compute centers of mass.
+     * @param {Frame} frame
+     * @param {ClusterResult} cluster_result
+     * @returns {CenterOfMassResult}
+     */
+    compute(frame, cluster_result) {
+        _assertClass(frame, Frame);
+        _assertClass(cluster_result, ClusterResult);
+        const ret = wasm.centerofmass_compute(this.__wbg_ptr, frame.__wbg_ptr, cluster_result.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return CenterOfMassResult.__wrap(ret[0]);
+    }
+    /**
+     * Create a center-of-mass calculator.
+     *
+     * Pass `null` for uniform masses, or a `Float32Array` of per-particle masses.
+     * @param {Float32Array | null} [masses]
+     */
+    constructor(masses) {
+        var ptr0 = isLikeNone(masses) ? 0 : passArrayF32ToWasm0(masses, wasm.__wbindgen_malloc_command_export);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.centerofmass_new(ptr0, len0);
+        this.__wbg_ptr = ret >>> 0;
+        CenterOfMassFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) CenterOfMass.prototype[Symbol.dispose] = CenterOfMass.prototype.free;
+
+/**
+ * Result of center-of-mass computation.
+ *
+ * # Example (JavaScript)
+ *
+ * ```js
+ * const com = new CenterOfMass().compute(frame, clusterResult);
+ * com.centersOfMass();   // Float32Array [x0,y0,z0, ...]
+ * com.clusterMasses();   // Float32Array
+ * ```
+ */
+export class CenterOfMassResult {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(CenterOfMassResult.prototype);
+        obj.__wbg_ptr = ptr;
+        CenterOfMassResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CenterOfMassResultFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_centerofmassresult_free(ptr, 0);
+    }
+    /**
+     * Mass-weighted centers, flat `[x0,y0,z0, x1,y1,z1, ...]`.
+     * @returns {Float32Array}
+     */
+    centersOfMass() {
+        const ret = wasm.centerofmassresult_centersOfMass(this.__wbg_ptr);
+        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Total mass per cluster.
+     * @returns {Float32Array}
+     */
+    clusterMasses() {
+        const ret = wasm.centerofmassresult_clusterMasses(this.__wbg_ptr);
+        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Number of clusters.
+     * @returns {number}
+     */
+    get numClusters() {
+        const ret = wasm.centerofmassresult_numClusters(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) CenterOfMassResult.prototype[Symbol.dispose] = CenterOfMassResult.prototype.free;
+
 /**
  * Distance-based cluster analysis using BFS on the neighbor graph.
  *
@@ -1241,6 +1347,53 @@ export class Cluster {
 }
 if (Symbol.dispose) Cluster.prototype[Symbol.dispose] = Cluster.prototype.free;
 
+/**
+ * Geometric cluster centers with minimum image convention.
+ *
+ * # Example (JavaScript)
+ *
+ * ```js
+ * const centers = new ClusterCenters().compute(frame, clusterResult);
+ * // Float32Array [x0,y0,z0, x1,y1,z1, ...]
+ * ```
+ */
+export class ClusterCenters {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ClusterCentersFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_clustercenters_free(ptr, 0);
+    }
+    /**
+     * Compute geometric centers. Returns flat `Float32Array` `[x0,y0,z0, ...]`.
+     * @param {Frame} frame
+     * @param {ClusterResult} cluster_result
+     * @returns {Float32Array}
+     */
+    compute(frame, cluster_result) {
+        _assertClass(frame, Frame);
+        _assertClass(cluster_result, ClusterResult);
+        const ret = wasm.clustercenters_compute(this.__wbg_ptr, frame.__wbg_ptr, cluster_result.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    constructor() {
+        const ret = wasm.clustercenters_new();
+        this.__wbg_ptr = ret >>> 0;
+        ClusterCentersFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) ClusterCenters.prototype[Symbol.dispose] = ClusterCenters.prototype.free;
+
 /**
  * Result of a distance-based cluster analysis.
  *
@@ -1683,6 +1836,170 @@ export class Frame {
 }
 if (Symbol.dispose) Frame.prototype[Symbol.dispose] = Frame.prototype.free;
 
+/**
+ * Gyration tensor per cluster.
+ *
+ * Returns flat array: `[g00,g01,g02, g10,g11,g12, g20,g21,g22, ...]` per cluster.
+ */
+export class GyrationTensor {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        GyrationTensorFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_gyrationtensor_free(ptr, 0);
+    }
+    /**
+     * Compute gyration tensors. Returns flat `Float32Array` (9 values per cluster).
+     * @param {Frame} frame
+     * @param {ClusterResult} cluster_result
+     * @returns {Float32Array}
+     */
+    compute(frame, cluster_result) {
+        _assertClass(frame, Frame);
+        _assertClass(cluster_result, ClusterResult);
+        const ret = wasm.gyrationtensor_compute(this.__wbg_ptr, frame.__wbg_ptr, cluster_result.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    constructor() {
+        const ret = wasm.gyrationtensor_new();
+        this.__wbg_ptr = ret >>> 0;
+        GyrationTensorFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) GyrationTensor.prototype[Symbol.dispose] = GyrationTensor.prototype.free;
+
+/**
+ * Moment of inertia tensor per cluster.
+ */
+export class InertiaTensor {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        InertiaTensorFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_inertiatensor_free(ptr, 0);
+    }
+    /**
+     * Compute inertia tensors. Returns flat `Float32Array` (9 values per cluster).
+     * @param {Frame} frame
+     * @param {ClusterResult} cluster_result
+     * @returns {Float32Array}
+     */
+    compute(frame, cluster_result) {
+        _assertClass(frame, Frame);
+        _assertClass(cluster_result, ClusterResult);
+        const ret = wasm.inertiatensor_compute(this.__wbg_ptr, frame.__wbg_ptr, cluster_result.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @param {Float32Array | null} [masses]
+     */
+    constructor(masses) {
+        var ptr0 = isLikeNone(masses) ? 0 : passArrayF32ToWasm0(masses, wasm.__wbindgen_malloc_command_export);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.inertiatensor_new(ptr0, len0);
+        this.__wbg_ptr = ret >>> 0;
+        InertiaTensorFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) InertiaTensor.prototype[Symbol.dispose] = InertiaTensor.prototype.free;
+
+/**
+ * LAMMPS dump trajectory file reader.
+ *
+ * Reads multi-frame LAMMPS dump files (the format produced by the
+ * `dump` command). Each frame produces a [`Frame`] containing an
+ * `"atoms"` block with columns matching the dump header (e.g.
+ * `id`, `type`, `x`, `y`, `z`, `vx`, `vy`, `vz`).
+ *
+ * # Example (JavaScript)
+ *
+ * ```js
+ * const reader = new LAMMPSDumpReader(dumpContent);
+ * console.log(reader.len()); // number of timesteps
+ * const frame = reader.read(0);
+ * const atoms = frame.getBlock("atoms");
+ * ```
+ */
+export class LAMMPSDumpReader {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        LAMMPSDumpReaderFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_lammpsdumpreader_free(ptr, 0);
+    }
+    /**
+     * Check whether the file contains no frames.
+     * @returns {boolean}
+     */
+    isEmpty() {
+        const ret = wasm.lammpsdumpreader_isEmpty(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Return the number of frames in the dump file.
+     * @returns {number}
+     */
+    len() {
+        const ret = wasm.lammpsdumpreader_len(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * Create a new LAMMPS dump reader from string content.
+     * @param {string} content
+     */
+    constructor(content) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc_command_export, wasm.__wbindgen_realloc_command_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.lammpsdumpreader_new(ptr0, len0);
+        this.__wbg_ptr = ret >>> 0;
+        LAMMPSDumpReaderFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Read a frame at the given step index.
+     * @param {number} step
+     * @returns {Frame | undefined}
+     */
+    read(step) {
+        const ret = wasm.lammpsdumpreader_read(this.__wbg_ptr, step);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] === 0 ? undefined : Frame.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) LAMMPSDumpReader.prototype[Symbol.dispose] = LAMMPSDumpReader.prototype.free;
+
 /**
  * LAMMPS data file reader.
  *
@@ -2569,6 +2886,51 @@ export class RDFResult {
 }
 if (Symbol.dispose) RDFResult.prototype[Symbol.dispose] = RDFResult.prototype.free;
 
+/**
+ * Radius of gyration per cluster.
+ */
+export class RadiusOfGyration {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RadiusOfGyrationFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_radiusofgyration_free(ptr, 0);
+    }
+    /**
+     * Compute radii of gyration. Returns `Float32Array` of length `numClusters`.
+     * @param {Frame} frame
+     * @param {ClusterResult} cluster_result
+     * @returns {Float32Array}
+     */
+    compute(frame, cluster_result) {
+        _assertClass(frame, Frame);
+        _assertClass(cluster_result, ClusterResult);
+        const ret = wasm.radiusofgyration_compute(this.__wbg_ptr, frame.__wbg_ptr, cluster_result.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @param {Float32Array | null} [masses]
+     */
+    constructor(masses) {
+        var ptr0 = isLikeNone(masses) ? 0 : passArrayF32ToWasm0(masses, wasm.__wbindgen_malloc_command_export);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.radiusofgyration_new(ptr0, len0);
+        this.__wbg_ptr = ret >>> 0;
+        RadiusOfGyrationFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) RadiusOfGyration.prototype[Symbol.dispose] = RadiusOfGyration.prototype.free;
+
 /**
  * Reader for Zarr V3 simulation archives.
  *
@@ -2812,6 +3174,326 @@ export class SmilesIR {
 }
 if (Symbol.dispose) SmilesIR.prototype[Symbol.dispose] = SmilesIR.prototype.free;
 
+/**
+ * Graph-based molecular topology with automated detection of angles,
+ * dihedrals, impropers, connected components, and rings (SSSR).
+ *
+ * API mirrors igraph / molpy conventions.
+ *
+ * # Example (JavaScript)
+ *
+ * ```js
+ * const topo = Topology.fromFrame(frame);
+ * console.log(topo.nAtoms, topo.nBonds);
+ *
+ * const angles = topo.angles();       // Uint32Array [i,j,k, ...]
+ * const dihedrals = topo.dihedrals(); // Uint32Array [i,j,k,l, ...]
+ * const cc = topo.connectedComponents(); // Int32Array per-atom labels
+ *
+ * const rings = topo.findRings();
+ * console.log(rings.numRings);
+ * ```
+ */
+export class Topology {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Topology.prototype);
+        obj.__wbg_ptr = ptr;
+        TopologyFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TopologyFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_topology_free(ptr, 0);
+    }
+    /**
+     * Add a single atom.
+     */
+    addAtom() {
+        wasm.topology_addAtom(this.__wbg_ptr);
+    }
+    /**
+     * Add a bond between atoms `i` and `j`.
+     * @param {number} i
+     * @param {number} j
+     */
+    addBond(i, j) {
+        wasm.topology_addBond(this.__wbg_ptr, i, j);
+    }
+    /**
+     * All angle triplets as flat `Uint32Array` `[i,j,k, ...]`.
+     * @returns {Uint32Array}
+     */
+    angles() {
+        const ret = wasm.topology_angles(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Whether atoms `i` and `j` are directly bonded.
+     * @param {number} i
+     * @param {number} j
+     * @returns {boolean}
+     */
+    areBonded(i, j) {
+        const ret = wasm.topology_areBonded(this.__wbg_ptr, i, j);
+        return ret !== 0;
+    }
+    /**
+     * All bond pairs as flat `Uint32Array` `[i0,j0, i1,j1, ...]`.
+     * @returns {Uint32Array}
+     */
+    bonds() {
+        const ret = wasm.topology_bonds(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Per-atom connected component labels as `Int32Array`.
+     *
+     * Labels are 0-based and contiguous. Each atom gets a component ID.
+     * Atoms in the same connected subgraph share the same label.
+     * @returns {Int32Array}
+     */
+    connectedComponents() {
+        const ret = wasm.topology_connectedComponents(this.__wbg_ptr);
+        var v1 = getArrayI32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Degree (number of bonds) of atom `idx`.
+     * @param {number} idx
+     * @returns {number}
+     */
+    degree(idx) {
+        const ret = wasm.topology_degree(this.__wbg_ptr, idx);
+        return ret >>> 0;
+    }
+    /**
+     * Delete an atom by index.
+     * @param {number} idx
+     */
+    deleteAtom(idx) {
+        wasm.topology_deleteAtom(this.__wbg_ptr, idx);
+    }
+    /**
+     * Delete a bond by edge index.
+     * @param {number} idx
+     */
+    deleteBond(idx) {
+        wasm.topology_deleteBond(this.__wbg_ptr, idx);
+    }
+    /**
+     * All proper dihedral quartets as flat `Uint32Array` `[i,j,k,l, ...]`.
+     * @returns {Uint32Array}
+     */
+    dihedrals() {
+        const ret = wasm.topology_dihedrals(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Compute the Smallest Set of Smallest Rings (SSSR).
+     * @returns {TopologyRingInfo}
+     */
+    findRings() {
+        const ret = wasm.topology_findRings(this.__wbg_ptr);
+        return TopologyRingInfo.__wrap(ret);
+    }
+    /**
+     * Build a topology from a Frame's `bonds` block.
+     *
+     * Reads the `atoms` block for atom count and `bonds` block for
+     * `i`, `j` columns (Uint32).
+     * @param {Frame} frame
+     * @returns {Topology}
+     */
+    static fromFrame(frame) {
+        _assertClass(frame, Frame);
+        const ret = wasm.topology_fromFrame(frame.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Topology.__wrap(ret[0]);
+    }
+    /**
+     * All improper dihedral quartets as flat `Uint32Array` `[center,i,j,k, ...]`.
+     * @returns {Uint32Array}
+     */
+    impropers() {
+        const ret = wasm.topology_impropers(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Number of unique angles.
+     * @returns {number}
+     */
+    get nAngles() {
+        const ret = wasm.topology_nAngles(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Number of atoms (vertices).
+     * @returns {number}
+     */
+    get nAtoms() {
+        const ret = wasm.topology_nAtoms(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Number of bonds (edges).
+     * @returns {number}
+     */
+    get nBonds() {
+        const ret = wasm.topology_nBonds(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Number of connected components.
+     * @returns {number}
+     */
+    get nComponents() {
+        const ret = wasm.topology_nComponents(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Number of unique proper dihedrals.
+     * @returns {number}
+     */
+    get nDihedrals() {
+        const ret = wasm.topology_nDihedrals(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Neighbor atom indices of atom `idx` as `Uint32Array`.
+     * @param {number} idx
+     * @returns {Uint32Array}
+     */
+    neighbors(idx) {
+        const ret = wasm.topology_neighbors(this.__wbg_ptr, idx);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Create a topology with `n` atoms and no bonds.
+     * @param {number} n_atoms
+     */
+    constructor(n_atoms) {
+        const ret = wasm.topology_new(n_atoms);
+        this.__wbg_ptr = ret >>> 0;
+        TopologyFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) Topology.prototype[Symbol.dispose] = Topology.prototype.free;
+
+/**
+ * Result of ring detection (SSSR) on a topology graph.
+ *
+ * # Example (JavaScript)
+ *
+ * ```js
+ * const rings = topo.findRings();
+ * console.log(rings.numRings);
+ * console.log(rings.ringSizes());   // Uint32Array
+ * console.log(rings.isAtomInRing(0));
+ *
+ * // Get all rings as flat array [size0, idx0_0, idx0_1, ..., size1, ...]
+ * const data = rings.rings();
+ * ```
+ */
+export class TopologyRingInfo {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(TopologyRingInfo.prototype);
+        obj.__wbg_ptr = ptr;
+        TopologyRingInfoFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TopologyRingInfoFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_topologyringinfo_free(ptr, 0);
+    }
+    /**
+     * Per-atom boolean mask as `Uint8Array` (0 or 1). 1 if atom is in any ring.
+     * @param {number} n_atoms
+     * @returns {Uint8Array}
+     */
+    atomRingMask(n_atoms) {
+        const ret = wasm.topologyringinfo_atomRingMask(this.__wbg_ptr, n_atoms);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * Whether atom `idx` belongs to any ring.
+     * @param {number} idx
+     * @returns {boolean}
+     */
+    isAtomInRing(idx) {
+        const ret = wasm.topologyringinfo_isAtomInRing(this.__wbg_ptr, idx);
+        return ret !== 0;
+    }
+    /**
+     * Number of rings containing atom `idx`.
+     * @param {number} idx
+     * @returns {number}
+     */
+    numAtomRings(idx) {
+        const ret = wasm.topologyringinfo_numAtomRings(this.__wbg_ptr, idx);
+        return ret >>> 0;
+    }
+    /**
+     * Total number of rings detected.
+     * @returns {number}
+     */
+    get numRings() {
+        const ret = wasm.topologyringinfo_numRings(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Size of each ring as `Uint32Array`.
+     * @returns {Uint32Array}
+     */
+    ringSizes() {
+        const ret = wasm.topologyringinfo_ringSizes(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * All rings as flat `Uint32Array` with length-prefixed encoding:
+     * `[size0, atom0, atom1, ..., size1, atom0, atom1, ...]`.
+     * @returns {Uint32Array}
+     */
+    rings() {
+        const ret = wasm.topologyringinfo_rings(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free_command_export(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+}
+if (Symbol.dispose) TopologyRingInfo.prototype[Symbol.dispose] = TopologyRingInfo.prototype.free;
+
 /**
  * Owned f32 array with ndarray-compatible shape metadata.
  *
@@ -3562,15 +4244,33 @@ const BlockFinalization = (typeof FinalizationRegistry === 'undefined')
 const BoxFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_box_free(ptr >>> 0, 1));
+const CenterOfMassFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_centerofmass_free(ptr >>> 0, 1));
+const CenterOfMassResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_centerofmassresult_free(ptr >>> 0, 1));
 const ClusterFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_cluster_free(ptr >>> 0, 1));
+const ClusterCentersFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_clustercenters_free(ptr >>> 0, 1));
 const ClusterResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_clusterresult_free(ptr >>> 0, 1));
 const FrameFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_frame_free(ptr >>> 0, 1));
+const GyrationTensorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_gyrationtensor_free(ptr >>> 0, 1));
+const InertiaTensorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_inertiatensor_free(ptr >>> 0, 1));
+const LAMMPSDumpReaderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_lammpsdumpreader_free(ptr >>> 0, 1));
 const LAMMPSReaderFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_lammpsreader_free(ptr >>> 0, 1));
@@ -3595,15 +4295,24 @@ const RDFFinalization = (typeof FinalizationRegistry === 'undefined')
 const RDFResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_rdfresult_free(ptr >>> 0, 1));
+const RadiusOfGyrationFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_radiusofgyration_free(ptr >>> 0, 1));
 const SimulationReaderFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_simulationreader_free(ptr >>> 0, 1));
+const TopologyRingInfoFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_topologyringinfo_free(ptr >>> 0, 1));
 const WasmArrayFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmarray_free(ptr >>> 0, 1));
 const SmilesIRFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_smilesir_free(ptr >>> 0, 1));
+const TopologyFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_topology_free(ptr >>> 0, 1));
 const XYZReaderFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_xyzreader_free(ptr >>> 0, 1));
@@ -3781,6 +4490,13 @@ function passArray32ToWasm0(arg, malloc) {
     return ptr;
 }
 
+function passArrayF32ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 4, 4) >>> 0;
+    getFloat32ArrayMemory0().set(arg, ptr / 4);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);

package/package.json

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