/* @ts-self-types="./ruvllm_wasm.d.ts" */

/**
 * Feedback for per-request adaptation.
 *
 * Provides quality scores and optional gradient estimates to guide
 * LoRA weight updates.
 */
export class AdaptFeedbackWasm {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        AdaptFeedbackWasmFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_adaptfeedbackwasm_free(ptr, 0);
    }
    /**
     * Get learning rate.
     * @returns {number}
     */
    get learningRate() {
        const ret = wasm.adaptfeedbackwasm_learningRate(this.__wbg_ptr);
        return ret;
    }
    /**
     * Create new feedback with quality score [0.0, 1.0].
     * @param {number} quality
     */
    constructor(quality) {
        const ret = wasm.adaptfeedbackwasm_new(quality);
        this.__wbg_ptr = ret >>> 0;
        AdaptFeedbackWasmFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * Get quality score.
     * @returns {number}
     */
    get quality() {
        const ret = wasm.adaptfeedbackwasm_quality(this.__wbg_ptr);
        return ret;
    }
    /**
     * Set learning rate.
     * @param {number} value
     */
    set learningRate(value) {
        wasm.adaptfeedbackwasm_set_learningRate(this.__wbg_ptr, value);
    }
    /**
     * Set quality score (clamped to [0.0, 1.0]).
     * @param {number} value
     */
    set quality(value) {
        wasm.adaptfeedbackwasm_set_quality(this.__wbg_ptr, value);
    }
}
if (Symbol.dispose) AdaptFeedbackWasm.prototype[Symbol.dispose] = AdaptFeedbackWasm.prototype.free;

/**
 * Buffer pool for efficient memory reuse.
 */
