kynjal-cli 4.0.0 → 4.0.1

package/dist/src/ruvector/ruvllm-wasm.js

@@ -20,508 +20,344 @@
  *
  * @module @claude-flow/cli/ruvector/ruvllm-wasm
  */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 import { readFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
 // ── WASM Module Detection & Init ─────────────────────────────
-var _wasmReady = false;
+let _wasmReady = false;
 /**
  * Check if @ruvector/ruvllm-wasm is installed and loadable.
  */
-export function isRuvllmWasmAvailable() {
-    return __awaiter(this, void 0, Promise, function () {
-        var mod, _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    _b.trys.push([0, 2, , 3]);
-                    return [4 /*yield*/, import('@ruvector/ruvllm-wasm')];
-                case 1:
-                    mod = _b.sent();
-                    return [2 /*return*/, typeof mod.RuvLLMWasm === 'function'];
-                case 2:
-                    _a = _b.sent();
-                    return [2 /*return*/, false];
-                case 3: return [2 /*return*/];
-            }
-        });
-    });
+export async function isRuvllmWasmAvailable() {
+    try {
+        const mod = await import('@ruvector/ruvllm-wasm');
+        return typeof mod.RuvLLMWasm === 'function';
+    }
+    catch {
+        return false;
+    }
 }
 /**
  * Initialize the WASM module for Node.js. Safe to call multiple times.
  * Uses initSync with object form: { module: bytes } (raw bytes deprecated).
  */
-export function initRuvllmWasm() {
-    return __awaiter(this, void 0, Promise, function () {
-        var mod, require_, wasmPath, wasmBytes, err_1;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    if (_wasmReady)
-                        return [2 /*return*/];
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, import('@ruvector/ruvllm-wasm')];
-                case 2:
-                    mod = _a.sent();
-                    require_ = createRequire(import.meta.url);
-                    wasmPath = require_.resolve('@ruvector/ruvllm-wasm/ruvllm_wasm_bg.wasm');
-                    wasmBytes = readFileSync(wasmPath);
-                    // MUST use object form — initSync(bytes) is deprecated
-                    mod.initSync({ module: wasmBytes });
-                    _wasmReady = true;
-                    return [3 /*break*/, 4];
-                case 3:
-                    err_1 = _a.sent();
-                    throw new Error("Failed to initialize @ruvector/ruvllm-wasm: " + err_1);
-                case 4: return [2 /*return*/];
-            }
-        });
-    });
+export async function initRuvllmWasm() {
+    if (_wasmReady)
+        return;
+    try {
+        const mod = await import('@ruvector/ruvllm-wasm');
+        const require_ = createRequire(import.meta.url);
+        const wasmPath = require_.resolve('@ruvector/ruvllm-wasm/ruvllm_wasm_bg.wasm');
+        const wasmBytes = readFileSync(wasmPath);
+        // MUST use object form — initSync(bytes) is deprecated
+        mod.initSync({ module: wasmBytes });
+        _wasmReady = true;
+    }
+    catch (err) {
+        throw new Error(`Failed to initialize @ruvector/ruvllm-wasm: ${err}`);
+    }
 }
 /**
  * Get ruvllm-wasm status.
  */
-export function getRuvllmStatus() {
-    return __awaiter(this, void 0, Promise, function () {
-        var available, mod, version, _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0: return [4 /*yield*/, isRuvllmWasmAvailable()];
-                case 1:
-                    available = _b.sent();
-                    if (!available) {
-                        return [2 /*return*/, { available: false, initialized: false, version: null }];
-                    }
-                    _b.label = 2;
-                case 2:
-                    _b.trys.push([2, 4, , 5]);
-                    return [4 /*yield*/, import('@ruvector/ruvllm-wasm')];
-                case 3:
-                    mod = _b.sent();
-                    version = typeof mod.getVersion === 'function' ? mod.getVersion() : null;
-                    return [2 /*return*/, { available: true, initialized: _wasmReady, version: version }];
-                case 4:
-                    _a = _b.sent();
-                    return [2 /*return*/, { available: true, initialized: _wasmReady, version: null }];
-                case 5: return [2 /*return*/];
-            }
-        });
-    });
+export async function getRuvllmStatus() {
+    const available = await isRuvllmWasmAvailable();
+    if (!available) {
+        return { available: false, initialized: false, version: null };
+    }
+    try {
+        const mod = await import('@ruvector/ruvllm-wasm');
+        // version is a standalone function, not on RuvLLMWasm class
+        const version = typeof mod.getVersion === 'function' ? mod.getVersion() : null;
+        return { available: true, initialized: _wasmReady, version };
+    }
+    catch {
+        return { available: true, initialized: _wasmReady, version: null };
+    }
 }
 // ── HNSW Router ──────────────────────────────────────────────
 /**
  * Maximum safe pattern count for HNSW router.
  * v2.0.2 supports 1000+ patterns (fixed connect_node ordering).
  */
