xtalforge-wasm 1.0.0 → 1.2.0

package/xtalforge_wasm_bg.js

@@ -286,6 +286,48 @@ export class WasmDocument {
 }
 if (Symbol.dispose) WasmDocument.prototype[Symbol.dispose] = WasmDocument.prototype.free;
 
+/**
+ * Adsorption sites as JSON.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid text or tolerance.
+ * @param {string} text
+ * @param {string} format_hint
+ * @param {number} tolerance
+ * @returns {string}
+ */
+export function adsorption_sites(text, format_hint, tolerance) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        const val3 = +tolerance;
+        let ptr0, len0, ptr1, len1;
+        try {
+            ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len0 = WASM_VECTOR_LEN;
+            ptr1 = passStringToWasm0(format_hint, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len1 = WASM_VECTOR_LEN;
+        } catch (e) {
+            if (ptr1) { wasm.__wbindgen_free(ptr1, len1 * 1, 1); }
+            if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 1, 1); }
+            throw e;
+        }
+        const ret = wasm.adsorption_sites(ptr0, len0, ptr1, len1, val3);
+        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);
+    }
+}
+
 /**
  * Runtime capability report as JSON.
  * @returns {string}
@@ -397,6 +439,80 @@ export function asymmetrize_info(text, symprec) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Detects the symmetry and returns the asymmetric unit as CIF.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid text or a failed search.
+ * @param {string} text
+ * @param {number} symprec
+ * @returns {string}
+ */
+export function asymmetrize_text(text, symprec) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const val2 = +symprec;
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.asymmetrize_text(ptr0, len0, val2);
+        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);
+    }
+}
+
+/**
+ * Bond-valence sums as JSON.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid text or cutoff.
+ * @param {string} text
+ * @param {string} format_hint
+ * @param {number} cutoff
+ * @returns {string}
+ */
+export function bond_valence_sums(text, format_hint, cutoff) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        const val3 = +cutoff;
+        let ptr0, len0, ptr1, len1;
+        try {
+            ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len0 = WASM_VECTOR_LEN;
+            ptr1 = passStringToWasm0(format_hint, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len1 = WASM_VECTOR_LEN;
+        } catch (e) {
+            if (ptr1) { wasm.__wbindgen_free(ptr1, len1 * 1, 1); }
+            if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 1, 1); }
+            throw e;
+        }
+        const ret = wasm.bond_valence_sums(ptr0, len0, ptr1, len1, val3);
+        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);
+    }
+}
+
 /**
  * Perceives the bonds of a structure.
  *
@@ -454,6 +570,33 @@ export function build_c20_info() {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Builds C20 and returns it as CIF.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` when the embedded data is invalid.
+ * @returns {string}
+ */
+export function build_c20_text() {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ret = wasm.build_c20_text();
+        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);
+    }
+}
+
 /**
  * Builds C60 and returns its summary.
  *
@@ -470,6 +613,33 @@ export function build_c60_info() {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Builds C60 and returns it as CIF.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` when the embedded data is invalid.
+ * @returns {string}
+ */
+export function build_c60_text() {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ret = wasm.build_c60_text();
+        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);
+    }
+}
+
 /**
  * Builds a disordered carbon from a recipe.
  *
@@ -510,6 +680,45 @@ export function build_carbon_recipe_info(net, repeat_x, repeat_y, repeat_z, dens
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Builds a disordered carbon from a net recipe and returns it as CIF.
+ *
+ * The other recipe fields keep their defaults; `build_carbon_recipe_info`
+ * exposes the full recipe and its statistics.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for an unknown net or invalid options.
+ * @param {string} net
+ * @param {number} repeat
+ * @param {number} density
+ * @param {number} seed
+ * @returns {string}
+ */
+export function build_carbon_text(net, repeat, density, seed) {
+    let deferred6_0;
+    let deferred6_1;
+    try {
+        const val2 = +repeat;
+        const val3 = +density;
+        const val4 = +seed;
+        const ptr0 = passStringToWasm0(net, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.build_carbon_text(ptr0, len0, val2, val3, val4);
+        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);
+    }
+}
+
 /**
  * Builds a graphene sheet and returns its summary.
  *
@@ -531,6 +740,38 @@ export function build_graphene_info(nx, ny, layers, interlayer, vacuum) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Builds a graphene sheet and returns it as CIF.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid repeats or spacing.
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} layers
+ * @param {number} interlayer
+ * @param {number} vacuum
+ * @returns {string}
+ */
+export function build_graphene_text(nx, ny, layers, interlayer, vacuum) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ret = wasm.build_graphene_text(nx, ny, layers, interlayer, vacuum);
+        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);
+    }
+}
+
 /**
  * Builds a framework and returns its summary and warnings.
  *
@@ -565,94 +806,27 @@ export function build_mof_info(topology, node, linker) {
 }
 
 /**
- * Builds a nanotube and returns its summary.
- *
- * # Errors
- *
- * Returns a JavaScript `Error` for a bad chiral vector or length.
- * @param {number} n
- * @param {number} m
- * @param {number} length
- * @param {number} vacuum
- * @returns {any}
- */
-export function build_nanotube_info(n, m, length, vacuum) {
-    const ret = wasm.build_nanotube_info(n, m, length, vacuum);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
-}
-
-/**
- * Volume of a cell in cubic Angstrom.
- *
- * # Errors
- *
- * Returns a JavaScript `Error` whose `code` property is the stable error
- * code from the Rust core.
- * @param {number} a
- * @param {number} b
- * @param {number} c
- * @param {number} alpha
- * @param {number} beta
- * @param {number} gamma
- * @returns {number}
- */
-export function cell_volume(a, b, c, alpha, beta, gamma) {
-    const ret = wasm.cell_volume(a, b, c, alpha, beta, gamma);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return ret[0];
-}
-
-/**
- * Changes the setting of a structure to a Hall number.
- *
- * # Errors
- *
- * Returns a JavaScript `Error` for invalid text or an unknown Hall number.
- * @param {string} text
- * @param {number} hall_number
- * @returns {any}
- */
-export function change_setting_info(text, hall_number) {
-    const val2 = +hall_number;
-    const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.change_setting_info(ptr0, len0, val2);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
-}
-
-/**
- * Converts structure text to another format and returns the file contents.
- *
- * `format_hint` is the input format (`cif`, `poscar` or `xyz`, or empty to
- * detect it) and `format` is the output format (`cif`, `poscar` or `xyz`).
+ * Builds a MOF and returns it as CIF.
  *
  * # Errors
  *
- * Returns a JavaScript `Error` for invalid text or an unknown format.
- * @param {string} text
- * @param {string} format_hint
- * @param {string} format
+ * Returns a JavaScript `Error` for an unknown topology or block.
+ * @param {string} topology
+ * @param {string} node
+ * @param {string} linker
  * @returns {string}
  */
