@kent-tokyo/chematic 0.1.25 → 0.1.37

package/chematic_wasm.js

@@ -731,6 +731,38 @@ export class MolHandle {
         const ret = wasm.molhandle_sum_estate(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * InChI string representation of the molecule.
+     * @returns {string}
+     */
+    to_inchi() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.molhandle_to_inchi(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * InChIKey (27-character identifier) for the molecule.
+     * @returns {string}
+     */
+    to_inchikey() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.molhandle_to_inchikey(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
     /**
      * Topological polar surface area (Ų).
      * @returns {number}
@@ -783,6 +815,29 @@ export function atom_pair_bitvec(mol) {
     return v1;
 }
 
+/**
+ * Check whether a reaction SMILES is atom-balanced.
+ *
+ * Returns JSON: `{ "balanced": true|false, "diff": ["C: 1 reactant vs 2 product", ...] }`
+ * Returns `"error:<msg>"` on parse failure.
+ * @param {string} reaction_smiles
+ * @returns {string}
+ */
+export function balance_check_json(reaction_smiles) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(reaction_smiles, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.balance_check_json(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
 /**
  * Number of BRICS fragments produced by fragmenting the molecule.
  *
@@ -922,6 +977,111 @@ export function cip_assignments_json(mol) {
     }
 }
 
+/**
+ * Compare multiple SMILES strings (up to 256 by default).
+ * Accepts a delimiter-separated list (e.g., newline or comma).
+ *
+ * # Example (JS)
+ * ```javascript
+ * const smilesList = "c1ccccc1\nCc1ccccc1\nCCc1ccccc1";
+ * const json = module.compare_molecules_batch_json(smilesList, "\n");
+ * const comparison = JSON.parse(json);
+ * ```
+ * @param {string} smiles_batch
+ * @param {string} delimiter
+ * @returns {string}
+ */
+export function compare_molecules_batch_json(smiles_batch, delimiter) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passStringToWasm0(smiles_batch, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(delimiter, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.compare_molecules_batch_json(ptr0, len0, ptr1, len1);
+        var ptr3 = ret[0];
+        var len3 = ret[1];
+        if (ret[3]) {
+            ptr3 = 0; len3 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
+}
+
+/**
+ * Compare two or more SMILES strings (JSON string output).
+ * Returns the JSON representation of a `MoleculeComparison` struct.
+ *
+ * # Example (JS)
+ * ```javascript
+ * const json = module.compare_molecules_json("c1ccccc1", "Cc1ccccc1");
+ * const comparison = JSON.parse(json);
+ * console.log(comparison.pairwise[0].similarities.ecfp4_tanimoto);
+ * ```
+ * @param {string} smiles1
+ * @param {string} smiles2
+ * @returns {string}
+ */
+export function compare_molecules_json(smiles1, smiles2) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passStringToWasm0(smiles1, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(smiles2, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.compare_molecules_json(ptr0, len0, ptr1, len1);
+        var ptr3 = ret[0];
+        var len3 = ret[1];
+        if (ret[3]) {
+            ptr3 = 0; len3 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
+}
+
+/**
+ * Compute direct Coulomb energy for a molecule with Gasteiger partial charges.
+ *
+ * Returns JSON object: `{ "coulomb_energy": E, "unit": "kcal/mol" }`
+ *
+ * # Arguments
+ * * `mol` - Molecule to evaluate
+ *
+ * # Example (JavaScript)
+ * ```js
+ * const mol = parse_smiles("CCO");
+ * const result = coulomb_energy_json(mol);
+ * // { "coulomb_energy": -12.34, "unit": "kcal/mol" }
+ * ```
+ * @param {MolHandle} mol
+ * @returns {string}
+ */
+export function coulomb_energy_json(mol) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        _assertClass(mol, MolHandle);
+        const ret = wasm.coulomb_energy_json(mol.__wbg_ptr);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
 /**
  * Return the CPK color (CSS hex string) for the given element symbol.
  *
@@ -1168,6 +1328,24 @@ export function ecfp4_bitvec(mol) {
     return v1;
 }
 
+/**
+ * Like `ecfp4_bitvec` but with explicit chirality control.
+ *
+ * When `use_chirality=true`, tetrahedral stereochemistry is included in the
+ * initial atom hash, making enantiomers have different fingerprints.
+ * When `false` (default), chirality is ignored.
+ * @param {MolHandle} mol
+ * @param {boolean} use_chirality
+ * @returns {Uint8Array}
+ */
+export function ecfp4_bitvec_with_chirality(mol, use_chirality) {
+    _assertClass(mol, MolHandle);
+    const ret = wasm.ecfp4_bitvec_with_chirality(mol.__wbg_ptr, use_chirality);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+}
+
 /**
  * ECFP6 (radius-3) fingerprint as a bit-packed byte vector (256 bytes = 2048 bits).
  * @param {MolHandle} mol
@@ -1181,6 +1359,24 @@ export function ecfp6_bitvec(mol) {
     return v1;
 }
 
+/**
+ * Like `ecfp6_bitvec` but with explicit chirality control.
+ *
+ * When `use_chirality=true`, tetrahedral stereochemistry is included in the
+ * initial atom hash, making enantiomers have different fingerprints.
+ * When `false` (default), chirality is ignored.
+ * @param {MolHandle} mol
+ * @param {boolean} use_chirality
+ * @returns {Uint8Array}
+ */
+export function ecfp6_bitvec_with_chirality(mol, use_chirality) {
+    _assertClass(mol, MolHandle);
+    const ret = wasm.ecfp6_bitvec_with_chirality(mol.__wbg_ptr, use_chirality);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+}
+
 /**
  * Compute a fingerprint bit-vector with configurable ECFP radius and bit width.
  *
@@ -1190,14 +1386,19 @@ export function ecfp6_bitvec(mol) {
  *
  * The hash modulo is applied at fingerprint-generation time (`id % nbits`),
  * so no post-processing fold is needed.
+ * Compute a custom ECFP (Extended Connectivity FingerPrint) with specified radius and bit count.
+ *
+ * When `use_chirality=true`, tetrahedral stereochemistry is included in the initial
+ * atom hash. When `false` (default), chirality is ignored.
  * @param {MolHandle} mol
  * @param {number} radius
  * @param {number} nbits
+ * @param {boolean} use_chirality
  * @returns {Uint8Array}
  */
-export function ecfp_bitvec_custom(mol, radius, nbits) {
+export function ecfp_bitvec_custom(mol, radius, nbits, use_chirality) {
     _assertClass(mol, MolHandle);
-    const ret = wasm.ecfp_bitvec_custom(mol.__wbg_ptr, radius, nbits);
+    const ret = wasm.ecfp_bitvec_custom(mol.__wbg_ptr, radius, nbits, use_chirality);
     var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
     wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
     return v1;
@@ -1304,6 +1505,30 @@ export function fcfp6_bitvec(mol) {
     return v1;
 }
 
+/**
+ * Analyze a reaction SMILES and return the reaction center as JSON.
+ *
+ * JSON schema: `{ broken: [[a1,a2],...], formed: [[a1,a2],...], changed: [a,...] }`
+ * where atom indices are 0-based within the first reactant molecule.
+ * Returns an error string prefixed with `"error:"` on failure.
+ * @param {string} reaction_smiles
+ * @returns {string}
+ */
+export function find_reaction_center_json(reaction_smiles) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(reaction_smiles, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.find_reaction_center_json(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
 /**
  * Gasteiger-Marsili PEOE partial charges as a JSON array of f64.
  * @param {MolHandle} mol
@@ -1323,6 +1548,39 @@ export function gasteiger_charges_json(mol) {
     }
 }
 
+/**
+ * Generate 3D coordinates from SMILES (raw distance geometry, no minimization).
+ * Returns PDB format string with atoms positioned in 3D space.
+ *
+ * # Example (JS)
+ * ```javascript
+ * const pdbStr = module.generate_3d_from_smiles("c1ccccc1");
+ * console.log(pdbStr);  // PDB file content
+ * ```
+ * @param {string} smiles
+ * @returns {string}
+ */
+export function generate_3d_from_smiles(smiles) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(smiles, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.generate_3d_from_smiles(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
 /**
  * Generate energy-minimized 3D coordinates and return a PDB string.
  *
@@ -1346,6 +1604,40 @@ export function generate_3d_minimized_pdb(mol) {
     }
 }
 
+/**
+ * Generate 3D coordinates and minimize from SMILES string.
+ * Pipeline: distance geometry → DREIDING minimization.
+ * Better geometry quality than raw DG; suitable for graphics.
+ *
+ * # Example (JS)
+ * ```javascript
+ * const pdbStr = module.generate_3d_optimized_pdb("c1ccccc1");
+ * console.log(pdbStr);  // PDB file with optimized geometry
+ * ```
+ * @param {string} smiles
+ * @returns {string}
+ */
+export function generate_3d_optimized_pdb(smiles) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(smiles, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.generate_3d_optimized_pdb(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
 /**
  * Generate 3D coordinates for the molecule and return a PDB string.
  *
@@ -1462,6 +1754,31 @@ export function get_bond_info(mol, idx) {
     }
 }
 
+/**
+ * Get bond length in Ångströms between two atoms from a SMILES string.
+ * Returns -1.0 if parsing fails or atom indices are out of range.
+ *
+ * # Arguments
+ * - `smiles`: SMILES string
+ * - `a`: first atom index
+ * - `b`: second atom index
+ *
+ * # Example
+ * ```javascript
+ * const len = get_bond_length_json("CC", 0, 1);  // C-C single bond ≈ 1.54 Å
+ * ```
+ * @param {string} smiles
+ * @param {number} a
+ * @param {number} b
+ * @returns {number}
+ */
+export function get_bond_length_json(smiles, a, b) {
+    const ptr0 = passStringToWasm0(smiles, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.get_bond_length_json(ptr0, len0, a, b);
+    return ret;
+}
+
 /**
  * All scalar molecular descriptors as a single JSON object.
  *
@@ -1484,6 +1801,32 @@ export function get_descriptors_json(mol) {
     }
 }
 
+/**
+ * Get dihedral angle A—B—C—D in degrees from a SMILES string.
+ * Returns null (JSON null) if any atom index is out of range or atoms are collinear.
+ *
+ * # Arguments
+ * - `smiles`: SMILES string
+ * - `a`, `b`, `c`, `d`: atom indices
+ *
+ * # Example
+ * ```javascript
+ * const dihedral = get_dihedral_json("CCCC", 0, 1, 2, 3);  // A-B-C-D
+ * ```
+ * @param {string} smiles
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @param {number} d
+ * @returns {any}
+ */
+export function get_dihedral_json(smiles, a, b, c, d) {
+    const ptr0 = passStringToWasm0(smiles, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.get_dihedral_json(ptr0, len0, a, b, c, d);
+    return ret;
+}
+
 /**
  * Identify functional groups. Returns a JSON array of objects:
  * `[{"atoms":[0,2,3],"type":"C,N,O"}, …]`
@@ -1504,6 +1847,68 @@ export function identify_functional_groups(mol) {
     }
 }
 
+/**
+ * Generate InChI string from SMILES.
+ *
+ * Returns `"error:<msg>"` on parse failure.
+ * @param {string} smiles
+ * @returns {string}
+ */
+export function inchi_from_smiles(smiles) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(smiles, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.inchi_from_smiles(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * Generate InChIKey from SMILES (27-character identifier).
+ *
+ * Returns `"error:<msg>"` on parse failure.
+ * @param {string} smiles
+ * @returns {string}
+ */
+export function inchikey_from_smiles(smiles) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(smiles, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.inchikey_from_smiles(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * Invert the stereochemistry of a tetrahedral stereocenter (U/D wedge bonds).
+ *
+ * If the atom has no wedge/dash bonds, returns an unchanged copy.
+ * Returns error if atom_idx is invalid.
+ * @param {MolHandle} mol
+ * @param {number} atom_idx
+ * @returns {MolHandle}
+ */
+export function invert_stereocenter_at(mol, atom_idx) {
+    _assertClass(mol, MolHandle);
+    const ret = wasm.invert_stereocenter_at(mol.__wbg_ptr, atom_idx);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return MolHandle.__wrap(ret[0]);
+}
+
 /**
  * Returns `true` if the SMILES string can be parsed without error.
  * @param {string} s
@@ -1680,6 +2085,34 @@ export function mcs_smiles_json(smiles_json) {
     }
 }
 
+/**
+ * Optimize molecular geometry using DREIDING force field.
+ *
+ * Performs geometry minimization with DREIDING force field parameters.
+ * Returns minimized coordinate PDB.
+ *
+ * # Arguments
+ * * `mol` - Molecule to optimize
+ *
+ * # Returns
+ * PDB format string with optimized coordinates
+ * @param {MolHandle} mol
+ * @returns {string}
+ */
+export function minimize_dreiding_json(mol) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        _assertClass(mol, MolHandle);
+        const ret = wasm.minimize_dreiding_json(mol.__wbg_ptr);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
 /**
  * Find matched molecular pairs in a set of molecules as JSON.
  *
@@ -1726,6 +2159,28 @@ export function mmp_pairs_json(smiles_json) {
     }
 }
 
+/**
+ * Parse a Tripos MOL2 string and return SMILES.
+ *
+ * Returns `"error:<msg>"` on failure.
+ * @param {string} mol2_str
+ * @returns {string}
+ */
+export function mol2_to_smiles(mol2_str) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(mol2_str, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.mol2_to_smiles(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
 /**
  * Parse a MOL V2000 string and return 2D coordinates as a JSON array.
  *
@@ -2010,6 +2465,40 @@ export function mol_with_bond_removed(mol, idx) {
     return MolHandle.__wrap(ret[0]);
 }
 
+/**
+ * Generate a complete molecular report (JSON string) from a SMILES.
+ * Returns the JSON representation of a `MoleculeReport` struct.
+ *
+ * # Example (JS)
+ * ```javascript
+ * const json = module.molecule_report_json("CC(=O)Oc1ccccc1C(=O)O");
+ * const report = JSON.parse(json);
+ * console.log(report.canonical_smiles, report.descriptors.tpsa);
+ * ```
+ * @param {string} smiles
+ * @returns {string}
+ */
+export function molecule_report_json(smiles) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(smiles, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.molecule_report_json(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
 /**
  * Per-atom molar refractivity contributions as a JSON array of f64.
  * @param {MolHandle} mol
@@ -2042,6 +2531,34 @@ export function murcko_scaffold(mol) {
     return MolHandle.__wrap(ret);
 }
 
+/**
+ * Find the k nearest neighbours of a query SMILES in a list of db SMILES.
+ *
+ * `db_smiles_json`: JSON array of SMILES strings, e.g. `["CC","c1ccccc1"]`.
+ * Returns JSON: `[{"index":0,"tanimoto":0.95},...]` sorted by descending Tanimoto.
+ * Returns `"error:<msg>"` on parse failure.
+ * @param {string} query_smiles
+ * @param {string} db_smiles_json
+ * @param {number} k
+ * @returns {string}
+ */
+export function nearest_neighbors_json(query_smiles, db_smiles_json, k) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(query_smiles, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(db_smiles_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.nearest_neighbors_json(ptr0, len0, ptr1, len1, k);
+        deferred3_0 = ret[0];
+        deferred3_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
 /**
  * Neutralize formal charges on `mol` by proton addition/removal.
  *
@@ -2055,6 +2572,33 @@ export function neutralize_charges(mol) {
     return MolHandle.__wrap(ret);
 }
 
+/**
+ * Parse and re-serialize CXSMILES, preserving supported CX metadata.
+ * Returns error if atom count exceeds 10,000.
+ * @param {string} s
+ * @returns {string}
+ */
+export function normalize_cxsmiles(s) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.normalize_cxsmiles(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
 /**
  * Parse and re-serialise a reaction SMILES string, returning the normalised form.
  *
@@ -2106,10 +2650,68 @@ export function pains_matches_json(mol) {
     }
 }
 
+/**
+ * Parse CXSMARTS and return preserved metadata as JSON.
+ * Returns error if atom count exceeds 10,000.
+ * @param {string} s
+ * @returns {string}
+ */
+export function parse_cxsmarts_json(s) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.parse_cxsmarts_json(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * Parse CXSMILES and return preserved metadata as JSON.
+ *
+ * Supported CX fields: atom labels (`$...$`), `atomProp`, atom radicals (`^n:`),
+ * and zero-order bonds (`Z:`). The `cxsmiles` field is a re-serialized
+ * round-trip form using the supported fields.
+ * Returns error if atom count exceeds 10,000.
+ * @param {string} s
+ * @returns {string}
+ */
+export function parse_cxsmiles_json(s) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.parse_cxsmiles_json(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
 /**
  * Parse a SMILES string into a `MolHandle`.
  *
- * Returns a JS error string on parse failure.
+ * Returns a JS error string on parse failure or if atom count exceeds 10,000.
  * @param {string} s
  * @returns {MolHandle}
  */
@@ -2142,6 +2744,47 @@ export function peoe_vsa_json(mol) {
     }
 }
 
+/**
+ * Generate `count` random SMILES from a SMILES string using the given seed.
+ * Atoms are permuted based on xorshift64 RNG. Each variant should parse back
+ * to the same molecule. Returns a JSON array of SMILES strings.
+ *
+ * # Arguments
+ * - `smiles`: input SMILES string
+ * - `count`: number of variants to generate (capped at 100)
+ * - `seed`: xorshift64 seed
+ *
+ * # Example
+ * ```javascript
+ * const variants = random_smiles_json("CC(C)O", 5, 42);
+ * // variants: ["CC(C)O", "C(C)(O)C", ...]
+ * ```
+ * @param {string} smiles
+ * @param {number} count
+ * @param {bigint} seed
+ * @returns {string}
+ */
+export function random_smiles_json(smiles, count, seed) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(smiles, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.random_smiles_json(ptr0, len0, count, seed);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
 /**
  * Return a copy of the molecule with all explicit hydrogen atoms removed.
  * @param {MolHandle} mol
@@ -2200,6 +2843,31 @@ export function rgroup_decompose_json(smiles_json, core_smarts) {
     }
 }
 
+/**
+ * Run molecular dynamics simulation and return trajectory as JSON.
+ *
+ * Returns JSON object with trajectory frames: `{ "frames": [{ "step": N, "potential": E, "kinetic": K, "temp": T }, …] }`
+ * Uses NVT ensemble (Berendsen thermostat) at 300 K by default.
+ * Note: Limited to molecules with ~50 atoms or fewer for practical WASM performance.
+ * @param {MolHandle} mol
+ * @param {number} steps
+ * @param {number} temp_k
+ * @returns {string}
+ */
+export function run_md_json(mol, steps, temp_k) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        _assertClass(mol, MolHandle);
+        const ret = wasm.run_md_json(mol.__wbg_ptr, steps, temp_k);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
 /**
  * Apply a SMIRKS reaction template and return product SMILES as a JSON string.
  *
@@ -2244,6 +2912,41 @@ export function sa_score(mol) {
     return ret;
 }
 
+/**
+ * Screen a batch of SMILES strings (JSON string output).
+ * Returns per-record results including pass/fail with error details.
+ * Includes MaxMin diversity picking and Butina clustering by default.
+ *
+ * # Example (JS)
+ * ```javascript
+ * const smilesList = "c1ccccc1\nCC\nCCC";
+ * const json = module.screen_smiles_json(smilesList, "\n");
+ * const report = JSON.parse(json);
+ * console.log(report.records); // Array of ScreeningRecord
+ * console.log(report.maxmin_picks); // Diversity-selected indices
+ * console.log(report.butina_clusters); // Clustering result
+ * ```
+ * @param {string} smiles_batch
+ * @param {string} delimiter
+ * @returns {string}
+ */
+export function screen_smiles_json(smiles_batch, delimiter) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(smiles_batch, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(delimiter, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.screen_smiles_json(ptr0, len0, ptr1, len1);
+        deferred3_0 = ret[0];
+        deferred3_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
 /**
  * Serialize multiple molecules with properties to an SDF string.
  *
@@ -2339,6 +3042,49 @@ export function sdf_to_smiles_json(sdf) {
     }
 }
 
+/**
+ * Set dihedral angle A—B—C—D and return PDB block with modified coordinates.
+ * Rotates the D-side subtree around the B—C bond.
+ * Returns a JS error if parsing fails or atom indices are invalid.
+ *
+ * # Arguments
+ * - `smiles`: SMILES string
+ * - `a`, `b`, `c`, `d`: atom indices
+ * - `angle_deg`: target dihedral angle in degrees
+ *
+ * # Example
+ * ```javascript
+ * const pdbBlock = set_dihedral_json("CCCC", 0, 1, 2, 3, 120.0);
+ * ```
+ * @param {string} smiles
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @param {number} d
+ * @param {number} angle_deg
+ * @returns {string}
+ */
+export function set_dihedral_json(smiles, a, b, c, d, angle_deg) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(smiles, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.set_dihedral_json(ptr0, len0, a, b, c, d, angle_deg);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
 /**
  * 3D shape descriptors as a JSON object.
  *
@@ -2413,6 +3159,39 @@ export function smarts_match_atoms(smarts, mol) {
     }
 }
 
+/**
+ * Like `smarts_match_atoms` but with explicit chirality matching control.
+ *
+ * When `use_chirality=true`, SMARTS chirality primitives `[@]` and `[@@]` are
+ * matched against the target molecule's stereochemistry. When `false`, chirality
+ * is ignored (RDKit default).
+ * @param {string} smarts
+ * @param {MolHandle} mol
+ * @param {boolean} use_chirality
+ * @returns {string}
+ */
+export function smarts_match_atoms_with_chirality(smarts, mol, use_chirality) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(smarts, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        _assertClass(mol, MolHandle);
+        const ret = wasm.smarts_match_atoms_with_chirality(ptr0, len0, mol.__wbg_ptr, use_chirality);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
 /**
  * Serialise a JSON array of SMILES to an SDF string.
  *
@@ -2442,6 +3221,28 @@ export function smiles_array_to_sdf(smiles_json) {
     }
 }
 
+/**
+ * Convert a SMILES to a minimal Tripos MOL2 string (no 3D coordinates).
+ *
+ * Returns `"error:<msg>"` on parse failure.
+ * @param {string} smiles
+ * @returns {string}
+ */
+export function smiles_to_mol2(smiles) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(smiles, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.smiles_to_mol2(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
 /**
  * Render a highlighted SVG from a SMILES string in one call.
  *
@@ -2524,6 +3325,56 @@ export function sssr_rings_json(mol) {
     }
 }
 
+/**
+ * Standardize a SMILES string and return the canonical SMILES of the result.
+ *
+ * Applies: largest fragment extraction → charge neutralization.
+ * Returns `"error:<msg>"` on parse failure.
+ * @param {string} smiles
+ * @returns {string}
+ */
+export function standardize_smiles(smiles) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(smiles, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.standardize_smiles(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * Standardize a SMILES string and return result SMILES plus an audit report as JSON.
+ *
+ * Boolean flags map directly to `StandardizeOptions`.
+ * Returns `"error:<msg>"` on parse or serialization failure.
+ * @param {string} smiles
+ * @param {boolean} largest_fragment_only
+ * @param {boolean} neutralize_charges
+ * @param {boolean} remove_explicit_h
+ * @param {boolean} canonical_tautomer
+ * @returns {string}
+ */
+export function standardize_smiles_report_json(smiles, largest_fragment_only, neutralize_charges, remove_explicit_h, canonical_tautomer) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(smiles, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.standardize_smiles_report_json(ptr0, len0, largest_fragment_only, neutralize_charges, remove_explicit_h, canonical_tautomer);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
 export function start() {
     wasm.start();
 }
@@ -2773,6 +3624,14 @@ export function write_smiles(mol) {
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
+        __wbg___wbindgen_string_get_72bdf95d3ae505b1: function(arg0, arg1) {
+            const obj = arg1;
+            const ret = typeof(obj) === 'string' ? obj : undefined;
+            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
         __wbg___wbindgen_throw_1506f2235d1bdba0: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
@@ -2787,6 +3646,9 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
+        __wbg_getRandomValues_3f44b700395062e5: function() { return handleError(function (arg0, arg1) {
+            globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
+        }, arguments); },
         __wbg_new_227d7c05414eb861: function() {
             const ret = new Error();
             return ret;
@@ -2798,7 +3660,12 @@ function __wbg_get_imports() {
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        __wbindgen_cast_0000000000000001: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000001: function(arg0) {
+            // Cast intrinsic for `F64 -> Externref`.
+            const ret = arg0;
+            return ret;
+        },
+        __wbindgen_cast_0000000000000002: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return ret;
@@ -2829,6 +3696,12 @@ const MolHandleFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_molhandle_free(ptr, 1));
 
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
 function _assertClass(instance, klass) {
     if (!(instance instanceof klass)) {
         throw new Error(`expected instance of ${klass.name}`);
@@ -2868,6 +3741,19 @@ function getUint8ArrayMemory0() {
     return cachedUint8ArrayMemory0;
 }
 
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
 function passArray32ToWasm0(arg, malloc) {
     const ptr = malloc(arg.length * 4, 4) >>> 0;
     getUint32ArrayMemory0().set(arg, ptr / 4);