-export var HNSW_MAX_SAFE_PATTERNS = 1024;
+export const HNSW_MAX_SAFE_PATTERNS = 1024;
 /**
  * Create a WASM HNSW router for semantic routing.
  * Returns an object with add/route/clear methods.
  *
  * Enforces HNSW_MAX_SAFE_PATTERNS limit (1024 in v2.0.2).
  */
-export function createHnswRouter(config) {
-    return __awaiter(this, void 0, Promise, function () {
-        var mod, router, count;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, initRuvllmWasm()];
-                case 1:
-                    _a.sent();
-                    return [4 /*yield*/, import('@ruvector/ruvllm-wasm')];
-                case 2:
-                    mod = _a.sent();
-                    router = new mod.HnswRouterWasm(config.dimensions, config.maxPatterns);
-                    if (config.efSearch) {
-                        router.setEfSearch(config.efSearch);
-                    }
-                    count = 0;
-                    return [2 /*return*/, {
-                            addPattern: function (pattern) {
-                                var _a;
-                                if (count >= HNSW_MAX_SAFE_PATTERNS) {
-                                    throw new Error("HNSW pattern limit reached (" + HNSW_MAX_SAFE_PATTERNS + ").");
-                                }
-                                var metadataJson = JSON.stringify((_a = pattern.metadata) !== null && _a !== void 0 ? _a : {});
-                                // addPattern requires 3 args: (embedding, name, metadata_json)
-                                var ok = router.addPattern(pattern.embedding, pattern.name, metadataJson);
-                                if (ok)
-                                    count++;
-                                return ok;
-                            },
-                            route: function (query, k) {
-                                if (k === void 0) { k = 3; }
-                                return router.route(query, k);
-                            },
-                            clear: function () {
-                                router.clear();
-                                count = 0;
-                            },
-                            patternCount: function () {
-                                return count;
-                            },
-                            toJson: function () {
-                                return router.toJson();
-                            }
-                        }];
+export async function createHnswRouter(config) {
+    await initRuvllmWasm();
+    const mod = await import('@ruvector/ruvllm-wasm');
+    const router = new mod.HnswRouterWasm(config.dimensions, config.maxPatterns);
+    if (config.efSearch) {
+        router.setEfSearch(config.efSearch);
+    }
+    let count = 0;
+    return {
+        addPattern(pattern) {
+            if (count >= HNSW_MAX_SAFE_PATTERNS) {
+                throw new Error(`HNSW pattern limit reached (${HNSW_MAX_SAFE_PATTERNS}).`);
             }
-        });
-    });
+            const metadataJson = JSON.stringify(pattern.metadata ?? {});
+            // addPattern requires 3 args: (embedding, name, metadata_json)
+            const ok = router.addPattern(pattern.embedding, pattern.name, metadataJson);
+            if (ok)
+                count++;
+            return ok;
+        },
+        route(query, k = 3) {
+            return router.route(query, k);
+        },
+        clear() {
+            router.clear();
+            count = 0;
+        },
+        patternCount() {
+            return count;
+        },
+        toJson() {
+            return router.toJson();
+        },
+    };
 }
 // ── SONA Instant Adaptation ──────────────────────────────────
 /**
  * Create a SONA instant adaptation loop (<1ms adaptation).
  * v2.0.1: requires SonaConfigWasm object, not raw number.
  */