-export function convert_structure(text, format_hint, format) {
+export function build_mof_text(topology, node, linker) {
     let deferred5_0;
     let deferred5_1;
     try {
         let ptr0, len0, ptr1, len1, ptr2, len2;
         try {
-            ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            ptr0 = passStringToWasm0(topology, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
             len0 = WASM_VECTOR_LEN;
-            ptr1 = passStringToWasm0(format_hint, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            ptr1 = passStringToWasm0(node, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
             len1 = WASM_VECTOR_LEN;
-            ptr2 = passStringToWasm0(format, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            ptr2 = passStringToWasm0(linker, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
             len2 = WASM_VECTOR_LEN;
         } catch (e) {
             if (ptr2) { wasm.__wbindgen_free(ptr2, len2 * 1, 1); }
@@ -660,7 +834,7 @@ export function convert_structure(text, format_hint, format) {
             if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 1, 1); }
             throw e;
         }
-        const ret = wasm.convert_structure(ptr0, len0, ptr1, len1, ptr2, len2);
+        const ret = wasm.build_mof_text(ptr0, len0, ptr1, len1, ptr2, len2);
         var ptr4 = ret[0];
         var len4 = ret[1];
         if (ret[3]) {
@@ -676,10 +850,463 @@ export function convert_structure(text, format_hint, format) {
 }
 
 /**
- * Detects the space group and returns the dataset as a JS object.
+ * Builds a nanotube and returns its summary.
  *
- * The object carries `number`, `hall_number`, `hm_symbol`, `pearson_symbol`,
- * `operations` (rotation, translation, triplet), `orbits`, `wyckoffs`,
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for a bad chiral vector or length.
+ * @param {number} n
+ * @param {number} m
+ * @param {number} length
+ * @param {number} vacuum
+ * @returns {any}
+ */
+export function build_nanotube_info(n, m, length, vacuum) {
+    const ret = wasm.build_nanotube_info(n, m, length, vacuum);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Builds a nanotube and returns it as CIF.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for a bad chiral vector or length.
+ * @param {number} n
+ * @param {number} m
+ * @param {number} length
+ * @param {number} vacuum
+ * @returns {string}
+ */
+export function build_nanotube_text(n, m, length, vacuum) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ret = wasm.build_nanotube_text(n, m, length, vacuum);
+        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);
+    }
+}
+
+/**
+ * Builds a polymer chain and returns it as CIF.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for an invalid SMILES or density.
+ * @param {string} smiles
+ * @param {number} monomers
+ * @param {number} density
+ * @returns {string}
+ */
+export function build_polymer_text(smiles, monomers, density) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        const val2 = +monomers;
+        const val3 = +density;
+        const ptr0 = passStringToWasm0(smiles, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.build_polymer_text(ptr0, len0, val2, val3);
+        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);
+    }
+}
+
+/**
+ * Builds a honeycomb nanoribbon and returns it as CIF.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid dimensions.
+ * @param {number} width
+ * @param {number} length
+ * @param {number} vacuum
+ * @returns {string}
+ */
+export function build_ribbon_text(width, length, vacuum) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ret = wasm.build_ribbon_text(width, length, vacuum);
+        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);
+    }
+}
+
+/**
+ * Builds a Schwarz P carbon model and returns it as CIF.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid options.
+ * @param {number} samples
+ * @param {number} cell
+ * @param {number} isovalue
+ * @returns {string}
+ */
+export function build_schwarzite_text(samples, cell, isovalue) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ret = wasm.build_schwarzite_text(samples, cell, isovalue);
+        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);
+    }
+}
+
+/**
+ * Builds two twisted graphene layers and returns them as CIF.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid repeats or angle.
+ * @param {number} n
+ * @param {number} m
+ * @param {number} theta
+ * @param {number} layers
+ * @returns {string}
+ */
+export function build_twist_text(n, m, theta, layers) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ret = wasm.build_twist_text(n, m, theta, layers);
+        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);
+    }
+}
+
+/**
+ * Builds a gyroid ZTC carbon model and returns it as CIF.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid options.
+ * @param {number} samples
+ * @param {number} cell
+ * @param {number} isovalue
+ * @returns {string}
+ */
+export function build_ztc_text(samples, cell, isovalue) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ret = wasm.build_ztc_text(samples, cell, isovalue);
+        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);
+    }
+}
+
+/**
+ * Volume of a cell in cubic Angstrom.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` whose `code` property is the stable error
+ * code from the Rust core.
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @param {number} alpha
+ * @param {number} beta
+ * @param {number} gamma
+ * @returns {number}
+ */
+export function cell_volume(a, b, c, alpha, beta, gamma) {
+    const ret = wasm.cell_volume(a, b, c, alpha, beta, gamma);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+
+/**
+ * Changes the setting of a structure to a Hall number.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid text or an unknown Hall number.
+ * @param {string} text
+ * @param {number} hall_number
+ * @returns {any}
+ */
+export function change_setting_info(text, hall_number) {
+    const val2 = +hall_number;
+    const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.change_setting_info(ptr0, len0, val2);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Changes the space-group setting and returns the result as CIF.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid text or a Hall number out of range.
+ * @param {string} text
+ * @param {number} hall_number
+ * @returns {string}
+ */
+export function change_setting_text(text, hall_number) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const val2 = +hall_number;
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.change_setting_text(ptr0, len0, val2);
+        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);
+    }
+}
+
+/**
+ * Converts structure text to another format and returns the file contents.
+ *
+ * `format_hint` is the input format (`cif`, `poscar` or `xyz`, or empty to
+ * detect it) and `format` is the output format (`cif`, `poscar` or `xyz`).
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid text or an unknown format.
+ * @param {string} text
+ * @param {string} format_hint
+ * @param {string} format
+ * @returns {string}
+ */
+export function convert_structure(text, format_hint, format) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        let ptr0, len0, ptr1, len1, ptr2, len2;
+        try {
+            ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len0 = WASM_VECTOR_LEN;
+            ptr1 = passStringToWasm0(format_hint, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len1 = WASM_VECTOR_LEN;
+            ptr2 = passStringToWasm0(format, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len2 = WASM_VECTOR_LEN;
+        } catch (e) {
+            if (ptr2) { wasm.__wbindgen_free(ptr2, len2 * 1, 1); }
+            if (ptr1) { wasm.__wbindgen_free(ptr1, len1 * 1, 1); }
+            if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 1, 1); }
+            throw e;
+        }
+        const ret = wasm.convert_structure(ptr0, len0, ptr1, len1, 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);
+    }
+}
+
+/**
+ * Convex hull as JSON from a JSON list of phases.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for an invalid phase list.
+ * @param {string} entries_json
+ * @returns {string}
+ */
+export function convex_hull(entries_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(entries_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.convex_hull(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);
+    }
+}
+
+/**
+ * Coordination shell and shape measures as JSON.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid text or an out-of-range index.
+ * @param {string} text
+ * @param {string} format_hint
+ * @param {number} index
+ * @param {string} strategy
+ * @param {number} cutoff
+ * @param {number} solid_angle
+ * @returns {string}
+ */
+export function coordination(text, format_hint, index, strategy, cutoff, solid_angle) {
+    let deferred8_0;
+    let deferred8_1;
+    try {
+        const val4 = +index;
+        const val5 = +cutoff;
+        const val6 = +solid_angle;
+        let ptr0, len0, ptr1, len1, ptr2, len2;
+        try {
+            ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len0 = WASM_VECTOR_LEN;
+            ptr1 = passStringToWasm0(format_hint, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len1 = WASM_VECTOR_LEN;
+            ptr2 = passStringToWasm0(strategy, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len2 = WASM_VECTOR_LEN;
+        } catch (e) {
+            if (ptr2) { wasm.__wbindgen_free(ptr2, len2 * 1, 1); }
+            if (ptr1) { wasm.__wbindgen_free(ptr1, len1 * 1, 1); }
+            if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 1, 1); }
+            throw e;
+        }
+        const ret = wasm.coordination(ptr0, len0, ptr1, len1, val4, ptr2, len2, val5, val6);
+        var ptr7 = ret[0];
+        var len7 = ret[1];
+        if (ret[3]) {
+            ptr7 = 0; len7 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred8_0 = ptr7;
+        deferred8_1 = len7;
+        return getStringFromWasm0(ptr7, len7);
+    } finally {
+        wasm.__wbindgen_free(deferred8_0, deferred8_1, 1);
+    }
+}
+
+/**
+ * Applies a strain, gradient, volume or density and returns structure JSON.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid text or deformation options.
+ * @param {string} text
+ * @param {string} format_hint
+ * @param {string} options_json
+ * @returns {string}
+ */
+export function deform(text, format_hint, options_json) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        let ptr0, len0, ptr1, len1, ptr2, len2;
+        try {
+            ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len0 = WASM_VECTOR_LEN;
+            ptr1 = passStringToWasm0(format_hint, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len1 = WASM_VECTOR_LEN;
+            ptr2 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len2 = WASM_VECTOR_LEN;
+        } catch (e) {
+            if (ptr2) { wasm.__wbindgen_free(ptr2, len2 * 1, 1); }
+            if (ptr1) { wasm.__wbindgen_free(ptr1, len1 * 1, 1); }
+            if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 1, 1); }
+            throw e;
+        }
+        const ret = wasm.deform(ptr0, len0, ptr1, len1, 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);
+    }
+}
+
+/**
+ * Detects the space group and returns the dataset as a JS object.
+ *
+ * The object carries `number`, `hall_number`, `hm_symbol`, `pearson_symbol`,
+ * `operations` (rotation, translation, triplet), `orbits`, `wyckoffs`,
  * `site_symmetry_symbols`, `std_lattice`, `std_positions`,
  * `std_origin_shift` and `std_rotation_matrix`.
  *
@@ -728,30 +1355,116 @@ export function diagnose_info(text, symbol) {
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
-    return takeFromExternrefTable0(ret[0]);
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Minimum-image distance between two P1 atoms, in Angstrom.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid text or an out-of-range index.
+ * @param {string} text
+ * @param {number} i
+ * @param {number} j
+ * @returns {number}
+ */
+export function distance(text, i, j) {
+    const val2 = +i;
+    const val3 = +j;
+    const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.distance(ptr0, len0, val2, val3);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+
+/**
+ * Site edits; returns structure JSON.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid text or edit options.
+ * @param {string} text
+ * @param {string} format_hint
+ * @param {string} options_json
+ * @returns {string}
+ */
+export function edit_structure(text, format_hint, options_json) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        let ptr0, len0, ptr1, len1, ptr2, len2;
+        try {
+            ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len0 = WASM_VECTOR_LEN;
+            ptr1 = passStringToWasm0(format_hint, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len1 = WASM_VECTOR_LEN;
+            ptr2 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len2 = WASM_VECTOR_LEN;
+        } catch (e) {
+            if (ptr2) { wasm.__wbindgen_free(ptr2, len2 * 1, 1); }
+            if (ptr1) { wasm.__wbindgen_free(ptr1, len1 * 1, 1); }
+            if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 1, 1); }
+            throw e;
+        }
+        const ret = wasm.edit_structure(ptr0, len0, ptr1, len1, 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);
+    }
 }
 
 /**
- * Minimum-image distance between two P1 atoms, in Angstrom.
+ * Elastic tensor from UFF stress finite differences as JSON.
  *
  * # Errors
  *
- * Returns a JavaScript `Error` for invalid text or an out-of-range index.
+ * Returns a JavaScript `Error` for invalid text or strain.
  * @param {string} text
- * @param {number} i
- * @param {number} j
- * @returns {number}
+ * @param {string} format_hint
+ * @param {number} strain
+ * @returns {string}
  */