export class BufferPoolWasm {
    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(BufferPoolWasm.prototype);
        obj.__wbg_ptr = ptr;
        BufferPoolWasmFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        BufferPoolWasmFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_bufferpoolwasm_free(ptr, 0);
    }
    /**
     * Clear all pooled buffers.
     */
    clear() {
        wasm.bufferpoolwasm_clear(this.__wbg_ptr);
    }
    /**
     * Get the hit rate (0.0 - 1.0).
     * @returns {number}
     */
    get hitRate() {
        const ret = wasm.bufferpoolwasm_hitRate(this.__wbg_ptr);
        return ret;
    }
    /**
     * Create a new buffer pool with default settings.
     */
    constructor() {
        const ret = wasm.bufferpoolwasm_new();
        this.__wbg_ptr = ret >>> 0;
        BufferPoolWasmFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * Pre-warm the pool by allocating buffers.
     * @param {number} count_per_class
     */
    prewarmAll(count_per_class) {
        wasm.bufferpoolwasm_prewarmAll(this.__wbg_ptr, count_per_class);
    }
    /**
     * Get pool statistics as JSON.
     * @returns {string}
     */
    statsJson() {
        let deferred2_0;
        let deferred2_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.bufferpoolwasm_statsJson(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
            var ptr1 = r0;
            var len1 = r1;
            if (r3) {
                ptr1 = 0; len1 = 0;
                throw takeObject(r2);
            }
            deferred2_0 = ptr1;
            deferred2_1 = len1;
            return getStringFromWasm0(ptr1, len1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
        }
    }
    /**
     * Create with specified max buffers per size class.
     * @param {number} max_buffers_per_class
     * @returns {BufferPoolWasm}
     */
    static withCapacity(max_buffers_per_class) {
        const ret = wasm.bufferpoolwasm_withCapacity(max_buffers_per_class);
        return BufferPoolWasm.__wrap(ret);
    }
}
if (Symbol.dispose) BufferPoolWasm.prototype[Symbol.dispose] = BufferPoolWasm.prototype.free;

/**
 * Chat message for instruction-tuned models.
 *
 * Used to construct conversations for chat-based inference.
 */
export class ChatMessageWasm {
    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(ChatMessageWasm.prototype);
        obj.__wbg_ptr = ptr;
        ChatMessageWasmFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    static __unwrap(jsValue) {
        if (!(jsValue instanceof ChatMessageWasm)) {
            return 0;
        }
        return jsValue.__destroy_into_raw();
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        ChatMessageWasmFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_chatmessagewasm_free(ptr, 0);
    }
    /**
     * Create an assistant message.
     * @param {string} content
     * @returns {ChatMessageWasm}
     */
    static assistant(content) {
        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.chatmessagewasm_assistant(ptr0, len0);
        return ChatMessageWasm.__wrap(ret);
    }
    /**
     * Get the message content.
     * @returns {string}
     */
    get content() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.chatmessagewasm_content(retptr, this.__wbg_ptr);
            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_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * Get the role as a string.
     * @returns {string}
     */
    get role() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.chatmessagewasm_role(retptr, this.__wbg_ptr);
            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_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * Create a system message.
     * @param {string} content
     * @returns {ChatMessageWasm}
     */
    static system(content) {
        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.chatmessagewasm_system(ptr0, len0);
        return ChatMessageWasm.__wrap(ret);
    }
    /**
     * Create a user message.
     * @param {string} content
     * @returns {ChatMessageWasm}
     */
    static user(content) {
        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.chatmessagewasm_user(ptr0, len0);
        return ChatMessageWasm.__wrap(ret);
    }
}
if (Symbol.dispose) ChatMessageWasm.prototype[Symbol.dispose] = ChatMessageWasm.prototype.free;

/**
 * Chat template for formatting conversations.
 */
export class ChatTemplateWasm {
    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(ChatTemplateWasm.prototype);
        obj.__wbg_ptr = ptr;
        ChatTemplateWasmFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        ChatTemplateWasmFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_chattemplatewasm_free(ptr, 0);
    }
    /**
     * Create a Qwen/ChatML chat template.
     * @returns {ChatTemplateWasm}
     */
    static chatml() {
        const ret = wasm.chattemplatewasm_chatml();
        return ChatTemplateWasm.__wrap(ret);
    }
    /**
     * Create a custom chat template.
     * @param {string} template
     * @returns {ChatTemplateWasm}
     */
    static custom(template) {
        const ptr0 = passStringToWasm0(template, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.chattemplatewasm_custom(ptr0, len0);
        return ChatTemplateWasm.__wrap(ret);
    }
    /**
     * Detect template from model ID.
     * @param {string} model_id
     * @returns {ChatTemplateWasm}
     */
    static detectFromModelId(model_id) {
        const ptr0 = passStringToWasm0(model_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.chattemplatewasm_detectFromModelId(ptr0, len0);
        return ChatTemplateWasm.__wrap(ret);
    }
    /**
     * Format messages using this template.
     * @param {ChatMessageWasm[]} messages
     * @returns {string}
     */
    format(messages) {
        let deferred2_0;
        let deferred2_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passArrayJsValueToWasm0(messages, wasm.__wbindgen_export);
            const len0 = WASM_VECTOR_LEN;
            wasm.chattemplatewasm_format(retptr, this.__wbg_ptr, ptr0, len0);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred2_0 = r0;
            deferred2_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
        }
    }
    /**
     * Create a Gemma chat template.
     * @returns {ChatTemplateWasm}
     */
    static gemma() {
        const ret = wasm.chattemplatewasm_gemma();
        return ChatTemplateWasm.__wrap(ret);
    }
    /**
     * Create a Llama 3 chat template.
     * @returns {ChatTemplateWasm}
     */
    static llama3() {
        const ret = wasm.chattemplatewasm_llama3();
        return ChatTemplateWasm.__wrap(ret);
    }
    /**
     * Create a Mistral chat template.
     * @returns {ChatTemplateWasm}
     */
    static mistral() {
        const ret = wasm.chattemplatewasm_mistral();
        return ChatTemplateWasm.__wrap(ret);
    }
    /**
     * Get the template name.
     * @returns {string}
     */
    get name() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.chattemplatewasm_name(retptr, this.__wbg_ptr);
            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_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * Create a Phi chat template.
     * @returns {ChatTemplateWasm}
     */
    static phi() {
        const ret = wasm.chattemplatewasm_phi();
        return ChatTemplateWasm.__wrap(ret);
    }
}
if (Symbol.dispose) ChatTemplateWasm.prototype[Symbol.dispose] = ChatTemplateWasm.prototype.free;

/**
 * Generation configuration for text generation.
 *
 * Controls sampling parameters and output constraints.
 * TypeScript-friendly with getter/setter methods.
 */
export class GenerateConfig {
    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(GenerateConfig.prototype);
        obj.__wbg_ptr = ptr;
        GenerateConfigFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        GenerateConfigFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_generateconfig_free(ptr, 0);
    }
    /**
     * Add a stop sequence.
     * @param {string} sequence
     */
    addStopSequence(sequence) {
        const ptr0 = passStringToWasm0(sequence, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len0 = WASM_VECTOR_LEN;
        wasm.generateconfig_addStopSequence(this.__wbg_ptr, ptr0, len0);
    }
    /**
     * Clear all stop sequences.
     */
    clearStopSequences() {
        wasm.generateconfig_clearStopSequences(this.__wbg_ptr);
    }
    /**
     * Create from JSON string.
     * @param {string} json
     * @returns {GenerateConfig}
     */
    static fromJson(json) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passStringToWasm0(json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len0 = WASM_VECTOR_LEN;
            wasm.generateconfig_fromJson(retptr, ptr0, len0);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            return GenerateConfig.__wrap(r0);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Get maximum tokens.
     * @returns {number}
     */
    get maxTokens() {
        const ret = wasm.generateconfig_maxTokens(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Create a new GenerateConfig with default values.
     */
    constructor() {
        const ret = wasm.generateconfig_new();
        this.__wbg_ptr = ret >>> 0;
        GenerateConfigFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * Get repetition penalty.
     * @returns {number}
     */
    get repetitionPenalty() {
        const ret = wasm.generateconfig_repetitionPenalty(this.__wbg_ptr);
        return ret;
    }
    /**
     * Set maximum tokens.
     * @param {number} value
     */
    set maxTokens(value) {
        wasm.generateconfig_set_maxTokens(this.__wbg_ptr, value);
    }
    /**
     * Set repetition penalty.
     * @param {number} value
     */
    set repetitionPenalty(value) {
        wasm.generateconfig_set_repetitionPenalty(this.__wbg_ptr, value);
    }
    /**
     * Set temperature.
     * @param {number} value
     */
    set temperature(value) {
        wasm.generateconfig_set_temperature(this.__wbg_ptr, value);
    }
    /**
     * Set top-k value.
     * @param {number} value
     */
    set topK(value) {
        wasm.generateconfig_set_topK(this.__wbg_ptr, value);
    }
    /**
     * Set top-p value.
     * @param {number} value
     */
    set topP(value) {
        wasm.generateconfig_set_topP(this.__wbg_ptr, value);
    }
    /**
     * Get temperature.
     * @returns {number}
     */
    get temperature() {
        const ret = wasm.generateconfig_temperature(this.__wbg_ptr);
        return ret;
    }
    /**
     * Convert to JSON string.
     * @returns {string}
     */
    toJson() {
        let deferred2_0;
        let deferred2_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.generateconfig_toJson(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
            var ptr1 = r0;
            var len1 = r1;
            if (r3) {
                ptr1 = 0; len1 = 0;
                throw takeObject(r2);
            }
            deferred2_0 = ptr1;
            deferred2_1 = len1;
            return getStringFromWasm0(ptr1, len1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
        }
    }
    /**
     * Get top-k value.
     * @returns {number}
     */
    get topK() {
        const ret = wasm.generateconfig_topK(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Get top-p value.
     * @returns {number}
     */
    get topP() {
        const ret = wasm.generateconfig_topP(this.__wbg_ptr);
        return ret;
    }
}
if (Symbol.dispose) GenerateConfig.prototype[Symbol.dispose] = GenerateConfig.prototype.free;

/**
 * HNSW Semantic Router for browser-compatible pattern routing
 *
 * Provides approximate nearest neighbor search over pattern embeddings
 * using the HNSW (Hierarchical Navigable Small World) algorithm.
 *
 * ## Memory Efficiency
 *
 * The router enforces a maximum number of patterns to prevent unbounded
 * memory growth in browser environments. When the limit is reached, adding
 * new patterns will fail.
 *
 * ## Thread Safety
 *
 * This implementation is single-threaded and designed for use in browser
 * main thread or Web Workers.
 */
export class HnswRouterWasm {
    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(HnswRouterWasm.prototype);
        obj.__wbg_ptr = ptr;
        HnswRouterWasmFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        HnswRouterWasmFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_hnswrouterwasm_free(ptr, 0);
    }
    /**
     * Add a pattern to the router
     *
     * # Parameters
     *
     * - `embedding`: Float32Array of embedding values (must match dimensions)
     * - `name`: Pattern name/identifier
     * - `metadata`: JSON string with additional metadata
     *
     * # Returns
     *
     * `true` if pattern was added, `false` if max_patterns limit reached
     *
     * # Example
     *
     * ```javascript
     * const embedding = new Float32Array([0.1, 0.2, 0.3, ...]); // 384 dims
     * const success = router.addPattern(
     *   embedding,
     *   "rust-expert",
     *   JSON.stringify({ domain: "rust", expertise: "high" })
     * );
     * ```
     * @param {Float32Array} embedding
     * @param {string} name
     * @param {string} metadata
     * @returns {boolean}
     */
    addPattern(embedding, name, metadata) {
        const ptr0 = passArrayF32ToWasm0(embedding, wasm.__wbindgen_export);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len1 = WASM_VECTOR_LEN;
        const ptr2 = passStringToWasm0(metadata, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len2 = WASM_VECTOR_LEN;
        const ret = wasm.hnswrouterwasm_addPattern(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
        return ret !== 0;
    }
    /**
     * Clear all patterns from the router
     *
     * Resets the router to empty state.
     */
    clear() {
        wasm.hnswrouterwasm_clear(this.__wbg_ptr);
    }
    /**
     * Get embedding dimensions
     * @returns {number}
     */
    get dimensions() {
        const ret = wasm.hnswrouterwasm_dimensions(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Get current efSearch parameter
     * @returns {number}
     */
    get efSearch() {
        const ret = wasm.hnswrouterwasm_efSearch(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Deserialize a router from JSON string
     *
     * # Example
     *
     * ```javascript
     * const json = localStorage.getItem('router');
     * const router = HnswRouterWasm.fromJson(json);
     * ```
     * @param {string} json
     * @returns {HnswRouterWasm}
     */
    static fromJson(json) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passStringToWasm0(json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len0 = WASM_VECTOR_LEN;
            wasm.hnswrouterwasm_fromJson(retptr, ptr0, len0);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            return HnswRouterWasm.__wrap(r0);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Get pattern by index
     *
     * # Parameters
     *
     * - `index`: Pattern index (0 to patternCount - 1)
     *
     * # Returns
     *
     * PatternWasm or null if index out of bounds
     * @param {number} index
     * @returns {PatternWasm | undefined}
     */
    getPattern(index) {
        const ret = wasm.hnswrouterwasm_getPattern(this.__wbg_ptr, index);
        return ret === 0 ? undefined : PatternWasm.__wrap(ret);
    }
    /**
     * Get maximum patterns limit
     * @returns {number}
     */
    get maxPatterns() {
        const ret = wasm.hnswrouterwasm_maxPatterns(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Create a new HNSW router
     *
     * # Parameters
     *
     * - `dimensions`: Size of embedding vectors (e.g., 384 for all-MiniLM-L6-v2)
     * - `max_patterns`: Maximum number of patterns to store (memory limit)
     *
     * # Example
     *
     * ```javascript
     * const router = HnswRouterWasm.new(384, 1000);
     * ```
     * @param {number} dimensions
     * @param {number} max_patterns
     */
    constructor(dimensions, max_patterns) {
        const ret = wasm.hnswrouterwasm_new(dimensions, max_patterns);
        this.__wbg_ptr = ret >>> 0;
        HnswRouterWasmFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * Get current number of patterns
     * @returns {number}
     */
    get patternCount() {
        const ret = wasm.hnswrouterwasm_patternCount(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Route a query to find similar patterns
     *
     * # Parameters
     *
     * - `query`: Float32Array of query embedding (must match dimensions)
     * - `top_k`: Number of top results to return
     *
     * # Returns
     *
     * Array of RouteResultWasm ordered by similarity (highest first)
     *
     * # Example
     *
     * ```javascript
     * const query = new Float32Array([0.15, 0.18, ...]); // 384 dims
     * const results = router.route(query, 5);
     * results.forEach(result => {
     *   console.log(`${result.name}: ${result.score}`);
     * });
     * ```
     * @param {Float32Array} query
     * @param {number} top_k
     * @returns {RouteResultWasm[]}
     */
    route(query, top_k) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passArrayF32ToWasm0(query, wasm.__wbindgen_export);
            const len0 = WASM_VECTOR_LEN;
            wasm.hnswrouterwasm_route(retptr, this.__wbg_ptr, ptr0, len0, top_k);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v2 = getArrayJsValueFromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 4, 4);
            return v2;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Set efSearch parameter for query-time accuracy tuning
     *
     * Higher values = more accurate but slower search.
     * Recommended range: 10-200.
     *
     * # Parameters
     *
     * - `ef_search`: Number of neighbors to explore during search
     * @param {number} ef_search
     */
    setEfSearch(ef_search) {
        wasm.hnswrouterwasm_setEfSearch(this.__wbg_ptr, ef_search);
    }
    /**
     * Serialize the router to JSON string
     *
     * Useful for persisting to IndexedDB or localStorage.
     *
     * # Example
     *
     * ```javascript
     * const json = router.toJson();
     * localStorage.setItem('router', json);
     * ```
     * @returns {string}
     */
    toJson() {
        let deferred2_0;
        let deferred2_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.hnswrouterwasm_toJson(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
            var ptr1 = r0;
            var len1 = r1;
            if (r3) {
                ptr1 = 0; len1 = 0;
                throw takeObject(r2);
            }
            deferred2_0 = ptr1;
            deferred2_1 = len1;
            return getStringFromWasm0(ptr1, len1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
        }
    }
}
if (Symbol.dispose) HnswRouterWasm.prototype[Symbol.dispose] = HnswRouterWasm.prototype.free;

/**
 * Arena allocator for inference buffers.
 *
 * Provides fast bump allocation with O(1) reset for
 * generation-step temporaries.
 */
export class InferenceArenaWasm {
    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(InferenceArenaWasm.prototype);
        obj.__wbg_ptr = ptr;
        InferenceArenaWasmFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        InferenceArenaWasmFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_inferencearenawasm_free(ptr, 0);
    }
    /**
     * Get total capacity.
     * @returns {number}
     */
    get capacity() {
        const ret = wasm.inferencearenawasm_capacity(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Create an arena sized for model dimensions.
     * @param {number} hidden_dim
     * @param {number} vocab_size
     * @param {number} batch_size
     * @returns {InferenceArenaWasm}
     */
    static forModel(hidden_dim, vocab_size, batch_size) {
        const ret = wasm.inferencearenawasm_forModel(hidden_dim, vocab_size, batch_size);
        return InferenceArenaWasm.__wrap(ret);
    }
    /**
     * Get high water mark (maximum bytes ever used).
     * @returns {number}
     */
    get highWaterMark() {
        const ret = wasm.inferencearenawasm_highWaterMark(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Create a new arena with the specified capacity in bytes.
     * @param {number} capacity
     */
    constructor(capacity) {
        const ret = wasm.inferencearenawasm_new(capacity);
        this.__wbg_ptr = ret >>> 0;
        InferenceArenaWasmFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * Get remaining available bytes.
     * @returns {number}
     */
    get remaining() {
        const ret = wasm.inferencearenawasm_remaining(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Reset the arena, making all memory available for reuse.
     */
    reset() {
        wasm.inferencearenawasm_reset(this.__wbg_ptr);
    }
    /**
     * Get statistics as JSON.
     * @returns {string}
     */
    statsJson() {
        let deferred2_0;
        let deferred2_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.inferencearenawasm_statsJson(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
            var ptr1 = r0;
            var len1 = r1;
            if (r3) {
                ptr1 = 0; len1 = 0;
                throw takeObject(r2);
            }
            deferred2_0 = ptr1;
            deferred2_1 = len1;
            return getStringFromWasm0(ptr1, len1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
        }
    }
    /**
     * Get current bytes used.
     * @returns {number}
     */
    get used() {
        const ret = wasm.inferencearenawasm_used(this.__wbg_ptr);
        return ret >>> 0;
    }
}
if (Symbol.dispose) InferenceArenaWasm.prototype[Symbol.dispose] = InferenceArenaWasm.prototype.free;

/**
 * KV cache configuration for WASM.
 */
export class KvCacheConfigWasm {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        KvCacheConfigWasmFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_kvcacheconfigwasm_free(ptr, 0);
    }
    /**
     * Get head dimension.
     * @returns {number}
     */
    get headDim() {
        const ret = wasm.kvcacheconfigwasm_headDim(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Get max tokens.
     * @returns {number}
     */
    get maxTokens() {
        const ret = wasm.kvcacheconfigwasm_maxTokens(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Create a new KV cache configuration.
     */
    constructor() {
        const ret = wasm.kvcacheconfigwasm_new();
        this.__wbg_ptr = ret >>> 0;
        KvCacheConfigWasmFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * Get number of KV heads.
     * @returns {number}
     */
    get numKvHeads() {
        const ret = wasm.kvcacheconfigwasm_numKvHeads(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Set head dimension.
     * @param {number} value
     */
    set headDim(value) {
        wasm.kvcacheconfigwasm_set_headDim(this.__wbg_ptr, value);
    }
    /**
     * Set max tokens.
     * @param {number} value
     */
    set maxTokens(value) {
        wasm.kvcacheconfigwasm_set_maxTokens(this.__wbg_ptr, value);
    }
    /**
     * Set number of KV heads.
     * @param {number} value
     */
    set numKvHeads(value) {
        wasm.kvcacheconfigwasm_set_numKvHeads(this.__wbg_ptr, value);
    }
    /**
     * Set tail length.
     * @param {number} value
     */
    set tailLength(value) {
        wasm.kvcacheconfigwasm_set_tailLength(this.__wbg_ptr, value);
    }
    /**
     * Get tail length.
     * @returns {number}
     */
    get tailLength() {
        const ret = wasm.kvcacheconfigwasm_tailLength(this.__wbg_ptr);
        return ret >>> 0;
    }
}
if (Symbol.dispose) KvCacheConfigWasm.prototype[Symbol.dispose] = KvCacheConfigWasm.prototype.free;

/**
 * KV cache statistics.
 */
export class KvCacheStatsWasm {
    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(KvCacheStatsWasm.prototype);
        obj.__wbg_ptr = ptr;
        KvCacheStatsWasmFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        KvCacheStatsWasmFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_kvcachestatswasm_free(ptr, 0);
    }
    /**
     * Get compression ratio.
     * @returns {number}
     */
    get compressionRatio() {
        const ret = wasm.kvcachestatswasm_compressionRatio(this.__wbg_ptr);
        return ret;
    }
    /**
     * Get store tokens.
     * @returns {number}
     */
    get storeTokens() {
        const ret = wasm.kvcachestatswasm_storeTokens(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Get tail tokens.
     * @returns {number}
     */
    get tailTokens() {
        const ret = wasm.kvcachestatswasm_tailTokens(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Convert to JSON.
     * @returns {string}
     */
    toJson() {
        let deferred2_0;
        let deferred2_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.kvcachestatswasm_toJson(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
            var ptr1 = r0;
            var len1 = r1;
            if (r3) {
                ptr1 = 0; len1 = 0;
                throw takeObject(r2);
            }
            deferred2_0 = ptr1;
            deferred2_1 = len1;
            return getStringFromWasm0(ptr1, len1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
        }
    }
    /**
     * Get total tokens.
     * @returns {number}
     */
    get totalTokens() {
        const ret = wasm.kvcachestatswasm_totalTokens(this.__wbg_ptr);
        return ret >>> 0;
    }
}
if (Symbol.dispose) KvCacheStatsWasm.prototype[Symbol.dispose] = KvCacheStatsWasm.prototype.free;

/**
 * Two-tier KV cache for WASM.
 *
 * Provides memory-efficient caching with a high-precision tail
 * and quantized store for older tokens.
 */
export class KvCacheWasm {
    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(KvCacheWasm.prototype);
        obj.__wbg_ptr = ptr;
        KvCacheWasmFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        KvCacheWasmFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_kvcachewasm_free(ptr, 0);
    }
    /**
     * Append KV pairs to the cache.
     * @param {Float32Array} keys
     * @param {Float32Array} values
     */
    append(keys, values) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passArrayF32ToWasm0(keys, wasm.__wbindgen_export);
            const len0 = WASM_VECTOR_LEN;
            const ptr1 = passArrayF32ToWasm0(values, wasm.__wbindgen_export);
            const len1 = WASM_VECTOR_LEN;
            wasm.kvcachewasm_append(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            if (r1) {
                throw takeObject(r0);
            }
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Clear the cache.
     */
    clear() {
        wasm.kvcachewasm_clear(this.__wbg_ptr);
    }
    /**
     * Get all cached KV pairs.
     * @returns {any}
     */
    getAllKv() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.kvcachewasm_getAllKv(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            return takeObject(r0);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Create a new KV cache with the given configuration.
     * @param {KvCacheConfigWasm} config
     */
    constructor(config) {
        _assertClass(config, KvCacheConfigWasm);
        const ret = wasm.kvcachewasm_new(config.__wbg_ptr);
        this.__wbg_ptr = ret >>> 0;
        KvCacheWasmFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * Get cache statistics.
     * @returns {KvCacheStatsWasm}
     */
    stats() {
        const ret = wasm.kvcachewasm_stats(this.__wbg_ptr);
        return KvCacheStatsWasm.__wrap(ret);
    }
    /**
     * Get the total number of cached tokens.
     * @returns {number}
     */
    get tokenCount() {
        const ret = wasm.kvcachewasm_tokenCount(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Create with default configuration.
     * @returns {KvCacheWasm}
     */
    static withDefaults() {
        const ret = wasm.kvcachewasm_withDefaults();
        return KvCacheWasm.__wrap(ret);
    }
}
if (Symbol.dispose) KvCacheWasm.prototype[Symbol.dispose] = KvCacheWasm.prototype.free;

/**
 * Configuration for MicroLoRA adapter.
 *
 * Controls the rank, scaling, and dimensions of the LoRA adapter.
 * TypeScript-friendly with getter/setter methods.
 */
export class MicroLoraConfigWasm {
    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(MicroLoraConfigWasm.prototype);
        obj.__wbg_ptr = ptr;
        MicroLoraConfigWasmFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        MicroLoraConfigWasmFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_microloraconfigwasm_free(ptr, 0);
    }
    /**
     * Get alpha scaling factor.
     * @returns {number}
     */
    get alpha() {
        const ret = wasm.microloraconfigwasm_alpha(this.__wbg_ptr);
        return ret;
    }
    /**
     * Get computed scaling factor (alpha / rank).
     * @returns {number}
     */
    computeScaling() {
        const ret = wasm.microloraconfigwasm_computeScaling(this.__wbg_ptr);
        return ret;
    }
    /**
     * Get input feature dimension.
     * @returns {number}
     */
    get inFeatures() {
        const ret = wasm.microloraconfigwasm_inFeatures(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Calculate memory footprint in bytes.
     * @returns {number}
     */
    memoryBytes() {
        const ret = wasm.microloraconfigwasm_memoryBytes(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Create a new config with default values (rank=2, alpha=4.0, 768x768).
     */
    constructor() {
        const ret = wasm.microloraconfigwasm_new();
        this.__wbg_ptr = ret >>> 0;
        MicroLoraConfigWasmFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * Get output feature dimension.
     * @returns {number}
     */
    get outFeatures() {
        const ret = wasm.microloraconfigwasm_outFeatures(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Get rank.
     * @returns {number}
     */
    get rank() {
        const ret = wasm.microloraconfigwasm_rank(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Set alpha scaling factor.
     * @param {number} value
     */
    set alpha(value) {
        wasm.microloraconfigwasm_set_alpha(this.__wbg_ptr, value);
    }
    /**
     * Set input feature dimension.
     * @param {number} value
     */
    set inFeatures(value) {
        wasm.microloraconfigwasm_set_inFeatures(this.__wbg_ptr, value);
    }
    /**
     * Set output feature dimension.
     * @param {number} value
     */
    set outFeatures(value) {
        wasm.microloraconfigwasm_set_outFeatures(this.__wbg_ptr, value);
    }
    /**
     * Set rank (clamped to 1-4 for browser efficiency).
     * @param {number} value
     */
    set rank(value) {
        wasm.microloraconfigwasm_set_rank(this.__wbg_ptr, value);
    }
}
if (Symbol.dispose) MicroLoraConfigWasm.prototype[Symbol.dispose] = MicroLoraConfigWasm.prototype.free;

/**
 * Statistics for MicroLoRA adapter.
 */
export class MicroLoraStatsWasm {
    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(MicroLoraStatsWasm.prototype);
        obj.__wbg_ptr = ptr;
        MicroLoraStatsWasmFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        MicroLoraStatsWasmFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_microlorastatswasm_free(ptr, 0);
    }
    /**
     * Get average quality score.
     * @returns {number}
     */
    get avgQuality() {
        const ret = wasm.microlorastatswasm_avgQuality(this.__wbg_ptr);
        return ret;
    }
    /**
     * Get memory usage in bytes.
     * @returns {number}
     */
    get memoryBytes() {
        const ret = wasm.microlorastatswasm_memoryBytes(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Get parameter count.
     * @returns {number}
     */
    get paramCount() {
        const ret = wasm.microlorastatswasm_paramCount(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Get number of samples seen.
     * @returns {number}
     */
    get samplesSeen() {
        const ret = wasm.microlorastatswasm_samplesSeen(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Convert to JSON string.
     * @returns {string}
     */
    toJson() {
        let deferred2_0;
        let deferred2_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.microlorastatswasm_toJson(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
            var ptr1 = r0;
            var len1 = r1;
            if (r3) {
                ptr1 = 0; len1 = 0;
                throw takeObject(r2);
            }
            deferred2_0 = ptr1;
            deferred2_1 = len1;
            return getStringFromWasm0(ptr1, len1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
        }
    }
}
if (Symbol.dispose) MicroLoraStatsWasm.prototype[Symbol.dispose] = MicroLoraStatsWasm.prototype.free;

/**
 * MicroLoRA adapter for browser-based real-time adaptation.
 *
 * Provides lightweight LoRA (Low-Rank Adaptation) with minimal memory footprint
 * suitable for browser environments. Supports per-request adaptation with
 * quality-based feedback.
 */
export class MicroLoraWasm {
    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(MicroLoraWasm.prototype);
        obj.__wbg_ptr = ptr;
        MicroLoraWasmFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        MicroLoraWasmFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_microlorawasm_free(ptr, 0);
    }
    /**
     * Adapt the LoRA weights based on feedback.
     *
     * Accumulates gradients based on the quality score. Call `applyUpdates()`
     * to actually apply the accumulated gradients.
     * @param {Float32Array} input
     * @param {AdaptFeedbackWasm} feedback
     */
    adapt(input, feedback) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passArrayF32ToWasm0(input, wasm.__wbindgen_export);
            const len0 = WASM_VECTOR_LEN;
            _assertClass(feedback, AdaptFeedbackWasm);
            wasm.microlorawasm_adapt(retptr, this.__wbg_ptr, ptr0, len0, feedback.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            if (r1) {
                throw takeObject(r0);
            }
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Apply LoRA transformation to input.
     *
     * Returns a new Float32Array with the transformed output.
     * The output is added to (not replaced) so you can combine with base model output.
     * @param {Float32Array} input
     * @returns {Float32Array}
     */
    apply(input) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passArrayF32ToWasm0(input, wasm.__wbindgen_export);
            const len0 = WASM_VECTOR_LEN;
            wasm.microlorawasm_apply(retptr, this.__wbg_ptr, ptr0, len0);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
            if (r3) {
                throw takeObject(r2);
            }
            var v2 = getArrayF32FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 4, 4);
            return v2;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Apply accumulated gradients with the given learning rate.
     *
     * Should be called after one or more `adapt()` calls to update the weights.
     * @param {number} learning_rate
     */
    applyUpdates(learning_rate) {
        wasm.microlorawasm_applyUpdates(this.__wbg_ptr, learning_rate);
    }
    /**
     * Deserialize from JSON string.
     * @param {string} json
     * @returns {MicroLoraWasm}
     */
    static fromJson(json) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passStringToWasm0(json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len0 = WASM_VECTOR_LEN;
            wasm.microlorawasm_fromJson(retptr, ptr0, len0);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            return MicroLoraWasm.__wrap(r0);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Get configuration.
     * @returns {MicroLoraConfigWasm}
     */
    getConfig() {
        const ret = wasm.microlorawasm_getConfig(this.__wbg_ptr);
        return MicroLoraConfigWasm.__wrap(ret);
    }
    /**
     * Create a new MicroLoRA adapter with the given configuration.
     * @param {MicroLoraConfigWasm} config
     */
    constructor(config) {
        _assertClass(config, MicroLoraConfigWasm);
        const ret = wasm.microlorawasm_new(config.__wbg_ptr);
        this.__wbg_ptr = ret >>> 0;
        MicroLoraWasmFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * Get number of pending gradient updates.
     * @returns {number}
     */
    pendingUpdates() {
        const ret = wasm.microlorawasm_pendingUpdates(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Reset the adapter to its initial state.
     *
     * Clears B weights and all statistics.
     */
    reset() {
        wasm.microlorawasm_reset(this.__wbg_ptr);
    }
    /**
     * Get adapter statistics.
     * @returns {MicroLoraStatsWasm}
     */
    stats() {
        const ret = wasm.microlorawasm_stats(this.__wbg_ptr);
        return MicroLoraStatsWasm.__wrap(ret);
    }
    /**
     * Serialize to JSON string for persistence.
     * @returns {string}
     */
    toJson() {
        let deferred2_0;
        let deferred2_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.microlorawasm_toJson(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
            var ptr1 = r0;
            var len1 = r1;
            if (r3) {
                ptr1 = 0; len1 = 0;
                throw takeObject(r2);
            }
            deferred2_0 = ptr1;
            deferred2_1 = len1;
            return getStringFromWasm0(ptr1, len1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
        }
    }
}
if (Symbol.dispose) MicroLoraWasm.prototype[Symbol.dispose] = MicroLoraWasm.prototype.free;

/**
 * Main parallel inference interface for WASM.
 *
 * Provides high-level API for parallel compute operations in the browser.
 * Automatically manages worker pool and shared memory.
 */
export class ParallelInference {
    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(ParallelInference.prototype);
        obj.__wbg_ptr = ptr;
        ParallelInferenceFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        ParallelInferenceFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_parallelinference_free(ptr, 0);
    }
    /**
     * Perform parallel multi-head attention.
     *
     * Computes softmax(Q * K^T / sqrt(d_k)) * V for each attention head.
     *
     * # Arguments
     * * `q` - Query tensor (batch_size, num_heads, seq_len, head_dim)
     * * `k` - Key tensor (batch_size, num_heads, seq_len, head_dim)
     * * `v` - Value tensor (batch_size, num_heads, seq_len, head_dim)
     * * `num_heads` - Number of attention heads
     * * `head_dim` - Dimension of each head
     * * `seq_len` - Sequence length
     *
     * # Returns
     * Output tensor (batch_size, num_heads, seq_len, head_dim)
     * @param {Float32Array} q
     * @param {Float32Array} k
     * @param {Float32Array} v
     * @param {number} num_heads
     * @param {number} head_dim
     * @param {number} seq_len
     * @returns {Promise<Float32Array>}
     */
    attention(q, k, v, num_heads, head_dim, seq_len) {
        const ptr0 = passArrayF32ToWasm0(q, wasm.__wbindgen_export);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passArrayF32ToWasm0(k, wasm.__wbindgen_export);
        const len1 = WASM_VECTOR_LEN;
        const ptr2 = passArrayF32ToWasm0(v, wasm.__wbindgen_export);
        const len2 = WASM_VECTOR_LEN;
        const ret = wasm.parallelinference_attention(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, num_heads, head_dim, seq_len);
        return takeObject(ret);
    }
    /**
     * Get statistics about worker pool.
     * @returns {string}
     */
    getStats() {
        let deferred2_0;
        let deferred2_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.parallelinference_getStats(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
            var ptr1 = r0;
            var len1 = r1;
            if (r3) {
                ptr1 = 0; len1 = 0;
                throw takeObject(r2);
            }
            deferred2_0 = ptr1;
            deferred2_1 = len1;
            return getStringFromWasm0(ptr1, len1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
        }
    }
    /**
     * Check if Atomics API is available.
     * @returns {boolean}
     */
    isAtomicsAvailable() {
        const ret = wasm.parallelinference_isAtomicsAvailable(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * Check if the page is cross-origin isolated.
     * @returns {boolean}
     */
    isCrossOriginIsolated() {
        const ret = wasm.parallelinference_isCrossOriginIsolated(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * Check if SharedArrayBuffer is available.
     * @returns {boolean}
     */
    isSharedMemoryAvailable() {
        const ret = wasm.parallelinference_isSharedMemoryAvailable(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * Perform parallel layer normalization.
     *
     * # Arguments
     * * `input` - Input tensor
     * * `gamma` - Scale parameter
     * * `beta` - Shift parameter
     * * `epsilon` - Small constant for numerical stability
     *
     * # Returns
     * Normalized tensor
     * @param {Float32Array} input
     * @param {Float32Array} gamma
     * @param {Float32Array} beta
     * @param {number} epsilon
     * @returns {Promise<Float32Array>}
     */
    layerNorm(input, gamma, beta, epsilon) {
        const ptr0 = passArrayF32ToWasm0(input, wasm.__wbindgen_export);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passArrayF32ToWasm0(gamma, wasm.__wbindgen_export);
        const len1 = WASM_VECTOR_LEN;
        const ptr2 = passArrayF32ToWasm0(beta, wasm.__wbindgen_export);
        const len2 = WASM_VECTOR_LEN;
        const ret = wasm.parallelinference_layerNorm(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, epsilon);
        return takeObject(ret);
    }
    /**
     * Perform parallel matrix multiplication.
     *
     * Computes C = A * B where:
     * - A is m x k
     * - B is k x n
     * - C is m x n
     *
     * # Arguments
     * * `a` - Matrix A as flat array (row-major)
     * * `b` - Matrix B as flat array (row-major)
     * * `m` - Number of rows in A
     * * `n` - Number of columns in B
     * * `k` - Number of columns in A / rows in B
     *
     * # Returns
     * Result matrix C as Float32Array
     * @param {Float32Array} a
     * @param {Float32Array} b
     * @param {number} m
     * @param {number} n
     * @param {number} k
     * @returns {Promise<Float32Array>}
     */
    matmul(a, b, m, n, k) {
        const ptr0 = passArrayF32ToWasm0(a, wasm.__wbindgen_export);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passArrayF32ToWasm0(b, wasm.__wbindgen_export);
        const len1 = WASM_VECTOR_LEN;
        const ret = wasm.parallelinference_matmul(this.__wbg_ptr, ptr0, len0, ptr1, len1, m, n, k);
        return takeObject(ret);
    }
    /**
     * Create a new ParallelInference instance.
     *
     * # Arguments
     * * `num_workers` - Number of workers to spawn. If None, uses optimal count.
     *
     * # Returns
     * A Promise that resolves to ParallelInference instance.
     *
     * # Example (JavaScript)
     * ```javascript
     * const inference = await ParallelInference.new(4);
     * ```
     * @param {number | null} [num_workers]
     */
    constructor(num_workers) {
        const ret = wasm.parallelinference_new(isLikeNone(num_workers) ? 0x100000001 : (num_workers) >>> 0);
        return takeObject(ret);
    }
    /**
     * Get optimal worker count for the current hardware.
     * @returns {number}
     */
    static optimalWorkerCount() {
        const ret = wasm.parallelinference_optimalWorkerCount();
        return ret >>> 0;
    }
    /**
     * Terminate all workers and clean up resources.
     */
    terminate() {
        wasm.parallelinference_terminate(this.__wbg_ptr);
    }
    /**
     * Get the number of active workers.
     * @returns {number}
     */
    workerCount() {
        const ret = wasm.parallelinference_workerCount(this.__wbg_ptr);
        return ret >>> 0;
    }
}
if (Symbol.dispose) ParallelInference.prototype[Symbol.dispose] = ParallelInference.prototype.free;

/**
 * A stored pattern with embedding and metadata
 *
 * Represents a routing pattern that can be matched against queries.
 * Each pattern has a name, embedding vector, and optional metadata.
 */
export class PatternWasm {
    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(PatternWasm.prototype);
        obj.__wbg_ptr = ptr;
        PatternWasmFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        PatternWasmFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_patternwasm_free(ptr, 0);
    }
    /**
     * Get pattern embedding as Float32Array
     * @returns {Float32Array}
     */
    get embedding() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.patternwasm_embedding(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF32FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 4, 4);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Get pattern metadata JSON string
     * @returns {string}
     */
    get metadata() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.patternwasm_metadata(retptr, this.__wbg_ptr);
            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_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * Get pattern name
     * @returns {string}
     */
    get name() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.patternwasm_name(retptr, this.__wbg_ptr);
            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_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * Create a new pattern
     *
     * # Parameters
     *
     * - `embedding`: Float32Array of embedding values
     * - `name`: Pattern name/identifier
     * - `metadata`: JSON string with additional metadata
     * @param {Float32Array} embedding
     * @param {string} name
     * @param {string} metadata
     */
    constructor(embedding, name, metadata) {
        const ptr0 = passArrayF32ToWasm0(embedding, wasm.__wbindgen_export);
        const len0 = WASM_VECTOR_LEN;
        const ptr1 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len1 = WASM_VECTOR_LEN;
        const ptr2 = passStringToWasm0(metadata, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len2 = WASM_VECTOR_LEN;
        const ret = wasm.patternwasm_new(ptr0, len0, ptr1, len1, ptr2, len2);
        this.__wbg_ptr = ret >>> 0;
        PatternWasmFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * Set pattern metadata
     * @param {string} metadata
     */
    set metadata(metadata) {
        const ptr0 = passStringToWasm0(metadata, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len0 = WASM_VECTOR_LEN;
        wasm.patternwasm_set_metadata(this.__wbg_ptr, ptr0, len0);
    }
    /**
     * Set pattern name
     * @param {string} name
     */
    set name(name) {
        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len0 = WASM_VECTOR_LEN;
        wasm.patternwasm_set_name(this.__wbg_ptr, ptr0, len0);
    }
}
if (Symbol.dispose) PatternWasm.prototype[Symbol.dispose] = PatternWasm.prototype.free;

/**
 * A routing search result with similarity score
 *
 * Represents a matched pattern from a semantic search query.
 */
export class RouteResultWasm {
    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(RouteResultWasm.prototype);
        obj.__wbg_ptr = ptr;
        RouteResultWasmFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        RouteResultWasmFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_routeresultwasm_free(ptr, 0);
    }
    /**
     * Get result embedding as Float32Array
     * @returns {Float32Array}
     */
    get embedding() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.routeresultwasm_embedding(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var v1 = getArrayF32FromWasm0(r0, r1).slice();
            wasm.__wbindgen_export4(r0, r1 * 4, 4);
            return v1;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Get result metadata JSON string
     * @returns {string}
     */
    get metadata() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.routeresultwasm_metadata(retptr, this.__wbg_ptr);
            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_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * Get result pattern name
     * @returns {string}
     */
    get name() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.routeresultwasm_name(retptr, this.__wbg_ptr);
            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_export4(deferred1_0, deferred1_1, 1);
        }
    }
    /**
     * Get similarity score (higher is better, 0.0-1.0 for cosine)
     * @returns {number}
     */
    get score() {
        const ret = wasm.routeresultwasm_score(this.__wbg_ptr);
        return ret;
    }
}
if (Symbol.dispose) RouteResultWasm.prototype[Symbol.dispose] = RouteResultWasm.prototype.free;

/**
 * Main RuvLLM WASM interface.
 *
 * Provides the primary entry point for LLM inference in the browser.
 * Manages KV cache, memory pools, and inference state.
 */
export class RuvLLMWasm {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        RuvLLMWasmFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_ruvllmwasm_free(ptr, 0);
    }
    /**
     * Format a chat conversation using a template.
     * @param {ChatTemplateWasm} template
     * @param {ChatMessageWasm[]} messages
     * @returns {string}
     */
    static formatChat(template, messages) {
        let deferred2_0;
        let deferred2_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            _assertClass(template, ChatTemplateWasm);
            const ptr0 = passArrayJsValueToWasm0(messages, wasm.__wbindgen_export);
            const len0 = WASM_VECTOR_LEN;
            wasm.ruvllmwasm_formatChat(retptr, template.__wbg_ptr, ptr0, len0);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            deferred2_0 = r0;
            deferred2_1 = r1;
            return getStringFromWasm0(r0, r1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
        }
    }
    /**
     * Get buffer pool statistics.
     * @returns {string}
     */
    getPoolStats() {
        let deferred2_0;
        let deferred2_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.ruvllmwasm_getPoolStats(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
            var ptr1 = r0;
            var len1 = r1;
            if (r3) {
                ptr1 = 0; len1 = 0;
                throw takeObject(r2);
            }
            deferred2_0 = ptr1;
            deferred2_1 = len1;
            return getStringFromWasm0(ptr1, len1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
        }
    }
    /**
     * Initialize the engine with default configuration.
     */
    initialize() {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.ruvllmwasm_initialize(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            if (r1) {
                throw takeObject(r0);
            }
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Initialize with custom KV cache configuration.
     * @param {KvCacheConfigWasm} config
     */
    initializeWithConfig(config) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            _assertClass(config, KvCacheConfigWasm);
            wasm.ruvllmwasm_initializeWithConfig(retptr, this.__wbg_ptr, config.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            if (r1) {
                throw takeObject(r0);
            }
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Check if the engine is initialized.
     * @returns {boolean}
     */
    get isInitialized() {
        const ret = wasm.ruvllmwasm_isInitialized(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * Create a new RuvLLM WASM instance.
     */
    constructor() {
        const ret = wasm.ruvllmwasm_new();
        this.__wbg_ptr = ret >>> 0;
        RuvLLMWasmFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * Clear all caches and reset state.
     */
    reset() {
        wasm.ruvllmwasm_reset(this.__wbg_ptr);
    }
    /**
     * Get version information.
     * @returns {string}
     */
    static version() {
        let deferred1_0;
        let deferred1_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.ruvllmwasm_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_export4(deferred1_0, deferred1_1, 1);
        }
    }
}
if (Symbol.dispose) RuvLLMWasm.prototype[Symbol.dispose] = RuvLLMWasm.prototype.free;

/**
 * Result of instant adaptation
 */
export class SonaAdaptResultWasm {
    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(SonaAdaptResultWasm.prototype);
        obj.__wbg_ptr = ptr;
        SonaAdaptResultWasmFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        SonaAdaptResultWasmFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_sonaadaptresultwasm_free(ptr, 0);
    }
    /**
     * Get applied status
     * @returns {boolean}
     */
    get applied() {
        const ret = wasm.sonaadaptresultwasm_applied(this.__wbg_ptr);
        return ret !== 0;
    }
    /**
     * Get current rank
     * @returns {number}
     */
    get currentRank() {
        const ret = wasm.sonaadaptresultwasm_currentRank(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Get latency in microseconds
     * @returns {bigint}
     */
    get latencyUs() {
        const ret = wasm.sonaadaptresultwasm_latencyUs(this.__wbg_ptr);
        return BigInt.asUintN(64, ret);
    }
    /**
     * Get quality delta
     * @returns {number}
     */
    get qualityDelta() {
        const ret = wasm.sonaadaptresultwasm_qualityDelta(this.__wbg_ptr);
        return ret;
    }
    /**
     * Get quality EMA
     * @returns {number}
     */
    get qualityEma() {
        const ret = wasm.sonaadaptresultwasm_qualityEma(this.__wbg_ptr);
        return ret;
    }
    /**
     * Convert to JSON
     * @returns {string}
     */
    toJson() {
        let deferred2_0;
        let deferred2_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.sonaadaptresultwasm_toJson(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
            var ptr1 = r0;
            var len1 = r1;
            if (r3) {
                ptr1 = 0; len1 = 0;
                throw takeObject(r2);
            }
            deferred2_0 = ptr1;
            deferred2_1 = len1;
            return getStringFromWasm0(ptr1, len1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
        }
    }
}
if (Symbol.dispose) SonaAdaptResultWasm.prototype[Symbol.dispose] = SonaAdaptResultWasm.prototype.free;

/**
 * Configuration for SONA Instant Loop (WASM)
 */
export class SonaConfigWasm {
    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(SonaConfigWasm.prototype);
        obj.__wbg_ptr = ptr;
        SonaConfigWasmFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        SonaConfigWasmFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_sonaconfigwasm_free(ptr, 0);
    }
    /**
     * Get EMA decay
     * @returns {number}
     */
    get emaDecay() {
        const ret = wasm.sonaconfigwasm_emaDecay(this.__wbg_ptr);
        return ret;
    }
    /**
     * Get EWC lambda
     * @returns {number}
     */
    get ewcLambda() {
        const ret = wasm.sonaconfigwasm_ewcLambda(this.__wbg_ptr);
        return ret;
    }
    /**
     * Create from JSON
     * @param {string} json
     * @returns {SonaConfigWasm}
     */
    static fromJson(json) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passStringToWasm0(json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len0 = WASM_VECTOR_LEN;
            wasm.sonaconfigwasm_fromJson(retptr, ptr0, len0);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            return SonaConfigWasm.__wrap(r0);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Get hidden dimension
     * @returns {number}
     */
    get hiddenDim() {
        const ret = wasm.sonaconfigwasm_hiddenDim(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Get learning rate
     * @returns {number}
     */
    get learningRate() {
        const ret = wasm.sonaconfigwasm_learningRate(this.__wbg_ptr);
        return ret;
    }
    /**
     * Get micro-LoRA rank
     * @returns {number}
     */
    get microLoraRank() {
        const ret = wasm.sonaconfigwasm_microLoraRank(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Create new config with defaults
     */
    constructor() {
        const ret = wasm.sonaconfigwasm_new();
        this.__wbg_ptr = ret >>> 0;
        SonaConfigWasmFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * Get pattern capacity
     * @returns {number}
     */
    get patternCapacity() {
        const ret = wasm.sonaconfigwasm_patternCapacity(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Set EMA decay
     * @param {number} value
     */
    set emaDecay(value) {
        wasm.sonaconfigwasm_set_emaDecay(this.__wbg_ptr, value);
    }
    /**
     * Set EWC lambda
     * @param {number} value
     */
    set ewcLambda(value) {
        wasm.sonaconfigwasm_set_ewcLambda(this.__wbg_ptr, value);
    }
    /**
     * Set hidden dimension
     * @param {number} value
     */
    set hiddenDim(value) {
        wasm.sonaconfigwasm_set_hiddenDim(this.__wbg_ptr, value);
    }
    /**
     * Set learning rate
     * @param {number} value
     */
    set learningRate(value) {
        wasm.sonaconfigwasm_set_learningRate(this.__wbg_ptr, value);
    }
    /**
     * Set micro-LoRA rank
     * @param {number} value
     */
    set microLoraRank(value) {
        wasm.sonaconfigwasm_set_microLoraRank(this.__wbg_ptr, value);
    }
    /**
     * Set pattern capacity
     * @param {number} value
     */
    set patternCapacity(value) {
        wasm.sonaconfigwasm_set_patternCapacity(this.__wbg_ptr, value);
    }
    /**
     * Convert to JSON
     * @returns {string}
     */
    toJson() {
        let deferred2_0;
        let deferred2_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.sonaconfigwasm_toJson(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
            var ptr1 = r0;
            var len1 = r1;
            if (r3) {
                ptr1 = 0; len1 = 0;
                throw takeObject(r2);
            }
            deferred2_0 = ptr1;
            deferred2_1 = len1;
            return getStringFromWasm0(ptr1, len1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
        }
    }
}
if (Symbol.dispose) SonaConfigWasm.prototype[Symbol.dispose] = SonaConfigWasm.prototype.free;

/**
 * SONA Instant Loop for WASM
 */
export class SonaInstantWasm {
    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(SonaInstantWasm.prototype);
        obj.__wbg_ptr = ptr;
        SonaInstantWasmFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        SonaInstantWasmFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_sonainstantwasm_free(ptr, 0);
    }
    /**
     * Import state from JSON (partial - doesn't restore patterns)
     * @param {string} json
     * @returns {SonaInstantWasm}
     */
    static fromJson(json) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passStringToWasm0(json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len0 = WASM_VECTOR_LEN;
            wasm.sonainstantwasm_fromJson(retptr, ptr0, len0);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            if (r2) {
                throw takeObject(r1);
            }
            return SonaInstantWasm.__wrap(r0);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Get number of important weights tracked (EWC-lite)
     * @returns {number}
     */
    importantWeightCount() {
        const ret = wasm.sonainstantwasm_importantWeightCount(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Instant adaptation based on quality signal
     *
     * Target: <1ms latency
     * @param {number} quality
     * @returns {SonaAdaptResultWasm}
     */
    instantAdapt(quality) {
        const ret = wasm.sonainstantwasm_instantAdapt(this.__wbg_ptr, quality);
        return SonaAdaptResultWasm.__wrap(ret);
    }
    /**
     * Create new SONA instant loop
     * @param {SonaConfigWasm} config
     */
    constructor(config) {
        _assertClass(config, SonaConfigWasm);
        var ptr0 = config.__destroy_into_raw();
        const ret = wasm.sonainstantwasm_new(ptr0);
        this.__wbg_ptr = ret >>> 0;
        SonaInstantWasmFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * Record a pattern outcome for future reference
     * @param {Float32Array} embedding
     * @param {boolean} success
     */
    recordPattern(embedding, success) {
        const ptr0 = passArrayF32ToWasm0(embedding, wasm.__wbindgen_export);
        const len0 = WASM_VECTOR_LEN;
        wasm.sonainstantwasm_recordPattern(this.__wbg_ptr, ptr0, len0, success);
    }
    /**
     * Reset all learning state
     */
    reset() {
        wasm.sonainstantwasm_reset(this.__wbg_ptr);
    }
    /**
     * Get current statistics
     * @returns {SonaStatsWasm}
     */
    stats() {
        const ret = wasm.sonainstantwasm_stats(this.__wbg_ptr);
        return SonaStatsWasm.__wrap(ret);
    }
    /**
     * Suggest action based on learned patterns
     *
     * Uses simple cosine similarity search (HNSW integration point for future)
     * @param {Float32Array} context
     * @returns {string | undefined}
     */
    suggestAction(context) {
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            const ptr0 = passArrayF32ToWasm0(context, wasm.__wbindgen_export);
            const len0 = WASM_VECTOR_LEN;
            wasm.sonainstantwasm_suggestAction(retptr, this.__wbg_ptr, ptr0, len0);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            let v2;
            if (r0 !== 0) {
                v2 = getStringFromWasm0(r0, r1).slice();
                wasm.__wbindgen_export4(r0, r1 * 1, 1);
            }
            return v2;
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
        }
    }
    /**
     * Export state to JSON
     * @returns {string}
     */
    toJson() {
        let deferred2_0;
        let deferred2_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.sonainstantwasm_toJson(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
            var ptr1 = r0;
            var len1 = r1;
            if (r3) {
                ptr1 = 0; len1 = 0;
                throw takeObject(r2);
            }
            deferred2_0 = ptr1;
            deferred2_1 = len1;
            return getStringFromWasm0(ptr1, len1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
        }
    }
}
if (Symbol.dispose) SonaInstantWasm.prototype[Symbol.dispose] = SonaInstantWasm.prototype.free;

/**
 * Learning statistics
 */
export class SonaStatsWasm {
    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(SonaStatsWasm.prototype);
        obj.__wbg_ptr = ptr;
        SonaStatsWasmFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        SonaStatsWasmFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_sonastatswasm_free(ptr, 0);
    }
    /**
     * Get adaptations count
     * @returns {bigint}
     */
    get adaptations() {
        const ret = wasm.sonastatswasm_adaptations(this.__wbg_ptr);
        return BigInt.asUintN(64, ret);
    }
    /**
     * Get average latency
     * @returns {number}
     */
    get avgLatencyUs() {
        const ret = wasm.sonastatswasm_avgLatencyUs(this.__wbg_ptr);
        return ret;
    }
    /**
     * Get average quality
     * @returns {number}
     */
    get avgQuality() {
        const ret = wasm.sonastatswasm_avgQuality(this.__wbg_ptr);
        return ret;
    }
    /**
     * Get buffer size
     * @returns {number}
     */
    get bufferSize() {
        const ret = wasm.sonastatswasm_bufferSize(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Get current rank
     * @returns {number}
     */
    get currentRank() {
        const ret = wasm.sonastatswasm_currentRank(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Get patterns recorded
     * @returns {bigint}
     */
    get patternsRecorded() {
        const ret = wasm.sonastatswasm_patternsRecorded(this.__wbg_ptr);
        return BigInt.asUintN(64, ret);
    }
    /**
     * Success rate
     * @returns {number}
     */
    successRate() {
        const ret = wasm.sonastatswasm_successRate(this.__wbg_ptr);
        return ret;
    }
    /**
     * Get successful patterns
     * @returns {bigint}
     */
    get successfulPatterns() {
        const ret = wasm.sonastatswasm_successfulPatterns(this.__wbg_ptr);
        return BigInt.asUintN(64, ret);
    }
    /**
     * Convert to JSON
     * @returns {string}
     */
    toJson() {
        let deferred2_0;
        let deferred2_1;
        try {
            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
            wasm.sonastatswasm_toJson(retptr, this.__wbg_ptr);
            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
            var ptr1 = r0;
            var len1 = r1;
            if (r3) {
                ptr1 = 0; len1 = 0;
                throw takeObject(r2);
            }
            deferred2_0 = ptr1;
            deferred2_1 = len1;
            return getStringFromWasm0(ptr1, len1);
        } finally {
            wasm.__wbindgen_add_to_stack_pointer(16);
            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
        }
    }
}
if (Symbol.dispose) SonaStatsWasm.prototype[Symbol.dispose] = SonaStatsWasm.prototype.free;

/**
 * Simple timer for measuring elapsed time in WASM.
 */
export class Timer {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        TimerFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_timer_free(ptr, 0);
    }
    /**
     * Get elapsed time in milliseconds.
     * @returns {number}
     */
    elapsed_ms() {
        const ret = wasm.timer_elapsed_ms(this.__wbg_ptr);
        return ret;
    }
    /**
     * Create a new timer with the given label.
     *
     * # Arguments
     *
     * * `label` - A descriptive label for the timer
     * @param {string} label
     */
    constructor(label) {
        const ptr0 = passStringToWasm0(label, wasm.__wbindgen_export, wasm.__wbindgen_export2);
        const len0 = WASM_VECTOR_LEN;
        const ret = wasm.timer_new(ptr0, len0);
        this.__wbg_ptr = ret >>> 0;
        TimerFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * Reset the timer.
     */
    reset() {
        wasm.timer_reset(this.__wbg_ptr);
    }
    /**
     * Log elapsed time to console and return the duration.
     * @returns {number}
     */
    stop() {
        const ret = wasm.timer_stop(this.__wbg_ptr);
        return ret;
    }
}
if (Symbol.dispose) Timer.prototype[Symbol.dispose] = Timer.prototype.free;

/**
 * Check if the page is cross-origin isolated.
 *
 * Cross-origin isolation is required for SharedArrayBuffer to work.
 * The page must be served with:
 * - `Cross-Origin-Opener-Policy: same-origin`
 * - `Cross-Origin-Embedder-Policy: require-corp`
 *
 * # Returns
 * `true` if cross-origin isolated, `false` otherwise.
 * @returns {boolean}
 */
export function cross_origin_isolated() {
    const ret = wasm.cross_origin_isolated();
    return ret !== 0;
}

/**
 * Detect chat template from model ID.
 * @param {string} model_id
 * @returns {ChatTemplateWasm}
 */
export function detectChatTemplate(model_id) {
    const ptr0 = passStringToWasm0(model_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
    const len0 = WASM_VECTOR_LEN;
    const ret = wasm.detectChatTemplate(ptr0, len0);
    return ChatTemplateWasm.__wrap(ret);
}

/**
 * Determine the capability level for parallel inference.
 *
 * # Returns
 * The capability level based on available features.
 * @returns {string}
 */
export function detect_capability_level() {
    let deferred1_0;
    let deferred1_1;
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        wasm.detect_capability_level(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_export4(deferred1_0, deferred1_1, 1);
    }
}

/**
 * Log an error to the browser console.
 *
 * # Arguments
 *
 * * `message` - The error message
 * @param {string} message
 */
export function error(message) {
    const ptr0 = passStringToWasm0(message, wasm.__wbindgen_export, wasm.__wbindgen_export2);
    const len0 = WASM_VECTOR_LEN;
    wasm.error(ptr0, len0);
}

/**
 * Get a summary of all available features.
 *
 * # Returns
 * JSON string with feature availability.
 * @returns {string}
 */
export function feature_summary() {
    let deferred1_0;
    let deferred1_1;
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        wasm.feature_summary(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_export4(deferred1_0, deferred1_1, 1);
    }
}

/**
 * Get the WASM module version.
 * @returns {string}
 */
export function getVersion() {
    let deferred1_0;
    let deferred1_1;
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        wasm.getVersion(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_export4(deferred1_0, deferred1_1, 1);
    }
}

/**
 * Perform a simple health check.
 *
 * Returns true if the WASM module is functioning correctly.
 * @returns {boolean}
 */
export function healthCheck() {
    const ret = wasm.healthCheck();
    return ret !== 0;
}

/**
 * Initialize the WASM module.
 *
 * This should be called once at application startup to set up
 * panic hooks and any other initialization.
 */
export function init() {
    wasm.init();
}

/**
 * Check if the WASM module is ready.
 * @returns {boolean}
 */
export function isReady() {
    const ret = wasm.isReady();
    return ret !== 0;
}

/**
 * Check if Atomics API is available.
 *
 * Atomics provides atomic operations for synchronization between
 * the main thread and Web Workers.
 *
 * # Returns
 * `true` if Atomics is available, `false` otherwise.
 * @returns {boolean}
 */
export function is_atomics_available() {
    const ret = wasm.is_atomics_available();
    return ret !== 0;
}

/**
 * Check if BigInt is available.
 *
 * BigInt is useful for 64-bit integer operations.
 *
 * # Returns
 * `true` if BigInt is available, `false` otherwise.
 * @returns {boolean}
 */
export function is_bigint_available() {
    const ret = wasm.is_bigint_available();
    return ret !== 0;
}

/**
 * Check if SharedArrayBuffer is available.
 *
 * SharedArrayBuffer is required for zero-copy memory sharing between
 * the main thread and Web Workers.
 *
 * # Notes
 * - SharedArrayBuffer was temporarily disabled in all browsers after
 *   Spectre/Meltdown vulnerabilities were discovered.
 * - It's now available again, but requires cross-origin isolation:
 *   - `Cross-Origin-Opener-Policy: same-origin`
 *   - `Cross-Origin-Embedder-Policy: require-corp`
 *
 * # Returns
 * `true` if SharedArrayBuffer is available, `false` otherwise.
 * @returns {boolean}
 */
export function is_shared_array_buffer_available() {
    const ret = wasm.is_shared_array_buffer_available();
    return ret !== 0;
}

/**
 * Check if SIMD (WebAssembly SIMD) is available.
 *
 * # Returns
 * `true` if WASM SIMD is available, `false` otherwise.
 * @returns {boolean}
 */
export function is_simd_available() {
    const ret = wasm.is_simd_available();
    return ret !== 0;
}

/**
 * Check if Transferable objects are available.
 *
 * Transferable objects (ArrayBuffer, MessagePort, etc.) can be
 * transferred to workers without copying.
 *
 * # Returns
 * `true` if Transferable objects are available, `false` otherwise.
 * @returns {boolean}
 */
export function is_transferable_available() {
    const ret = wasm.is_transferable_available();
    return ret !== 0;
}

/**
 * Check if Web Workers are available.
 *
 * # Returns
 * `true` if Web Workers are available, `false` otherwise.
 * @returns {boolean}
 */
export function is_web_workers_available() {
    const ret = wasm.is_web_workers_available();
    return ret !== 0;
}

/**
 * Log a message to the browser console.
 *
 * # Arguments
 *
 * * `message` - The message to log
 * @param {string} message
 */
export function log(message) {
    const ptr0 = passStringToWasm0(message, wasm.__wbindgen_export, wasm.__wbindgen_export2);
    const len0 = WASM_VECTOR_LEN;
    wasm.log(ptr0, len0);
}

/**
 * Get current timestamp in milliseconds using Performance API.
 *
 * Returns high-resolution timestamp for performance measurements.
 * @returns {number}
 */
export function now_ms() {
    const ret = wasm.now_ms();
    return ret;
}

/**
 * Get the optimal number of workers based on hardware concurrency.
 *
 * Uses `navigator.hardwareConcurrency` if available, otherwise falls
 * back to a reasonable default.
 *
 * # Notes
 * - Caps the result at MAX_WORKERS to prevent resource exhaustion.
 * - Leaves at least 1 core for the main thread.
 * - Falls back to 4 if hardware concurrency is not available.
 *
 * # Returns
 * Recommended number of workers.
 * @returns {number}
 */
export function optimal_worker_count() {
    const ret = wasm.optimal_worker_count();
    return ret >>> 0;
}

/**
 * Get a message explaining why parallel inference is not available.
 *
 * # Returns
 * Explanation string, or empty string if parallel inference is available.
 * @returns {string}
 */
export function parallel_inference_unavailable_reason() {
    let deferred1_0;
    let deferred1_1;
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        wasm.parallel_inference_unavailable_reason(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_export4(deferred1_0, deferred1_1, 1);
    }
}

/**
 * Check if the environment supports parallel inference.
 *
 * # Arguments
 * * `require_shared_memory` - Whether to require SharedArrayBuffer
 *
 * # Returns
 * `true` if parallel inference is supported, `false` otherwise.
 * @param {boolean} require_shared_memory
 * @returns {boolean}
 */
export function supports_parallel_inference(require_shared_memory) {
    const ret = wasm.supports_parallel_inference(require_shared_memory);
    return ret !== 0;
}

/**
 * Log a warning to the browser console.
 *
 * # Arguments
 *
 * * `message` - The warning message
 * @param {string} message
 */
export function warn(message) {
    const ptr0 = passStringToWasm0(message, wasm.__wbindgen_export, wasm.__wbindgen_export2);
    const len0 = WASM_VECTOR_LEN;
    wasm.warn(ptr0, len0);
}

function __wbg_get_imports() {
    const import0 = {
        __proto__: null,
        __wbg_Error_4577686b3a6d9b3a: function(arg0, arg1) {
            const ret = Error(getStringFromWasm0(arg0, arg1));
            return addHeapObject(ret);
        },
        __wbg___wbindgen_boolean_get_18c4ed9422296fff: function(arg0) {
            const v = getObject(arg0);
            const ret = typeof(v) === 'boolean' ? v : undefined;
            return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
        },
        __wbg___wbindgen_debug_string_ddde1867f49c2442: function(arg0, arg1) {
            const ret = debugString(getObject(arg1));
            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len1 = WASM_VECTOR_LEN;
            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
        },
        __wbg___wbindgen_is_function_d633e708baf0d146: function(arg0) {
            const ret = typeof(getObject(arg0)) === 'function';
            return ret;
        },
        __wbg___wbindgen_is_null_a2a19127c13e7126: function(arg0) {
            const ret = getObject(arg0) === null;
            return ret;
        },
        __wbg___wbindgen_is_string_7debe47dc1e045c2: function(arg0) {
            const ret = typeof(getObject(arg0)) === 'string';
            return ret;
        },
        __wbg___wbindgen_is_undefined_c18285b9fc34cb7d: function(arg0) {
            const ret = getObject(arg0) === undefined;
            return ret;
        },
        __wbg___wbindgen_number_get_5854912275df1894: function(arg0, arg1) {
            const obj = getObject(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);
        },
        __wbg___wbindgen_throw_39bc967c0e5a9b58: function(arg0, arg1) {
            throw new Error(getStringFromWasm0(arg0, arg1));
        },
        __wbg__wbg_cb_unref_b6d832240a919168: function(arg0) {
            getObject(arg0)._wbg_cb_unref();
        },
        __wbg_call_08ad0d89caa7cb79: function() { return handleError(function (arg0, arg1, arg2) {
            const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
            return addHeapObject(ret);
        }, arguments); },
        __wbg_chatmessagewasm_unwrap: function(arg0) {
            const ret = ChatMessageWasm.__unwrap(getObject(arg0));
            return ret;
        },
        __wbg_createObjectURL_5d73c8f8b9442674: function() { return handleError(function (arg0, arg1) {
            const ret = URL.createObjectURL(getObject(arg1));
            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len1 = WASM_VECTOR_LEN;
            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
        }, arguments); },
        __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_export4(deferred0_0, deferred0_1, 1);
            }
        },
        __wbg_error_ad28debb48b5c6bb: function(arg0) {
            console.error(getObject(arg0));
        },
        __wbg_get_18349afdb36339a9: function() { return handleError(function (arg0, arg1) {
            const ret = Reflect.get(getObject(arg0), getObject(arg1));
            return addHeapObject(ret);
        }, arguments); },
        __wbg_hardwareConcurrency_bcfa777517afe30c: function(arg0) {
            const ret = getObject(arg0).hardwareConcurrency;
            return ret;
        },
        __wbg_instanceof_Window_4aba49e4d1a12365: function(arg0) {
            let result;
            try {
                result = getObject(arg0) instanceof Window;
            } catch (_) {
                result = false;
            }
            const ret = result;
            return ret;
        },
        __wbg_length_326999dcd07f2163: function(arg0) {
            const ret = getObject(arg0).length;
            return ret;
        },
        __wbg_log_3c5e4b64af29e724: function(arg0) {
            console.log(getObject(arg0));
        },
        __wbg_navigator_bb9bf52d5003ebaa: function(arg0) {
            const ret = getObject(arg0).navigator;
            return addHeapObject(ret);
        },
        __wbg_new_09959f7b4c92c246: function(arg0) {
            const ret = new Uint8Array(getObject(arg0));
            return addHeapObject(ret);
        },
        __wbg_new_227d7c05414eb861: function() {
            const ret = new Error();
            return addHeapObject(ret);
        },
        __wbg_new_4cd4d9a832c6a95c: function(arg0) {
            const ret = new SharedArrayBuffer(arg0 >>> 0);
            return addHeapObject(ret);
        },
        __wbg_new_79ce7968119cfd96: function(arg0, arg1) {
            try {
                var state0 = {a: arg0, b: arg1};
                var cb0 = (arg0, arg1) => {
                    const a = state0.a;
                    state0.a = 0;
                    try {
                        return __wasm_bindgen_func_elem_1019(a, state0.b, arg0, arg1);
                    } finally {
                        state0.a = a;
                    }
                };
                const ret = new Promise(cb0);
                return addHeapObject(ret);
            } finally {
                state0.a = state0.b = 0;
            }
        },
        __wbg_new_92df58a8ec3bfb6b: function() {
            const ret = new Map();
            return addHeapObject(ret);
        },
        __wbg_new_98878c09b40e999e: function(arg0) {
            const ret = new Float32Array(getObject(arg0));
            return addHeapObject(ret);
        },
        __wbg_new_bf17400457cc915c: function(arg0) {
            const ret = new ArrayBuffer(arg0 >>> 0);
            return addHeapObject(ret);
        },
        __wbg_new_cbee8c0d5c479eac: function() {
            const ret = new Array();
            return addHeapObject(ret);
        },
        __wbg_new_ed69e637b553a997: function() {
            const ret = new Object();
            return addHeapObject(ret);
        },
        __wbg_new_from_slice_d7e202fdbee3c396: function(arg0, arg1) {
            const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
            return addHeapObject(ret);
        },
        __wbg_new_from_slice_e21686f285806d67: function(arg0, arg1) {
            const ret = new Float32Array(getArrayF32FromWasm0(arg0, arg1));
            return addHeapObject(ret);
        },
        __wbg_new_typed_8258a0d8488ef2a2: function(arg0, arg1) {
            try {
                var state0 = {a: arg0, b: arg1};
                var cb0 = (arg0, arg1) => {
                    const a = state0.a;
                    state0.a = 0;
                    try {
                        return __wasm_bindgen_func_elem_1019(a, state0.b, arg0, arg1);
                    } finally {
                        state0.a = a;
                    }
                };
                const ret = new Promise(cb0);
                return addHeapObject(ret);
            } finally {
                state0.a = state0.b = 0;
            }
        },
        __wbg_new_with_byte_offset_and_length_0c7bf082a18bcb5d: function(arg0, arg1, arg2) {
            const ret = new Float32Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
            return addHeapObject(ret);
        },
        __wbg_new_with_options_6430dd96b9678e36: function() { return handleError(function (arg0, arg1, arg2) {
            const ret = new Worker(getStringFromWasm0(arg0, arg1), getObject(arg2));
            return addHeapObject(ret);
        }, arguments); },
        __wbg_new_with_str_sequence_and_options_9cb2ac4601afacae: function() { return handleError(function (arg0, arg1) {
            const ret = new Blob(getObject(arg0), getObject(arg1));
            return addHeapObject(ret);
        }, arguments); },
        __wbg_now_b134ec02cd6d8b88: function(arg0) {
            const ret = getObject(arg0).now();
            return ret;
        },
        __wbg_parallelinference_new: function(arg0) {
            const ret = ParallelInference.__wrap(arg0);
            return addHeapObject(ret);
        },
        __wbg_performance_14d1bb70cebe5f40: function(arg0) {
            const ret = getObject(arg0).performance;
            return isLikeNone(ret) ? 0 : addHeapObject(ret);
        },
        __wbg_postMessage_af6209ddad5840b9: function() { return handleError(function (arg0, arg1) {
            getObject(arg0).postMessage(getObject(arg1));
        }, arguments); },
        __wbg_prototypesetcall_75794f1851d5d9c5: function(arg0, arg1, arg2) {
            Float32Array.prototype.set.call(getArrayF32FromWasm0(arg0, arg1), getObject(arg2));
        },
        __wbg_push_a6f9488ffd3fae3b: function(arg0, arg1) {
            const ret = getObject(arg0).push(getObject(arg1));
            return ret;
        },
        __wbg_queueMicrotask_2c8dfd1056f24fdc: function(arg0) {
            const ret = getObject(arg0).queueMicrotask;
            return addHeapObject(ret);
        },
        __wbg_queueMicrotask_8985ad63815852e7: function(arg0) {
            queueMicrotask(getObject(arg0));
        },
        __wbg_resolve_5d61e0d10c14730a: function(arg0) {
            const ret = Promise.resolve(getObject(arg0));
            return addHeapObject(ret);
        },
        __wbg_revokeObjectURL_a1d0e19a2a752132: function() { return handleError(function (arg0, arg1) {
            URL.revokeObjectURL(getStringFromWasm0(arg0, arg1));
        }, arguments); },
        __wbg_routeresultwasm_new: function(arg0) {
            const ret = RouteResultWasm.__wrap(arg0);
            return addHeapObject(ret);
        },
        __wbg_setTimeout_67bc3096eef9fc6b: function() { return handleError(function (arg0, arg1, arg2) {
            const ret = getObject(arg0).setTimeout(getObject(arg1), arg2);
            return ret;
        }, arguments); },
        __wbg_set_410caa03fd65d0ba: function(arg0, arg1, arg2) {
            getObject(arg0).set(getObject(arg1), arg2 >>> 0);
        },
        __wbg_set_4c81cfb5dc3a333c: function(arg0, arg1, arg2) {
            getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
        },
        __wbg_set_548a8710171e41da: function(arg0, arg1, arg2) {
            getObject(arg0).set(getObject(arg1), arg2 >>> 0);
        },
        __wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
            getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
        },
        __wbg_set_bad5c505cc70b5f8: function() { return handleError(function (arg0, arg1, arg2) {
            const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
            return ret;
        }, arguments); },
        __wbg_set_cfc6de03f990decf: function(arg0, arg1, arg2) {
            const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
            return addHeapObject(ret);
        },
        __wbg_set_type_1631880f22765d5c: function(arg0, arg1, arg2) {
            getObject(arg0).type = getStringFromWasm0(arg1, arg2);
        },
        __wbg_stack_3b0d974bbf31e44f: function(arg0, arg1) {
            const ret = getObject(arg1).stack;
            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
            const len1 = WASM_VECTOR_LEN;
            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
        },
        __wbg_static_accessor_GLOBAL_THIS_14325d8cca34bb77: function() {
            const ret = typeof globalThis === 'undefined' ? null : globalThis;
            return isLikeNone(ret) ? 0 : addHeapObject(ret);
        },
        __wbg_static_accessor_GLOBAL_f3a1e69f9c5a7e8e: function() {
            const ret = typeof global === 'undefined' ? null : global;
            return isLikeNone(ret) ? 0 : addHeapObject(ret);
        },
        __wbg_static_accessor_SELF_50cdb5b517789aca: function() {
            const ret = typeof self === 'undefined' ? null : self;
            return isLikeNone(ret) ? 0 : addHeapObject(ret);
        },
        __wbg_static_accessor_WINDOW_d6c4126e4c244380: function() {
            const ret = typeof window === 'undefined' ? null : window;
            return isLikeNone(ret) ? 0 : addHeapObject(ret);
        },
        __wbg_terminate_02cd97d7ca95494d: function(arg0) {
            getObject(arg0).terminate();
        },
        __wbg_then_d4163530723f56f4: function(arg0, arg1, arg2) {
            const ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
            return addHeapObject(ret);
        },
        __wbg_then_f1c954fe00733701: function(arg0, arg1) {
            const ret = getObject(arg0).then(getObject(arg1));
            return addHeapObject(ret);
        },
        __wbg_warn_3310c7343993c074: function(arg0) {
            console.warn(getObject(arg0));
        },
        __wbindgen_cast_0000000000000001: function(arg0, arg1) {
            // Cast intrinsic for `Closure(Closure { dtor_idx: 89, function: Function { arguments: [Externref], shim_idx: 90, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_980, __wasm_bindgen_func_elem_981);
            return addHeapObject(ret);
        },
        __wbindgen_cast_0000000000000002: function(arg0) {
            // Cast intrinsic for `F64 -> Externref`.
            const ret = arg0;
            return addHeapObject(ret);
        },
        __wbindgen_cast_0000000000000003: function(arg0, arg1) {
            // Cast intrinsic for `Ref(String) -> Externref`.
            const ret = getStringFromWasm0(arg0, arg1);
            return addHeapObject(ret);
        },
        __wbindgen_cast_0000000000000004: function(arg0) {
            // Cast intrinsic for `U64 -> Externref`.
            const ret = BigInt.asUintN(64, arg0);
            return addHeapObject(ret);
        },
        __wbindgen_cast_0000000000000005: function(arg0, arg1) {
            var v0 = getArrayF32FromWasm0(arg0, arg1).slice();
            wasm.__wbindgen_export4(arg0, arg1 * 4, 4);
            // Cast intrinsic for `Vector(F32) -> Externref`.
            const ret = v0;
            return addHeapObject(ret);
        },
        __wbindgen_object_clone_ref: function(arg0) {
            const ret = getObject(arg0);
            return addHeapObject(ret);
        },
        __wbindgen_object_drop_ref: function(arg0) {
            takeObject(arg0);
        },
    };
    return {
        __proto__: null,
        "./ruvllm_wasm_bg.js": import0,
    };
}

function __wasm_bindgen_func_elem_981(arg0, arg1, arg2) {
    try {
        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
        wasm.__wasm_bindgen_func_elem_981(retptr, arg0, arg1, addHeapObject(arg2));
        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
        if (r1) {
            throw takeObject(r0);
        }
    } finally {
        wasm.__wbindgen_add_to_stack_pointer(16);
    }
}

function __wasm_bindgen_func_elem_1019(arg0, arg1, arg2, arg3) {
    wasm.__wasm_bindgen_func_elem_1019(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
}

const AdaptFeedbackWasmFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_adaptfeedbackwasm_free(ptr >>> 0, 1));
const BufferPoolWasmFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_bufferpoolwasm_free(ptr >>> 0, 1));
const ChatMessageWasmFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_chatmessagewasm_free(ptr >>> 0, 1));
const ChatTemplateWasmFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_chattemplatewasm_free(ptr >>> 0, 1));
const GenerateConfigFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_generateconfig_free(ptr >>> 0, 1));
const HnswRouterWasmFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_hnswrouterwasm_free(ptr >>> 0, 1));
const InferenceArenaWasmFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_inferencearenawasm_free(ptr >>> 0, 1));
const KvCacheConfigWasmFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_kvcacheconfigwasm_free(ptr >>> 0, 1));
const KvCacheStatsWasmFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_kvcachestatswasm_free(ptr >>> 0, 1));
const KvCacheWasmFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_kvcachewasm_free(ptr >>> 0, 1));
const MicroLoraConfigWasmFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_microloraconfigwasm_free(ptr >>> 0, 1));
const MicroLoraStatsWasmFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_microlorastatswasm_free(ptr >>> 0, 1));
const MicroLoraWasmFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_microlorawasm_free(ptr >>> 0, 1));
const ParallelInferenceFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_parallelinference_free(ptr >>> 0, 1));
const PatternWasmFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_patternwasm_free(ptr >>> 0, 1));
const RouteResultWasmFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_routeresultwasm_free(ptr >>> 0, 1));
const RuvLLMWasmFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_ruvllmwasm_free(ptr >>> 0, 1));
const SonaAdaptResultWasmFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_sonaadaptresultwasm_free(ptr >>> 0, 1));
const SonaConfigWasmFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_sonaconfigwasm_free(ptr >>> 0, 1));
const SonaInstantWasmFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_sonainstantwasm_free(ptr >>> 0, 1));
const SonaStatsWasmFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_sonastatswasm_free(ptr >>> 0, 1));
const TimerFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_timer_free(ptr >>> 0, 1));

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 _assertClass(instance, klass) {
    if (!(instance instanceof klass)) {
        throw new Error(`expected instance of ${klass.name}`);
    }
}

const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(state => state.dtor(state.a, state.b));

function debugString(val) {
    // primitive types
    const type = typeof val;
    if (type == 'number' || type == 'boolean' || val == null) {
        return  `${val}`;
    }
    if (type == 'string') {
        return `"${val}"`;
    }
    if (type == 'symbol') {
        const description = val.description;
        if (description == null) {
            return 'Symbol';
        } else {
            return `Symbol(${description})`;
        }
    }
    if (type == 'function') {
        const name = val.name;
        if (typeof name == 'string' && name.length > 0) {
            return `Function(${name})`;
        } else {
            return 'Function';
        }
    }
    // objects
    if (Array.isArray(val)) {
        const length = val.length;
        let debug = '[';
        if (length > 0) {
            debug += debugString(val[0]);
        }
        for(let i = 1; i < length; i++) {
            debug += ', ' + debugString(val[i]);
        }
        debug += ']';
        return debug;
    }
    // Test for built-in
    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
    let className;
    if (builtInMatches && builtInMatches.length > 1) {
        className = builtInMatches[1];
    } else {
        // Failed to match the standard '[object ClassName]'
        return toString.call(val);
    }
    if (className == 'Object') {
        // we're a user defined class or Object
        // JSON.stringify avoids problems with cycles, and is generally much
        // easier than looping through ownProperties of `val`.
        try {
            return 'Object(' + JSON.stringify(val) + ')';
        } catch (_) {
            return 'Object';
        }
    }
    // errors
    if (val instanceof Error) {
        return `${val.name}: ${val.message}\n${val.stack}`;
    }
    // TODO we could test for more things here, like `Set`s and `Map`s.
    return className;
}

function dropObject(idx) {
    if (idx < 1028) return;
    heap[idx] = heap_next;
    heap_next = idx;
}

function getArrayF32FromWasm0(ptr, len) {
    ptr = ptr >>> 0;
    return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
}

function getArrayJsValueFromWasm0(ptr, len) {
    ptr = ptr >>> 0;
    const mem = getDataViewMemory0();
    const result = [];
    for (let i = ptr; i < ptr + 4 * len; i += 4) {
        result.push(takeObject(mem.getUint32(i, true)));
    }
    return result;
}

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;
}

let cachedFloat32ArrayMemory0 = null;
function getFloat32ArrayMemory0() {
    if (cachedFloat32ArrayMemory0 === null || cachedFloat32ArrayMemory0.byteLength === 0) {
        cachedFloat32ArrayMemory0 = new Float32Array(wasm.memory.buffer);
    }
    return cachedFloat32ArrayMemory0;
}

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]; }

function handleError(f, args) {
    try {
        return f.apply(this, args);
    } catch (e) {
        wasm.__wbindgen_export3(addHeapObject(e));
    }
}

let heap = new Array(1024).fill(undefined);
heap.push(undefined, null, true, false);

let heap_next = heap.length;

function isLikeNone(x) {
    return x === undefined || x === null;
}

function makeMutClosure(arg0, arg1, dtor, f) {
    const state = { a: arg0, b: arg1, cnt: 1, dtor };
    const real = (...args) => {

        // First up with a closure we increment the internal reference
        // count. This ensures that the Rust closure environment won't
        // be deallocated while we're invoking it.
        state.cnt++;
        const a = state.a;
        state.a = 0;
        try {
            return f(a, state.b, ...args);
        } finally {
            state.a = a;
            real._wbg_cb_unref();
        }
    };
    real._wbg_cb_unref = () => {
        if (--state.cnt === 0) {
            state.dtor(state.a, state.b);
            state.a = 0;
            CLOSURE_DTORS.unregister(state);
        }
    };
    CLOSURE_DTORS.register(real, state, state);
    return real;
}

function passArrayF32ToWasm0(arg, malloc) {
    const ptr = malloc(arg.length * 4, 4) >>> 0;
    getFloat32ArrayMemory0().set(arg, ptr / 4);
    WASM_VECTOR_LEN = arg.length;
    return ptr;
}

function passArrayJsValueToWasm0(array, malloc) {
    const ptr = malloc(array.length * 4, 4) >>> 0;
    const mem = getDataViewMemory0();
    for (let i = 0; i < array.length; i++) {
        mem.setUint32(ptr + 4 * i, addHeapObject(array[i]), true);
    }
    WASM_VECTOR_LEN = array.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 takeObject(idx) {
    const ret = getObject(idx);
    dropObject(idx);
    return ret;
}

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 wasmModule, wasm;
function __wbg_finalize_init(instance, module) {
    wasm = instance.exports;
    wasmModule = module;
    cachedDataViewMemory0 = null;
    cachedFloat32ArrayMemory0 = null;
    cachedUint8ArrayMemory0 = null;
    wasm.__wbindgen_start();
    return wasm;
}

async function __wbg_load(module, imports) {
    if (typeof Response === 'function' && module instanceof Response) {
        if (typeof WebAssembly.instantiateStreaming === 'function') {
            try {
                return await WebAssembly.instantiateStreaming(module, imports);
            } catch (e) {
                const validResponse = module.ok && expectedResponseType(module.type);

                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);

                } else { throw e; }
            }
        }

        const bytes = await module.arrayBuffer();
        return await WebAssembly.instantiate(bytes, imports);
    } else {
        const instance = await WebAssembly.instantiate(module, imports);

        if (instance instanceof WebAssembly.Instance) {
            return { instance, module };
        } else {
            return instance;
        }
    }

    function expectedResponseType(type) {
        switch (type) {
            case 'basic': case 'cors': case 'default': return true;
        }
        return false;
    }
}

function initSync(module) {
    if (wasm !== undefined) return wasm;


    if (module !== undefined) {
        if (Object.getPrototypeOf(module) === Object.prototype) {
            ({module} = module)
        } else {
            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
        }
    }

    const imports = __wbg_get_imports();
    if (!(module instanceof WebAssembly.Module)) {
        module = new WebAssembly.Module(module);
    }
    const instance = new WebAssembly.Instance(module, imports);
    return __wbg_finalize_init(instance, module);
}

async function __wbg_init(module_or_path) {
    if (wasm !== undefined) return wasm;


    if (module_or_path !== undefined) {
        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
            ({module_or_path} = module_or_path)
        } else {
            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
        }
    }

    if (module_or_path === undefined) {
        module_or_path = new URL('ruvllm_wasm_bg.wasm', import.meta.url);
    }
    const imports = __wbg_get_imports();

    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
        module_or_path = fetch(module_or_path);
    }

    const { instance, module } = await __wbg_load(await module_or_path, imports);

    return __wbg_finalize_init(instance, module);
}

export { initSync, __wbg_init as default };