@openfluke/welvet 0.1.3 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfluke/welvet",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "TypeScript/JavaScript bindings for LOOM neural network framework with WebAssembly support - GPU-accelerated machine learning in the browser",
   "type": "module",
   "main": "./dist/index.js",
@@ -50,7 +50,9 @@
     "clean": "rm -rf dist",
     "build": "tsc -p tsconfig.json",
     "postbuild": "cp -r assets/* dist/",
-    "prepare": "bun run build"
+    "prepare": "bun run build",
+    "serve": "python3 serve.py",
+    "dev": "bun run build && bun run serve"
   },
   "devDependencies": {
     "@types/node": "^22.7.5",

package/dist/env.d.ts

@@ -1,3 +0,0 @@
-export declare const isBrowser: boolean;
-export declare const isNode: boolean;
-export declare const isBun: boolean;

package/dist/env.js

@@ -1,3 +0,0 @@
-export const isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
-export const isNode = typeof process !== "undefined" && !!process.versions?.node;
-export const isBun = typeof globalThis.Bun !== "undefined";

package/dist/transformer.d.ts

@@ -1,5 +0,0 @@
-import type { TransformerAPI } from "./types.js";
-/**
- * Create transformer API wrapper around WASM functions
- */
-export declare function createTransformerAPI(): Promise<TransformerAPI>;

package/dist/transformer.js

@@ -1,127 +0,0 @@
-/**
- * Helper to wait for a global function to be available
- */
-async function waitForGlobal(name, timeoutMs = 5000) {
-    const t0 = performance.now();
-    for (;;) {
-        if (globalThis[name])
-            return;
-        if (performance.now() - t0 > timeoutMs) {
-            throw new Error(`Timeout waiting for ${name}`);
-        }
-        await new Promise((r) => setTimeout(r, 10));
-    }
-}
-/**
- * Create transformer API wrapper around WASM functions
- */
-export async function createTransformerAPI() {
-    // Wait for transformer functions to be available
-    await Promise.all([
-        waitForGlobal("LoadTokenizerFromBytes"),
-        waitForGlobal("LoadTransformerFromBytes"),
-        waitForGlobal("EncodeText"),
-        waitForGlobal("DecodeTokens"),
-        waitForGlobal("GenerateNextToken"),
-        waitForGlobal("GenerateText"),
-    ]);
-    const g = globalThis;
-    return {
-        async loadTokenizer(tokenizerData) {
-            return new Promise((resolve, reject) => {
-                try {
-                    const resultStr = g.LoadTokenizerFromBytes(tokenizerData);
-                    // If it's already an object, return it directly
-                    if (typeof resultStr === "object") {
-                        resolve(resultStr);
-                        return;
-                    }
-                    const result = JSON.parse(resultStr);
-                    resolve(result);
-                }
-                catch (error) {
-                    reject(error);
-                }
-            });
-        },
-        async loadModel(configData, weightsData) {
-            return new Promise((resolve, reject) => {
-                try {
-                    const resultStr = g.LoadTransformerFromBytes(configData, weightsData);
-                    const result = JSON.parse(resultStr);
-                    resolve(result);
-                }
-                catch (error) {
-                    reject(error);
-                }
-            });
-        },
-        async encode(text, addSpecialTokens = true) {
-            return new Promise((resolve, reject) => {
-                try {
-                    const resultStr = g.EncodeText(text, addSpecialTokens);
-                    const result = JSON.parse(resultStr);
-                    resolve(result);
-                }
-                catch (error) {
-                    reject(error);
-                }
-            });
-        },
-        async decode(tokenIds, skipSpecialTokens = true) {
-            return new Promise((resolve, reject) => {
-                try {
-                    const resultStr = g.DecodeTokens(tokenIds, skipSpecialTokens);
-                    const result = JSON.parse(resultStr);
-                    resolve(result);
-                }
-                catch (error) {
-                    reject(error);
-                }
-            });
-        },
-        async generate(prompt, maxTokens = 50, temperature = 0.7) {
-            return new Promise((resolve, reject) => {
-                try {
-                    const resultStr = g.GenerateText(prompt, maxTokens, temperature);
-                    const result = JSON.parse(resultStr);
-                    resolve(result);
-                }
-                catch (error) {
-                    reject(error);
-                }
-            });
-        },
-        async *generateStream(prompt, maxTokens = 50, temperature = 0.7) {
-            // Encode the prompt
-            const encodeResultStr = g.EncodeText(prompt, true);
-            const encodeResult = JSON.parse(encodeResultStr);
-            if (!encodeResult.success || !encodeResult.ids) {
-                throw new Error(encodeResult.error || "Failed to encode prompt");
-            }
-            const tokens = [...encodeResult.ids];
-            // Generate tokens one at a time
-            for (let i = 0; i < maxTokens; i++) {
-                const resultStr = g.GenerateNextToken(tokens, temperature);
-                const result = JSON.parse(resultStr);
-                if (!result.success) {
-                    throw new Error(result.error || "Failed to generate token");
-                }
-                if (result.token === undefined) {
-                    break;
-                }
-                tokens.push(result.token);
-                // Decode just this token
-                const decodeResultStr = g.DecodeTokens([result.token], true);
-                const decodeResult = JSON.parse(decodeResultStr);
-                if (decodeResult.success && decodeResult.text) {
-                    yield decodeResult.text;
-                }
-                // Check for end of sequence
-                if (result.is_eos) {
-                    break;
-                }
-            }
-        },
-    };
-}