-export function distance(text, i, j) {
-    const val2 = +i;
-    const val3 = +j;
-    const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.distance(ptr0, len0, val2, val3);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
+export function elastic_tensor(text, format_hint, strain) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        const val3 = +strain;
+        let ptr0, len0, ptr1, len1;
+        try {
+            ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len0 = WASM_VECTOR_LEN;
+            ptr1 = passStringToWasm0(format_hint, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len1 = WASM_VECTOR_LEN;
+        } catch (e) {
+            if (ptr1) { wasm.__wbindgen_free(ptr1, len1 * 1, 1); }
+            if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 1, 1); }
+            throw e;
+        }
+        const ret = wasm.elastic_tensor(ptr0, len0, ptr1, len1, val3);
+        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);
     }
-    return ret[0];
 }
 
 /**
@@ -775,7 +1488,37 @@ export function element_info(input) {
 }
 
 /**
- * Returns QEq or EQeq charges.
+ * Equation-of-state fit as JSON.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for an unknown model or too few points.
+ * @param {string} options_json
+ * @returns {string}
+ */
+export function eos_fit(options_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.eos_fit(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);
+    }
+}
+
+/**
+ * Returns QEq, EQeq or EEQ2019 charges (`qeq`, `eqeq`, `eeq`).
  *
  * # Errors
  *
@@ -880,6 +1623,52 @@ export function ff_optimize_info(text, minimizer, max_steps, force_tolerance, ce
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Relaxes a structure and returns the result as CIF.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid text or an unknown minimizer.
+ * @param {string} text
+ * @param {string} minimizer
+ * @param {number} max_steps
+ * @param {number} force_tolerance
+ * @param {boolean} cell
+ * @returns {string}
+ */
+export function ff_optimize_text(text, minimizer, max_steps, force_tolerance, cell) {
+    let deferred7_0;
+    let deferred7_1;
+    try {
+        const val3 = +max_steps;
+        const val4 = +force_tolerance;
+        const val5 = +cell;
+        let ptr0, len0, ptr1, len1;
+        try {
+            ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len0 = WASM_VECTOR_LEN;
+            ptr1 = passStringToWasm0(minimizer, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len1 = WASM_VECTOR_LEN;
+        } catch (e) {
+            if (ptr1) { wasm.__wbindgen_free(ptr1, len1 * 1, 1); }
+            if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 1, 1); }
+            throw e;
+        }
+        const ret = wasm.ff_optimize_text(ptr0, len0, ptr1, len1, val3, val4, val5);
+        var ptr6 = ret[0];
+        var len6 = ret[1];
+        if (ret[3]) {
+            ptr6 = 0; len6 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred7_0 = ptr6;
+        deferred7_1 = len6;
+        return getStringFromWasm0(ptr6, len6);
+    } finally {
+        wasm.__wbindgen_free(deferred7_0, deferred7_1, 1);
+    }
+}
+
 /**
  * Runs the preparation pipeline and returns its report.
  *
@@ -976,6 +1765,87 @@ export function ff_vibrations_info(text, step) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Similarity of two fingerprints.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid text.
+ * @param {string} first
+ * @param {string} second
+ * @param {string} format_hint
+ * @param {number} r_max
+ * @param {number} bin_width
+ * @returns {number}
+ */
+export function fingerprint_similarity(first, second, format_hint, r_max, bin_width) {
+    const val4 = +r_max;
+    const val5 = +bin_width;
+    let ptr0, len0, ptr1, len1, ptr2, len2;
+    try {
+        ptr0 = passStringToWasm0(first, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        len0 = WASM_VECTOR_LEN;
+        ptr1 = passStringToWasm0(second, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        len1 = WASM_VECTOR_LEN;
+        ptr2 = passStringToWasm0(format_hint, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        len2 = WASM_VECTOR_LEN;
+    } catch (e) {
+        if (ptr2) { wasm.__wbindgen_free(ptr2, len2 * 1, 1); }
+        if (ptr1) { wasm.__wbindgen_free(ptr1, len1 * 1, 1); }
+        if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 1, 1); }
+        throw e;
+    }
+    const ret = wasm.fingerprint_similarity(ptr0, len0, ptr1, len1, ptr2, len2, val4, val5);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+
+/**
+ * Equality classes of a list of structure texts.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid text.
+ * @param {string[]} structures
+ * @param {string} format_hint
+ * @param {string} options_json
+ * @returns {string}
+ */
+export function group_structures(structures, format_hint, options_json) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        let ptr0, len0, ptr1, len1, ptr2, len2;
+        try {
+            ptr0 = passArrayJsValueToWasm0(structures, wasm.__wbindgen_malloc);
+            len0 = WASM_VECTOR_LEN;
+            ptr1 = passStringToWasm0(format_hint, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len1 = WASM_VECTOR_LEN;
+            ptr2 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len2 = WASM_VECTOR_LEN;
+        } catch (e) {
+            if (ptr2) { wasm.__wbindgen_free(ptr2, len2 * 1, 1); }
+            if (ptr1) { wasm.__wbindgen_free(ptr1, len1 * 1, 1); }
+            if (ptr0) { wasm.__externref_drop_slice(ptr0, len0); wasm.__wbindgen_free(ptr0, len0 * 4, 4); }
+            throw e;
+        }
+        const ret = wasm.group_structures(ptr0, len0, ptr1, len1, 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);
+    }
+}
+
 /**
  * Finds the functional groups of a structure.
  *
@@ -1016,7 +1886,178 @@ export function hydrogens_info(text, distance) {
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
-    return takeFromExternrefTable0(ret[0]);
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Adds hydrogens at the missing valences and returns the result as CIF.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid text or a bad distance.
+ * @param {string} text
+ * @param {number} distance
+ * @returns {string}
+ */
+export function hydrogens_text(text, distance) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const val2 = +distance;
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.hydrogens_text(ptr0, len0, val2);
+        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);
+    }
+}
+
+/**
+ * Linear interpolation between matched structures; returns a JSON array of
+ * structure documents.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` when the structures do not match.
+ * @param {string} first
+ * @param {string} second
+ * @param {number} images
+ * @param {string} format_hint
+ * @param {string} options_json
+ * @returns {string}
+ */
+export function interpolate(first, second, images, format_hint, options_json) {
+    let deferred7_0;
+    let deferred7_1;
+    try {
+        const val5 = +images;
+        let ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3;
+        try {
+            ptr0 = passStringToWasm0(first, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len0 = WASM_VECTOR_LEN;
+            ptr1 = passStringToWasm0(second, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len1 = WASM_VECTOR_LEN;
+            ptr2 = passStringToWasm0(format_hint, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len2 = WASM_VECTOR_LEN;
+            ptr3 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len3 = WASM_VECTOR_LEN;
+        } catch (e) {
+            if (ptr3) { wasm.__wbindgen_free(ptr3, len3 * 1, 1); }
+            if (ptr2) { wasm.__wbindgen_free(ptr2, len2 * 1, 1); }
+            if (ptr1) { wasm.__wbindgen_free(ptr1, len1 * 1, 1); }
+            if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 1, 1); }
+            throw e;
+        }
+        const ret = wasm.interpolate(ptr0, len0, ptr1, len1, val5, ptr2, len2, ptr3, len3);
+        var ptr6 = ret[0];
+        var len6 = ret[1];
+        if (ret[3]) {
+            ptr6 = 0; len6 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred7_0 = ptr6;
+        deferred7_1 = len6;
+        return getStringFromWasm0(ptr6, len6);
+    } finally {
+        wasm.__wbindgen_free(deferred7_0, deferred7_1, 1);
+    }
+}
+
+/**
+ * Interstitial candidates as JSON.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid text or options.
+ * @param {string} text
+ * @param {string} format_hint
+ * @param {string} species
+ * @param {string} options_json
+ * @returns {string}
+ */
+export function interstitials(text, format_hint, species, options_json) {
+    let deferred6_0;
+    let deferred6_1;
+    try {
+        let ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3;
+        try {
+            ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len0 = WASM_VECTOR_LEN;
+            ptr1 = passStringToWasm0(format_hint, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len1 = WASM_VECTOR_LEN;
+            ptr2 = passStringToWasm0(species, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len2 = WASM_VECTOR_LEN;
+            ptr3 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len3 = WASM_VECTOR_LEN;
+        } catch (e) {
+            if (ptr3) { wasm.__wbindgen_free(ptr3, len3 * 1, 1); }
+            if (ptr2) { wasm.__wbindgen_free(ptr2, len2 * 1, 1); }
+            if (ptr1) { wasm.__wbindgen_free(ptr1, len1 * 1, 1); }
+            if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 1, 1); }
+            throw e;
+        }
+        const ret = wasm.interstitials(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);
+    }
+}
+
+/**
+ * Kabsch alignment; points are a flat `xyzxyz...` array.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for mismatched or non-finite point sets.
+ * @param {Float64Array | number[]} points
+ * @param {Float64Array | number[]} reference
+ * @returns {string}
+ */
+export function kabsch_alignment(points, reference) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        let ptr0, len0, ptr1, len1;
+        try {
+            ptr0 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
+            len0 = WASM_VECTOR_LEN;
+            ptr1 = passArrayF64ToWasm0(reference, wasm.__wbindgen_malloc);
+            len1 = WASM_VECTOR_LEN;
+        } catch (e) {
+            if (ptr1) { wasm.__wbindgen_free(ptr1, len1 * 8, 8); }
+            if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 8, 8); }
+            throw e;
+        }
+        const ret = wasm.kabsch_alignment(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);
+    }
 }
 
 /**
@@ -1061,6 +2102,54 @@ export function lattice_info(a, b, c, alpha, beta, gamma) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Commensurate 2D lattice matches as JSON.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid text or options.
+ * @param {string} film
+ * @param {string} substrate
+ * @param {string} format_hint
+ * @param {string} options_json
+ * @returns {string}
+ */
+export function lattice_matches(film, substrate, format_hint, options_json) {
+    let deferred6_0;
+    let deferred6_1;
+    try {
+        let ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3;
+        try {
+            ptr0 = passStringToWasm0(film, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len0 = WASM_VECTOR_LEN;
+            ptr1 = passStringToWasm0(substrate, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len1 = WASM_VECTOR_LEN;
+            ptr2 = passStringToWasm0(format_hint, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len2 = WASM_VECTOR_LEN;
+            ptr3 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len3 = WASM_VECTOR_LEN;
+        } catch (e) {
+            if (ptr3) { wasm.__wbindgen_free(ptr3, len3 * 1, 1); }
+            if (ptr2) { wasm.__wbindgen_free(ptr2, len2 * 1, 1); }
+            if (ptr1) { wasm.__wbindgen_free(ptr1, len1 * 1, 1); }
+            if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 1, 1); }
+            throw e;
+        }
+        const ret = wasm.lattice_matches(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);
+    }
+}
+
 /**
  * Minimum-image fractional vector and distance.
  *
@@ -1198,6 +2287,40 @@ export function lower_to_subgroup_info(text, subgroup, tolerance) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Lowers a structure to a subgroup and returns it as CIF.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid text or an unknown subgroup.
+ * @param {string} text
+ * @param {number} subgroup_number
+ * @param {number} tolerance
+ * @returns {string}
+ */
+export function lower_to_subgroup_text(text, subgroup_number, tolerance) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        const val2 = +subgroup_number;
+        const val3 = +tolerance;
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.lower_to_subgroup_text(ptr0, len0, val2, val3);
+        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);
+    }
+}
+
 /**
  * Detects the collinear magnetic space group (experimental).
  *
@@ -1219,6 +2342,54 @@ export function magnetic_group_info(text, symprec) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Matches two structures and returns the match record as JSON.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid text or tolerances.
+ * @param {string} first
+ * @param {string} second
+ * @param {string} format_hint
+ * @param {string} options_json
+ * @returns {string}
+ */
+export function match_structures(first, second, format_hint, options_json) {
+    let deferred6_0;
+    let deferred6_1;
+    try {
+        let ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3;
+        try {
+            ptr0 = passStringToWasm0(first, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len0 = WASM_VECTOR_LEN;
+            ptr1 = passStringToWasm0(second, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len1 = WASM_VECTOR_LEN;
+            ptr2 = passStringToWasm0(format_hint, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len2 = WASM_VECTOR_LEN;
+            ptr3 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len3 = WASM_VECTOR_LEN;
+        } catch (e) {
+            if (ptr3) { wasm.__wbindgen_free(ptr3, len3 * 1, 1); }
+            if (ptr2) { wasm.__wbindgen_free(ptr2, len2 * 1, 1); }
+            if (ptr1) { wasm.__wbindgen_free(ptr1, len1 * 1, 1); }
+            if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 1, 1); }
+            throw e;
+        }
+        const ret = wasm.match_structures(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);
+    }
+}
+
 /**
  * Builds an ASCII STL string.
  *
@@ -1290,27 +2461,195 @@ export function mof_topologies_info() {
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
-    return takeFromExternrefTable0(ret[0]);
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Finds the periodic neighbors within `cutoff` Angstrom.
+ *
+ * Each element has `i`, `j`, `image` (the lattice translation of `j`) and
+ * `distance`.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid text or a non-positive cutoff.
+ * @param {string} text
+ * @param {number} cutoff
+ * @returns {Array<any>}
+ */
+export function neighbors(text, cutoff) {
+    const val2 = +cutoff;
+    const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.neighbors(ptr0, len0, val2);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Returns the invariants of every CGD entry.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for an invalid net.
+ * @param {string} text
+ * @param {number} tolerance
+ * @returns {Array<any>}
+ */
+export function net_invariants_info(text, tolerance) {
+    const val2 = +tolerance;
+    const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.net_invariants_info(ptr0, len0, val2);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Supercell closest to a cube; returns structure JSON.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for an invalid cell count.
+ * @param {string} text
+ * @param {number} cells
+ * @param {string} format_hint
+ * @returns {string}
+ */
+export function optimal_supercell(text, cells, format_hint) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        const val3 = +cells;
+        let ptr0, len0, ptr1, len1;
+        try {
+            ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len0 = WASM_VECTOR_LEN;
+            ptr1 = passStringToWasm0(format_hint, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len1 = WASM_VECTOR_LEN;
+        } catch (e) {
+            if (ptr1) { wasm.__wbindgen_free(ptr1, len1 * 1, 1); }
+            if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 1, 1); }
+            throw e;
+        }
+        const ret = wasm.optimal_supercell(ptr0, len0, val3, ptr1, len1);
+        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);
+    }
+}
+
+/**
+ * Orderings of partial occupancies as JSON.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for a structure without partial occupancy.
+ * @param {string} text
+ * @param {string} format_hint
+ * @param {string} options_json
+ * @returns {string}
+ */
+export function orderings(text, format_hint, options_json) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        let ptr0, len0, ptr1, len1, ptr2, len2;
+        try {
+            ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len0 = WASM_VECTOR_LEN;
+            ptr1 = passStringToWasm0(format_hint, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len1 = WASM_VECTOR_LEN;
+            ptr2 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len2 = WASM_VECTOR_LEN;
+        } catch (e) {
+            if (ptr2) { wasm.__wbindgen_free(ptr2, len2 * 1, 1); }
+            if (ptr1) { wasm.__wbindgen_free(ptr1, len1 * 1, 1); }
+            if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 1, 1); }
+            throw e;
+        }
+        const ret = wasm.orderings(ptr0, len0, ptr1, len1, 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);
+    }
+}
+
+/**
+ * Oxidation states as JSON.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid text or cutoff.
+ * @param {string} text
+ * @param {string} format_hint
+ * @param {number} cutoff
+ * @returns {string}
+ */
+export function oxidation_states(text, format_hint, cutoff) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        const val3 = +cutoff;
+        let ptr0, len0, ptr1, len1;
+        try {
+            ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len0 = WASM_VECTOR_LEN;
+            ptr1 = passStringToWasm0(format_hint, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len1 = WASM_VECTOR_LEN;
+        } catch (e) {
+            if (ptr1) { wasm.__wbindgen_free(ptr1, len1 * 1, 1); }
+            if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 1, 1); }
+            throw e;
+        }
+        const ret = wasm.oxidation_states(ptr0, len0, ptr1, len1, val3);
+        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);
+    }
 }
 
 /**
- * Finds the periodic neighbors within `cutoff` Angstrom.
- *
- * Each element has `i`, `j`, `image` (the lattice translation of `j`) and
- * `distance`.
+ * Returns the JSON schema of a built-in parameter preset.
  *
  * # Errors
  *
- * Returns a JavaScript `Error` for invalid text or a non-positive cutoff.
- * @param {string} text
- * @param {number} cutoff
- * @returns {Array<any>}
+ * Returns a JavaScript `Error` for an unknown preset.
+ * @param {string} name
+ * @returns {any}
  */
