ruvector 0.2.20 → 0.2.22

package/wasm/ruvector_decompiler_wasm.js

@@ -0,0 +1,220 @@
+/* @ts-self-types="./ruvector_decompiler_wasm.d.ts" */
+
+/**
+ * Decompile a minified JavaScript bundle using the full Louvain pipeline.
+ *
+ * # Arguments
+ *
+ * * `source` - The minified JavaScript source code.
+ * * `config_json` - JSON string of `DecompileConfig` fields. Pass `"{}"` for defaults.
+ *
+ * # Returns
+ *
+ * A JSON string containing the `DecompileResult` (modules, witness, inferred names, etc.)
+ * or a JSON object with an `"error"` field on failure.
+ * @param {string} source
+ * @param {string} config_json
+ * @returns {string}
+ */
+function decompile(source, config_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(source, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(config_json, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.decompile(retptr, ptr0, len0, ptr1, len1);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        deferred3_0 = r0;
+        deferred3_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export(deferred3_0, deferred3_1, 1);
+    }
+}
+exports.decompile = decompile;
+
+/**
+ * Initialize the WASM module (sets up panic hook for better error messages).
+ */
+function init() {
+    wasm.init();
+}
+exports.init = init;
+
+/**
+ * Return the version of the decompiler WASM module.
+ * @returns {string}
+ */
+function version() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.version(retptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        deferred1_0 = r0;
+        deferred1_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export(deferred1_0, deferred1_1, 1);
+    }
+}
+exports.version = version;
+
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg___wbindgen_throw_39bc967c0e5a9b58: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbg_error_a6fa202b58aa1cd3: function(arg0, arg1) {
+            let deferred0_0;
+            let deferred0_1;
+            try {
+                deferred0_0 = arg0;
+                deferred0_1 = arg1;
+                console.error(getStringFromWasm0(arg0, arg1));
+            } finally {
+                wasm.__wbindgen_export(deferred0_0, deferred0_1, 1);
+            }
+        },
+        __wbg_new_227d7c05414eb861: function() {
+            const ret = new Error();
+            return addHeapObject(ret);
+        },
+        __wbg_stack_3b0d974bbf31e44f: function(arg0, arg1) {
+            const ret = getObject(arg1).stack;
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbindgen_object_drop_ref: function(arg0) {
+            takeObject(arg0);
+        },
+    };
+    return {
+        __proto__: null,
+        "./ruvector_decompiler_wasm_bg.js": import0,
+    };
+}
+
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
+function dropObject(idx) {
+    if (idx < 1028) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+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 getObject(idx) { return heap[idx]; }
+
+let heap = new Array(1024).fill(undefined);
+heap.push(undefined, null, true, false);
+
+let heap_next = heap.length;
+
+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 takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+function decodeText(ptr, 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;
+
+const wasmPath = `${__dirname}/ruvector_decompiler_wasm_bg.wasm`;
+const wasmBytes = require('fs').readFileSync(wasmPath);
+const wasmModule = new WebAssembly.Module(wasmBytes);
+let wasm = new WebAssembly.Instance(wasmModule, __wbg_get_imports()).exports;
+wasm.__wbindgen_start();

package/wasm/ruvector_decompiler_wasm_bg.wasm.d.ts

@@ -0,0 +1,16 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const decompile: (a: number, b: number, c: number, d: number, e: number) => void;
+export const version: (a: number) => void;
+export const init: () => void;
+export const mincut_add_result: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+export const mincut_get_coordinator: () => number;
+export const mincut_get_result: () => number;
+export const mincut_init: (a: number, b: number, c: number) => void;
+export const mincut_is_complete: () => number;
+export const __wbindgen_export: (a: number, b: number, c: number) => void;
+export const __wbindgen_export2: (a: number, b: number) => number;
+export const __wbindgen_export3: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_add_to_stack_pointer: (a: number) => number;
+export const __wbindgen_start: () => void;

package/dist/core/onnx/loader.js

@@ -1,348 +0,0 @@
-/**
- * Model Loader for RuVector ONNX Embeddings WASM
- *
- * Provides easy loading of pre-trained models from HuggingFace Hub
- */
-
-/**
- * Pre-configured models with their HuggingFace URLs
- */
-export const MODELS = {
-    // Sentence Transformers - Small & Fast
-    'all-MiniLM-L6-v2': {
-        name: 'all-MiniLM-L6-v2',
-        dimension: 384,
-        maxLength: 256,
-        size: '23MB',
-        description: 'Fast, general-purpose embeddings',
-        model: 'https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2/resolve/main/onnx/model.onnx',
-        tokenizer: 'https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2/resolve/main/tokenizer.json',
-    },
-    'all-MiniLM-L12-v2': {
-        name: 'all-MiniLM-L12-v2',
-        dimension: 384,
-        maxLength: 256,
-        size: '33MB',
-        description: 'Better quality, balanced speed',
-        model: 'https://huggingface.co/sentence-transformers/all-MiniLM-L12-v2/resolve/main/onnx/model.onnx',
-        tokenizer: 'https://huggingface.co/sentence-transformers/all-MiniLM-L12-v2/resolve/main/tokenizer.json',
-    },
-
-    // BGE Models - State of the art
-    'bge-small-en-v1.5': {
-        name: 'bge-small-en-v1.5',
-        dimension: 384,
-        maxLength: 512,
-        size: '33MB',
-        description: 'State-of-the-art small model',
-        model: 'https://huggingface.co/BAAI/bge-small-en-v1.5/resolve/main/onnx/model.onnx',
-        tokenizer: 'https://huggingface.co/BAAI/bge-small-en-v1.5/resolve/main/tokenizer.json',
-    },
-    'bge-base-en-v1.5': {
-        name: 'bge-base-en-v1.5',
-        dimension: 768,
-        maxLength: 512,
-        size: '110MB',
-        description: 'Best overall quality',
-        model: 'https://huggingface.co/BAAI/bge-base-en-v1.5/resolve/main/onnx/model.onnx',
-        tokenizer: 'https://huggingface.co/BAAI/bge-base-en-v1.5/resolve/main/tokenizer.json',
-    },
-
-    // E5 Models - Microsoft
-    'e5-small-v2': {
-        name: 'e5-small-v2',
-        dimension: 384,
-        maxLength: 512,
-        size: '33MB',
-        description: 'Excellent for search & retrieval',
-        model: 'https://huggingface.co/intfloat/e5-small-v2/resolve/main/onnx/model.onnx',
-        tokenizer: 'https://huggingface.co/intfloat/e5-small-v2/resolve/main/tokenizer.json',
-    },
-
-    // GTE Models - Alibaba
-    'gte-small': {
-        name: 'gte-small',
-        dimension: 384,
-        maxLength: 512,
-        size: '33MB',
-        description: 'Good multilingual support',
-        model: 'https://huggingface.co/thenlper/gte-small/resolve/main/onnx/model.onnx',
-        tokenizer: 'https://huggingface.co/thenlper/gte-small/resolve/main/tokenizer.json',
-    },
-};
-
-/**
- * Default model for quick start
- */
-export const DEFAULT_MODEL = 'all-MiniLM-L6-v2';
-
-/**
- * Model loader with caching support
- */
-export class ModelLoader {
-    constructor(options = {}) {
-        this.cache = options.cache ?? true;
-        this.cacheStorage = options.cacheStorage ?? 'ruvector-models';
-        this.onProgress = options.onProgress ?? null;
-    }
-
-    /**
-     * Load a pre-configured model by name
-     * @param {string} modelName - Model name from MODELS
-     * @returns {Promise<{modelBytes: Uint8Array, tokenizerJson: string, config: object}>}
-     */
-    async loadModel(modelName = DEFAULT_MODEL) {
-        const modelConfig = MODELS[modelName];
-        if (!modelConfig) {
-            throw new Error(`Unknown model: ${modelName}. Available: ${Object.keys(MODELS).join(', ')}`);
-        }
-
-        console.log(`Loading model: ${modelConfig.name} (${modelConfig.size})`);
-
-        const [modelBytes, tokenizerJson] = await Promise.all([
-            this.fetchWithCache(modelConfig.model, `${modelName}-model.onnx`, 'arraybuffer'),
-            this.fetchWithCache(modelConfig.tokenizer, `${modelName}-tokenizer.json`, 'text'),
-        ]);
-
-        return {
-            modelBytes: new Uint8Array(modelBytes),
-            tokenizerJson,
-            config: modelConfig,
-        };
-    }
-
-    /**
-     * Load model from custom URLs
-     * @param {string} modelUrl - URL to ONNX model
-     * @param {string} tokenizerUrl - URL to tokenizer.json
-     * @returns {Promise<{modelBytes: Uint8Array, tokenizerJson: string}>}
-     */
-    async loadFromUrls(modelUrl, tokenizerUrl) {
-        const [modelBytes, tokenizerJson] = await Promise.all([
-            this.fetchWithCache(modelUrl, null, 'arraybuffer'),
-            this.fetchWithCache(tokenizerUrl, null, 'text'),
-        ]);
-
-        return {
-            modelBytes: new Uint8Array(modelBytes),
-            tokenizerJson,
-        };
-    }
-
-    /**
-     * Load model from local files (Node.js)
-     * @param {string} modelPath - Path to ONNX model
-     * @param {string} tokenizerPath - Path to tokenizer.json
-     * @returns {Promise<{modelBytes: Uint8Array, tokenizerJson: string}>}
-     */
-    async loadFromFiles(modelPath, tokenizerPath) {
-        // Node.js environment
-        if (typeof process !== 'undefined' && process.versions?.node) {
-            const fs = await import('fs/promises');
-            const [modelBytes, tokenizerJson] = await Promise.all([
-                fs.readFile(modelPath),
-                fs.readFile(tokenizerPath, 'utf8'),
-            ]);
-            return {
-                modelBytes: new Uint8Array(modelBytes),
-                tokenizerJson,
-            };
-        }
-        throw new Error('loadFromFiles is only available in Node.js');
-    }
-
-    /**
-     * Fetch with optional caching (uses Cache API in browsers)
-     */
-    async fetchWithCache(url, cacheKey, responseType) {
-        // Try cache first (browser only)
-        if (this.cache && typeof caches !== 'undefined' && cacheKey) {
-            try {
-                const cache = await caches.open(this.cacheStorage);
-                const cached = await cache.match(cacheKey);
-                if (cached) {
-                    console.log(`  Cache hit: ${cacheKey}`);
-                    return responseType === 'arraybuffer'
-                        ? await cached.arrayBuffer()
-                        : await cached.text();
-                }
-            } catch (e) {
-                // Cache API not available, continue with fetch
-            }
-        }
-
-        // Fetch from network
-        console.log(`  Downloading: ${url}`);
-        const response = await this.fetchWithProgress(url);
-
-        if (!response.ok) {
-            throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
-        }
-
-        // Clone for caching
-        const responseClone = response.clone();
-
-        // Cache the response (browser only)
-        if (this.cache && typeof caches !== 'undefined' && cacheKey) {
-            try {
-                const cache = await caches.open(this.cacheStorage);
-                await cache.put(cacheKey, responseClone);
-            } catch (e) {
-                // Cache write failed, continue
-            }
-        }
-
-        return responseType === 'arraybuffer'
-            ? await response.arrayBuffer()
-            : await response.text();
-    }
-
-    /**
-     * Fetch with progress reporting
-     */
-    async fetchWithProgress(url) {
-        const response = await fetch(url);
-
-        if (!this.onProgress || !response.body) {
-            return response;
-        }
-
-        const contentLength = response.headers.get('content-length');
-        if (!contentLength) {
-            return response;
-        }
-
-        const total = parseInt(contentLength, 10);
-        let loaded = 0;
-
-        const reader = response.body.getReader();
-        const chunks = [];
-
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done) break;
-
-            chunks.push(value);
-            loaded += value.length;
-
-            this.onProgress({
-                loaded,
-                total,
-                percent: Math.round((loaded / total) * 100),
-            });
-        }
-
-        const body = new Uint8Array(loaded);
-        let position = 0;
-        for (const chunk of chunks) {
-            body.set(chunk, position);
-            position += chunk.length;
-        }
-
-        return new Response(body, {
-            headers: response.headers,
-            status: response.status,
-            statusText: response.statusText,
-        });
-    }
-
-    /**
-     * Clear cached models
-     */
-    async clearCache() {
-        if (typeof caches !== 'undefined') {
-            await caches.delete(this.cacheStorage);
-            console.log('Model cache cleared');
-        }
-    }
-
-    /**
-     * List available models
-     */
-    static listModels() {
-        return Object.entries(MODELS).map(([key, config]) => ({
-            id: key,
-            ...config,
-        }));
-    }
-}
-
-/**
- * Quick helper to create an embedder with a pre-configured model
- *
- * @example
- * ```javascript
- * import { createEmbedder } from './loader.js';
- *
- * const embedder = await createEmbedder('all-MiniLM-L6-v2');
- * const embedding = embedder.embedOne("Hello world");
- * ```
- */
-export async function createEmbedder(modelName = DEFAULT_MODEL, wasmModule = null) {
-    // Import WASM module if not provided
-    if (!wasmModule) {
-        wasmModule = await import('./pkg/ruvector_onnx_embeddings_wasm.js');
-        await wasmModule.default();
-    }
-
-    const loader = new ModelLoader();
-    const { modelBytes, tokenizerJson, config } = await loader.loadModel(modelName);
-
-    const embedderConfig = new wasmModule.WasmEmbedderConfig()
-        .setMaxLength(config.maxLength)
-        .setNormalize(true)
-        .setPooling(0); // Mean pooling
-
-    const embedder = wasmModule.WasmEmbedder.withConfig(
-        modelBytes,
-        tokenizerJson,
-        embedderConfig
-    );
-
-    return embedder;
-}
-
-/**
- * Quick helper for one-off embedding (loads model, embeds, returns)
- *
- * @example
- * ```javascript
- * import { embed } from './loader.js';
- *
- * const embedding = await embed("Hello world");
- * const embeddings = await embed(["Hello", "World"]);
- * ```
- */
-export async function embed(text, modelName = DEFAULT_MODEL) {
-    const embedder = await createEmbedder(modelName);
-
-    if (Array.isArray(text)) {
-        return embedder.embedBatch(text);
-    }
-    return embedder.embedOne(text);
-}
-
-/**
- * Quick helper for similarity comparison
- *
- * @example
- * ```javascript
- * import { similarity } from './loader.js';
- *
- * const score = await similarity("I love dogs", "I adore puppies");
- * console.log(score); // ~0.85
- * ```
- */
-export async function similarity(text1, text2, modelName = DEFAULT_MODEL) {
-    const embedder = await createEmbedder(modelName);
-    return embedder.similarity(text1, text2);
-}
-
-export default {
-    MODELS,
-    DEFAULT_MODEL,
-    ModelLoader,
-    createEmbedder,
-    embed,
-    similarity,
-};

package/dist/core/onnx/pkg/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 rUv
-
-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.