-export function createSonaInstant(config) {
-    if (config === void 0) { config = {}; }
-    return __awaiter(this, void 0, Promise, function () {
-        var mod, sonaConfig, sona;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, initRuvllmWasm()];
-                case 1:
-                    _a.sent();
-                    return [4 /*yield*/, import('@ruvector/ruvllm-wasm')];
-                case 2:
-                    mod = _a.sent();
-                    sonaConfig = new mod.SonaConfigWasm();
-                    if (config.hiddenDim !== undefined)
-                        sonaConfig.hiddenDim = config.hiddenDim;
-                    if (config.learningRate !== undefined)
-                        sonaConfig.learningRate = config.learningRate;
-                    if (config.emaDecay !== undefined)
-                        sonaConfig.emaDecay = config.emaDecay;
-                    if (config.ewcLambda !== undefined)
-                        sonaConfig.ewcLambda = config.ewcLambda;
-                    if (config.microLoraRank !== undefined)
-                        sonaConfig.microLoraRank = config.microLoraRank;
-                    if (config.patternCapacity !== undefined)
-                        sonaConfig.patternCapacity = config.patternCapacity;
-                    sona = new mod.SonaInstantWasm(sonaConfig);
-                    return [2 /*return*/, {
-                            adapt: function (quality) {
-                                sona.instantAdapt(quality);
-                            },
-                            recordPattern: function (embedding, success) {
-                                sona.recordPattern(embedding, success);
-                            },
-                            suggestAction: function (context) {
-                                return sona.suggestAction(context);
-                            },
-                            stats: function () {
-                                return sona.toJson();
-                            },
-                            reset: function () {
-                                sona.reset();
-                            },
-                            toJson: function () {
-                                return sona.toJson();
-                            }
-                        }];
-            }
-        });
-    });
+export async function createSonaInstant(config = {}) {
+    await initRuvllmWasm();
+    const mod = await import('@ruvector/ruvllm-wasm');
+    const sonaConfig = new mod.SonaConfigWasm();
+    if (config.hiddenDim !== undefined)
+        sonaConfig.hiddenDim = config.hiddenDim;
+    if (config.learningRate !== undefined)
+        sonaConfig.learningRate = config.learningRate;
+    if (config.emaDecay !== undefined)
+        sonaConfig.emaDecay = config.emaDecay;
+    if (config.ewcLambda !== undefined)
+        sonaConfig.ewcLambda = config.ewcLambda;
+    if (config.microLoraRank !== undefined)
+        sonaConfig.microLoraRank = config.microLoraRank;
+    if (config.patternCapacity !== undefined)
+        sonaConfig.patternCapacity = config.patternCapacity;
+    const sona = new mod.SonaInstantWasm(sonaConfig);
+    return {
+        adapt(quality) {
+            sona.instantAdapt(quality);
+        },
+        recordPattern(embedding, success) {
+            sona.recordPattern(embedding, success);
+        },
+        suggestAction(context) {
+            return sona.suggestAction(context);
+        },
+        stats() {
+            return sona.toJson();
+        },
+        reset() {
+            sona.reset();
+        },
+        toJson() {
+            return sona.toJson();
+        },
+    };
 }
 // ── MicroLoRA ────────────────────────────────────────────────
 /**
  * Create a MicroLoRA adapter (ultra-lightweight LoRA, ranks 1-4).
  * v2.0.2: .adapt(input, feedback) takes Float32Array + AdaptFeedbackWasm.
  */