-export function neighbors(text, cutoff) {
-    const val2 = +cutoff;
-    const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+export function param_schema(name) {
+    const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.neighbors(ptr0, len0, val2);
+    const ret = wasm.param_schema(ptr0, len0);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1318,43 +2657,88 @@ export function neighbors(text, cutoff) {
 }
 
 /**
- * Returns the invariants of every CGD entry.
+ * Periodic RMSD for an explicit atom mapping.
  *
  * # Errors
  *
- * Returns a JavaScript `Error` for an invalid net.
- * @param {string} text
- * @param {number} tolerance
- * @returns {Array<any>}
+ * Returns a JavaScript `Error` for invalid text or an incomplete mapping.
+ * @param {string} first
+ * @param {string} second
+ * @param {Uint32Array | number[]} mapping
+ * @param {string} format_hint
+ * @returns {number}
  */
-export function net_invariants_info(text, tolerance) {
-    const val2 = +tolerance;
-    const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.net_invariants_info(ptr0, len0, val2);
+export function periodic_rmsd(first, second, mapping, format_hint) {
+    let ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3;
+    try {
+        ptr0 = passStringToWasm0(first, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        len0 = WASM_VECTOR_LEN;
+        ptr1 = passStringToWasm0(second, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        len1 = WASM_VECTOR_LEN;
+        ptr2 = passArray32ToWasm0(mapping, wasm.__wbindgen_malloc);
+        len2 = WASM_VECTOR_LEN;
+        ptr3 = passStringToWasm0(format_hint, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        len3 = WASM_VECTOR_LEN;
+    } catch (e) {
+        if (ptr3) { wasm.__wbindgen_free(ptr3, len3 * 1, 1); }
+        if (ptr2) { wasm.__wbindgen_free(ptr2, len2 * 4, 4); }
+        if (ptr1) { wasm.__wbindgen_free(ptr1, len1 * 1, 1); }
+        if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 1, 1); }
+        throw e;
+    }
+    const ret = wasm.periodic_rmsd(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
-    return takeFromExternrefTable0(ret[0]);
+    return ret[0];
 }
 
 /**
- * Returns the JSON schema of a built-in parameter preset.
+ * Places a molecule on an adsorption site and returns structure JSON.
  *
  * # Errors
  *
- * Returns a JavaScript `Error` for an unknown preset.
- * @param {string} name
- * @returns {any}
+ * Returns a JavaScript `Error` for invalid text or an out-of-range site.
+ * @param {string} slab
+ * @param {string} molecule
+ * @param {string} format_hint
+ * @param {string} options_json
+ * @returns {string}
  */
-export function param_schema(name) {
-    const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.param_schema(ptr0, len0);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
+export function place_molecule(slab, molecule, format_hint, options_json) {
+    let deferred6_0;
+    let deferred6_1;
+    try {
+        let ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3;
+        try {
+            ptr0 = passStringToWasm0(slab, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len0 = WASM_VECTOR_LEN;
+            ptr1 = passStringToWasm0(molecule, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len1 = WASM_VECTOR_LEN;
+            ptr2 = passStringToWasm0(format_hint, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len2 = WASM_VECTOR_LEN;
+            ptr3 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len3 = WASM_VECTOR_LEN;
+        } catch (e) {
+            if (ptr3) { wasm.__wbindgen_free(ptr3, len3 * 1, 1); }
+            if (ptr2) { wasm.__wbindgen_free(ptr2, len2 * 1, 1); }
+            if (ptr1) { wasm.__wbindgen_free(ptr1, len1 * 1, 1); }
+            if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 1, 1); }
+            throw e;
+        }
+        const ret = wasm.place_molecule(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);
     }
-    return takeFromExternrefTable0(ret[0]);
 }
 
 /**
@@ -1498,6 +2882,38 @@ export function powder_index_info(pattern_text, wavelength, max_index, tolerance
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Le Bail extraction with the default options.
+ *
+ * Returns `{ positions, intensities, intensity_esds, r_factor, rwp,
+ * chi_squared }`, the same fields as `xtalforge --json powder lebail`.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid structure or pattern text.
+ * @param {string} text
+ * @param {string} pattern_text
+ * @returns {any}
+ */
+export function powder_lebail_info(text, pattern_text) {
+    let ptr0, len0, ptr1, len1;
+    try {
+        ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        len0 = WASM_VECTOR_LEN;
+        ptr1 = passStringToWasm0(pattern_text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        len1 = WASM_VECTOR_LEN;
+    } catch (e) {
+        if (ptr1) { wasm.__wbindgen_free(ptr1, len1 * 1, 1); }
+        if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 1, 1); }
+        throw e;
+    }
+    const ret = wasm.powder_lebail_info(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Fits a Pawley model: free intensities, cell, zero shift and width model.
  *
@@ -1531,6 +2947,45 @@ export function powder_pawley_info(text, pattern_text, profile) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Pawley fit that can also refine the size (constant) and strain
+ * (`tan theta`) width terms, like Python `powder_pawley(refine_size=...,
+ * refine_strain=...)`.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid text or a failed fit.
+ * @param {string} text
+ * @param {string} pattern_text
+ * @param {string} profile
+ * @param {boolean} refine_size
+ * @param {boolean} refine_strain
+ * @returns {any}
+ */
+export function powder_pawley_width_info(text, pattern_text, profile, refine_size, refine_strain) {
+    const val4 = +refine_size;
+    const val5 = +refine_strain;
+    let ptr0, len0, ptr1, len1, ptr2, len2;
+    try {
+        ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        len0 = WASM_VECTOR_LEN;
+        ptr1 = passStringToWasm0(pattern_text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        len1 = WASM_VECTOR_LEN;
+        ptr2 = passStringToWasm0(profile, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        len2 = WASM_VECTOR_LEN;
+    } catch (e) {
+        if (ptr2) { wasm.__wbindgen_free(ptr2, len2 * 1, 1); }
+        if (ptr1) { wasm.__wbindgen_free(ptr1, len1 * 1, 1); }
+        if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 1, 1); }
+        throw e;
+    }
+    const ret = wasm.powder_pawley_width_info(ptr0, len0, ptr1, len1, ptr2, len2, val4, val5);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Refines a phase with the McCusker stages.
  *
@@ -1600,6 +3055,38 @@ export function primitive_info(text, symprec) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Builds the primitive cell and returns it as CIF.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid text or a failed search.
+ * @param {string} text
+ * @param {number} symprec
+ * @returns {string}
+ */
+export function primitive_text(text, symprec) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const val2 = +symprec;
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.primitive_text(ptr0, len0, val2);
+        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);
+    }
+}
+
 /**
  * Reads `.xtalproj` bytes and returns the structure summary.
  *
@@ -1673,6 +3160,96 @@ export function pxrd_info(text, radiation, max_two_theta, step) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Total and partial RDF as JSON.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid text or range.
+ * @param {string} text
+ * @param {string} format_hint
+ * @param {number} r_max
+ * @param {number} bin_width
+ * @param {number} smoothing
+ * @returns {string}
+ */
+export function radial_distribution(text, format_hint, r_max, bin_width, smoothing) {
+    let deferred7_0;
+    let deferred7_1;
+    try {
+        const val3 = +r_max;
+        const val4 = +bin_width;
+        const val5 = +smoothing;
+        let ptr0, len0, ptr1, len1;
+        try {
+            ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len0 = WASM_VECTOR_LEN;
+            ptr1 = passStringToWasm0(format_hint, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len1 = WASM_VECTOR_LEN;
+        } catch (e) {
+            if (ptr1) { wasm.__wbindgen_free(ptr1, len1 * 1, 1); }
+            if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 1, 1); }
+            throw e;
+        }
+        const ret = wasm.radial_distribution(ptr0, len0, ptr1, len1, val3, val4, val5);
+        var ptr6 = ret[0];
+        var len6 = ret[1];
+        if (ret[3]) {
+            ptr6 = 0; len6 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred7_0 = ptr6;
+        deferred7_1 = len6;
+        return getStringFromWasm0(ptr6, len6);
+    } finally {
+        wasm.__wbindgen_free(deferred7_0, deferred7_1, 1);
+    }
+}
+
+/**
+ * Random displacements with a fixed seed; returns structure JSON.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid text or options.
+ * @param {string} text
+ * @param {string} format_hint
+ * @param {string} options_json
+ * @returns {string}
+ */
+export function rattle(text, format_hint, options_json) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        let ptr0, len0, ptr1, len1, ptr2, len2;
+        try {
+            ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len0 = WASM_VECTOR_LEN;
+            ptr1 = passStringToWasm0(format_hint, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len1 = WASM_VECTOR_LEN;
+            ptr2 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len2 = WASM_VECTOR_LEN;
+        } catch (e) {
+            if (ptr2) { wasm.__wbindgen_free(ptr2, len2 * 1, 1); }
+            if (ptr1) { wasm.__wbindgen_free(ptr1, len1 * 1, 1); }
+            if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 1, 1); }
+            throw e;
+        }
+        const ret = wasm.rattle(ptr0, len0, ptr1, len1, 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);
+    }
+}
+
 /**
  * Reads a CIF and returns its summary object.
  *
@@ -1757,7 +3334,47 @@ export function reduce_info(text, algorithm) {
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
-    return takeFromExternrefTable0(ret[0]);
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Reduces a structure and returns it as CIF.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid text or an unknown algorithm.
+ * @param {string} text
+ * @param {string} algorithm
+ * @returns {string}
+ */
+export function reduce_text(text, algorithm) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        let ptr0, len0, ptr1, len1;
+        try {
+            ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len0 = WASM_VECTOR_LEN;
+            ptr1 = passStringToWasm0(algorithm, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len1 = WASM_VECTOR_LEN;
+        } catch (e) {
+            if (ptr1) { wasm.__wbindgen_free(ptr1, len1 * 1, 1); }
+            if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 1, 1); }
+            throw e;
+        }
+        const ret = wasm.reduce_text(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);
+    }
 }
 
 /**
@@ -1814,6 +3431,48 @@ export function rings(text, max_size) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Builds the full scene geometry for a structure.
+ *
+ * The object has three arrays:
+ *
+ * - `atoms`: `element`, `position` (Cartesian Angstrom), `radius`, `color`
+ *   (0-255 RGB), `index` in the P1 cell and `hidden`.
+ * - `bonds`: `i`, `j`, `start`, `end`, `radius`, `color` and `order`.
+ * - `cell_edges`: pairs of Cartesian endpoints.
+ *
+ * `settings` repeats the sanitized style, atom scale, bond radius, cell and
+ * axes flags and background colour used to build the frame.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` with a stable `code` property for invalid
+ * structure text or an unknown draw style.
+ * @param {string} text
+ * @param {string} style
+ * @param {number} scale
+ * @returns {any}
+ */
+export function scene_data(text, style, scale) {
+    const val3 = +scale;
+    let ptr0, len0, ptr1, len1;
+    try {
+        ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        len0 = WASM_VECTOR_LEN;
+        ptr1 = passStringToWasm0(style, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        len1 = WASM_VECTOR_LEN;
+    } catch (e) {
+        if (ptr1) { wasm.__wbindgen_free(ptr1, len1 * 1, 1); }
+        if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 1, 1); }
+        throw e;
+    }
+    const ret = wasm.scene_data(ptr0, len0, ptr1, len1, val3);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Summarizes a scene for the given draw style.
  *
