@kent-tokyo/chematic 0.17.0 → 0.19.0

package/chematic_wasm.js

@@ -1398,6 +1398,27 @@ export function cdxml_to_smiles_json(cdxml) {
     }
 }
 
+/**
+ * The `chematic-wasm` crate version (matches the workspace release version).
+ *
+ * Lets callers (e.g. the browser playground demo) display the running
+ * version without hardcoding it — `demo/index.html` previously had a
+ * static version string that silently went stale across releases.
+ * @returns {string}
+ */
+export function chematic_version() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.chematic_version();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
 /**
  * CIP stereo assignments via the accurate hierarchical-digraph engine, as a JSON
  * array of `{atomIdx, cipCode}` objects -- same shape as [`cip_assignments_json`],
@@ -1586,6 +1607,71 @@ export function cpk_color(element_symbol) {
     }
 }
 
+/**
+ * Parse a Gaussian Cube file and return its full [`chematic_mol::VolumetricGrid`]
+ * as JSON: `{"origin":[x,y,z],"axes":[[..],[..],[..]],"shape":[nx,ny,nz],
+ * "values":[...flat, row-major third-axis-fastest...],
+ * "atoms":[{"element":"C","charge":6.0,"position":[x,y,z]}],
+ * "units":"bohr"|"angstrom"}`. See module docs for the perf tradeoff of a
+ * full `values` JSON round trip on a large grid.
+ * @param {string} text
+ * @returns {string}
+ */
+export function cube_grid_json(text) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.cube_grid_json(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * `[nx, ny, nz]` for a Gaussian Cube file's grid, as a `Uint32Array`.
+ * @param {string} text
+ * @returns {Uint32Array}
+ */
+export function cube_shape_u32(text) {
+    const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.cube_shape_u32(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Flat `values` from a Gaussian Cube file's grid, as a `Float64Array` --
+ * same data [`cube_grid_json`]'s `"values"` field carries (row-major,
+ * third-axis-fastest order -- see `chematic_mol::volumetric`'s module
+ * docs for the exact index formula), as a real typed array instead of a
+ * JSON number array.
+ * @param {string} text
+ * @returns {Float64Array}
+ */
+export function cube_values_f64(text) {
+    const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.cube_values_f64(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Compute structured depiction data for `mol` as a JSON object.
  *
@@ -2704,6 +2790,221 @@ export function labute_asa_per_atom_json(mol) {
     }
 }
 
+/**
+ * Parse a LAMMPS data file (`read_data` format) and return every section
+ * as JSON: `{"counts":[["atoms",120],["atom types",4],...],
+ * "atom_style":"atomic"|"charge"|"molecular"|"full"|"<other>",
+ * "simulation_box":{"lo":[x,y,z],"hi":[x,y,z],"tilt":[xy,xz,yz]|null},
+ * "masses":[{"atom_type":N,"mass":N}],
+ * "atoms":[{"id":N,"molecule_id":N|null,"atom_type":N,"charge":N|null,"x":N,"y":N,"z":N,"image":[ix,iy,iz]|null}],
+ * "velocities":[{"atom_id":N,"vx":N,"vy":N,"vz":N}],
+ * "bonds":[{"id":N,"bond_type":N,"atom1":N,"atom2":N}],
+ * "unparsed_sections":[["Angles","<raw row text>"],...]}`. `atom_type`
+ * must be exactly `"atomic"`/`"charge"`/`"molecular"`/`"full"` -- LAMMPS's
+ * atom style is not recoverable from the file itself (see
+ * [`chematic_mol::LammpsData`]'s module doc comment); any other value is
+ * rejected with a JS error, matching
+ * [`chematic_mol::LammpsDataError::UnsupportedAtomStyle`].
+ *
+ * This module has no bond-perception step of its own: `Angles`/
+ * `Dihedrals`/`Impropers`/`*Coeffs`/any other section not listed above
+ * are preserved verbatim (byte-for-byte, `#` comments included) in
+ * `unparsed_sections`, not modeled field-by-field.
+ * @param {string} text
+ * @param {string} atom_style
+ * @returns {string}
+ */
+export function lammps_data_to_json(text, atom_style) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(atom_style, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.lammps_data_to_json(ptr0, len0, ptr1, len1);
+        var ptr3 = ret[0];
+        var len3 = ret[1];
+        if (ret[3]) {
+            ptr3 = 0; len3 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
+}
+
+/**
+ * Like [`lammps_dump_cartesian_positions_json`], but returns a flat
+ * `Float64Array` (`[x0,y0,z0,x1,y1,z1,...]`, 3 values per atom) instead
+ * of a JSON `[[x,y,z],...]` array.
+ *
+ * **Behavioral difference from the JSON sibling**: when the frame has no
+ * recognized coordinate columns, [`lammps_dump_cartesian_positions_json`]
+ * returns JSON `null`; a `Float64Array` has no `null`, so this function
+ * returns `Err` instead, with a message naming the columns it looked for.
+ * @param {string} frame_json
+ * @returns {Float64Array}
+ */
+export function lammps_dump_cartesian_positions_f64(frame_json) {
+    const ptr0 = passStringToWasm0(frame_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.lammps_dump_cartesian_positions_f64(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Real Cartesian positions for a LAMMPS dump frame (in the JSON shape
+ * [`lammps_dump_frame_to_json_str`] returns), resolved by delegating
+ * directly to [`chematic_mol::LammpsDumpFrame::cartesian_positions`] --
+ * this function does not reimplement any part of the box-bounds or
+ * scaled-coordinate math itself; that method is the single place this
+ * crate gets the (orthogonal or triclinic) transform right, and every
+ * WASM caller must go through it rather than re-deriving the transform in
+ * JS (the same reasoning behind this crate's OpenDX fail-closed unit
+ * handling and QCSchema's single Bohr<->Ångström conversion point).
+ *
+ * - `x y z` columns: passed straight through.
+ * - `xs ys zs` columns: transformed through `frame.box_bounds` (including
+ *   the triclinic shear terms when a tilt is present).
+ * - Neither present (including an `xu yu zu`-only frame -- "unwrapped" is
+ *   a materially different physical quantity from a scaled coordinate,
+ *   never resolved by this method): returns JSON `null`, not an error and
+ *   not an empty array, matching
+ *   [`chematic_mol::LammpsDumpFrame::cartesian_positions`]'s own
+ *   `Option` semantics exactly.
+ *
+ * Returns JSON `[[x,y,z],...]` on success, in the same atom order as
+ * `frame.rows`. See [`lammps_dump_cartesian_positions_f64`] for a flat
+ * `Float64Array` sibling -- note its `null` case becomes an `Err` there
+ * instead, a disclosed, real API-shape difference (a typed array has no
+ * `null`).
+ * @param {string} frame_json
+ * @returns {string}
+ */
+export function lammps_dump_cartesian_positions_json(frame_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(frame_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.lammps_dump_cartesian_positions_json(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * Parse a single LAMMPS dump/trajectory frame and return it as JSON:
+ * `{"timestep":N,"num_atoms":N,
+ * "box_bounds":{"lo":[x,y,z],"hi":[x,y,z],"tilt":[xy,xz,yz]|null},
+ * "boundary_flags":["pp","pp","pp"],"column_names":[...],
+ * "rows":[[...values, one per column_names entry...],...]}`.
+ * `box_bounds` is already the resolved TRUE simulation box (the parser
+ * applies [`chematic_mol::box_bounds_to_true`] internally before
+ * `LammpsDumpFrame` is ever built) -- not the file's raw
+ * `xlo_bound`/`xhi_bound`/... values. `rows` is the raw per-atom column
+ * data as declared by `column_names`, which may be `x y z`
+ * (already-Cartesian), `xs ys zs` (box-scaled), `xu yu zu` (unwrapped), or
+ * any other dump-command column -- use
+ * [`lammps_dump_cartesian_positions_json`] to resolve real Cartesian
+ * positions from whichever convention is present, rather than
+ * reimplementing that resolution/transform in JS.
+ * @param {string} text
+ * @returns {string}
+ */
+export function lammps_dump_frame_to_json_str(text) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.lammps_dump_frame_to_json_str(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);
+    }
+}
+
+/**
+ * Flattens a LAMMPS dump frame's `rows` (JSON shape
+ * [`lammps_dump_frame_to_json_str`] returns) into a single flat
+ * `Float64Array`, row-major (atom 0's `column_names.len()` values, then
+ * atom 1's, ...). The caller already has `column_names` from
+ * [`lammps_dump_frame_to_json_str`] and can compute the row length
+ * itself (`column_names.length`); no separate row-length accessor is
+ * provided here.
+ * @param {string} frame_json
+ * @returns {Float64Array}
+ */
+export function lammps_dump_rows_f64(frame_json) {
+    const ptr0 = passStringToWasm0(frame_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.lammps_dump_rows_f64(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Parse every frame of a LAMMPS dump/trajectory file and return them as a
+ * JSON array (same per-frame shape as [`lammps_dump_frame_to_json_str`]).
+ *
+ * This reads the whole input, parses it fully, and returns every frame at
+ * once -- [`chematic_mol::LammpsDumpReader`]'s per-frame streaming
+ * iteration (reading one frame at a time from a `BufRead` without holding
+ * the whole trajectory in memory) has no natural equivalent across the
+ * JS/WASM boundary in this first pass and is deliberately not exposed
+ * here, not silently dropped: a JS caller with a truly large trajectory
+ * that needs bounded memory should process it server-side instead.
+ * @param {string} text
+ * @returns {string}
+ */
+export function lammps_trajectory_to_json(text) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.lammps_trajectory_to_json(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
 /**
  * Return the largest fragment of `mol` (salt/solvent stripping).
  *
@@ -2979,8 +3280,13 @@ export function minimize_mmff94_lbfgs_json(mol, max_iter) {
  * `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.
+ * Returns JSON: `{"coords":[[x,y,z],...], "energy":float, "iterations":int, "converged":bool, "sound":bool}`
+ * or `{"error":"<msg>"}` on failure. `sound` is all-finite coordinates and
+ * no bond stretched past a sane covalent-bond length — independent of
+ * `converged`, since steepest descent often reports `converged:false` on
+ * geometries that are perfectly fine but simply haven't hit the tight
+ * RMS-gradient threshold yet. Check `sound`, not just `converged`, before
+ * trusting a result.
  * @param {string} smiles
  * @param {string} coords_json
  * @param {number} max_iter
@@ -3003,6 +3309,66 @@ export function minimize_uff_json(smiles, coords_json, max_iter) {
     }
 }
 
+/**
+ * Cartesian coordinates from an mmCIF file, in the SAME atom order
+ * [`mol_from_mmcif`] returns topology for. Returns JSON `[[x,y,z],...]`
+ * (Å).
+ * @param {string} text
+ * @returns {string}
+ */
+export function mmcif_coords_json(text) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.mmcif_coords_json(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * Parse an mmCIF file and return every `_atom_site` field (occupancy,
+ * B-factor, chain/residue bookkeeping, formal charge, model number, ...),
+ * the unit cell, space group, and any loop column this reader saw but
+ * does not model, as JSON: `{"atoms":[{...}],"cell":{...}|null,
+ * "space_group":"..."|null,"unhandled_columns":[...]}`. See
+ * [`chematic_mol::MmcifAtomRecord`]'s doc comment for each atom field's
+ * exact source column and defaulting rule.
+ * @param {string} text
+ * @returns {string}
+ */
+export function mmcif_to_json(text) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.mmcif_to_json(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
 /**
  * MMFF94 partial charges (BCI table, ±0.1e accuracy) as a JSON array of f64.
  *
@@ -3321,6 +3687,24 @@ export function mol_from_cml(cml) {
     return MolHandle.__wrap(ret[0]);
 }
 
+/**
+ * Parse a Gaussian Cube file and return a `MolHandle` (topology only --
+ * element list, no bonds; Cube carries no bond table). Use
+ * [`cube_grid_json`] to recover coordinates, the scalar field, and the
+ * grid geometry.
+ * @param {string} text
+ * @returns {MolHandle}
+ */
+export function mol_from_cube(text) {
+    const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mol_from_cube(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return MolHandle.__wrap(ret[0]);
+}
+
 /**
  * Parse an Extended XYZ (extxyz) frame and return a `MolHandle` (topology +
  * element/position only; use [`extxyz_frame_json`] to recover coordinates,
@@ -3344,6 +3728,25 @@ export function mol_from_extxyz(text) {
     return MolHandle.__wrap(ret[0]);
 }
 
+/**
+ * Parse an mmCIF file and return a `MolHandle` (topology only -- element
+ * list, no bonds; mmCIF's `_atom_site` category carries no connectivity).
+ * Includes every model's atoms if the file has more than one -- use
+ * [`mmcif_to_json`] to get each atom's `model_num` for filtering. Use
+ * [`mmcif_coords_json`] to recover coordinates in the same atom order.
+ * @param {string} text
+ * @returns {MolHandle}
+ */
+export function mol_from_mmcif(text) {
+    const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mol_from_mmcif(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return MolHandle.__wrap(ret[0]);
+}
+
 /**
  * Parse a MolJSON string into a `MolHandle`.
  *
@@ -3362,6 +3765,28 @@ export function mol_from_moljson(json) {
     return MolHandle.__wrap(ret[0]);
 }
 
+/**
+ * Parse an ORCA input file (`.inp`) and return a `MolHandle` (topology
+ * only -- element list, no bonds; ORCA input carries no bond table).
+ * Returns a JS error unless the file's coordinate block is an embedded
+ * `* xyz ... *` block -- `xyzfile`/`gzmtfile`/`int` (Z-matrix) blocks
+ * carry no atom list to convert, or none is present at all. Use
+ * [`orca_input_coords_json`] to recover coordinates + charge +
+ * multiplicity in the same atom order, or [`orca_input_to_json`] for the
+ * full input (comments/keywords/blocks/any coordinate-block kind).
+ * @param {string} text
+ * @returns {MolHandle}
+ */
+export function mol_from_orca_input(text) {
+    const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mol_from_orca_input(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 -- use [`pdb_coords_json`] to recover them in the SAME atom
@@ -3381,16 +3806,54 @@ export function mol_from_pdb(pdb) {
 }
 
 /**
- * Parse a MOL V2000 block and return a `MolHandle`.
- *
- * Returns a JS error string on parse failure.
- * @param {string} block
+ * Parse a PQR file and return a `MolHandle` (topology only -- element
+ * list inferred per-atom, no bonds; PQR carries no connectivity). Use
+ * [`pqr_coords_json`] to recover coordinates in the same atom order.
+ * @param {string} text
  * @returns {MolHandle}
  */
-export function mol_from_sdf_block(block) {
-    const ptr0 = passStringToWasm0(block, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+export function mol_from_pqr(text) {
+    const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.mol_from_sdf_block(ptr0, len0);
+    const ret = wasm.mol_from_pqr(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return MolHandle.__wrap(ret[0]);
+}
+
+/**
+ * Parse a QCSchema `qcschema_molecule` JSON document and return a
+ * `MolHandle` (topology + `atomic_numbers`-derived isotopes -- no bonds
+ * unless the document's optional `connectivity` list is present, in which
+ * case those bond orders are mapped onto the nearest
+ * [`chematic_core::BondOrder`]). Use [`qcschema_molecule_coords_json`] to
+ * recover coordinates (converted Bohr -> Å) plus molecular
+ * charge/multiplicity, in the same atom order.
+ * @param {string} json
+ * @returns {MolHandle}
+ */
+export function mol_from_qcschema_molecule(json) {
+    const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mol_from_qcschema_molecule(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return MolHandle.__wrap(ret[0]);
+}
+
+/**
+ * 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]);
     }
@@ -3766,6 +4229,162 @@ export function normalize_reaction_smiles(rxn_smiles) {
     }
 }
 
+/**
+ * Parse an OpenDX (APBS scalar-field subset) file and return its full
+ * [`chematic_mol::VolumetricGrid`] as JSON (same shape as
+ * [`cube_grid_json`]; `atoms` is always empty -- OpenDX has no atom
+ * section). No `mol_from_opendx` is provided: an OpenDX grid never carries
+ * atoms, so a `MolHandle` from one would always be empty and is not a
+ * useful binding.
+ * @param {string} text
+ * @returns {string}
+ */
+export function opendx_grid_json(text) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.opendx_grid_json(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * `[nx, ny, nz]` for an OpenDX file's grid, as a `Uint32Array`.
+ * @param {string} text
+ * @returns {Uint32Array}
+ */
+export function opendx_shape_u32(text) {
+    const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.opendx_shape_u32(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Flat `values` from an OpenDX file's grid, as a `Float64Array` -- same
+ * data [`opendx_grid_json`]'s `"values"` field carries.
+ * @param {string} text
+ * @returns {Float64Array}
+ */
+export function opendx_values_f64(text) {
+    const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.opendx_values_f64(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Coordinates + charge + multiplicity from an ORCA input file's embedded
+ * `* xyz ... *` block, in the SAME atom order [`mol_from_orca_input`]
+ * returns topology for. Returns JSON
+ * `{"coords":[[x,y,z],...],"charge":0,"multiplicity":1}`, or a JS error
+ * under the same conditions as [`mol_from_orca_input`].
+ * @param {string} text
+ * @returns {string}
+ */
+export function orca_input_coords_json(text) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.orca_input_coords_json(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * Parse an ORCA input file and return every field as JSON:
+ * `{"comments":[...],"keywords":[...],
+ * "blocks":[{"name":"scf","raw":"...","has_end":true},...],
+ * "coords":{"type":"xyz"|"xyzfile"|"gzmtfile"|"internal",...}|null}`.
+ * See [`chematic_mol::OrcaInput`]'s doc comment for each field's meaning.
+ * @param {string} text
+ * @returns {string}
+ */
+export function orca_input_to_json(text) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.orca_input_to_json(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * Parse an ORCA output file (`.out`/`.log`) and return every extracted
+ * field as JSON: `{"charge":N|null,"multiplicity":N|null,
+ * "final_energy_hartree":N|null,
+ * "trajectory":[{"elements":[...],"coords":[[x,y,z],...]},...],
+ * "frequencies_cm1":[...],
+ * "termination":{"kind":"normal"|"error"|"incomplete","detail":"..."?},
+ * "optimization_convergence":"not_requested"|"converged"|"not_converged"|"unknown"}`.
+ * No writer is provided -- an ORCA output file is a job log, not a
+ * document this crate constructs.
+ * @param {string} text
+ * @returns {string}
+ */
+export function orca_output_to_json(text) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.orca_output_to_json(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
 /**
  * PAINS structural alert names matched by `mol` as a JSON array.
  *
@@ -3970,6 +4589,86 @@ export function pharmacophore_fp_3d_summary(mol) {
     }
 }
 
+/**
+ * Cartesian coordinates from a PQR file, in the SAME atom order
+ * [`mol_from_pqr`] returns topology for. Returns JSON `[[x,y,z],...]` (Å).
+ * @param {string} text
+ * @returns {string}
+ */
+export function pqr_coords_json(text) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.pqr_coords_json(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * Infer an element from a PQR atom name (see
+ * [`chematic_mol::infer_element`]'s doc comment for the heuristic).
+ * Returns `undefined` (JS) / `None` if no element could be inferred.
+ * @param {string} group_pdb
+ * @param {string} res_name
+ * @param {string} atom_name
+ * @returns {string | undefined}
+ */
+export function pqr_infer_element(group_pdb, res_name, atom_name) {
+    const ptr0 = passStringToWasm0(group_pdb, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(res_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(atom_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.pqr_infer_element(ptr0, len0, ptr1, len1, ptr2, len2);
+    let v4;
+    if (ret[0] !== 0) {
+        v4 = getStringFromWasm0(ret[0], ret[1]);
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    }
+    return v4;
+}
+
+/**
+ * Parse a PQR file and return every field (charge, radius, chain,
+ * residue, inferred element, ...) as JSON: `{"atoms":[{...}]}`. See
+ * [`chematic_mol::PqrAtomRecord`]'s doc comment for each field's meaning.
+ * @param {string} text
+ * @returns {string}
+ */
+export function pqr_to_json(text) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.pqr_to_json(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
 /**
  * Predict pKa for all ionizable sites in a molecule.
  *
@@ -3994,6 +4693,97 @@ export function predict_pka_json(smiles) {
     }
 }
 
+/**
+ * Coordinates (Å) plus molecular charge/multiplicity from a QCSchema
+ * `qcschema_molecule` document, in the SAME atom order
+ * [`mol_from_qcschema_molecule`] returns topology for. Returns JSON
+ * `{"coords":[[x,y,z],...],"molecular_charge":0.0,"molecular_multiplicity":1}`.
+ * @param {string} json
+ * @returns {string}
+ */
+export function qcschema_molecule_coords_json(json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.qcschema_molecule_coords_json(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * Parse a QCSchema `qcschema_input`/`qc_schema_input` JSON document
+ * (molecule + driver + model + keywords) and re-emit it, validating and
+ * canonicalizing field defaults in the process (e.g. a missing
+ * `schema_name`/`schema_version` is filled in). Job-level fields
+ * (`driver`, `model`, `keywords`, `protocols`, `extras`) are round-tripped
+ * opaquely -- this binding validates/reformats the document; it does not
+ * expose a separate JS-facing accessor for each field (out of scope for
+ * this first pass, see module docs' "None of these formats carry a bond
+ * table" section for the analogous molecule-centric scope choice made
+ * elsewhere in this file).
+ * @param {string} json
+ * @returns {string}
+ */
+export function qcschema_validate_atomic_input(json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.qcschema_validate_atomic_input(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);
+    }
+}
+
+/**
+ * Like [`qcschema_validate_atomic_input`], for a QCSchema
+ * `qcschema_output`/`qc_schema_output` (`AtomicResult`) document.
+ * @param {string} json
+ * @returns {string}
+ */
+export function qcschema_validate_atomic_result(json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.qcschema_validate_atomic_result(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
 /**
  * Generate `count` random SMILES from a SMILES string using the given seed.
  * Atoms are permuted based on xorshift64 RNG. Each variant should parse back
@@ -5134,6 +5924,41 @@ export function to_moljson(mol) {
     }
 }
 
+/**
+ * Serialize a `MolHandle` + coordinates (Å) + molecular charge/multiplicity
+ * as a QCSchema `qcschema_molecule` JSON document (coordinates converted
+ * to Bohr).
+ *
+ * `coords_json`: `[[x,y,z],...]` (Å), same order and length as `mol`'s
+ * atoms.
+ * @param {MolHandle} mol
+ * @param {string} coords_json
+ * @param {number} charge
+ * @param {bigint} multiplicity
+ * @returns {string}
+ */
+export function to_qcschema_molecule_json(mol, coords_json, charge, multiplicity) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        _assertClass(mol, MolHandle);
+        const ptr0 = passStringToWasm0(coords_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.to_qcschema_molecule_json(mol.__wbg_ptr, ptr0, len0, charge, multiplicity);
+        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);
+    }
+}
+
 /**
  * Serialize a molecule to XYZ format.
  *
@@ -5241,6 +6066,274 @@ export function whim_getaway_combined_json(mol) {
     }
 }
 
+/**
+ * Write a grid (in the JSON shape [`cube_grid_json`] returns) as a
+ * Gaussian Cube file.
+ * @param {string} grid_json
+ * @returns {string}
+ */
+export function write_cube_json(grid_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(grid_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.write_cube_json(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * Write a LAMMPS data file from the JSON shape [`lammps_data_to_json`]
+ * returns.
+ * @param {string} json
+ * @returns {string}
+ */
+export function write_lammps_data_json(json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.write_lammps_data_json(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * Write a single LAMMPS dump frame from the JSON shape
+ * [`lammps_dump_frame_to_json_str`] returns.
+ * @param {string} json
+ * @returns {string}
+ */
+export function write_lammps_dump_frame_json(json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.write_lammps_dump_frame_json(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * Write a LAMMPS trajectory (N frames concatenated back to back, matching
+ * [`chematic_mol::write_lammps_trajectory`]) from a JSON array of frames
+ * in the shape [`lammps_dump_frame_to_json_str`] returns.
+ * @param {string} json
+ * @returns {string}
+ */
+export function write_lammps_trajectory_json(json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.write_lammps_trajectory_json(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * Write an mmCIF file from atom records in the JSON shape
+ * [`mmcif_to_json`]'s `"atoms"` array uses (a full record per atom, not
+ * just element+coordinates -- mmCIF has no equivalent of "build from a
+ * bare `MolHandle`", since occupancy/B-factor/chain/residue fields have no
+ * source in a plain [`MolHandle`]).
+ *
+ * `cell_json`: `"null"` or `{"a":...,"b":...,"c":...,"alpha":...,"beta":...,"gamma":...}`.
+ * `space_group`: pass `""` for none.
+ * @param {string} records_json
+ * @param {string} cell_json
+ * @param {string} space_group
+ * @param {string} data_block_name
+ * @returns {string}
+ */
+export function write_mmcif_json(records_json, cell_json, space_group, data_block_name) {
+    let deferred6_0;
+    let deferred6_1;
+    try {
+        const ptr0 = passStringToWasm0(records_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(cell_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(space_group, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(data_block_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ret = wasm.write_mmcif_json(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);
+    }
+}
+
+/**
+ * Write a grid as an OpenDX file. Fails closed for a
+ * [`chematic_mol::GridUnits::Bohr`]-tagged grid (OpenDX has no unit tag of
+ * its own and is universally read back as Ångström -- see
+ * `chematic_mol::opendx`'s module docs) and for a grid carrying any atoms
+ * (OpenDX has no atom section). Use [`write_opendx_lossy_json`] to opt
+ * into an explicit Bohr->Ångström conversion instead of failing.
+ * @param {string} grid_json
+ * @returns {string}
+ */
+export function write_opendx_json(grid_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(grid_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.write_opendx_json(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * Like [`write_opendx_json`], but a [`chematic_mol::GridUnits::Bohr`] grid
+ * has its `origin`/`axes` explicitly converted to Ångström rather than
+ * rejected (`values` -- the scalar-field samples themselves -- are never
+ * rescaled; see `write_opendx_lossy`'s doc comment). Still fails for a
+ * grid carrying any atoms.
+ * @param {string} grid_json
+ * @returns {string}
+ */
+export function write_opendx_lossy_json(grid_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(grid_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.write_opendx_lossy_json(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * Write an ORCA input file from the JSON shape [`orca_input_to_json`]
+ * returns.
+ * @param {string} json
+ * @returns {string}
+ */
+export function write_orca_input_json(json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.write_orca_input_json(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * Write a PQR file from atom records in the JSON shape [`pqr_to_json`]'s
+ * `"atoms"` array uses. Each atom's `chain_id` independently controls
+ * whether that line is written with or without the (optional) chain
+ * column.
+ * @param {string} records_json
+ * @returns {string}
+ */
+export function write_pqr_json(records_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(records_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.write_pqr_json(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
 /**
  * Non-canonical SMILES for `mol`.
  *
@@ -5324,6 +6417,14 @@ function __wbg_get_imports() {
         __wbg_error_dd408a7b3cb542dd: function(arg0) {
             console.error(arg0);
         },
+        __wbg_new_from_slice_8aed4f0384605526: function(arg0, arg1) {
+            const ret = new Uint32Array(getArrayU32FromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg_new_from_slice_f6e95bc2809a2b07: function(arg0, arg1) {
+            const ret = new Float64Array(getArrayF64FromWasm0(arg0, arg1));
+            return ret;
+        },
         __wbg_now_e7c6795a7f81e10f: function(arg0) {
             const ret = arg0.now();
             return ret;
@@ -5399,6 +6500,16 @@ function _assertClass(instance, klass) {
     }
 }
 
+function getArrayF64FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
+}
+
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
 function getArrayU8FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
@@ -5412,6 +6523,14 @@ function getDataViewMemory0() {
     return cachedDataViewMemory0;
 }
 
+let cachedFloat64ArrayMemory0 = null;
+function getFloat64ArrayMemory0() {
+    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
+        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
+    }
+    return cachedFloat64ArrayMemory0;
+}
+
 function getStringFromWasm0(ptr, len) {
     return decodeText(ptr >>> 0, len);
 }
@@ -5521,6 +6640,7 @@ function __wbg_finalize_init(instance, module) {
     wasm = instance.exports;
     wasmModule = module;
     cachedDataViewMemory0 = null;
+    cachedFloat64ArrayMemory0 = null;
     cachedUint32ArrayMemory0 = null;
     cachedUint8ArrayMemory0 = null;
     wasm.__wbindgen_start();