@kotoshu/wasm 0.1.0 → 0.3.0

package/kotoshu_wasm.d.ts

@@ -1,6 +1,18 @@
 /* tslint:disable */
 /* eslint-disable */
 
+/**
+ * One loaded embedding tier: the wasm twin of the `onnx` feature's
+ * ort provider — same artifacts, scored in pure Rust. Handle-shaped:
+ * opaque on the JS side, freed by GC or `free()` (see the module docs
+ * for the memory footprint).
+ */
+export class KotoshuModel {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+}
+
 /**
  * One loaded dictionary: the JS twin of the `ruby` feature's
  * `Kotoshu::Native::Dictionary` — same engine, same suggestion-row shape.
@@ -37,3 +49,29 @@ export class KotoshuWasm {
      */
     static readonly VERSION: string;
 }
+
+/**
+ * Load an int8-per-row embedding tier from the byte CONTENTS of its
+ * `.onnx` artifact and `.vocab.json` sibling (wasm has no filesystem;
+ * the host fetches the pair — mini ≈ 3 MB, fluency ≈ 15 MB).
+ * Failures reject with the Rust error message.
+ */
+export function loadModel(model_bytes: Uint8Array, vocab_bytes: Uint8Array): KotoshuModel;
+
+/**
+ * Score `word` against `context` (free text): the mean cosine over the
+ * in-vocabulary context tokens, in `[-1, 1]` — `0.0` when the word or
+ * every token is out of vocabulary. Ranking by this score orders
+ * candidates as the gem's context boost does; see the module docs.
+ */
+export function rerank(model: KotoshuModel, word: string, context: string): number;
+
+/**
+ * The `k` nearest vocabulary words to `word` by cosine — semantic
+ * candidate GENERATION (see `Int8Model::semantic_neighbors`): one plain
+ * `{ word, score }` row per neighbor, score-descending, the query word
+ * itself excluded. Empty when `k` is 0 or the word embeds nowhere (out
+ * of vocabulary with no in-vocabulary character n-gram). `k` defaults
+ * to 5 when omitted.
+ */
+export function semanticSuggest(model: KotoshuModel, word: string, k?: number | null): Array<any>;

package/kotoshu_wasm.js

@@ -5,5 +5,5 @@ import { __wbg_set_wasm } from "./kotoshu_wasm_bg.js";
 __wbg_set_wasm(wasm);
 wasm.__wbindgen_start();
 export {
-    KotoshuWasm
+    KotoshuModel, KotoshuWasm, loadModel, rerank, semanticSuggest
 } from "./kotoshu_wasm_bg.js";

package/kotoshu_wasm_bg.js

@@ -1,3 +1,29 @@
+/**
+ * One loaded embedding tier: the wasm twin of the `onnx` feature's
+ * ort provider — same artifacts, scored in pure Rust. Handle-shaped:
+ * opaque on the JS side, freed by GC or `free()` (see the module docs
+ * for the memory footprint).
+ */
+export class KotoshuModel {
+    static __wrap(ptr) {
+        const obj = Object.create(KotoshuModel.prototype);
+        obj.__wbg_ptr = ptr;
+        KotoshuModelFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        KotoshuModelFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_kotoshumodel_free(ptr, 0);
+    }
+}
+if (Symbol.dispose) KotoshuModel.prototype[Symbol.dispose] = KotoshuModel.prototype.free;
+
 /**
  * One loaded dictionary: the JS twin of the `ruby` feature's
  * `Kotoshu::Native::Dictionary` — same engine, same suggestion-row shape.
@@ -84,6 +110,67 @@ export class KotoshuWasm {
     }
 }
 if (Symbol.dispose) KotoshuWasm.prototype[Symbol.dispose] = KotoshuWasm.prototype.free;
+
+/**
+ * Load an int8-per-row embedding tier from the byte CONTENTS of its
+ * `.onnx` artifact and `.vocab.json` sibling (wasm has no filesystem;
+ * the host fetches the pair — mini ≈ 3 MB, fluency ≈ 15 MB).
+ * Failures reject with the Rust error message.
+ * @param {Uint8Array} model_bytes
+ * @param {Uint8Array} vocab_bytes
+ * @returns {KotoshuModel}
+ */
+export function loadModel(model_bytes, vocab_bytes) {
+    const ptr0 = passArray8ToWasm0(model_bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(vocab_bytes, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.loadModel(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return KotoshuModel.__wrap(ret[0]);
+}
+
+/**
+ * Score `word` against `context` (free text): the mean cosine over the
+ * in-vocabulary context tokens, in `[-1, 1]` — `0.0` when the word or
+ * every token is out of vocabulary. Ranking by this score orders
+ * candidates as the gem's context boost does; see the module docs.
+ * @param {KotoshuModel} model
+ * @param {string} word
+ * @param {string} context
+ * @returns {number}
+ */
+export function rerank(model, word, context) {
+    _assertClass(model, KotoshuModel);
+    const ptr0 = passStringToWasm0(word, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(context, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.rerank(model.__wbg_ptr, ptr0, len0, ptr1, len1);
+    return ret;
+}
+
+/**
+ * The `k` nearest vocabulary words to `word` by cosine — semantic
+ * candidate GENERATION (see `Int8Model::semantic_neighbors`): one plain
+ * `{ word, score }` row per neighbor, score-descending, the query word
+ * itself excluded. Empty when `k` is 0 or the word embeds nowhere (out
+ * of vocabulary with no in-vocabulary character n-gram). `k` defaults
+ * to 5 when omitted.
+ * @param {KotoshuModel} model
+ * @param {string} word
+ * @param {number | null} [k]
+ * @returns {Array<any>}
+ */
+export function semanticSuggest(model, word, k) {
+    _assertClass(model, KotoshuModel);
+    const ptr0 = passStringToWasm0(word, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.semanticSuggest(model.__wbg_ptr, ptr0, len0, isLikeNone(k) ? Number.MAX_SAFE_INTEGER : (k) >>> 0);
+    return ret;
+}
 export function __wbg_Error_408e67f47ca7b58b(arg0, arg1) {
     const ret = Error(getStringFromWasm0(arg0, arg1));
     return ret;
@@ -155,6 +242,9 @@ export function __wbindgen_init_externref_table() {
     table.set(offset + 2, true);
     table.set(offset + 3, false);
 }
+const KotoshuModelFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_kotoshumodel_free(ptr, 1));
 const KotoshuWasmFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_kotoshuwasm_free(ptr, 1));
@@ -165,6 +255,12 @@ function addToExternrefTable0(obj) {
     return idx;
 }
 
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+
 function debugString(val) {
     // primitive types
     const type = typeof val;
@@ -263,6 +359,13 @@ 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);

package/package.json

@@ -5,7 +5,7 @@
     "Ribose Inc. <open.source@ribose.com>"
   ],
   "description": "npm @kotoshu/wasm packaging shim: wasm-pack build of the kotoshu engine's wasm-bindgen surface",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "license": "BSD-2-Clause",
   "repository": {
     "type": "git",