@kent-tokyo/chematic 0.1.9 → 0.1.19

package/README.md

@@ -13,11 +13,23 @@ npm install @kent-tokyo/chematic
 ## Features
 
 - Parse SMILES strings into molecule handles
-- Molecular descriptors: MW, TPSA, LogP, Fsp3, QED, exact mass, rotatable bonds, HBD/HBA, aromatic ring count
-- Lipinski Rule-of-Five check
+- Molecular descriptors: MW, TPSA, LogP, Fsp3, QED, exact mass, rotatable bonds, HBD/HBA, aromatic ring count, Labute ASA
+- Drug-likeness filters: Lipinski, Veber, Egan, REOS, Ghose
+- EState indices (Hall & Kier 1991): per-atom values, sum/max/min
+- Gasteiger-Marsili PEOE partial charges: per-heavy-atom charges
+- VSA descriptors: SlogP_VSA (×12), SMR_VSA (×10), PEOE_VSA (×14)
+- SA score: synthetic accessibility estimate [1, 10]
+- Functional group identification (Ertl 2017 IFG)
 - Canonical SMILES generation
-- ECFP4, AtomPair, and Topological Torsion fingerprints with Tanimoto similarity
+- ECFP4/6, AtomPair, Torsion, and path fingerprints with Tanimoto similarity
 - BRICS fragment count
+- SDF/MOL block parsing
+- Topological descriptors: Wiener index, Hall-Kier κ, χ connectivity indices, Bertz CT
+- Shape descriptors (with 3D coordinates): PMI, NPR, radius of gyration, asphericity
+- 2D SVG depiction with CPK colors and atom/bond highlighting
+- SVG grid layout for multiple molecules
+- Reaction SMILES/SMIRKS parsing and transform
+- Add/remove explicit hydrogens
 
 ## Usage
 
@@ -28,6 +40,11 @@ import init, {
   tanimoto_atom_pair,
   tanimoto_torsion,
   brics_fragment_count,
+  gasteiger_charges_json,
+  slogp_vsa_json,
+  smr_vsa_json,
+  peoe_vsa_json,
+  identify_functional_groups,
 } from '@kent-tokyo/chematic';
 
 await init();
@@ -60,6 +77,25 @@ console.log(tanimoto_atom_pair(mol, caffeine)); // AtomPair Tanimoto
 console.log(tanimoto_torsion(mol, caffeine));   // Torsion Tanimoto
 ```
 
+```js
+// Sprint Q: New descriptors (v0.1.15)
+console.log(mol.sa_score());                     // synthetic accessibility [1,10]
+console.log(mol.labute_asa());                   // Labute approx. surface area (Ų)
+
+// Gasteiger partial charges (per heavy atom)
+const charges = JSON.parse(gasteiger_charges_json(mol));
+console.log(charges); // [-0.08, 0.12, -0.43, ...]
+
+// VSA descriptor bins
+const slogpVsa = JSON.parse(slogp_vsa_json(mol));
+const smrVsa   = JSON.parse(smr_vsa_json(mol));
+const peoeVsa  = JSON.parse(peoe_vsa_json(mol));
+
+// Functional group identification
+const ifg = JSON.parse(identify_functional_groups(mol));
+console.log(ifg); // [{"atoms":[1,2,3],"types":"OC=O"}, ...]
+```
+
 ## Building from source
 
 ```sh

package/chematic_wasm.d.ts

@@ -17,13 +17,22 @@ export class DepictOptions {
     free(): void;
     [Symbol.dispose](): void;
     constructor();
+    /**
+     * Set a per-atom color override (CSS color string).  Calling multiple times
+     * for the same `idx` uses the last value.  The atom is highlighted even if
+     * not in `set_highlight_atoms`.
+     */
+    set_atom_color(idx: number, color: string): void;
+    set_atom_ids(v: boolean): void;
     set_background(bg: string): void;
     set_dark(dark: boolean): void;
     set_height(h: number): void;
     set_highlight_atoms(atoms: Uint32Array): void;
     set_highlight_bonds(bonds: Uint32Array): void;
     set_highlight_color(color: string): void;
+    set_kekulize(v: boolean): void;
     set_padding(p: number): void;
+    set_show_atom_indices(v: boolean): void;
     set_width(w: number): void;
 }
 
