@bio-rs/biors-wasm 0.47.4 → 0.47.9

package/LICENSE-APACHE

@@ -0,0 +1,17 @@
+Apache License
+Version 2.0, January 2004
+
+Copyright 2026 Bio.rs contributors
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not
+use this file except in compliance with the License. You may obtain a copy of
+the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+License for the specific language governing permissions and limitations under
+the License.
+

package/LICENSE-MIT

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Bio.rs contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -5,7 +5,7 @@ WebAssembly/JavaScript bindings for [bio-rs](https://github.com/bio-rs/bio-rs) c
 ## Usage
 
 ```javascript
-import init, {
+import {
   parseFasta,
   validateFasta,
   tokenize,
@@ -13,14 +13,13 @@ import init, {
   runWorkflow,
 } from "@bio-rs/biors-wasm";
 
-await init();
-
 const fastaText = ">seq1\nACDE\n>seq2\nFGHI\n";
 const bytes = new TextEncoder().encode(fastaText);
 
 const parsed = parseFasta(bytes);
 const validated = validateFasta(bytes, "protein");
 const tokenized = tokenize(parsed, "protein-20");
+const dnaTokens = tokenize(parseFasta(new TextEncoder().encode(">dna\nACGT\n")), "dna-iupac");
 const modelInput = buildModelInputWithPolicy(tokenized.records, 8, 0, "fixed_length");
 const workflow = runWorkflow({
   fastaBytes: bytes,
@@ -28,6 +27,12 @@ const workflow = runWorkflow({
   padding: "fixed_length",
   padTokenId: 0,
 });
+const dnaWorkflow = runWorkflow({
+  fastaBytes: new TextEncoder().encode(">dna\nACGT\n"),
+  kind: "dna",
+  profile: "dna-iupac",
+  maxLength: 8,
+});
 ```
 
 ## Development
@@ -39,6 +44,9 @@ cargo check -p biors-wasm --target wasm32-unknown-unknown
 # Build for bundlers
 wasm-pack build packages/rust/biors-wasm --target bundler
 
+# Enable browser panic stack traces for local debugging
+wasm-pack build packages/rust/biors-wasm --target bundler --features console_error_panic_hook
+
 # Run browser tests
 wasm-pack test --headless --chrome packages/rust/biors-wasm
 ```

package/biors_wasm.d.ts

@@ -96,7 +96,7 @@ export interface ValidationReport {
 export interface WorkflowConfig {
     fastaBytes: Uint8Array;
     kind?: "auto" | "protein" | "dna" | "rna";
-    profile?: "protein-20" | "protein-20-special";
+    profile?: "protein-20" | "protein-20-special" | "dna-iupac" | "dna-iupac-special" | "rna-iupac" | "rna-iupac-special";
     maxLength: number;
     padding?: "fixed_length" | "no_padding";
     padTokenId?: number;

package/biors_wasm_bg.js

@@ -0,0 +1,286 @@
+/**
+ * @param {any} tokenized
+ * @param {number} max_length
+ * @returns {any}
+ */
+export function buildModelInput(tokenized, max_length) {
+    const ret = wasm.buildModelInput(tokenized, max_length);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {any} tokenized
+ * @param {number} max_length
+ * @param {number} pad_token_id
+ * @param {string} padding
+ * @returns {any}
+ */
+export function buildModelInputWithPolicy(tokenized, max_length, pad_token_id, padding) {
+    const ptr0 = passStringToWasm0(padding, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.buildModelInputWithPolicy(tokenized, max_length, pad_token_id, ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+export function init_panic_hook() {
+    wasm.init_panic_hook();
+}
+
+/**
+ * Parse FASTA bytes into an array of sequence records.
+ * @param {Uint8Array} bytes
+ * @returns {any}
+ */
+export function parseFasta(bytes) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.parseFasta(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {any} config
+ * @returns {any}
+ */
+export function runWorkflow(config) {
+    const ret = wasm.runWorkflow(config);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {any} records
+ * @param {string} profile
+ * @returns {any}
+ */
+export function tokenize(records, profile) {
+    const ptr0 = passStringToWasm0(profile, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.tokenize(records, ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Validate FASTA bytes and return a structured validation report.
+ * @param {Uint8Array} bytes
+ * @param {string} kind
+ * @returns {any}
+ */
+export function validateFasta(bytes, kind) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(kind, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.validateFasta(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+export function __wbg___wbindgen_is_undefined_29a43b4d42920abd(arg0) {
+    const ret = arg0 === undefined;
+    return ret;
+}
+export function __wbg___wbindgen_number_get_c7f42aed0525c451(arg0, arg1) {
+    const obj = arg1;
+    const ret = typeof(obj) === 'number' ? obj : undefined;
+    getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+}
+export function __wbg___wbindgen_string_get_7ed5322991caaec5(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 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+}
+export function __wbg___wbindgen_throw_6b64449b9b9ed33c(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+}
+export function __wbg_get_6011fa3a58f61074() { return handleError(function (arg0, arg1) {
+    const ret = Reflect.get(arg0, arg1);
+    return ret;
+}, arguments); }
+export function __wbg_instanceof_Uint8Array_152ba1f289edcf3f(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof Uint8Array;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+}
+export function __wbg_length_9f1775224cf1d815(arg0) {
+    const ret = arg0.length;
+    return ret;
+}
+export function __wbg_parse_1bbc9c053611d0a7() { return handleError(function (arg0, arg1) {
+    const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
+    return ret;
+}, arguments); }
+export function __wbg_prototypesetcall_a6b02eb00b0f4ce2(arg0, arg1, arg2) {
+    Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+}
+export function __wbg_stringify_91082ed7a5a5769e() { return handleError(function (arg0) {
+    const ret = JSON.stringify(arg0);
+    return ret;
+}, arguments); }
+export function __wbindgen_cast_0000000000000001(arg0, arg1) {
+    // Cast intrinsic for `Ref(String) -> Externref`.
+    const ret = getStringFromWasm0(arg0, arg1);
+    return ret;
+}
+export function __wbindgen_init_externref_table() {
+    const table = wasm.__wbindgen_externrefs;
+    const offset = table.grow(4);
+    table.set(0, undefined);
+    table.set(offset + 0, undefined);
+    table.set(offset + 1, null);
+    table.set(offset + 2, true);
+    table.set(offset + 3, false);
+}
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+
+let wasm;
+export function __wbg_set_wasm(val) {
+    wasm = val;
+}

package/biors_wasm_bg.wasm.d.ts

@@ -0,0 +1,17 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const runWorkflow: (a: any) => [number, number, number];
+export const buildModelInput: (a: any, b: number) => [number, number, number];
+export const buildModelInputWithPolicy: (a: any, b: number, c: number, d: number, e: number) => [number, number, number];
+export const init_panic_hook: () => void;
+export const parseFasta: (a: number, b: number) => [number, number, number];
+export const validateFasta: (a: number, b: number, c: number, d: number) => [number, number, number];
+export const tokenize: (a: any, b: number, c: number) => [number, number, number];
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_exn_store: (a: number) => void;
+export const __externref_table_alloc: () => number;
+export const __wbindgen_externrefs: WebAssembly.Table;
+export const __externref_table_dealloc: (a: number) => void;
+export const __wbindgen_start: () => void;

package/index.d.ts

@@ -9,7 +9,6 @@ export {
     buildModelInput,
     buildModelInputWithPolicy,
     runWorkflow,
-    default as init,
 } from "./biors_wasm.js";
 
 export type {

package/package.json

@@ -2,7 +2,7 @@
   "name": "@bio-rs/biors-wasm",
   "type": "module",
   "description": "WebAssembly bindings for bio-rs biological sequence processing",
-  "version": "0.47.4",
+  "version": "0.47.9",
   "license": "MIT OR Apache-2.0",
   "repository": {
     "type": "git",
@@ -10,7 +10,11 @@
     "directory": "packages/rust/biors-wasm"
   },
   "files": [
+    "LICENSE-APACHE",
+    "LICENSE-MIT",
+    "biors_wasm_bg.js",
     "biors_wasm_bg.wasm",
+    "biors_wasm_bg.wasm.d.ts",
     "biors_wasm.js",
     "biors_wasm.d.ts",
     "index.d.ts",