-export function createMicroLora(config) {
-    var _a, _b;
-    return __awaiter(this, void 0, Promise, function () {
-        var mod, loraConfig, lora;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0: return [4 /*yield*/, initRuvllmWasm()];
-                case 1:
-                    _c.sent();
-                    return [4 /*yield*/, import('@ruvector/ruvllm-wasm')];
-                case 2:
-                    mod = _c.sent();
-                    loraConfig = new mod.MicroLoraConfigWasm();
-                    loraConfig.inputDim = config.inputDim;
-                    loraConfig.outputDim = config.outputDim;
-                    loraConfig.rank = (_a = config.rank) !== null && _a !== void 0 ? _a : 2;
-                    loraConfig.alpha = (_b = config.alpha) !== null && _b !== void 0 ? _b : 1.0;
-                    lora = new mod.MicroLoraWasm(loraConfig);
-                    return [2 /*return*/, {
-                            apply: function (input) {
-                                return lora.apply(input);
-                            },
-                            adapt: function (quality, learningRate, success) {
-                                if (learningRate === void 0) { learningRate = 0.01; }
-                                if (success === void 0) { success = true; }
-                                // v2.0.2: adapt(input, feedback) — two args
-                                var feedback = new mod.AdaptFeedbackWasm();
-                                feedback.quality = quality;
-                                feedback.learningRate = learningRate;
-                                // Note: feedback.success not on prototype in v2.0.2, set via property
-                                try {
-                                    feedback.success = success;
-                                }
-                                catch ( /* v2.0.2 quirk */_a) { /* v2.0.2 quirk */ }
-                                // Create a dummy input vector matching the configured inputDim
-                                var input = new Float32Array(config.inputDim);
-                                lora.adapt(input, feedback);
-                            },
-                            applyUpdates: function (gradients) {
-                                lora.applyUpdates(gradients);
-                            },
-                            stats: function () {
-                                return lora.toJson();
-                            },
-                            reset: function () {
-                                lora.reset();
-                            },
-                            toJson: function () {
-                                return lora.toJson();
-                            },
-                            pendingUpdates: function () {
-                                return lora.pendingUpdates();
-                            }
-                        }];
+export async function createMicroLora(config) {
+    await initRuvllmWasm();
+    const mod = await import('@ruvector/ruvllm-wasm');
+    const loraConfig = new mod.MicroLoraConfigWasm();
+    loraConfig.inputDim = config.inputDim;
+    loraConfig.outputDim = config.outputDim;
+    loraConfig.rank = config.rank ?? 2;
+    loraConfig.alpha = config.alpha ?? 1.0;
+    const lora = new mod.MicroLoraWasm(loraConfig);
+    return {
+        apply(input) {
+            return lora.apply(input);
+        },
+        adapt(quality, learningRate = 0.01, success = true) {
+            // v2.0.2: adapt(input, feedback) — two args
+            const feedback = new mod.AdaptFeedbackWasm();
+            feedback.quality = quality;
+            feedback.learningRate = learningRate;
+            // Note: feedback.success not on prototype in v2.0.2, set via property
+            try {
+                feedback.success = success;
             }
-        });
-    });
+            catch { /* v2.0.2 quirk */ }
+            // Create a dummy input vector matching the configured inputDim
+            const input = new Float32Array(config.inputDim);
+            lora.adapt(input, feedback);
+        },
+        applyUpdates(gradients) {
+            lora.applyUpdates(gradients);
+        },
+        stats() {
+            return lora.toJson();
+        },
+        reset() {
+            lora.reset();
+        },
+        toJson() {
+            return lora.toJson();
+        },
+        pendingUpdates() {
+            return lora.pendingUpdates();
+        },
+    };
 }
 /**
  * Format chat messages using a chat template.
  * Supports presets (llama3, mistral, chatml, phi, gemma) and auto-detection.
  */
-export function formatChat(messages, template) {
-    return __awaiter(this, void 0, Promise, function () {
-        var mod, tmpl, presets, factory, wasmMessages;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, initRuvllmWasm()];
-                case 1:
-                    _a.sent();
-                    return [4 /*yield*/, import('@ruvector/ruvllm-wasm')];
-                case 2:
-                    mod = _a.sent();
-                    if (typeof template === 'string') {
-                        presets = {
-                            llama3: function () { return mod.ChatTemplateWasm.llama3(); },
-                            mistral: function () { return mod.ChatTemplateWasm.mistral(); },
-                            chatml: function () { return mod.ChatTemplateWasm.chatml(); },
-                            phi: function () { return mod.ChatTemplateWasm.phi(); },
-                            gemma: function () { return mod.ChatTemplateWasm.gemma(); }
-                        };
-                        factory = presets[template];
-                        if (!factory)
-                            throw new Error("Unknown template preset: " + template + ". Use: " + Object.keys(presets).join(', '));
-                        tmpl = factory();
-                    }
-                    else if ('custom' in template) {
-                        tmpl = mod.ChatTemplateWasm.custom(template.custom);
-                    }
-                    else if ('modelId' in template) {
-                        tmpl = mod.ChatTemplateWasm.detectFromModelId(template.modelId);
-                    }
-                    wasmMessages = messages.map(function (m) {
-                        switch (m.role) {
-                            case 'system': return mod.ChatMessageWasm.system(m.content);
-                            case 'user': return mod.ChatMessageWasm.user(m.content);
-                            case 'assistant': return mod.ChatMessageWasm.assistant(m.content);
-                            default: throw new Error("Unknown role: " + m.role);
-                        }
-                    });
-                    return [2 /*return*/, tmpl.format(wasmMessages)];
-            }
-        });
+export async function formatChat(messages, template) {
+    await initRuvllmWasm();
+    const mod = await import('@ruvector/ruvllm-wasm');
+    // Build template
+    let tmpl;
+    if (typeof template === 'string') {
+        const presets = {
+            llama3: () => mod.ChatTemplateWasm.llama3(),
+            mistral: () => mod.ChatTemplateWasm.mistral(),
+            chatml: () => mod.ChatTemplateWasm.chatml(),
+            phi: () => mod.ChatTemplateWasm.phi(),
+            gemma: () => mod.ChatTemplateWasm.gemma(),
+        };
+        const factory = presets[template];
+        if (!factory)
+            throw new Error(`Unknown template preset: ${template}. Use: ${Object.keys(presets).join(', ')}`);
+        tmpl = factory();
+    }
+    else if ('custom' in template) {
+        tmpl = mod.ChatTemplateWasm.custom(template.custom);
+    }
+    else if ('modelId' in template) {
+        tmpl = mod.ChatTemplateWasm.detectFromModelId(template.modelId);
+    }
+    // Build messages
+    const wasmMessages = messages.map(m => {
+        switch (m.role) {
+            case 'system': return mod.ChatMessageWasm.system(m.content);
+            case 'user': return mod.ChatMessageWasm.user(m.content);
+            case 'assistant': return mod.ChatMessageWasm.assistant(m.content);
+            default: throw new Error(`Unknown role: ${m.role}`);
+        }
     });
+    return tmpl.format(wasmMessages);
 }
 // ── KV Cache ─────────────────────────────────────────────────
 /**
  * Create a KV cache for token management.
  */