@@ -1900,6 +3559,50 @@ export function set_space_group_info(text, symbol, mode) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Applies a space group and returns the result as CIF.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid text, an unknown symbol or mode.
+ * @param {string} text
+ * @param {string} symbol
+ * @param {string} mode
+ * @returns {string}
+ */
+export function set_space_group_text(text, symbol, mode) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        let ptr0, len0, ptr1, len1, ptr2, len2;
+        try {
+            ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len0 = WASM_VECTOR_LEN;
+            ptr1 = passStringToWasm0(symbol, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len1 = WASM_VECTOR_LEN;
+            ptr2 = passStringToWasm0(mode, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len2 = WASM_VECTOR_LEN;
+        } catch (e) {
+            if (ptr2) { wasm.__wbindgen_free(ptr2, len2 * 1, 1); }
+            if (ptr1) { wasm.__wbindgen_free(ptr1, len1 * 1, 1); }
+            if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 1, 1); }
+            throw e;
+        }
+        const ret = wasm.set_space_group_text(ptr0, len0, ptr1, len1, 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);
+    }
+}
+
 /**
  * Cuts a slab and returns its summary object.
  *
@@ -1933,6 +3636,50 @@ export function slab_info(text, h, k, l, layers, vacuum) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Every termination of a surface as JSON with structure documents.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid text or a degenerate plane.
+ * @param {string} text
+ * @param {string} format_hint
+ * @param {string} options_json
+ * @returns {string}
+ */
+export function slab_terminations(text, format_hint, options_json) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        let ptr0, len0, ptr1, len1, ptr2, len2;
+        try {
+            ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len0 = WASM_VECTOR_LEN;
+            ptr1 = passStringToWasm0(format_hint, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len1 = WASM_VECTOR_LEN;
+            ptr2 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len2 = WASM_VECTOR_LEN;
+        } catch (e) {
+            if (ptr2) { wasm.__wbindgen_free(ptr2, len2 * 1, 1); }
+            if (ptr1) { wasm.__wbindgen_free(ptr1, len1 * 1, 1); }
+            if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 1, 1); }
+            throw e;
+        }
+        const ret = wasm.slab_terminations(ptr0, len0, ptr1, len1, 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);
+    }
+}
+
 /**
  * Cuts a slab and returns it as CIF text.
  *
@@ -1963,36 +3710,204 @@ export function slab_text(text, h, k, l, layers, vacuum) {
         var ptr7 = ret[0];
         var len7 = ret[1];
         if (ret[3]) {
-            ptr7 = 0; len7 = 0;
+            ptr7 = 0; len7 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred8_0 = ptr7;
+        deferred8_1 = len7;
+        return getStringFromWasm0(ptr7, len7);
+    } finally {
+        wasm.__wbindgen_free(deferred8_0, deferred8_1, 1);
+    }
+}
+
+/**
+ * SQS generation as JSON.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for a structure without binary disorder.
+ * @param {string} text
+ * @param {string} format_hint
+ * @param {string} options_json
+ * @returns {string}
+ */
+export function special_quasirandom(text, format_hint, options_json) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        let ptr0, len0, ptr1, len1, ptr2, len2;
+        try {
+            ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len0 = WASM_VECTOR_LEN;
+            ptr1 = passStringToWasm0(format_hint, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len1 = WASM_VECTOR_LEN;
+            ptr2 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len2 = WASM_VECTOR_LEN;
+        } catch (e) {
+            if (ptr2) { wasm.__wbindgen_free(ptr2, len2 * 1, 1); }
+            if (ptr1) { wasm.__wbindgen_free(ptr1, len1 * 1, 1); }
+            if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 1, 1); }
+            throw e;
+        }
+        const ret = wasm.special_quasirandom(ptr0, len0, ptr1, len1, 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);
+    }
+}
+
+/**
+ * Stacks a film on a substrate; returns structure JSON.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for empty slabs or invalid options.
+ * @param {string} film
+ * @param {string} substrate
+ * @param {string} format_hint
+ * @param {string} options_json
+ * @returns {string}
+ */
+export function stack_slabs(film, substrate, format_hint, options_json) {
+    let deferred6_0;
+    let deferred6_1;
+    try {
+        let ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3;
+        try {
+            ptr0 = passStringToWasm0(film, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len0 = WASM_VECTOR_LEN;
+            ptr1 = passStringToWasm0(substrate, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len1 = WASM_VECTOR_LEN;
+            ptr2 = passStringToWasm0(format_hint, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len2 = WASM_VECTOR_LEN;
+            ptr3 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len3 = WASM_VECTOR_LEN;
+        } catch (e) {
+            if (ptr3) { wasm.__wbindgen_free(ptr3, len3 * 1, 1); }
+            if (ptr2) { wasm.__wbindgen_free(ptr2, len2 * 1, 1); }
+            if (ptr1) { wasm.__wbindgen_free(ptr1, len1 * 1, 1); }
+            if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 1, 1); }
+            throw e;
+        }
+        const ret = wasm.stack_slabs(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);
+    }
+}
+
+/**
+ * Standardizes a structure to the conventional cell.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid text or a failed search.
+ * @param {string} text
+ * @param {number} symprec
+ * @returns {any}
+ */
+export function standardize_info(text, symprec) {
+    const val2 = +symprec;
+    const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.standardize_info(ptr0, len0, val2);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Standardizes a structure and returns it as CIF.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid text or a failed search.
+ * @param {string} text
+ * @param {number} symprec
+ * @returns {string}
+ */
+export function standardize_text(text, symprec) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const val2 = +symprec;
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.standardize_text(ptr0, len0, val2);
+        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);
+    }
+}
+
+/**
+ * Structure fingerprint as JSON.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid text or range.
+ * @param {string} text
+ * @param {string} format_hint
+ * @param {number} r_max
+ * @param {number} bin_width
+ * @returns {string}
+ */
+export function structure_fingerprint(text, format_hint, r_max, bin_width) {
+    let deferred6_0;
+    let deferred6_1;
+    try {
+        const val3 = +r_max;
+        const val4 = +bin_width;
+        let ptr0, len0, ptr1, len1;
+        try {
+            ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len0 = WASM_VECTOR_LEN;
+            ptr1 = passStringToWasm0(format_hint, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len1 = WASM_VECTOR_LEN;
+        } catch (e) {
+            if (ptr1) { wasm.__wbindgen_free(ptr1, len1 * 1, 1); }
+            if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 1, 1); }
+            throw e;
+        }
+        const ret = wasm.structure_fingerprint(ptr0, len0, ptr1, len1, val3, val4);
+        var ptr5 = ret[0];
+        var len5 = ret[1];
+        if (ret[3]) {
+            ptr5 = 0; len5 = 0;
             throw takeFromExternrefTable0(ret[2]);
         }
-        deferred8_0 = ptr7;
-        deferred8_1 = len7;
-        return getStringFromWasm0(ptr7, len7);
+        deferred6_0 = ptr5;
+        deferred6_1 = len5;
+        return getStringFromWasm0(ptr5, len5);
     } finally {
-        wasm.__wbindgen_free(deferred8_0, deferred8_1, 1);
-    }
-}
-
-/**
- * Standardizes a structure to the conventional cell.
- *
- * # Errors
- *
- * Returns a JavaScript `Error` for invalid text or a failed search.
- * @param {string} text
- * @param {number} symprec
- * @returns {any}
- */
-export function standardize_info(text, symprec) {
-    const val2 = +symprec;
-    const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.standardize_info(ptr0, len0, val2);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
+        wasm.__wbindgen_free(deferred6_0, deferred6_1, 1);
     }