@@ -165,6 +174,14 @@ export class MolHandle {
      * Crippen–Wildman octanol/water partition coefficient (LogP).
      */
     logp_crippen(): number;
+    /**
+     * Maximum EState index across all heavy atoms.
+     */
+    max_estate(): number;
+    /**
+     * Minimum EState index across all heavy atoms.
+     */
+    min_estate(): number;
     /**
      * Wildman–Crippen molar refractivity (MR).
      */
@@ -227,6 +244,10 @@ export class MolHandle {
      * Number of rotatable bonds.
      */
     rotatable_bond_count(): number;
+    /**
+     * Sum of EState indices over all heavy atoms.
+     */
+    sum_estate(): number;
     /**
      * Topological polar surface area (Ų).
      */
@@ -254,6 +275,14 @@ export function add_hydrogens(mol: MolHandle): MolHandle;
  */
 export function brics_fragment_count(mol: MolHandle): number;
 
+/**
+ * Render a reaction SMILES string (e.g. `"CC(=O)O.CCO>>CC(=O)OCC.O"`) as a
+ * single SVG showing reactants → products with `+` separators.
+ *
+ * Returns a self-contained SVG string.  Returns a JS error on invalid input.
+ */
+export function depict_reaction_svg(rxn_smiles: string): string;
+
 /**
  * Render a grid SVG from newline-separated SMILES (one per line).
  *
@@ -262,16 +291,110 @@ export function brics_fragment_count(mol: MolHandle): number;
  */
 export function depict_svg_grid(smiles_block: string, cols: number): string;
 
+/**
+ * Detect named functional groups in `mol`.
+ *
+ * Returns a JSON array of `{"name":"hydroxyl","atoms":[3]}` objects.
+ * Multiple matches of the same group (e.g. two hydroxyl groups) each appear
+ * as a separate entry.  Overlapping groups (carboxylic acid → "carboxyl" +
+ * "hydroxyl" + "carbonyl") are all returned.
+ */
+export function detect_functional_groups(mol: MolHandle): string;
+
 /**
  * Compute the ECFP4 fingerprint as a bit-packed byte vector (256 bytes = 2048 bits).
  */
 export function ecfp4_bitvec(mol: MolHandle): Uint8Array;
 
+/**
+ * Per-atom EState values as a JSON array of f64.
+ *
+ * Indices match `mol.atoms()` order.  Hydrogen atoms get 0.0.
+ */
+export function estate_indices_json(mol: MolHandle): string;
+
+/**
+ * Gasteiger-Marsili PEOE partial charges as a JSON array of f64.
+ */
+export function gasteiger_charges_json(mol: MolHandle): string;
+
+/**
+ * Generate 3D coordinates for the molecule and return a PDB string.
+ *
+ * Coordinates are generated using distance-geometry placement with ring templates.
+ * Returns heavy-atom PDB (HETATM records, no explicit H).
+ */
+export function generate_3d_pdb(mol: MolHandle): string;
+
+/**
+ * Return information about a single atom as a JSON object.
+ *
+ * `idx` is the 0-based atom index (matching `atoms()` order).
+ * Returns `"null"` if `idx` is out of range.
+ *
+ * Fields: `element` (symbol), `hybridization` ("sp"/"sp2"/"sp3"),
+ * `charge` (formal charge integer), `isAromatic` (bool),
+ * `totalHydrogens` (explicit + implicit H count, integer).
+ * sp3d/sp3d2 (hypervalent P/S) are not distinguished from sp3/sp2.
+ */
+export function get_atom_info(mol: MolHandle, idx: number): string;
+
+/**
+ * Return bond information as a JSON object, looked up by the two bonded atom indices.
+ *
+ * Useful when you know the atom indices from SMARTS matching or `data-atom-idx` SVG
+ * attributes but not the bond index.  Returns `"null"` if no bond exists between them.
+ *
+ * Fields: same as `get_bond_info` plus `bondIdx` (u32).
+ */
+export function get_bond_between(mol: MolHandle, atom1: number, atom2: number): string;
+
+/**
+ * Return bond information as a JSON object, looked up by bond index.
+ *
+ * `idx` is the 0-based bond index (order matches `mol.bonds()` iteration).
+ * Returns `"null"` if `idx` is out of range.
+ *
+ * Fields: `bondOrder` (1.0/1.5/2.0/3.0), `isAromatic` (bool),
+ * `isInRing` (bool), `atomFrom` (u32), `atomTo` (u32).
+ */
+export function get_bond_info(mol: MolHandle, idx: number): string;
+
+/**
+ * Identify functional groups. Returns a JSON array of objects:
+ * `[{"atoms":[0,2,3],"type":"C,N,O"}, …]`
+ */
+export function identify_functional_groups(mol: MolHandle): string;
+
 /**
  * Returns `true` if the SMILES string can be parsed without error.
  */
 export function is_valid_smiles(s: string): boolean;
 
+/**
+ * Find all SMARTS matches in a molecule given only SMILES strings.
+ *
+ * Convenience wrapper around `smarts_match_atoms` that accepts raw SMILES
+ * instead of a `MolHandle`.  Returns the same JSON format: `[[0,1],[3,4]]`.
+ * Returns a JS error on SMILES or SMARTS parse failure.
+ */
+export function match_smarts_smiles(smiles: string, smarts: string): string;
+
+/**
+ * Serialize a SMILES string directly to a MOL V2000 block.
+ *
+ * Convenience wrapper; all atom coordinates are 0.0.
+ * Returns a JS error on SMILES parse failure.
+ */
+export function mol_block_from_smiles(smiles: string): string;
+
+/**
+ * Parse a MOL V2000 block and return a `MolHandle`.
+ *
+ * Returns a JS error string on parse failure.
+ */
+export function mol_from_sdf_block(block: string): MolHandle;
+
 /**
  * Parse a SMILES string into a `MolHandle`.
  *
@@ -279,6 +402,11 @@ export function is_valid_smiles(s: string): boolean;
  */
 export function parse_smiles(s: string): MolHandle;
 
+/**
+ * PEOE_VSA descriptors (14 bins) as a JSON array.
+ */
+export function peoe_vsa_json(mol: MolHandle): string;
+
 /**
  * Return a copy of the molecule with all explicit hydrogen atoms removed.
  */
@@ -293,6 +421,50 @@ export function remove_hydrogens(mol: MolHandle): MolHandle;
  */
 export function run_reactants(smirks: string, reactants_smiles: string): string;
 
+/**
+ * Synthetic Accessibility Score (1 = easy, 10 = hard).
+ */
+export function sa_score(mol: MolHandle): number;
+
+/**
+ * Parse an SDF string and return a JSON array of canonical SMILES strings.
+ *
+ * Invalid records are represented as `null` in the array.
+ */
+export function sdf_to_smiles_json(sdf: string): string;
+
+/**
+ * SlogP_VSA descriptors (12 bins) as a JSON array.
+ */
+export function slogp_vsa_json(mol: MolHandle): string;
+
+/**
+ * Find all substructure matches of a SMARTS pattern in `mol`.
+ *
+ * Returns JSON array of arrays of atom indices (sorted, 0-based).
+ * Example: `[[0,1,2],[3,4,5]]` — two matches.
+ * Returns `"[]"` if no match. Returns a JS error on invalid SMARTS.
+ */
+export function smarts_match_atoms(smarts: string, mol: MolHandle): string;
+
+/**
+ * Render a highlighted SVG from a SMILES string in one call.
+ *
+ * `atoms` — 0-based atom indices to highlight (Uint32Array in JS).
+ * `bonds` — 0-based bond indices to highlight (Uint32Array in JS).
+ * `color` — CSS color for highlights (e.g. `"#ef4444"`); empty string uses default yellow.
+ *
+ * Returns a JS error on SMILES parse failure.
+ */
+export function smiles_to_svg_highlighted(smiles: string, atoms: Uint32Array, bonds: Uint32Array, color: string): string;
+
+/**
+ * SMR_VSA descriptors (10 bins) as a JSON array.
+ */
+export function smr_vsa_json(mol: MolHandle): string;
+
+export function start(): void;
+
 /**
  * Tanimoto similarity between two molecules using AtomPair fingerprints.
  */
@@ -308,11 +480,31 @@ export function tanimoto_ecfp4(a: MolHandle, b: MolHandle): number;
  */
 export function tanimoto_fcfp4(a: MolHandle, b: MolHandle): number;
 
+/**
+ * Tanimoto similarity between two molecules given only SMILES strings (ECFP4).
+ *
+ * Returns a JS error on parse failure.
+ */
+export function tanimoto_smiles(smiles1: string, smiles2: string): number;
+
+/**
+ * Tanimoto similarity between two molecules using topological path fingerprints.
+ */
+export function tanimoto_topo_path(a: MolHandle, b: MolHandle): number;
+
 /**
  * Tanimoto similarity between two molecules using Topological Torsion fingerprints.
  */
 export function tanimoto_torsion(a: MolHandle, b: MolHandle): number;
 
+/**
+ * Serialize a molecule to a MOL V2000 block.
+ *
+ * All atom coordinates are written as 0.0 (the `Molecule` type has no 2D
+ * coordinate storage; real coordinates would require a separate layout pass).
+ */
+export function to_mol_block(mol: MolHandle): string;
+
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
 export interface InitOutput {
@@ -321,18 +513,34 @@ export interface InitOutput {
     readonly __wbg_molhandle_free: (a: number, b: number) => void;
     readonly add_hydrogens: (a: number) => number;
     readonly brics_fragment_count: (a: number) => number;
+    readonly depict_reaction_svg: (a: number, b: number) => [number, number, number, number];
     readonly depict_svg_grid: (a: number, b: number, c: number) => [number, number];
     readonly depictoptions_new: () => number;
+    readonly depictoptions_set_atom_color: (a: number, b: number, c: number, d: number) => void;
+    readonly depictoptions_set_atom_ids: (a: number, b: number) => void;
     readonly depictoptions_set_background: (a: number, b: number, c: number) => void;
     readonly depictoptions_set_dark: (a: number, b: number) => void;
     readonly depictoptions_set_height: (a: number, b: number) => void;
     readonly depictoptions_set_highlight_atoms: (a: number, b: number, c: number) => void;
     readonly depictoptions_set_highlight_bonds: (a: number, b: number, c: number) => void;
     readonly depictoptions_set_highlight_color: (a: number, b: number, c: number) => void;
+    readonly depictoptions_set_kekulize: (a: number, b: number) => void;
     readonly depictoptions_set_padding: (a: number, b: number) => void;
+    readonly depictoptions_set_show_atom_indices: (a: number, b: number) => void;
     readonly depictoptions_set_width: (a: number, b: number) => void;
+    readonly detect_functional_groups: (a: number) => [number, number];
     readonly ecfp4_bitvec: (a: number) => [number, number];
+    readonly estate_indices_json: (a: number) => [number, number];
+    readonly gasteiger_charges_json: (a: number) => [number, number];
+    readonly generate_3d_pdb: (a: number) => [number, number];
+    readonly get_atom_info: (a: number, b: number) => [number, number];
+    readonly get_bond_between: (a: number, b: number, c: number) => [number, number];
+    readonly get_bond_info: (a: number, b: number) => [number, number];
+    readonly identify_functional_groups: (a: number) => [number, number];
     readonly is_valid_smiles: (a: number, b: number) => number;
+    readonly match_smarts_smiles: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+    readonly mol_block_from_smiles: (a: number, b: number) => [number, number, number, number];
+    readonly mol_from_sdf_block: (a: number, b: number) => [number, number, number];
     readonly molhandle_aromatic_ring_count: (a: number) => number;
     readonly molhandle_atom_count: (a: number) => number;
     readonly molhandle_bertz_ct: (a: number) => number;
@@ -365,6 +573,8 @@ export interface InitOutput {
     readonly molhandle_labute_asa: (a: number) => number;
     readonly molhandle_lipinski_passes: (a: number) => number;
     readonly molhandle_logp_crippen: (a: number) => number;
+    readonly molhandle_max_estate: (a: number) => number;
+    readonly molhandle_min_estate: (a: number) => number;
     readonly molhandle_molar_refractivity: (a: number) => number;
     readonly molhandle_molecular_weight: (a: number) => number;
     readonly molhandle_morgan_fp_counts_json: (a: number, b: number) => [number, number];
@@ -380,20 +590,32 @@ export interface InitOutput {
     readonly molhandle_reos_passes: (a: number) => number;
     readonly molhandle_ring_count: (a: number) => number;
     readonly molhandle_rotatable_bond_count: (a: number) => number;
+    readonly molhandle_sum_estate: (a: number) => number;
     readonly molhandle_tpsa: (a: number) => number;
     readonly molhandle_veber_passes: (a: number) => number;
     readonly molhandle_wiener_index: (a: number) => number;
     readonly parse_smiles: (a: number, b: number) => [number, number, number];
+    readonly peoe_vsa_json: (a: number) => [number, number];
     readonly remove_hydrogens: (a: number) => number;
     readonly run_reactants: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+    readonly sa_score: (a: number) => number;
+    readonly sdf_to_smiles_json: (a: number, b: number) => [number, number];
+    readonly slogp_vsa_json: (a: number) => [number, number];
+    readonly smarts_match_atoms: (a: number, b: number, c: number) => [number, number, number, number];
+    readonly smiles_to_svg_highlighted: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number, number, number];
+    readonly smr_vsa_json: (a: number) => [number, number];
     readonly tanimoto_atom_pair: (a: number, b: number) => number;
     readonly tanimoto_ecfp4: (a: number, b: number) => number;
     readonly tanimoto_fcfp4: (a: number, b: number) => number;
+    readonly tanimoto_smiles: (a: number, b: number, c: number, d: number) => [number, number, number];
+    readonly tanimoto_topo_path: (a: number, b: number) => number;
     readonly tanimoto_torsion: (a: number, b: number) => number;
-    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly to_mol_block: (a: number) => [number, number];
+    readonly start: () => void;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
     readonly __wbindgen_malloc: (a: number, b: number) => number;
     readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
-    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_externrefs: WebAssembly.Table;
     readonly __externref_table_dealloc: (a: number) => void;
     readonly __wbindgen_start: () => void;
 }

package/chematic_wasm.js

@@ -29,6 +29,24 @@ export class DepictOptions {
         DepictOptionsFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
+    /**
+     * Set a per-atom color override (CSS color string).  Calling multiple times
+     * for the same `idx` uses the last value.  The atom is highlighted even if
+     * not in `set_highlight_atoms`.
+     * @param {number} idx
+     * @param {string} color
+     */
+    set_atom_color(idx, color) {
+        const ptr0 = passStringToWasm0(color, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.depictoptions_set_atom_color(this.__wbg_ptr, idx, ptr0, len0);
+    }
+    /**
+     * @param {boolean} v
+     */
+    set_atom_ids(v) {
+        wasm.depictoptions_set_atom_ids(this.__wbg_ptr, v);
+    }
     /**
      * @param {string} bg
      */
@@ -73,12 +91,24 @@ export class DepictOptions {
         const len0 = WASM_VECTOR_LEN;
         wasm.depictoptions_set_highlight_color(this.__wbg_ptr, ptr0, len0);
     }
+    /**
+     * @param {boolean} v
+     */
+    set_kekulize(v) {
+        wasm.depictoptions_set_kekulize(this.__wbg_ptr, v);
+    }
     /**
      * @param {number} p
      */
     set_padding(p) {
         wasm.depictoptions_set_padding(this.__wbg_ptr, p);
     }
+    /**
+     * @param {boolean} v
+     */
+    set_show_atom_indices(v) {
+        wasm.depictoptions_set_show_atom_indices(this.__wbg_ptr, v);
+    }
     /**
      * @param {number} w
      */
@@ -401,6 +431,22 @@ export class MolHandle {
         const ret = wasm.molhandle_logp_crippen(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * Maximum EState index across all heavy atoms.
+     * @returns {number}
+     */
+    max_estate() {
+        const ret = wasm.molhandle_max_estate(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Minimum EState index across all heavy atoms.
+     * @returns {number}
+     */
+    min_estate() {
+        const ret = wasm.molhandle_min_estate(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * Wildman–Crippen molar refractivity (MR).
      * @returns {number}
@@ -532,6 +578,14 @@ export class MolHandle {
         const ret = wasm.molhandle_rotatable_bond_count(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * Sum of EState indices over all heavy atoms.
+     * @returns {number}
+     */
+    sum_estate() {
+        const ret = wasm.molhandle_sum_estate(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * Topological polar surface area (Ų).
      * @returns {number}
@@ -584,6 +638,35 @@ export function brics_fragment_count(mol) {
     return ret >>> 0;
 }
 
+/**
+ * Render a reaction SMILES string (e.g. `"CC(=O)O.CCO>>CC(=O)OCC.O"`) as a
+ * single SVG showing reactants → products with `+` separators.
+ *
+ * Returns a self-contained SVG string.  Returns a JS error on invalid input.
+ * @param {string} rxn_smiles
+ * @returns {string}
+ */
+export function depict_reaction_svg(rxn_smiles) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(rxn_smiles, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.depict_reaction_svg(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);
+    }
+}
+
 /**
  * Render a grid SVG from newline-separated SMILES (one per line).
  *
@@ -608,6 +691,30 @@ export function depict_svg_grid(smiles_block, cols) {
     }
 }
 
+/**
+ * Detect named functional groups in `mol`.
+ *
+ * Returns a JSON array of `{"name":"hydroxyl","atoms":[3]}` objects.
+ * Multiple matches of the same group (e.g. two hydroxyl groups) each appear
+ * as a separate entry.  Overlapping groups (carboxylic acid → "carboxyl" +
+ * "hydroxyl" + "carbonyl") are all returned.
+ * @param {MolHandle} mol
+ * @returns {string}
+ */
+export function detect_functional_groups(mol) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        _assertClass(mol, MolHandle);
+        const ret = wasm.detect_functional_groups(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);
+    }
+}
+
 /**
  * Compute the ECFP4 fingerprint as a bit-packed byte vector (256 bytes = 2048 bits).
  * @param {MolHandle} mol
@@ -621,6 +728,168 @@ export function ecfp4_bitvec(mol) {
     return v1;
 }
 
+/**
+ * Per-atom EState values as a JSON array of f64.
+ *
+ * Indices match `mol.atoms()` order.  Hydrogen atoms get 0.0.
+ * @param {MolHandle} mol
+ * @returns {string}
+ */
+export function estate_indices_json(mol) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        _assertClass(mol, MolHandle);
+        const ret = wasm.estate_indices_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);
+    }
+}
+
+/**
+ * Gasteiger-Marsili PEOE partial charges as a JSON array of f64.
+ * @param {MolHandle} mol
+ * @returns {string}
+ */
+export function gasteiger_charges_json(mol) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        _assertClass(mol, MolHandle);
+        const ret = wasm.gasteiger_charges_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 for the molecule and return a PDB string.
+ *
+ * Coordinates are generated using distance-geometry placement with ring templates.
+ * Returns heavy-atom PDB (HETATM records, no explicit H).
+ * @param {MolHandle} mol
+ * @returns {string}
+ */
+export function generate_3d_pdb(mol) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        _assertClass(mol, MolHandle);
+        const ret = wasm.generate_3d_pdb(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 information about a single atom as a JSON object.
+ *
+ * `idx` is the 0-based atom index (matching `atoms()` order).
+ * Returns `"null"` if `idx` is out of range.
+ *
+ * Fields: `element` (symbol), `hybridization` ("sp"/"sp2"/"sp3"),
+ * `charge` (formal charge integer), `isAromatic` (bool),
+ * `totalHydrogens` (explicit + implicit H count, integer).
+ * sp3d/sp3d2 (hypervalent P/S) are not distinguished from sp3/sp2.
+ * @param {MolHandle} mol
+ * @param {number} idx
+ * @returns {string}
+ */
+export function get_atom_info(mol, idx) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        _assertClass(mol, MolHandle);
+        const ret = wasm.get_atom_info(mol.__wbg_ptr, idx);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * Return bond information as a JSON object, looked up by the two bonded atom indices.
+ *
+ * Useful when you know the atom indices from SMARTS matching or `data-atom-idx` SVG
+ * attributes but not the bond index.  Returns `"null"` if no bond exists between them.
+ *
+ * Fields: same as `get_bond_info` plus `bondIdx` (u32).
+ * @param {MolHandle} mol
+ * @param {number} atom1
+ * @param {number} atom2
+ * @returns {string}
+ */
+export function get_bond_between(mol, atom1, atom2) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        _assertClass(mol, MolHandle);
+        const ret = wasm.get_bond_between(mol.__wbg_ptr, atom1, atom2);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * Return bond information as a JSON object, looked up by bond index.
+ *
+ * `idx` is the 0-based bond index (order matches `mol.bonds()` iteration).
+ * Returns `"null"` if `idx` is out of range.
+ *
+ * Fields: `bondOrder` (1.0/1.5/2.0/3.0), `isAromatic` (bool),
+ * `isInRing` (bool), `atomFrom` (u32), `atomTo` (u32).
+ * @param {MolHandle} mol
+ * @param {number} idx
+ * @returns {string}
+ */
+export function get_bond_info(mol, idx) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        _assertClass(mol, MolHandle);
+        const ret = wasm.get_bond_info(mol.__wbg_ptr, idx);
+        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"}, …]`
+ * @param {MolHandle} mol
+ * @returns {string}
+ */
+export function identify_functional_groups(mol) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        _assertClass(mol, MolHandle);
+        const ret = wasm.identify_functional_groups(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);
+    }
+}
+
 /**
  * Returns `true` if the SMILES string can be parsed without error.
  * @param {string} s
@@ -633,6 +902,85 @@ export function is_valid_smiles(s) {
     return ret !== 0;
 }
 
+/**
+ * Find all SMARTS matches in a molecule given only SMILES strings.
+ *
+ * Convenience wrapper around `smarts_match_atoms` that accepts raw SMILES
+ * instead of a `MolHandle`.  Returns the same JSON format: `[[0,1],[3,4]]`.
+ * Returns a JS error on SMILES or SMARTS parse failure.
+ * @param {string} smiles
+ * @param {string} smarts
+ * @returns {string}
+ */
+export function match_smarts_smiles(smiles, smarts) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passStringToWasm0(smiles, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(smarts, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.match_smarts_smiles(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);
+    }
+}
+
+/**
+ * Serialize a SMILES string directly to a MOL V2000 block.
+ *
+ * Convenience wrapper; all atom coordinates are 0.0.
+ * Returns a JS error on SMILES parse failure.
+ * @param {string} smiles
+ * @returns {string}
+ */
+export function mol_block_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.mol_block_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);
+    }
+}
+
+/**
+ * Parse a MOL V2000 block and return a `MolHandle`.
+ *
+ * Returns a JS error string on parse failure.
+ * @param {string} block
+ * @returns {MolHandle}
+ */
+export function mol_from_sdf_block(block) {
+    const ptr0 = passStringToWasm0(block, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mol_from_sdf_block(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return MolHandle.__wrap(ret[0]);
+}
+
 /**
  * Parse a SMILES string into a `MolHandle`.
  *
@@ -650,6 +998,25 @@ export function parse_smiles(s) {
     return MolHandle.__wrap(ret[0]);
 }
 
+/**
+ * PEOE_VSA descriptors (14 bins) as a JSON array.
+ * @param {MolHandle} mol
+ * @returns {string}
+ */
+export function peoe_vsa_json(mol) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        _assertClass(mol, MolHandle);
+        const ret = wasm.peoe_vsa_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 a copy of the molecule with all explicit hydrogen atoms removed.
  * @param {MolHandle} mol
@@ -694,6 +1061,154 @@ export function run_reactants(smirks, reactants_smiles) {
     }
 }
 
+/**
+ * Synthetic Accessibility Score (1 = easy, 10 = hard).
+ * @param {MolHandle} mol
+ * @returns {number}
+ */
+export function sa_score(mol) {
+    _assertClass(mol, MolHandle);
+    const ret = wasm.sa_score(mol.__wbg_ptr);
+    return ret;
+}
+
+/**
+ * Parse an SDF string and return a JSON array of canonical SMILES strings.
+ *
+ * Invalid records are represented as `null` in the array.
+ * @param {string} sdf
+ * @returns {string}
+ */
+export function sdf_to_smiles_json(sdf) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(sdf, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.sdf_to_smiles_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);
+    }
+}
+
+/**
+ * SlogP_VSA descriptors (12 bins) as a JSON array.
+ * @param {MolHandle} mol
+ * @returns {string}
+ */
+export function slogp_vsa_json(mol) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        _assertClass(mol, MolHandle);
+        const ret = wasm.slogp_vsa_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 all substructure matches of a SMARTS pattern in `mol`.
+ *
+ * Returns JSON array of arrays of atom indices (sorted, 0-based).
+ * Example: `[[0,1,2],[3,4,5]]` — two matches.
+ * Returns `"[]"` if no match. Returns a JS error on invalid SMARTS.
+ * @param {string} smarts
+ * @param {MolHandle} mol
+ * @returns {string}
+ */
+export function smarts_match_atoms(smarts, mol) {
+    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(ptr0, len0, mol.__wbg_ptr);
+        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);
+    }
+}
+
+/**
+ * Render a highlighted SVG from a SMILES string in one call.
+ *
+ * `atoms` — 0-based atom indices to highlight (Uint32Array in JS).
+ * `bonds` — 0-based bond indices to highlight (Uint32Array in JS).
+ * `color` — CSS color for highlights (e.g. `"#ef4444"`); empty string uses default yellow.
+ *
+ * Returns a JS error on SMILES parse failure.
+ * @param {string} smiles
+ * @param {Uint32Array} atoms
+ * @param {Uint32Array} bonds
+ * @param {string} color
+ * @returns {string}
+ */
+export function smiles_to_svg_highlighted(smiles, atoms, bonds, color) {
+    let deferred6_0;
+    let deferred6_1;
+    try {
+        const ptr0 = passStringToWasm0(smiles, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray32ToWasm0(atoms, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArray32ToWasm0(bonds, wasm.__wbindgen_malloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(color, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ret = wasm.smiles_to_svg_highlighted(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+        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);
+    }
+}
+
+/**
+ * SMR_VSA descriptors (10 bins) as a JSON array.
+ * @param {MolHandle} mol
+ * @returns {string}
+ */
+export function smr_vsa_json(mol) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        _assertClass(mol, MolHandle);
+        const ret = wasm.smr_vsa_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);
+    }
+}
+
+export function start() {
+    wasm.start();
+}
+
 /**
  * Tanimoto similarity between two molecules using AtomPair fingerprints.
  * @param {MolHandle} a
@@ -733,6 +1248,39 @@ export function tanimoto_fcfp4(a, b) {
     return ret;
 }
 
+/**
+ * Tanimoto similarity between two molecules given only SMILES strings (ECFP4).
+ *
+ * Returns a JS error on parse failure.
+ * @param {string} smiles1
+ * @param {string} smiles2
+ * @returns {number}
+ */
+export function tanimoto_smiles(smiles1, smiles2) {
+    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.tanimoto_smiles(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+
+/**
+ * Tanimoto similarity between two molecules using topological path fingerprints.
+ * @param {MolHandle} a
+ * @param {MolHandle} b
+ * @returns {number}
+ */
+export function tanimoto_topo_path(a, b) {
+    _assertClass(a, MolHandle);
+    _assertClass(b, MolHandle);
+    const ret = wasm.tanimoto_topo_path(a.__wbg_ptr, b.__wbg_ptr);
+    return ret;
+}
+
 /**
  * Tanimoto similarity between two molecules using Topological Torsion fingerprints.
  * @param {MolHandle} a
@@ -745,12 +1293,56 @@ export function tanimoto_torsion(a, b) {
     const ret = wasm.tanimoto_torsion(a.__wbg_ptr, b.__wbg_ptr);
     return ret;
 }
+
+/**
+ * Serialize a molecule to a MOL V2000 block.
+ *
+ * All atom coordinates are written as 0.0 (the `Molecule` type has no 2D
+ * coordinate storage; real coordinates would require a separate layout pass).
+ * @param {MolHandle} mol
+ * @returns {string}
+ */
+export function to_mol_block(mol) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        _assertClass(mol, MolHandle);
+        const ret = wasm.to_mol_block(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_throw_1506f2235d1bdba0: 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_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);
+        },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
@@ -790,6 +1382,14 @@ function getArrayU8FromWasm0(ptr, len) {
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
 }
 
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
 function getStringFromWasm0(ptr, len) {
     return decodeText(ptr >>> 0, len);
 }
@@ -894,6 +1494,7 @@ function __wbg_finalize_init(instance, module) {
     wasmInstance = instance;
     wasm = instance.exports;
     wasmModule = module;
+    cachedDataViewMemory0 = null;
     cachedUint32ArrayMemory0 = null;
     cachedUint8ArrayMemory0 = null;
     wasm.__wbindgen_start();

package/package.json

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