@kent-tokyo/chematic 1.0.41 → 1.1.0

package/README.md

@@ -4,7 +4,7 @@ WebAssembly bindings for [chematic](https://github.com/kent-tokyo/chematic), a p
 
 Published to npm as [`@kent-tokyo/chematic`](https://www.npmjs.com/package/@kent-tokyo/chematic).
 
-The current workspace line is 1.0.41. The binding keeps bounded parsing,
+The current workspace line is 1.1.0. The binding keeps bounded parsing,
 typed failures, and opt-in `embed_pipeline_v2_json`; 3D/MMFF94 behavior remains
 Experimental and is not a claim of full RDKit parity.
 
@@ -25,6 +25,9 @@ npm install @kent-tokyo/chematic
 - SA score: synthetic accessibility estimate [1, 10]
 - Functional group identification (Ertl 2017 IFG)
 - Canonical SMILES generation
+- Separately named RDKit 2026.03.1 compatibility bindings for SMARTS/PDB,
+  format readers, Murcko/stereo/hash/Morgan inspection, bounded alignment,
+  seeded ETKDG, and distance bounds
 - ECFP4/6, AtomPair, Torsion, path, and RDKit-compatible RDK fingerprints
   with Tanimoto similarity
 - BRICS fragment count
@@ -71,6 +74,7 @@ libraries):
 ```js
 import init, {
   parse_smiles,
+  add_hydrogens,
   tanimoto_ecfp4,
   tanimoto_atom_pair,
   tanimoto_torsion,
@@ -112,6 +116,28 @@ console.log(tanimoto_atom_pair(mol, caffeine)); // AtomPair Tanimoto
 console.log(tanimoto_torsion(mol, caffeine));   // Torsion Tanimoto
 ```
 
+### RDKit-compatible interoperability
+
+The `rdkit_*` methods are opt-in compatibility paths and do not replace the
+native browser APIs. JSON atom indices and coordinate rows are zero-based in
+`MolHandle` atom order:
+
+```js
+const smarts = mol.rdkit_smarts(true);
+const centers = JSON.parse(mol.rdkit_chiral_centers_json(true));
+const bitInfo = JSON.parse(mol.rdkit_morgan_bit_info_json(2, 2048, false));
+
+const withH = add_hydrogens(parse_smiles('CCO'));
+const coords = JSON.parse(withH.rdkit_embed_json(42, 0));
+const bounds = JSON.parse(withH.rdkit_bounds_matrix_json(true, true, false));
+```
+
+PDB, XYZ, and MOL2 readers return `RdkitReadResult`; call `molecule()` for a
+handle and `coords_json()` for index-aligned coordinates. Browser limits are
+explicit: at most 512 atoms for ETKDG/bounds, 4,096 stereoisomers, and
+1,000,000 alignment matches. Invalid or unsupported inputs throw a stable JS
+error instead of being silently coerced.
+
 ### Node.js
 
 The published package is built with wasm-pack's `web` target. In a browser,

package/chematic_wasm.d.ts

@@ -384,6 +384,10 @@ export class MolHandle {
      * Number of heteroatoms (non-C, non-H heavy atoms).
      */
     num_heteroatoms(): number;
+    /**
+     * Number of rings using RDKit's symmetrized-SSSR semantics.
+     */
+    num_rings(): number;
     /**
      * Number of fully saturated rings containing at least one heteroatom.
      */
@@ -430,6 +434,63 @@ export class MolHandle {
      * χ₀ = Σ 1/√(d_i × d_j) over all bonds, where d is heavy-atom degree.
      */
     randic_index(): number;
+    /**
+     * RDKit `AlignMol` result JSON. Coordinates and optional atom map and
+     * weights use zero-based molecule atom order.
+     */
+    rdkit_align_json(probe_coords_json: string, reference_coords_json: string, atom_map_json: string | null | undefined, weights_json: string | null | undefined, reflect: boolean, max_iterations: number): string;
+    /**
+     * RDKit `GetBestAlignmentTransform` as JSON, bounded by `max_matches`.
+     */
+    rdkit_best_alignment_json(probe_coords_json: string, reference_coords_json: string, max_matches: number, symmetrize: boolean, weights_json?: string | null): string;
+    /**
+     * RDKit `GetBestRMS`, bounded by `max_matches <= 1_000_000`.
+     */
+    rdkit_best_rms(probe_coords_json: string, reference_coords_json: string, max_matches: number, symmetrize: boolean, weights_json?: string | null): number;
+    /**
+     * RDKit distance-geometry bounds matrix JSON. Row and column `i`
+     * refer to zero-based molecule atom `i`; upper bounds are above the
+     * diagonal and lower bounds below it. At most 512 atoms are accepted.
+     */
+    rdkit_bounds_matrix_json(set15bounds: boolean, do_triangle_smoothing: boolean, use_macrocycle_14_config: boolean): string;
+    /**
+     * RDKit `CalcRMS`, bounded by `max_matches <= 1_000_000`.
+     */
+    rdkit_calc_rms(probe_coords_json: string, reference_coords_json: string, max_matches: number, symmetrize: boolean, weights_json?: string | null): number;
+    /**
+     * Chiral centres as `[[atomIndex,"R"|"S"|"?"], ...]` JSON.
+     */
+    rdkit_chiral_centers_json(include_unassigned: boolean): string;
+    /**
+     * RDKit-compatible CXSMARTS.
+     */
+    rdkit_cx_smarts(): string;
+    /**
+     * Seeded RDKit ETKDGv3 coordinates as JSON. Call on an
+     * explicit-hydrogen molecule. At most 512 atoms are accepted.
+     */
+    rdkit_embed_json(random_seed: number, max_iterations: number): string;
+    /**
+     * RDKit MolHash by case-insensitive function name.
+     */
+    rdkit_mol_hash(_function: string, use_cx_smiles: boolean): string;
+    /**
+     * RDKit Morgan folded bitInfo as `{bit:[[atomIndex,radius],...]}` JSON.
+     */
+    rdkit_morgan_bit_info_json(radius: number, n_bits: number, include_chirality: boolean): string;
+    /**
+     * RDKit-compatible Murcko scaffold SMILES.
+     */
+    rdkit_murcko_scaffold(): string;
+    /**
+     * RDKit-compatible PDB block. Optional coordinates are a JSON array in
+     * zero-based molecule atom order; omit them to write zero coordinates.
+     */
+    rdkit_pdb_block(coords_json?: string | null): string;
+    /**
+     * RDKit-compatible SMARTS in input atom order.
+     */
+    rdkit_smarts(isomeric: boolean, rooted_at_atom?: number | null): string;
     /**
      * Canonical SMILES exactly as RDKit 2026.03.1 writes it
      * (`Chem.MolToSmiles(Chem.MolFromSmiles(s))` for a molecule parsed
@@ -438,6 +499,15 @@ export class MolHandle {
      * rejects; `canonical_smiles` is unchanged.
      */
     rdkit_smiles(): string;
+    /**
+     * Number of default RDKit stereoisomers as a decimal string (u128-safe).
+     */
+    rdkit_stereoisomer_count(): string;
+    /**
+     * Sorted RDKit stereoisomer SMILES JSON. `max_isomers` is required and
+     * must be between 1 and 4096 so browser work remains bounded.
+     */
+    rdkit_stereoisomer_smiles_json(max_isomers: number): string;
     /**
      * Returns `true` if the molecule passes the REOS (Rapid Elimination Of Swill) filter.
      */
@@ -497,6 +567,30 @@ export class PreparedRdkitEcfp4Handle {
     bitvec(): Uint8Array;
 }
 
+/**
+ * Result of an RDKit-compatible PDB, XYZ, or MOL2 reader.
+ *
+ * `coords_json()` is a JSON array with one `[x,y,z]` row per zero-based
+ * molecule atom. `smiles` is empty for XYZ and unsanitized readers.
+ */
+export class RdkitReadResult {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Coordinates as JSON, in zero-based molecule atom order.
+     */
+    coords_json(): string;
+    /**
+     * A cloned handle to the parsed molecule.
+     */
+    molecule(): MolHandle;
+    /**
+     * RDKit canonical SMILES when the reader sanitized the molecule.
+     */
+    readonly smiles: string;
+}
+
 /**
  * Reusable prepared index for the RDKit-compatible Morgan profile.
  *
@@ -1647,6 +1741,14 @@ export function mmcif_coords_json(text: string): string;
  */
 export function mmcif_to_json(text: string): string;
 
+/**
+ * Checked legacy MMFF94 charges.
+ *
+ * Returns `{"charges":[...]}` or a typed `{"error":"unsupported_element",...}`
+ * object instead of silently returning zeros for an unparameterized atom.
+ */
+export function mmff94_charges_checked_json(mol: MolHandle): string;
+
 /**
  * MMFF94 partial charges (BCI table, ±0.1e accuracy) as a JSON array of f64.
  *
@@ -2359,6 +2461,21 @@ export function rdkit_ecfp_config_chiral_detail_json(mol: MolHandle, radius: num
  */
 export function rdkit_ecfp_config_detail_json(mol: MolHandle, radius: number, nbits: number): string;
 
+/**
+ * RDKit-compatible `MolFromMol2Block` with molecule and coordinates.
+ */
+export function rdkit_from_mol2_block(text: string, sanitize: boolean, remove_hs: boolean, cleanup_substructures: boolean): RdkitReadResult;
+
+/**
+ * RDKit-compatible `MolFromPDBBlock` with molecule and coordinates.
+ */
+export function rdkit_from_pdb_block(text: string, sanitize: boolean, remove_hs: boolean, flavor: number, proximity_bonding: boolean): RdkitReadResult;
+
+/**
+ * RDKit-compatible `MolFromXYZBlock`; the molecule has atoms but no bonds.
+ */
+export function rdkit_from_xyz_block(text: string): RdkitReadResult;
+
 /**
  * Find the k nearest neighbours using the RDKit-compatible Morgan/ECFP4
  * profile. This is intentionally separate from [`nearest_neighbors_json`],
@@ -3087,6 +3204,7 @@ export interface InitOutput {
     readonly __wbg_mhfplshhandle_free: (a: number, b: number) => void;
     readonly __wbg_molhandle_free: (a: number, b: number) => void;
     readonly __wbg_preparedrdkitecfp4handle_free: (a: number, b: number) => void;
+    readonly __wbg_rdkitreadresult_free: (a: number, b: number) => void;
     readonly __wbg_rdkitsearchindex_free: (a: number, b: number) => void;
     readonly __wbg_smilesbatchstreamhandle_free: (a: number, b: number) => void;
     readonly add_hydrogens: (a: number) => number;
@@ -3226,6 +3344,7 @@ export interface InitOutput {
     readonly minimize_uff_json: (a: number, b: number, c: number, d: number, e: number) => [number, number];
     readonly mmcif_coords_json: (a: number, b: number) => [number, number, number, number];
     readonly mmcif_to_json: (a: number, b: number) => [number, number, number, number];
+    readonly mmff94_charges_checked_json: (a: number) => [number, number];
     readonly mmff94_charges_json: (a: number) => [number, number];
     readonly mmff94_charges_typed_json: (a: number) => [number, number];
     readonly mmff94_energy_breakdown_from_coords_json: (a: number, b: number, c: number) => [number, number];
@@ -3318,6 +3437,7 @@ export interface InitOutput {
     readonly molhandle_num_aromatic_heterocycles: (a: number) => number;
     readonly molhandle_num_bridgehead_atoms: (a: number) => number;
     readonly molhandle_num_heteroatoms: (a: number) => number;
+    readonly molhandle_num_rings: (a: number) => number;
     readonly molhandle_num_saturated_heterocycles: (a: number) => number;
     readonly molhandle_num_saturated_rings: (a: number) => number;
     readonly molhandle_num_spiro_atoms: (a: number) => number;
@@ -3329,7 +3449,22 @@ export interface InitOutput {
     readonly molhandle_potential_stereocenter_indices: (a: number) => [number, number];
     readonly molhandle_qed: (a: number) => number;
     readonly molhandle_randic_index: (a: number) => number;
+    readonly molhandle_rdkit_align_json: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => [number, number, number, number];
+    readonly molhandle_rdkit_best_alignment_json: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number, number, number];
+    readonly molhandle_rdkit_best_rms: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number, number];
+    readonly molhandle_rdkit_bounds_matrix_json: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+    readonly molhandle_rdkit_calc_rms: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number, number];
+    readonly molhandle_rdkit_chiral_centers_json: (a: number, b: number) => [number, number, number, number];
+    readonly molhandle_rdkit_cx_smarts: (a: number) => [number, number, number, number];
+    readonly molhandle_rdkit_embed_json: (a: number, b: number, c: number) => [number, number, number, number];
+    readonly molhandle_rdkit_mol_hash: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+    readonly molhandle_rdkit_morgan_bit_info_json: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+    readonly molhandle_rdkit_murcko_scaffold: (a: number) => [number, number, number, number];
+    readonly molhandle_rdkit_pdb_block: (a: number, b: number, c: number) => [number, number, number, number];
+    readonly molhandle_rdkit_smarts: (a: number, b: number, c: number) => [number, number, number, number];
     readonly molhandle_rdkit_smiles: (a: number) => [number, number, number, number];
+    readonly molhandle_rdkit_stereoisomer_count: (a: number) => [number, number, number, number];
+    readonly molhandle_rdkit_stereoisomer_smiles_json: (a: number, b: number) => [number, number, number, number];
     readonly molhandle_reos_passes: (a: number) => number;
     readonly molhandle_ring_count: (a: number) => number;
     readonly molhandle_rotatable_bond_count: (a: number) => number;
@@ -3383,10 +3518,16 @@ export interface InitOutput {
     readonly rdkit_ecfp_config_chiral_bitvec: (a: number, b: number, c: number) => [number, number, number, number];
     readonly rdkit_ecfp_config_chiral_detail_json: (a: number, b: number, c: number) => [number, number, number, number];
     readonly rdkit_ecfp_config_detail_json: (a: number, b: number, c: number) => [number, number, number, number];
+    readonly rdkit_from_mol2_block: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
+    readonly rdkit_from_pdb_block: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
+    readonly rdkit_from_xyz_block: (a: number, b: number) => [number, number, number];
     readonly rdkit_nearest_neighbors_json: (a: number, b: number, c: number, d: number, e: number) => [number, number];
     readonly rdkit_path_bitvec: (a: number) => [number, number];
     readonly rdkit_rdk_bitvec: (a: number) => [number, number];
     readonly rdkit_torsion_bitvec: (a: number) => [number, number];
+    readonly rdkitreadresult_coords_json: (a: number) => [number, number, number, number];
+    readonly rdkitreadresult_molecule: (a: number) => number;
+    readonly rdkitreadresult_smiles: (a: number) => [number, number];
     readonly rdkitsearchindex_is_empty: (a: number) => number;
     readonly rdkitsearchindex_len: (a: number) => number;
     readonly rdkitsearchindex_new: (a: number, b: number) => [number, number, number];

package/chematic_wasm.js

@@ -916,6 +916,14 @@ export class MolHandle {
         const ret = wasm.molhandle_num_heteroatoms(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * Number of rings using RDKit's symmetrized-SSSR semantics.
+     * @returns {number}
+     */
+    num_rings() {
+        const ret = wasm.molhandle_num_rings(this.__wbg_ptr);
+        return ret >>> 0;
+    }
     /**
      * Number of fully saturated rings containing at least one heteroatom.
      * @returns {number}
@@ -1008,6 +1016,340 @@ export class MolHandle {
         const ret = wasm.molhandle_randic_index(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * RDKit `AlignMol` result JSON. Coordinates and optional atom map and
+     * weights use zero-based molecule atom order.
+     * @param {string} probe_coords_json
+     * @param {string} reference_coords_json
+     * @param {string | null | undefined} atom_map_json
+     * @param {string | null | undefined} weights_json
+     * @param {boolean} reflect
+     * @param {number} max_iterations
+     * @returns {string}
+     */
+    rdkit_align_json(probe_coords_json, reference_coords_json, atom_map_json, weights_json, reflect, max_iterations) {
+        let deferred6_0;
+        let deferred6_1;
+        try {
+            const ptr0 = passStringToWasm0(probe_coords_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(reference_coords_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            var ptr2 = isLikeNone(atom_map_json) ? 0 : passStringToWasm0(atom_map_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len2 = WASM_VECTOR_LEN;
+            var ptr3 = isLikeNone(weights_json) ? 0 : passStringToWasm0(weights_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len3 = WASM_VECTOR_LEN;
+            const ret = wasm.molhandle_rdkit_align_json(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, reflect, max_iterations);
+            var ptr5 = ret[0];
+            var len5 = ret[1];
+            if (ret[3]) {
+                ptr5 = 0; len5 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred6_0 = ptr5;
+            deferred6_1 = len5;
+            return getStringFromWasm0(ptr5, len5);
+        } finally {
+            wasm.__wbindgen_free(deferred6_0, deferred6_1, 1);
+        }
+    }
+    /**
+     * RDKit `GetBestAlignmentTransform` as JSON, bounded by `max_matches`.
+     * @param {string} probe_coords_json
+     * @param {string} reference_coords_json
+     * @param {number} max_matches
+     * @param {boolean} symmetrize
+     * @param {string | null} [weights_json]
+     * @returns {string}
+     */
+    rdkit_best_alignment_json(probe_coords_json, reference_coords_json, max_matches, symmetrize, weights_json) {
+        let deferred5_0;
+        let deferred5_1;
+        try {
+            const ptr0 = passStringToWasm0(probe_coords_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(reference_coords_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            var ptr2 = isLikeNone(weights_json) ? 0 : passStringToWasm0(weights_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len2 = WASM_VECTOR_LEN;
+            const ret = wasm.molhandle_rdkit_best_alignment_json(this.__wbg_ptr, ptr0, len0, ptr1, len1, max_matches, symmetrize, ptr2, len2);
+            var ptr4 = ret[0];
+            var len4 = ret[1];
+            if (ret[3]) {
+                ptr4 = 0; len4 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred5_0 = ptr4;
+            deferred5_1 = len4;
+            return getStringFromWasm0(ptr4, len4);
+        } finally {
+            wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+        }
+    }
+    /**
+     * RDKit `GetBestRMS`, bounded by `max_matches <= 1_000_000`.
+     * @param {string} probe_coords_json
+     * @param {string} reference_coords_json
+     * @param {number} max_matches
+     * @param {boolean} symmetrize
+     * @param {string | null} [weights_json]
+     * @returns {number}
+     */
+    rdkit_best_rms(probe_coords_json, reference_coords_json, max_matches, symmetrize, weights_json) {
+        const ptr0 = passStringToWasm0(probe_coords_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(reference_coords_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        var ptr2 = isLikeNone(weights_json) ? 0 : passStringToWasm0(weights_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len2 = WASM_VECTOR_LEN;
+        const ret = wasm.molhandle_rdkit_best_rms(this.__wbg_ptr, ptr0, len0, ptr1, len1, max_matches, symmetrize, ptr2, len2);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * RDKit distance-geometry bounds matrix JSON. Row and column `i`
+     * refer to zero-based molecule atom `i`; upper bounds are above the
+     * diagonal and lower bounds below it. At most 512 atoms are accepted.
+     * @param {boolean} set15bounds
+     * @param {boolean} do_triangle_smoothing
+     * @param {boolean} use_macrocycle_14_config
+     * @returns {string}
+     */
+    rdkit_bounds_matrix_json(set15bounds, do_triangle_smoothing, use_macrocycle_14_config) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.molhandle_rdkit_bounds_matrix_json(this.__wbg_ptr, set15bounds, do_triangle_smoothing, use_macrocycle_14_config);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * RDKit `CalcRMS`, bounded by `max_matches <= 1_000_000`.
+     * @param {string} probe_coords_json
+     * @param {string} reference_coords_json
+     * @param {number} max_matches
+     * @param {boolean} symmetrize
+     * @param {string | null} [weights_json]
+     * @returns {number}
+     */
+    rdkit_calc_rms(probe_coords_json, reference_coords_json, max_matches, symmetrize, weights_json) {
+        const ptr0 = passStringToWasm0(probe_coords_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(reference_coords_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        var ptr2 = isLikeNone(weights_json) ? 0 : passStringToWasm0(weights_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len2 = WASM_VECTOR_LEN;
+        const ret = wasm.molhandle_rdkit_calc_rms(this.__wbg_ptr, ptr0, len0, ptr1, len1, max_matches, symmetrize, ptr2, len2);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * Chiral centres as `[[atomIndex,"R"|"S"|"?"], ...]` JSON.
+     * @param {boolean} include_unassigned
+     * @returns {string}
+     */
+    rdkit_chiral_centers_json(include_unassigned) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.molhandle_rdkit_chiral_centers_json(this.__wbg_ptr, include_unassigned);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * RDKit-compatible CXSMARTS.
+     * @returns {string}
+     */
+    rdkit_cx_smarts() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.molhandle_rdkit_cx_smarts(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Seeded RDKit ETKDGv3 coordinates as JSON. Call on an
+     * explicit-hydrogen molecule. At most 512 atoms are accepted.
+     * @param {number} random_seed
+     * @param {number} max_iterations
+     * @returns {string}
+     */
+    rdkit_embed_json(random_seed, max_iterations) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.molhandle_rdkit_embed_json(this.__wbg_ptr, random_seed, max_iterations);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * RDKit MolHash by case-insensitive function name.
+     * @param {string} _function
+     * @param {boolean} use_cx_smiles
+     * @returns {string}
+     */
+    rdkit_mol_hash(_function, use_cx_smiles) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(_function, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.molhandle_rdkit_mol_hash(this.__wbg_ptr, ptr0, len0, use_cx_smiles);
+            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);
+        }
+    }
+    /**
+     * RDKit Morgan folded bitInfo as `{bit:[[atomIndex,radius],...]}` JSON.
+     * @param {number} radius
+     * @param {number} n_bits
+     * @param {boolean} include_chirality
+     * @returns {string}
+     */
+    rdkit_morgan_bit_info_json(radius, n_bits, include_chirality) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.molhandle_rdkit_morgan_bit_info_json(this.__wbg_ptr, radius, n_bits, include_chirality);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * RDKit-compatible Murcko scaffold SMILES.
+     * @returns {string}
+     */
+    rdkit_murcko_scaffold() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.molhandle_rdkit_murcko_scaffold(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * RDKit-compatible PDB block. Optional coordinates are a JSON array in
+     * zero-based molecule atom order; omit them to write zero coordinates.
+     * @param {string | null} [coords_json]
+     * @returns {string}
+     */
+    rdkit_pdb_block(coords_json) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            var ptr0 = isLikeNone(coords_json) ? 0 : passStringToWasm0(coords_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len0 = WASM_VECTOR_LEN;
+            const ret = wasm.molhandle_rdkit_pdb_block(this.__wbg_ptr, 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);
+        }
+    }
+    /**
+     * RDKit-compatible SMARTS in input atom order.
+     * @param {boolean} isomeric
+     * @param {number | null} [rooted_at_atom]
+     * @returns {string}
+     */
+    rdkit_smarts(isomeric, rooted_at_atom) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.molhandle_rdkit_smarts(this.__wbg_ptr, isomeric, isLikeNone(rooted_at_atom) ? Number.MAX_SAFE_INTEGER : (rooted_at_atom) >>> 0);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
     /**
      * Canonical SMILES exactly as RDKit 2026.03.1 writes it
      * (`Chem.MolToSmiles(Chem.MolFromSmiles(s))` for a molecule parsed
@@ -1034,6 +1376,52 @@ export class MolHandle {
             wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
         }
     }
+    /**
+     * Number of default RDKit stereoisomers as a decimal string (u128-safe).
+     * @returns {string}
+     */
+    rdkit_stereoisomer_count() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.molhandle_rdkit_stereoisomer_count(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Sorted RDKit stereoisomer SMILES JSON. `max_isomers` is required and
+     * must be between 1 and 4096 so browser work remains bounded.
+     * @param {number} max_isomers
+     * @returns {string}
+     */
+    rdkit_stereoisomer_smiles_json(max_isomers) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.molhandle_rdkit_stereoisomer_smiles_json(this.__wbg_ptr, max_isomers);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
     /**
      * Returns `true` if the molecule passes the REOS (Rapid Elimination Of Swill) filter.
      * @returns {boolean}
@@ -1170,6 +1558,78 @@ export class PreparedRdkitEcfp4Handle {
 }
 if (Symbol.dispose) PreparedRdkitEcfp4Handle.prototype[Symbol.dispose] = PreparedRdkitEcfp4Handle.prototype.free;
 
+/**
+ * Result of an RDKit-compatible PDB, XYZ, or MOL2 reader.
+ *
+ * `coords_json()` is a JSON array with one `[x,y,z]` row per zero-based
+ * molecule atom. `smiles` is empty for XYZ and unsanitized readers.
+ */
+export class RdkitReadResult {
+    static __wrap(ptr) {
+        const obj = Object.create(RdkitReadResult.prototype);
+        obj.__wbg_ptr = ptr;
+        RdkitReadResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RdkitReadResultFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_rdkitreadresult_free(ptr, 0);
+    }
+    /**
+     * Coordinates as JSON, in zero-based molecule atom order.
+     * @returns {string}
+     */
+    coords_json() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.rdkitreadresult_coords_json(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * A cloned handle to the parsed molecule.
+     * @returns {MolHandle}
+     */
+    molecule() {
+        const ret = wasm.rdkitreadresult_molecule(this.__wbg_ptr);
+        return MolHandle.__wrap(ret);
+    }
+    /**
+     * RDKit canonical SMILES when the reader sanitized the molecule.
+     * @returns {string}
+     */
+    get smiles() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.rdkitreadresult_smiles(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);
+        }
+    }
+}
+if (Symbol.dispose) RdkitReadResult.prototype[Symbol.dispose] = RdkitReadResult.prototype.free;
+
 /**
  * Reusable prepared index for the RDKit-compatible Morgan profile.
  *
@@ -4171,6 +4631,28 @@ export function mmcif_to_json(text) {
     }
 }
 
+/**
+ * Checked legacy MMFF94 charges.
+ *
+ * Returns `{"charges":[...]}` or a typed `{"error":"unsupported_element",...}`
+ * object instead of silently returning zeros for an unparameterized atom.
+ * @param {MolHandle} mol
+ * @returns {string}
+ */
+export function mmff94_charges_checked_json(mol) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        _assertClass(mol, MolHandle);
+        const ret = wasm.mmff94_charges_checked_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);
+    }
+}
+
 /**
  * MMFF94 partial charges (BCI table, ±0.1e accuracy) as a JSON array of f64.
  *
@@ -6082,6 +6564,58 @@ export function rdkit_ecfp_config_detail_json(mol, radius, nbits) {
     }
 }
 
+/**
+ * RDKit-compatible `MolFromMol2Block` with molecule and coordinates.
+ * @param {string} text
+ * @param {boolean} sanitize
+ * @param {boolean} remove_hs
+ * @param {boolean} cleanup_substructures
+ * @returns {RdkitReadResult}
+ */
+export function rdkit_from_mol2_block(text, sanitize, remove_hs, cleanup_substructures) {
+    const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.rdkit_from_mol2_block(ptr0, len0, sanitize, remove_hs, cleanup_substructures);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return RdkitReadResult.__wrap(ret[0]);
+}
+
+/**
+ * RDKit-compatible `MolFromPDBBlock` with molecule and coordinates.
+ * @param {string} text
+ * @param {boolean} sanitize
+ * @param {boolean} remove_hs
+ * @param {number} flavor
+ * @param {boolean} proximity_bonding
+ * @returns {RdkitReadResult}
+ */
+export function rdkit_from_pdb_block(text, sanitize, remove_hs, flavor, proximity_bonding) {
+    const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.rdkit_from_pdb_block(ptr0, len0, sanitize, remove_hs, flavor, proximity_bonding);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return RdkitReadResult.__wrap(ret[0]);
+}
+
+/**
+ * RDKit-compatible `MolFromXYZBlock`; the molecule has atoms but no bonds.
+ * @param {string} text
+ * @returns {RdkitReadResult}
+ */
+export function rdkit_from_xyz_block(text) {
+    const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.rdkit_from_xyz_block(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return RdkitReadResult.__wrap(ret[0]);
+}
+
 /**
  * Find the k nearest neighbours using the RDKit-compatible Morgan/ECFP4
  * profile. This is intentionally separate from [`nearest_neighbors_json`],
@@ -8342,6 +8876,9 @@ const MolHandleFinalization = (typeof FinalizationRegistry === 'undefined')
 const PreparedRdkitEcfp4HandleFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_preparedrdkitecfp4handle_free(ptr, 1));
+const RdkitReadResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_rdkitreadresult_free(ptr, 1));
 const RdkitSearchIndexFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_rdkitsearchindex_free(ptr, 1));

package/package.json

@@ -5,7 +5,7 @@
     "Kentaro Tanabe (kent-tokyo) <kent-tokyo@users.noreply.github.com>"
   ],
   "description": "WebAssembly bindings for chematic — use chematic from JavaScript/TypeScript",
-  "version": "1.0.41",
+  "version": "1.1.0",
   "license": "MIT OR Apache-2.0",
   "repository": {
     "type": "git",