-    return takeFromExternrefTable0(ret[0]);
 }
 
 /**
@@ -2033,6 +3948,52 @@ export function subgroups_info(hall_number, epsilon) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Symmetry-unique substitutions as JSON.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid text or species.
+ * @param {string} text
+ * @param {string} format_hint
+ * @param {string} species
+ * @param {number} min_image
+ * @returns {string}
+ */
+export function substitutions(text, format_hint, species, min_image) {
+    let deferred6_0;
+    let deferred6_1;
+    try {
+        const val4 = +min_image;
+        let ptr0, len0, ptr1, len1, ptr2, len2;
+        try {
+            ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len0 = WASM_VECTOR_LEN;
+            ptr1 = passStringToWasm0(format_hint, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len1 = WASM_VECTOR_LEN;
+            ptr2 = passStringToWasm0(species, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len2 = WASM_VECTOR_LEN;
+        } catch (e) {
+            if (ptr2) { wasm.__wbindgen_free(ptr2, len2 * 1, 1); }
+            if (ptr1) { wasm.__wbindgen_free(ptr1, len1 * 1, 1); }
+            if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 1, 1); }
+            throw e;
+        }
+        const ret = wasm.substitutions(ptr0, len0, ptr1, len1, ptr2, len2, val4);
+        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);
+    }
+}
+
 /**
  * Builds a supercell and returns its summary object.
  *
@@ -2118,6 +4079,36 @@ export function to_p1_info(text) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Expands a structure to P1 and returns it as CIF.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid text or an empty structure.
+ * @param {string} text
+ * @returns {string}
+ */
+export function to_p1_text(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.to_p1_text(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);
+    }
+}
+
 /**
  * Detects across the default tolerance ladder.
  *
@@ -2185,6 +4176,92 @@ export function twist_info(n, m, theta, layers) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Symmetry-unique Miller indices as JSON.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid text or a bad index bound.
+ * @param {string} text
+ * @param {string} format_hint
+ * @param {string} options_json
+ * @returns {string}
+ */
+export function unique_miller_indices(text, format_hint, options_json) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        let ptr0, len0, ptr1, len1, ptr2, len2;
+        try {
+            ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len0 = WASM_VECTOR_LEN;
+            ptr1 = passStringToWasm0(format_hint, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len1 = WASM_VECTOR_LEN;
+            ptr2 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len2 = WASM_VECTOR_LEN;
+        } catch (e) {
+            if (ptr2) { wasm.__wbindgen_free(ptr2, len2 * 1, 1); }
+            if (ptr1) { wasm.__wbindgen_free(ptr1, len1 * 1, 1); }
+            if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 1, 1); }
+            throw e;
+        }
+        const ret = wasm.unique_miller_indices(ptr0, len0, ptr1, len1, 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);
+    }
+}
+
+/**
+ * Symmetry-unique vacancies as JSON.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid text or distance.
+ * @param {string} text
+ * @param {string} format_hint
+ * @param {number} min_image
+ * @returns {string}
+ */
+export function vacancies(text, format_hint, min_image) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        const val3 = +min_image;
+        let ptr0, len0, ptr1, len1;
+        try {
+            ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len0 = WASM_VECTOR_LEN;
+            ptr1 = passStringToWasm0(format_hint, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len1 = WASM_VECTOR_LEN;
+        } catch (e) {
+            if (ptr1) { wasm.__wbindgen_free(ptr1, len1 * 1, 1); }
+            if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 1, 1); }
+            throw e;
+        }
+        const ret = wasm.vacancies(ptr0, len0, ptr1, len1, val3);
+        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);
+    }
+}
+
 /**
  * Version of the workspace.
  * @returns {string}
@@ -2202,6 +4279,48 @@ export function version() {
     }
 }
 
+/**
+ * Periodic Voronoi cells as JSON.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid text or cutoff.
+ * @param {string} text
+ * @param {string} format_hint
+ * @param {number} cutoff
+ * @returns {string}
+ */
+export function voronoi(text, format_hint, cutoff) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        const val3 = +cutoff;
+        let ptr0, len0, ptr1, len1;
+        try {
+            ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len0 = WASM_VECTOR_LEN;
+            ptr1 = passStringToWasm0(format_hint, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len1 = WASM_VECTOR_LEN;
+        } catch (e) {
+            if (ptr1) { wasm.__wbindgen_free(ptr1, len1 * 1, 1); }
+            if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 1, 1); }
+            throw e;
+        }
+        const ret = wasm.voronoi(ptr0, len0, ptr1, len1, val3);
+        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);
+    }
+}
+
 /**
  * Archives run records (a JSON array) into an in-memory ZIP.
  *
@@ -2242,6 +4361,50 @@ export function workspace_read_archive(bytes) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Wulff construction as JSON.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript `Error` for invalid text or surface energies.
+ * @param {string} text
+ * @param {string} format_hint
+ * @param {string} options_json
+ * @returns {string}
+ */
+export function wulff(text, format_hint, options_json) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        let ptr0, len0, ptr1, len1, ptr2, len2;
+        try {
+            ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len0 = WASM_VECTOR_LEN;
+            ptr1 = passStringToWasm0(format_hint, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len1 = WASM_VECTOR_LEN;
+            ptr2 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len2 = WASM_VECTOR_LEN;
+        } catch (e) {
+            if (ptr2) { wasm.__wbindgen_free(ptr2, len2 * 1, 1); }
+            if (ptr1) { wasm.__wbindgen_free(ptr1, len1 * 1, 1); }
+            if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 1, 1); }
+            throw e;
+        }
+        const ret = wasm.wulff(ptr0, len0, ptr1, len1, 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);
+    }
+}
+
 /**
  * Returns Wyckoff assignments.
  *
@@ -2307,12 +4470,24 @@ export function __wbg___wbindgen_debug_string_f249a2a76caa9a55(arg0, arg1) {
     getDataViewMemory0().setInt32((arg0 >>> 0) + 4 * 1, len1, true);
     getDataViewMemory0().setInt32((arg0 >>> 0) + 4 * 0, ptr1, true);
 }
+export function __wbg___wbindgen_string_get_7ce8eee7fd327545(arg0, arg1) {
+    const obj = arg1;
+    const ret = typeof(obj) === 'string' ? obj : undefined;
+    var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32((arg0 >>> 0) + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32((arg0 >>> 0) + 4 * 0, ptr1, true);
+}
 export function __wbg___wbindgen_throw_4c88d8bf264fd984(arg0, arg1) {
     throw new Error(getStringFromWasm0(arg0, arg1));
 }
 export function __wbg_getRandomValues_8b6f1f663e6f188d() { return handleError(function (arg0, arg1) {
     globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
 }, arguments); }
+export function __wbg_length_b03a0fabb109b1e9(arg0) {
+    const ret = arg0.length;
+    return ret;
+}
 export function __wbg_new_37eb45aaf5eeb820() {
     const ret = new Array();
     return ret;
@@ -2502,6 +4677,16 @@ function passArrayF64ToWasm0(arg, malloc) {
     return ptr;
 }
 
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4, 4) >>> 0;
+    for (let i = 0; i < array.length; i++) {
+        const add = addToExternrefTable0(array[i]);
+        getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
+}
+
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);