@kent-tokyo/chematic 0.2.11 → 0.4.28

package/chematic_wasm.js

@@ -264,17 +264,6 @@ export class DepictOptions {
 }
 if (Symbol.dispose) DepictOptions.prototype[Symbol.dispose] = DepictOptions.prototype.free;
 
-/**
- * MinHash LSH index: insert MHFP fingerprints and query by approximate similarity.
- *
- * ```js
- * const idx = new MhfpLshHandle(128);
- * const i0 = idx.add_smiles("c1ccccc1");    // benzene → index 0
- * const i1 = idx.add_smiles("Cc1ccccc1");   // toluene → index 1
- * const hits = JSON.parse(idx.query_json("c1ccccc1", 0.5));
- * // hits: [{index:0,similarity:1.0}, {index:1,similarity:0.xxx}]
- * ```
- */
 export class MhfpLshHandle {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -415,6 +404,23 @@ export class MolHandle {
         const ret = wasm.molhandle_atom_count(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * Returns true when TPSA < 90 Ų, MW < 400, HBD ≤ 3.
+     * @returns {boolean}
+     */
+    bbb_passes() {
+        const ret = wasm.molhandle_bbb_passes(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Clark (2000) blood-brain barrier logBB score.
+     * logBB > −1.0 = likely CNS penetrant.
+     * @returns {number}
+     */
+    bbb_score() {
+        const ret = wasm.molhandle_bbb_score(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * Bertz complexity index (BertzCT).
      * @returns {number}
@@ -431,6 +437,15 @@ export class MolHandle {
         const ret = wasm.molhandle_bond_count(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * Palm (1997) Caco-2 intestinal permeability (logPCaco2).
+     * > −5.5 = high permeability.
+     * @returns {number}
+     */
+    caco2_permeability() {
+        const ret = wasm.molhandle_caco2_permeability(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * Canonical SMILES string.
      * @returns {string}
@@ -528,8 +543,16 @@ export class MolHandle {
         return ret;
     }
     /**
-     * 2D PNG depiction (rasterized from SVG).
-     * Returns PNG data as base64-encoded string for embedding in HTML/JS.
+     * CYP3A4 metabolic inhibition risk score (0.0–1.0).
+     * @returns {number}
+     */
+    cyp3a4_inhibition_risk() {
+        const ret = wasm.molhandle_cyp3a4_inhibition_risk(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * 2D PNG depiction — not available in the WASM build (PNG stack disabled to reduce bundle size).
+     * Use `depict_svg()` in browser contexts; rasterize client-side if needed.
      * @returns {Uint8Array}
      */
     depict_png() {
@@ -654,6 +677,14 @@ export class MolHandle {
         const ret = wasm.molhandle_heavy_atom_count(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * hERG cardiac toxicity risk score (0.0–1.0).
+     * @returns {number}
+     */
+    herg_risk_score() {
+        const ret = wasm.molhandle_herg_risk_score(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * Isotope distribution as JSON.
      *
@@ -914,6 +945,22 @@ export class MolHandle {
         const ret = wasm.molhandle_pains_passes(this.__wbg_ptr);
         return ret !== 0;
     }
+    /**
+     * Most acidic pKa in the molecule, or NaN if no acidic site.
+     * @returns {number}
+     */
+    pka_acid_value() {
+        const ret = wasm.molhandle_pka_acid_value(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Most basic pKa in the molecule, or NaN if no basic site.
+     * @returns {number}
+     */
+    pka_base_value() {
+        const ret = wasm.molhandle_pka_base_value(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * Quantitative Estimate of Drug-likeness (QED); range [0, 1].
      * @returns {number}
@@ -1043,6 +1090,33 @@ export function add_hydrogens(mol) {
     return MolHandle.__wrap(ret);
 }
 
+/**
+ * Compute a full ADMET property profile for a molecule.
+ *
+ * Returns a JSON object with fields:
+ * `bbb_score`, `bbb_passes`, `caco2`, `herg_risk`, `cyp3a4_risk`,
+ * `pka_acid` (null if absent), `pka_base` (null if absent),
+ * `esol`, `logd74`, `mw`, `logp`, `tpsa`, `hbd`, `hba`, `rotatable_bonds`
+ *
+ * Returns `{"error":"..."}` on parse failure.
+ * @param {string} smiles
+ * @returns {string}
+ */
+export function admet_profile_json(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.admet_profile_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);
+    }
+}
+
 /**
  * AtomPair fingerprint as a bit-packed byte vector (256 bytes = 2048 bits).
  * @param {MolHandle} mol
@@ -1118,6 +1192,67 @@ export function balance_check_json(reaction_smiles) {
     }
 }
 
+/**
+ * MinHash LSH index: insert MHFP fingerprints and query by approximate similarity.
+ *
+ * ```js
+ * const idx = new MhfpLshHandle(128);
+ * const i0 = idx.add_smiles("c1ccccc1");    // benzene → index 0
+ * const i1 = idx.add_smiles("Cc1ccccc1");   // toluene → index 1
+ * const hits = JSON.parse(idx.query_json("c1ccccc1", 0.5));
+ * // hits: [{index:0,similarity:1.0}, {index:1,similarity:0.xxx}]
+ * ```
+ * Generate a self-contained HTML report for a newline-separated list of SMILES.
+ *
+ * Empty lines and invalid SMILES are silently skipped.
+ * Returns the same card-grid HTML as Python's `chematic.report()`.
+ *
+ * ```js
+ * const html = mod.batch_report_html("CCO\nc1ccccc1\nCC(=O)O");
+ * const blob = new Blob([html], {type:'text/html'});
+ * const url  = URL.createObjectURL(blob);
+ * ```
+ * @param {string} smiles_lines
+ * @returns {string}
+ */
+export function batch_report_html(smiles_lines) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(smiles_lines, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.batch_report_html(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);
+    }
+}
+
+/**
+ * Predict GI absorption and BBB penetration using the BOILED-Egg method
+ * (Daina & Zoete 2016).
+ *
+ * Returns JSON: `{"gi_absorbed":bool,"bbb_penetrant":bool,"logp":f64,"tpsa":f64}`
+ * @param {string} smiles
+ * @returns {string}
+ */
+export function boiled_egg_json(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.boiled_egg_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.
  *
@@ -1360,28 +1495,19 @@ export function compare_molecules_json(smiles1, smiles2) {
 }
 
 /**
- * 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" }
- * ```
+ * Generate multiple conformers with RMSD-based pruning.
+ * Returns JSON: `{"conformers": [[[x,y,z],...], ...], "count": int}`.
  * @param {MolHandle} mol
+ * @param {number} n
+ * @param {number} rmsd_threshold
  * @returns {string}
  */
-export function coulomb_energy_json(mol) {
+export function conformer_ensemble_json(mol, n, rmsd_threshold) {
     let deferred1_0;
     let deferred1_1;
     try {
         _assertClass(mol, MolHandle);
-        const ret = wasm.coulomb_energy_json(mol.__wbg_ptr);
+        const ret = wasm.conformer_ensemble_json(mol.__wbg_ptr, n, rmsd_threshold);
         deferred1_0 = ret[0];
         deferred1_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -1584,36 +1710,6 @@ export function detect_functional_groups(mol) {
     }
 }
 
-/**
- * Infer bond connectivity and bond orders from an XYZ-format string.
- *
- * Explicit hydrogen atoms must be present in the XYZ for reliable bond-order
- * assignment (without H, carbonyl C=O cannot be distinguished from C-O).
- *
- * Returns JSON on success: `{"smiles":"CCO","atom_count":3,"bond_count":2}`.
- * `atom_count` and `bond_count` refer to the heavy-atom skeleton (H removed).
- *
- * Returns JSON on error: `{"error":"molecule has 450 atoms; maximum is 300"}`.
- *
- * Safe: never freezes. All internal loops are O(n²). Capped at 300 atoms.
- * @param {string} xyz_str
- * @returns {string}
- */
-export function determine_bonds_from_xyz_json(xyz_str) {
-    let deferred2_0;
-    let deferred2_1;
-    try {
-        const ptr0 = passStringToWasm0(xyz_str, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.determine_bonds_from_xyz_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);
-    }
-}
-
 /**
  * Dice similarity between `a` and `b` using ECFP4 fingerprints.
  * @param {MolHandle} a
@@ -1947,6 +2043,47 @@ export function gasteiger_charges_json(mol) {
     }
 }
 
+/**
+ * Generate 3D coordinates as raw JSON array [[x,y,z], ...].
+ *
+ * Unlike `generate_3d_pdb`, this returns coordinates that can be passed
+ * to descriptor functions like `whim_descriptors_json` or `shape_descriptors_json`.
+ * @param {MolHandle} mol
+ * @returns {string}
+ */
+export function generate_3d_coords_json(mol) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        _assertClass(mol, MolHandle);
+        const ret = wasm.generate_3d_coords_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);
+    }
+}
+
+/**
+ * Generate 3D coordinates using ETKDG as raw JSON array [[x,y,z], ...].
+ * @param {MolHandle} mol
+ * @returns {string}
+ */
+export function generate_3d_etkdg_coords_json(mol) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        _assertClass(mol, MolHandle);
+        const ret = wasm.generate_3d_etkdg_coords_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);
+    }
+}
+
 /**
  * Generate 3D coordinates using ETKDG and minimize with DREIDING force field.
  * @param {MolHandle} mol
@@ -2267,10 +2404,15 @@ export function get_dihedral_json(smiles, a, b, c, d) {
 }
 
 /**
- * Compute GETAWAY descriptors (GEometric, Topologic And wAveleT descriptors) from 3D coordinates.
- * Returns JSON array of 9 values: [G1, G2, G3, D1, D2, D3, T, V, A]
- * where G* = geometric autocorrelations (lag-1,2,3), D* = topologic distances,
- * T = total pairwise distance, V = bounding-box volume, A = anisotropy ratio.
+ * Compute GETAWAY descriptors (GEometry, Topology and Atom-Weights AssemblY) from 3D coords.
+ *
+ * Returns a JSON array of **19** values:
+ * - `[0..7]`  H[1..8]  — leverage autocorrelation at topological lags 1–8
+ * - `[8..15]` R[1..8]  — H[k] normalised by pair count W_k
+ * - `[16]` Hmax, `[17]` Hmean, `[18]` Htot — per-atom leverage statistics
+ *
+ * Note: requires 3D coordinates (non-planar); for flat/2D structures the hat matrix
+ * is degenerate and descriptors reflect squared centroid distances, not true leverage.
  * @param {MolHandle} mol
  * @returns {string}
  */
@@ -2288,6 +2430,38 @@ export function getaway_descriptors_json(mol) {
     }
 }
 
+/**
+ * Parse a ChemDraw XML (CDXML) string into a `MolHandle`.
+ *
+ * Compute an HDF fingerprint and return it as a JSON array of float32 values.
+ *
+ * Returns a unit-norm vector of length `dim` as a JSON number array.
+ * Use cosine dot product for similarity: `a · b = sum(a[i]*b[i])`.
+ *
+ * ```js
+ * const fp = JSON.parse(hdf_json(mol));        // float[] of length 1024
+ * const sim = fp.reduce((s, v, i) => s + v * fp2[i], 0);  // cosine similarity
+ * ```
+ * @param {MolHandle} mol
+ * @param {number} dim
+ * @param {number} radius
+ * @param {bigint} seed
+ * @returns {string}
+ */
+export function hdf_json(mol, dim, radius, seed) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        _assertClass(mol, MolHandle);
+        const ret = wasm.hdf_json(mol.__wbg_ptr, dim, radius, seed);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
 /**
  * Identify functional groups. Returns a JSON array of objects:
  * `[{"atoms":[0,2,3],"type":"C,N,O"}, …]`
@@ -2546,6 +2720,39 @@ export function mcs_smiles_json(smiles_json) {
     }
 }
 
+/**
+ * MCS with ring-awareness constraints.
+ *
+ * `smiles_json` — JSON array of at least 2 SMILES strings.
+ * `ring_matches_ring_only` — ring atoms may only match ring atoms.
+ * `complete_rings_only` — partial ring inclusion is removed from the result.
+ * Returns the MCS SMILES, or `"null"` when no common substructure was found.
+ * @param {string} smiles_json
+ * @param {boolean} ring_matches_ring_only
+ * @param {boolean} complete_rings_only
+ * @returns {string}
+ */
+export function mcs_smiles_json_with_ring_config(smiles_json, ring_matches_ring_only, complete_rings_only) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(smiles_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.mcs_smiles_json_with_ring_config(ptr0, len0, ring_matches_ring_only, complete_rings_only);
+        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);
+    }
+}
+
 /**
  * MinHash fingerprint (128 hashes) as JSON.
  *
@@ -2639,6 +2846,36 @@ export function minimize_mmff94_lbfgs_json(mol, max_iter) {
     }
 }
 
+/**
+ * Minimise a molecule's geometry using the Universal Force Field (UFF).
+ *
+ * `coords_json` — JSON array of `[x,y,z]` arrays (Å), one per atom.
+ * `max_iter` — maximum iterations (0 = default 500).
+ *
+ * Returns JSON: `{"coords":[[x,y,z],...], "energy":float, "iterations":int, "converged":bool}`
+ * or `{"error":"<msg>"}` on failure.
+ * @param {string} smiles
+ * @param {string} coords_json
+ * @param {number} max_iter
+ * @returns {string}
+ */
+export function minimize_uff_json(smiles, coords_json, max_iter) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(smiles, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(coords_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.minimize_uff_json(ptr0, len0, ptr1, len1, max_iter);
+        deferred3_0 = ret[0];
+        deferred3_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
 /**
  * MMFF94 partial charges (BCI table, ±0.1e accuracy) as a JSON array of f64.
  *
@@ -2850,8 +3087,6 @@ export function mol_block_from_smiles(smiles) {
 }
 
 /**
- * Parse a ChemDraw XML (CDXML) string into a `MolHandle`.
- *
  * Only the first molecular fragment in the document is returned.
  * Returns a JS error if the document cannot be parsed.
  * @param {string} cdxml
@@ -2884,6 +3119,24 @@ export function mol_from_cml(cml) {
     return MolHandle.__wrap(ret[0]);
 }
 
+/**
+ * Parse a MolJSON string into a `MolHandle`.
+ *
+ * MolJSON is a JSON-based molecular representation designed for LLM
+ * (large language model) compatibility.  Returns a JS error on invalid input.
+ * @param {string} json
+ * @returns {MolHandle}
+ */
+export function mol_from_moljson(json) {
+    const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mol_from_moljson(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return MolHandle.__wrap(ret[0]);
+}
+
 /**
  * Parse a PDB file and return a `MolHandle` (topology only; coordinates are discarded).
  *
@@ -3434,6 +3687,30 @@ export function pharmacophore_fp_3d_summary(mol) {
     }
 }
 
+/**
+ * Predict pKa for all ionizable sites in a molecule.
+ *
+ * Returns a JSON array: `[{"atom_idx":8,"pka":4.0,"type":"acid","group":"carboxylic_acid"},...]`
+ *
+ * Returns `[]` if no ionizable sites are found, or `{"error":"..."}` on parse failure.
+ * @param {string} smiles
+ * @returns {string}
+ */
+export function predict_pka_json(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.predict_pka_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);
+    }
+}
+
 /**
  * Generate `count` random SMILES from a SMILES string using the given seed.
  * Atoms are permuted based on xorshift64 RNG. Each variant should parse back
@@ -3559,31 +3836,6 @@ export function ring_families_json(mol) {
     }
 }
 
-/**
- * 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.
  *
@@ -3959,6 +4211,41 @@ export function smiles_to_mol2(smiles) {
     }
 }
 
+/**
+ * Write a molecule to AutoDock PDBQT format.
+ *
+ * `coords_json` — JSON array of `[x,y,z]` arrays (Å). Pass `"[]"` for zero coords.
+ * `charges_json` — JSON array of partial charges. Pass `"[]"` to write zeros.
+ * `name` — ligand name for the REMARK header.
+ *
+ * Returns the PDBQT string, or `"error:<msg>"` on failure.
+ * @param {string} smiles
+ * @param {string} coords_json
+ * @param {string} charges_json
+ * @param {string} name
+ * @returns {string}
+ */
+export function smiles_to_pdbqt(smiles, coords_json, charges_json, name) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        const ptr0 = passStringToWasm0(smiles, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(coords_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(charges_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ret = wasm.smiles_to_pdbqt(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+        deferred5_0 = ret[0];
+        deferred5_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+    }
+}
+
 /**
  * Render a highlighted SVG from a SMILES string in one call.
  *
@@ -4328,6 +4615,28 @@ export function to_mol_v3000_block(mol) {
     }
 }
 
+/**
+ * Serialise a `MolHandle` to a MolJSON string (pretty-printed).
+ *
+ * Atom IDs are assigned as `"a1"`, `"a2"`, … in molecule atom order.
+ * The `hydrogens` field reflects computed implicit H count.
+ * @param {MolHandle} mol
+ * @returns {string}
+ */
+export function to_moljson(mol) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        _assertClass(mol, MolHandle);
+        const ret = wasm.to_moljson(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);
+    }
+}
+
 /**
  * Serialize a molecule to XYZ format.
  *
@@ -4362,31 +4671,6 @@ export function torsion_bitvec(mol) {
     return v1;
 }
 
-/**
- * Scan a torsion dihedral i-j-k-l from 0° to 360° in `steps` increments.
- * Returns JSON array: [{"angle":0.0,"energy":E},...] or {"error":"..."}.
- * @param {MolHandle} mol
- * @param {number} i
- * @param {number} j
- * @param {number} k
- * @param {number} l
- * @param {number} steps
- * @returns {string}
- */
-export function torsion_scan_json(mol, i, j, k, l, steps) {
-    let deferred1_0;
-    let deferred1_1;
-    try {
-        _assertClass(mol, MolHandle);
-        const ret = wasm.torsion_scan_json(mol.__wbg_ptr, i, j, k, l, steps);
-        deferred1_0 = ret[0];
-        deferred1_1 = ret[1];
-        return getStringFromWasm0(ret[0], ret[1]);
-    } finally {
-        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
-    }
-}
-
 /**
  * Virtual screen a query SMILES against a database of SMILES using ECFP4 Tanimoto.
  *
@@ -4419,9 +4703,8 @@ export function virtual_screen_ecfp4_json(query_smi, db_smiles_json, k) {
 
 /**
  * Compute WHIM descriptors (Weighted Holistic Invariant Molecular) from 3D coordinates.
- * Returns JSON array of 10 values: [L1, L2, L3, P1, P2, P3, ALPHA, BETA, GAMMA, DELTA]
- * where L* = inertia tensor eigenvalues, P* = principal moments, ALPHA = sum of moments,
- * BETA = average pairwise interaction, GAMMA = geometric mean, DELTA = anisotropy.
+ * Returns JSON array of 22 values: 11 unit-weight descriptors followed by 11 mass-weight
+ * descriptors. Each 11-element block is [λ₁, λ₂, λ₃, ν₁, ν₂, ν₃, T, A, V, K, D].
  * @param {MolHandle} mol
  * @returns {string}
  */
@@ -4440,7 +4723,9 @@ export function whim_descriptors_json(mol) {
 }
 
 /**
- * Compute combined WHIM + GETAWAY descriptors (19 values total) as JSON array.
+ * Compute combined WHIM + GETAWAY descriptors (**41** values total) as JSON array.
+ *
+ * Returns WHIM[0..21] (22 values) followed by GETAWAY[0..18] (19 values) = 41 total.
  * Useful for ML pipelines requiring both shape and topologic features.
  * @param {MolHandle} mol
  * @returns {string}
@@ -4481,10 +4766,50 @@ export function write_smiles(mol) {
         wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
 }
+
+/**
+ * XLogP3 partition coefficient (alternative to Crippen LogP).
+ * Returns JSON: `{"xlogp3": float}`.
+ * @param {MolHandle} mol
+ * @returns {string}
+ */
+export function xlogp3_json(mol) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        _assertClass(mol, MolHandle);
+        const ret = wasm.xlogp3_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);
+    }
+}
+
+/**
+ * Per-atom XLogP3 contributions.
+ * Returns JSON array of floats (one per heavy atom).
+ * @param {MolHandle} mol
+ * @returns {string}
+ */
+export function xlogp3_per_atom_json(mol) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        _assertClass(mol, MolHandle);
+        const ret = wasm.xlogp3_per_atom_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);
+    }
+}
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
-        __wbg___wbindgen_string_get_72bdf95d3ae505b1: function(arg0, arg1) {
+        __wbg___wbindgen_string_get_b0ca35b86a603356: 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);
@@ -4492,33 +4817,11 @@ function __wbg_get_imports() {
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        __wbg___wbindgen_throw_1506f2235d1bdba0: function(arg0, arg1) {
+        __wbg___wbindgen_throw_344f42d3211c4765: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
-        __wbg_error_a6fa202b58aa1cd3: function(arg0, arg1) {
-            let deferred0_0;
-            let deferred0_1;
-            try {
-                deferred0_0 = arg0;
-                deferred0_1 = arg1;
-                console.error(getStringFromWasm0(arg0, arg1));
-            } finally {
-                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;
-        },
-        __wbg_stack_3b0d974bbf31e44f: function(arg0, arg1) {
-            const ret = arg1.stack;
-            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-            const len1 = WASM_VECTOR_LEN;
-            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        __wbg_error_744744ff0c9861e6: function(arg0) {
+            console.error(arg0);
         },
         __wbindgen_cast_0000000000000001: function(arg0) {
             // Cast intrinsic for `F64 -> Externref`.
@@ -4559,12 +4862,6 @@ 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}`);
@@ -4604,15 +4901,6 @@ 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;
 }