-export function createKvCache(opts) {
-    return __awaiter(this, void 0, Promise, function () {
-        var mod, cache, config;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, initRuvllmWasm()];
-                case 1:
-                    _a.sent();
-                    return [4 /*yield*/, import('@ruvector/ruvllm-wasm')];
-                case 2:
-                    mod = _a.sent();
-                    if (opts) {
-                        config = new mod.KvCacheConfigWasm();
-                        if (opts.tailLength !== undefined)
-                            config.tailLength = opts.tailLength;
-                        if (opts.maxTokens !== undefined)
-                            config.maxTokens = opts.maxTokens;
-                        if (opts.numKvHeads !== undefined)
-                            config.numKvHeads = opts.numKvHeads;
-                        if (opts.headDim !== undefined)
-                            config.headDim = opts.headDim;
-                        cache = new mod.KvCacheWasm(config);
-                    }
-                    else {
-                        cache = mod.KvCacheWasm.withDefaults();
-                    }
-                    return [2 /*return*/, {
-                            append: function (keys, values) {
-                                cache.append(keys, values);
-                            },
-                            stats: function () {
-                                // Use toJson if available, otherwise stringify
-                                try {
-                                    return JSON.stringify(cache.stats());
-                                }
-                                catch (_a) {
-                                    return '{}';
-                                }
-                            },
-                            clear: function () {
-                                cache.clear();
-                            },
-                            tokenCount: function () {
-                                return cache.tokenCount;
-                            }
-                        }];
+export async function createKvCache(opts) {
+    await initRuvllmWasm();
+    const mod = await import('@ruvector/ruvllm-wasm');
+    let cache;
+    if (opts) {
+        const config = new mod.KvCacheConfigWasm();
+        if (opts.tailLength !== undefined)
+            config.tailLength = opts.tailLength;
+        if (opts.maxTokens !== undefined)
+            config.maxTokens = opts.maxTokens;
+        if (opts.numKvHeads !== undefined)
+            config.numKvHeads = opts.numKvHeads;
+        if (opts.headDim !== undefined)
+            config.headDim = opts.headDim;
+        cache = new mod.KvCacheWasm(config);
+    }
+    else {
+        cache = mod.KvCacheWasm.withDefaults();
+    }
+    return {
+        append(keys, values) {
+            cache.append(keys, values);
+        },
+        stats() {
+            // Use toJson if available, otherwise stringify
+            try {
+                return JSON.stringify(cache.stats());
             }
-        });
-    });
+            catch {
+                return '{}';
+            }
+        },
+        clear() {
+            cache.clear();
+        },
+        tokenCount() {
+            return cache.tokenCount;
+        },
+    };
 }
 // ── Generate Config ──────────────────────────────────────────
 /**
  * Create a generation config object.
  * Note: f32 precision loss is expected (0.7 → 0.699999...).
  */
-export function createGenerateConfig(opts) {
-    var _a;
-    if (opts === void 0) { opts = {}; }
-    return __awaiter(this, void 0, Promise, function () {
-        var mod, config, _i, _b, seq;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0: return [4 /*yield*/, initRuvllmWasm()];
-                case 1:
-                    _c.sent();
-                    return [4 /*yield*/, import('@ruvector/ruvllm-wasm')];
-                case 2:
-                    mod = _c.sent();
-                    config = new mod.GenerateConfig();
-                    if (opts.maxTokens !== undefined)
-                        config.maxTokens = opts.maxTokens;
-                    if (opts.temperature !== undefined)
-                        config.temperature = opts.temperature;
-                    if (opts.topP !== undefined)
-                        config.topP = opts.topP;
-                    if (opts.topK !== undefined)
-                        config.topK = opts.topK;
-                    if (opts.repetitionPenalty !== undefined)
-                        config.repetitionPenalty = opts.repetitionPenalty;
-                    for (_i = 0, _b = (_a = opts.stopSequences) !== null && _a !== void 0 ? _a : []; _i < _b.length; _i++) {
-                        seq = _b[_i];
-                        config.addStopSequence(seq);
-                    }
-                    return [2 /*return*/, config.toJson()];
-            }
-        });
-    });
+export async function createGenerateConfig(opts = {}) {
+    await initRuvllmWasm();
+    const mod = await import('@ruvector/ruvllm-wasm');
+    const config = new mod.GenerateConfig();
+    if (opts.maxTokens !== undefined)
+        config.maxTokens = opts.maxTokens;
+    if (opts.temperature !== undefined)
+        config.temperature = opts.temperature;
+    if (opts.topP !== undefined)
+        config.topP = opts.topP;
+    if (opts.topK !== undefined)
+        config.topK = opts.topK;
+    if (opts.repetitionPenalty !== undefined)
+        config.repetitionPenalty = opts.repetitionPenalty;
+    for (const seq of opts.stopSequences ?? []) {
+        config.addStopSequence(seq);
+    }
+    return config.toJson();
 }
 // ── Buffer Pool ──────────────────────────────────────────────
 /**
  * Create a buffer pool for inference memory management.
  */
-export function createBufferPool(capacity) {
-    return __awaiter(this, void 0, Promise, function () {
-        var mod, pool;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, initRuvllmWasm()];
-                case 1:
-                    _a.sent();
-                    return [4 /*yield*/, import('@ruvector/ruvllm-wasm')];
-                case 2:
-                    mod = _a.sent();
-                    pool = mod.BufferPoolWasm.withCapacity(capacity);
-                    return [2 /*return*/, {
-                            prewarm: function (count) {
-                                pool.prewarmAll(count);
-                            },
-                            stats: function () {
-                                return pool.statsJson();
-                            },
-                            hitRate: function () {
-                                return pool.hitRate;
-                            },
-                            clear: function () {
-                                pool.clear();
-                            }
-                        }];
-            }
-        });
-    });
+export async function createBufferPool(capacity) {
+    await initRuvllmWasm();
+    const mod = await import('@ruvector/ruvllm-wasm');
+    const pool = mod.BufferPoolWasm.withCapacity(capacity);
+    return {
+        prewarm(count) {
+            pool.prewarmAll(count);
+        },
+        stats() {
+            return pool.statsJson();
+        },
+        hitRate() {
+            return pool.hitRate;
+        },
+        clear() {
+            pool.clear();
+        },
+    };
 }
 // ── Inference Arena ──────────────────────────────────────────
 /**
  * Create an inference arena for model memory allocation.
  */
-export function createInferenceArena(opts) {
-    return __awaiter(this, void 0, Promise, function () {
-        var mod, arena;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, initRuvllmWasm()];
-                case 1:
-                    _a.sent();
-                    return [4 /*yield*/, import('@ruvector/ruvllm-wasm')];
-                case 2:
-                    mod = _a.sent();
-                    arena = 'capacity' in opts
-                        ? new mod.InferenceArenaWasm(opts.capacity)
-                        : mod.InferenceArenaWasm.forModel(opts.hiddenDim, opts.vocabSize, opts.batchSize);
-                    return [2 /*return*/, {
-                            reset: function () { arena.reset(); },
-                            used: function () { return arena.used; },
-                            capacity: function () { return arena.capacity; },
-                            remaining: function () { return arena.remaining; }
-                        }];
-            }
-        });
-    });
+export async function createInferenceArena(opts) {
+    await initRuvllmWasm();
+    const mod = await import('@ruvector/ruvllm-wasm');
+    const arena = 'capacity' in opts
+        ? new mod.InferenceArenaWasm(opts.capacity)
+        : mod.InferenceArenaWasm.forModel(opts.hiddenDim, opts.vocabSize, opts.batchSize);
+    return {
+        reset() { arena.reset(); },
+        used() { return arena.used; },
+        capacity() { return arena.capacity; },
+        remaining() { return arena.remaining; },
+    };
 }
 //# sourceMappingURL=ruvllm-wasm.js.map