baraqex 1.0.17 → 1.0.19

package/dist/server/wasm.js

@@ -1,7 +1,10 @@
 /**
  * Server-side Go WASM integration for Node.js
+ * Uses the standard Go WASM runtime (wasm_exec.js)
  */
 import fs from 'fs/promises';
+import path from 'path';
+import { pathToFileURL } from 'url';
 // Global flag to ensure we only initialize WASM once
 let initialized = false;
 /**
@@ -11,14 +14,6 @@ export async function initNodeWasm() {
     if (initialized)
         return;
     try {
-        // Check if node requires WASM flags
-        const nodeVersion = process.version;
-        const majorVersion = parseInt(nodeVersion.slice(1).split('.')[0], 10);
-        // Node.js version check for WASM flags requirement
-        if (majorVersion < 16) {
-            console.warn('[WASM] Note: Node.js version < 16 detected. ' +
-                'You may need --experimental-wasm-bigint flag for Go WASM modules.');
-        }
         // Global WASM environment setup for Node.js
         globalThis.TextEncoder = globalThis.TextEncoder || TextEncoder;
         globalThis.TextDecoder = globalThis.TextDecoder || TextDecoder;
@@ -31,443 +26,127 @@ export async function initNodeWasm() {
     }
 }
 /**
- * Load a Go WASM module from a file path for server-side usage
+ * Load Go WASM runtime from wasm_exec.js file
  */
-export async function loadGoWasmFromFile(wasmFilePath, options = {}) {
-    try {
-        // Initialize Node.js WASM environment
-        await initNodeWasm();
-        // Create a proper Go runtime that matches what Go WASM expects
-        const Go = class {
-            constructor() {
-                this.importObject = {
-                    gojs: {
-                        // Memory management
-                        'runtime.wasmExit': (sp) => {
-                            const code = new DataView(this.mem.buffer).getInt32(sp + 8, true);
-                            process.exit(code);
-                        },
-                        'runtime.wasmWrite': (sp) => {
-                            const fd = new DataView(this.mem.buffer).getInt32(sp + 8, true);
-                            const p = new DataView(this.mem.buffer).getInt32(sp + 16, true);
-                            const n = new DataView(this.mem.buffer).getInt32(sp + 24, true);
-                            if (fd === 1) { // stdout
-                                process.stdout.write(new Uint8Array(this.mem.buffer, p, n));
-                            }
-                            else if (fd === 2) { // stderr
-                                process.stderr.write(new Uint8Array(this.mem.buffer, p, n));
-                            }
-                        },
-                        'runtime.resetMemoryDataView': () => {
-                            this.mem = this.inst?.exports.mem;
-                        },
-                        'runtime.nanotime1': (sp) => {
-                            const nsec = Date.now() * 1000000;
-                            new DataView(this.mem.buffer).setBigInt64(sp + 8, BigInt(nsec), true);
-                        },
-                        'runtime.walltime': (sp) => {
-                            const msec = Date.now();
-                            const sec = Math.floor(msec / 1000);
-                            const nsec = (msec % 1000) * 1000000;
-                            new DataView(this.mem.buffer).setBigInt64(sp + 8, BigInt(sec), true);
-                            new DataView(this.mem.buffer).setInt32(sp + 16, nsec, true);
-                        },
-                        'runtime.scheduleTimeoutEvent': (sp) => {
-                            const id = this._nextCallbackTimeoutID++;
-                            const delay = new DataView(this.mem.buffer).getBigInt64(sp + 8, true);
-                            setTimeout(() => {
-                                this._resume();
-                            }, Number(delay));
-                            new DataView(this.mem.buffer).setInt32(sp + 16, id, true);
-                        },
-                        'runtime.clearTimeoutEvent': (sp) => {
-                            // Simplified implementation
-                        },
-                        'runtime.getRandomData': (sp) => {
-                            const buf = new DataView(this.mem.buffer).getInt32(sp + 8, true);
-                            const len = new DataView(this.mem.buffer).getInt32(sp + 16, true);
-                            crypto.getRandomValues(new Uint8Array(this.mem.buffer, buf, len));
-                        },
-                        // JavaScript interop
-                        'syscall/js.finalizeRef': () => { },
-                        'syscall/js.stringVal': (sp) => {
-                            const s = this._loadString(new DataView(this.mem.buffer).getInt32(sp + 8, true));
-                            this._storeValue(sp + 16, s);
-                        },
-                        'syscall/js.valueGet': (sp) => {
-                            try {
-                                const v = this._loadValue(new DataView(this.mem.buffer).getInt32(sp + 8, true));
-                                const p = this._loadString(new DataView(this.mem.buffer).getInt32(sp + 16, true));
-                                // Ensure v is a valid object before using Reflect.get
-                                if (v === null || v === undefined) {
-                                    console.warn(`[WASM] valueGet called on null/undefined object for property: ${p}`);
-                                    this._storeValue(sp + 24, undefined);
-                                    return;
-                                }
-                                if (typeof v !== 'object' && typeof v !== 'function') {
-                                    console.warn(`[WASM] valueGet called on non-object (${typeof v}) for property: ${p}`);
-                                    this._storeValue(sp + 24, undefined);
-                                    return;
-                                }
-                                const result = Reflect.get(v, p);
-                                this._storeValue(sp + 24, result);
-                            }
-                            catch (error) {
-                                console.warn(`[WASM] Error in valueGet:`, error);
-                                this._storeValue(sp + 24, undefined);
-                            }
-                        },
-                        'syscall/js.valueSet': (sp) => {
-                            const v = this._loadValue(new DataView(this.mem.buffer).getInt32(sp + 8, true));
-                            const p = this._loadString(new DataView(this.mem.buffer).getInt32(sp + 16, true));
-                            const x = this._loadValue(new DataView(this.mem.buffer).getInt32(sp + 24, true));
-                            Reflect.set(v, p, x);
-                        },
-                        'syscall/js.valueDelete': (sp) => {
-                            const v = this._loadValue(new DataView(this.mem.buffer).getInt32(sp + 8, true));
-                            const p = this._loadString(new DataView(this.mem.buffer).getInt32(sp + 16, true));
-                            Reflect.deleteProperty(v, p);
-                        },
-                        'syscall/js.valueIndex': (sp) => {
-                            const v = this._loadValue(new DataView(this.mem.buffer).getInt32(sp + 8, true));
-                            const i = new DataView(this.mem.buffer).getInt32(sp + 16, true);
-                            this._storeValue(sp + 20, Reflect.get(v, i));
-                        },
-                        'syscall/js.valueSetIndex': (sp) => {
-                            const v = this._loadValue(new DataView(this.mem.buffer).getInt32(sp + 8, true));
-                            const i = new DataView(this.mem.buffer).getInt32(sp + 16, true);
-                            const x = this._loadValue(new DataView(this.mem.buffer).getInt32(sp + 20, true));
-                            Reflect.set(v, i, x);
-                        },
-                        'syscall/js.valueCall': (sp) => {
-                            try {
-                                const v = this._loadValue(new DataView(this.mem.buffer).getInt32(sp + 8, true));
-                                const m = this._loadString(new DataView(this.mem.buffer).getInt32(sp + 16, true));
-                                const args = this._loadSliceOfValues(new DataView(this.mem.buffer).getInt32(sp + 24, true));
-                                const result = Reflect.apply(v[m], v, args);
-                                this._storeValue(sp + 40, result);
-                                new DataView(this.mem.buffer).setUint8(sp + 48, 1);
-                            }
-                            catch (err) {
-                                this._storeValue(sp + 40, err);
-                                new DataView(this.mem.buffer).setUint8(sp + 48, 0);
-                            }
-                        },
-                        'syscall/js.valueInvoke': (sp) => {
-                            try {
-                                const v = this._loadValue(new DataView(this.mem.buffer).getInt32(sp + 8, true));
-                                const args = this._loadSliceOfValues(new DataView(this.mem.buffer).getInt32(sp + 16, true));
-                                const result = Reflect.apply(v, undefined, args);
-                                this._storeValue(sp + 32, result);
-                                new DataView(this.mem.buffer).setUint8(sp + 40, 1);
-                            }
-                            catch (err) {
-                                this._storeValue(sp + 32, err);
-                                new DataView(this.mem.buffer).setUint8(sp + 40, 0);
-                            }
-                        },
-                        'syscall/js.valueNew': (sp) => {
-                            try {
-                                const v = this._loadValue(new DataView(this.mem.buffer).getInt32(sp + 8, true));
-                                const args = this._loadSliceOfValues(new DataView(this.mem.buffer).getInt32(sp + 16, true));
-                                const result = Reflect.construct(v, args);
-                                this._storeValue(sp + 32, result);
-                                new DataView(this.mem.buffer).setUint8(sp + 40, 1);
-                            }
-                            catch (err) {
-                                this._storeValue(sp + 32, err);
-                                new DataView(this.mem.buffer).setUint8(sp + 40, 0);
-                            }
-                        },
-                        'syscall/js.valueLength': (sp) => {
-                            const v = this._loadValue(new DataView(this.mem.buffer).getInt32(sp + 8, true));
-                            new DataView(this.mem.buffer).setInt32(sp + 16, parseInt(v.length), true);
-                        },
-                        'syscall/js.valuePrepareString': (sp) => {
-                            const s = String(this._loadValue(new DataView(this.mem.buffer).getInt32(sp + 8, true)));
-                            const str = new TextEncoder().encode(s);
-                            this._storeValue(sp + 16, str);
-                            new DataView(this.mem.buffer).setInt32(sp + 24, str.length, true);
-                        },
-                        'syscall/js.valueLoadString': (sp) => {
-                            const str = this._loadValue(new DataView(this.mem.buffer).getInt32(sp + 8, true));
-                            new Uint8Array(this.mem.buffer, new DataView(this.mem.buffer).getInt32(sp + 16, true)).set(str);
-                        },
-                        'syscall/js.valueInstanceOf': (sp) => {
-                            const v = this._loadValue(new DataView(this.mem.buffer).getInt32(sp + 8, true));
-                            const t = this._loadValue(new DataView(this.mem.buffer).getInt32(sp + 16, true));
-                            new DataView(this.mem.buffer).setUint8(sp + 24, v instanceof t ? 1 : 0);
-                        },
-                        'syscall/js.copyBytesToGo': (sp) => {
-                            const dst = new DataView(this.mem.buffer).getInt32(sp + 8, true);
-                            const src = this._loadValue(new DataView(this.mem.buffer).getInt32(sp + 16, true));
-                            new Uint8Array(this.mem.buffer, dst).set(src);
-                            new DataView(this.mem.buffer).setInt32(sp + 24, src.length, true);
-                        },
-                        'syscall/js.copyBytesToJS': (sp) => {
-                            const dst = this._loadValue(new DataView(this.mem.buffer).getInt32(sp + 8, true));
-                            const src = new DataView(this.mem.buffer).getInt32(sp + 16, true);
-                            const len = new DataView(this.mem.buffer).getInt32(sp + 24, true);
-                            dst.set(new Uint8Array(this.mem.buffer, src, len));
-                            new DataView(this.mem.buffer).setInt32(sp + 32, len, true);
-                        },
-                        // Debug functions
-                        'debug': (value) => {
-                            console.log('[Go WASM Debug]:', value);
-                        }
-                    }
-                };
-                this._nextCallbackTimeoutID = 1;
-                this._values = [NaN, 0, null, true, false, global, this];
-                this._goRefCounts = [];
-                this._ids = new Map();
-                this._idPool = [];
-            }
-            _storeValue(addr, v) {
-                const nanHead = 0x7FF80000;
-                if (typeof v === "number" && v !== 0) {
-                    if (isNaN(v)) {
-                        new DataView(this.mem.buffer).setUint32(addr + 4, nanHead, true);
-                        new DataView(this.mem.buffer).setUint32(addr, 0, true);
-                        return;
-                    }
-                    new DataView(this.mem.buffer).setFloat64(addr, v, true);
-                    return;
-                }
-                if (v === undefined) {
-                    new DataView(this.mem.buffer).setFloat64(addr, 0, true);
-                    return;
-                }
-                let id = this._ids.get(v);
-                if (id === undefined) {
-                    id = this._idPool.pop();
-                    if (id === undefined) {
-                        id = this._values.length;
-                    }
-                    this._values[id] = v;
-                    this._goRefCounts[id] = 0;
-                    this._ids.set(v, id);
-                }
-                this._goRefCounts[id]++;
-                let typeFlag = 0;
-                switch (typeof v) {
-                    case "object":
-                        if (v !== null) {
-                            typeFlag = 1;
-                        }
-                        break;
-                    case "string":
-                        typeFlag = 2;
-                        break;
-                    case "symbol":
-                        typeFlag = 3;
-                        break;
-                    case "function":
-                        typeFlag = 4;
-                        break;
+async function loadGoRuntime(goWasmPath) {
+    if (typeof global.Go === 'function') {
+        return global.Go;
+    }
+    // Try to find wasm_exec.js or wasm_exec.cjs
+    const possiblePaths = [
+        goWasmPath,
+        './wasm_exec.cjs',
+        './wasm_exec.js',
+        './public/wasm_exec.cjs',
+        './public/wasm_exec.js',
+        './src/wasm_exec.cjs',
+        './src/wasm_exec.js',
+        path.join(process.cwd(), 'wasm_exec.cjs'),
+        path.join(process.cwd(), 'wasm_exec.js'),
+        path.join(process.cwd(), 'public', 'wasm_exec.cjs'),
+        path.join(process.cwd(), 'public', 'wasm_exec.js'),
+        path.join(process.cwd(), 'src', 'wasm_exec.cjs'),
+        path.join(process.cwd(), 'src', 'wasm_exec.js')
+    ].filter(Boolean);
+    for (const wasmExecPath of possiblePaths) {
+        try {
+            const resolvedPath = path.resolve(wasmExecPath);
+            // Check if file exists using fs.stat instead of fs.access
+            try {
+                const stats = await fs.stat(resolvedPath);
+                if (!stats.isFile()) {
+                    continue;
                 }
-                new DataView(this.mem.buffer).setUint32(addr + 4, nanHead | typeFlag, true);
-                new DataView(this.mem.buffer).setUint32(addr, id, true);
             }
-            _loadValue(addr) {
-                try {
-                    // Validate address bounds
-                    if (addr < 0 || addr >= this.mem.buffer.byteLength - 8) {
-                        console.warn(`[WASM] Invalid _loadValue address: ${addr}`);
-                        return undefined;
-                    }
-                    const f = new DataView(this.mem.buffer).getFloat64(addr, true);
-                    if (f === 0) {
-                        return undefined;
-                    }
-                    if (!isNaN(f)) {
-                        return f;
-                    }
-                    const id = new DataView(this.mem.buffer).getUint32(addr, true);
-                    // Validate the ID is within bounds
-                    if (id < 0 || id >= this._values.length) {
-                        console.warn(`[WASM] Invalid value ID: ${id}, values length: ${this._values.length}`);
-                        return undefined;
-                    }
-                    return this._values[id];
-                }
-                catch (error) {
-                    console.warn(`[WASM] Error loading value at ${addr}:`, error);
-                    return undefined;
-                }
+            catch (statError) {
+                continue; // File doesn't exist, try next path
             }
-            _loadString(addr) {
-                try {
-                    // Validate the address is within bounds
-                    if (addr < 0 || addr >= this.mem.buffer.byteLength - 8) {
-                        console.warn(`[WASM] Invalid string address: ${addr}, buffer size: ${this.mem.buffer.byteLength}`);
-                        return '';
-                    }
-                    const saddr = new DataView(this.mem.buffer).getInt32(addr + 0, true);
-                    const len = new DataView(this.mem.buffer).getInt32(addr + 8, true);
-                    // Validate string data address and length
-                    if (saddr < 0 || len < 0 || saddr + len > this.mem.buffer.byteLength) {
-                        console.warn(`[WASM] Invalid string data - addr: ${saddr}, len: ${len}, buffer size: ${this.mem.buffer.byteLength}`);
-                        return '';
-                    }
-                    return new TextDecoder("utf-8").decode(new DataView(this.mem.buffer, saddr, len));
-                }
-                catch (error) {
-                    console.warn(`[WASM] Error loading string at ${addr}:`, error);
-                    return '';
-                }
+            // Load the Go runtime using dynamic import with file:// URL
+            const wasmExecUrl = pathToFileURL(resolvedPath).href;
+            // Clear global.Go to ensure fresh import
+            if (global.Go) {
+                delete global.Go;
             }
-            _loadSliceOfValues(addr) {
-                try {
-                    // Validate the address is within bounds
-                    if (addr < 0 || addr >= this.mem.buffer.byteLength - 16) {
-                        console.warn(`[WASM] Invalid slice address: ${addr}`);
-                        return [];
-                    }
-                    const array = new DataView(this.mem.buffer).getInt32(addr + 0, true);
-                    const len = new DataView(this.mem.buffer).getInt32(addr + 8, true);
-                    // Validate array parameters
-                    if (len < 0 || len > 1000) { // Reasonable limit
-                        console.warn(`[WASM] Invalid slice length: ${len}`);
-                        return [];
-                    }
-                    if (array < 0 || array + (len * 8) > this.mem.buffer.byteLength) {
-                        console.warn(`[WASM] Invalid slice data - addr: ${array}, len: ${len}`);
-                        return [];
-                    }
-                    const a = new Array(len);
-                    for (let i = 0; i < len; i++) {
-                        a[i] = this._loadValue(array + i * 8);
-                    }
-                    return a;
-                }
-                catch (error) {
-                    console.warn(`[WASM] Error loading slice at ${addr}:`, error);
-                    return [];
-                }
+            // Import the module
+            await import(wasmExecUrl);
+            if (typeof global.Go === 'function') {
+                console.log(`[WASM] Loaded Go runtime from: ${resolvedPath}`);
+                return global.Go;
             }
-            _resume() {
-                if (this.inst && this.inst.exports.resume) {
-                    try {
-                        this.inst.exports.resume();
-                    }
-                    catch (error) {
-                        console.warn('[WASM] Error resuming:', error);
-                    }
-                }
+            else {
+                console.warn(`[WASM] File found but Go class not exported: ${resolvedPath}`);
             }
-            run(instance) {
-                this.inst = instance;
-                this.mem = instance.exports.mem;
-                // Set up the global object with common browser APIs
-                global.global = global;
-                global.Object = Object;
-                global.Array = Array;
-                global.console = console;
-                global.document = {
-                    createElement: (tag) => ({ tagName: tag, innerHTML: '', style: {} }),
-                    getElementById: () => null,
-                    querySelector: () => null
-                };
-                global.window = global;
-                // Add required crypto for Go WASM
-                if (!global.crypto) {
-                    global.crypto = {
-                        getRandomValues: (array) => {
-                            if (array && array instanceof Uint8Array) {
-                                for (let i = 0; i < array.length; i++) {
-                                    array[i] = Math.floor(Math.random() * 256);
-                                }
-                            }
-                            return array;
-                        },
-                        subtle: {},
-                        randomUUID: () => {
-                            return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
-                                const r = Math.random() * 16 | 0;
-                                const v = c === 'x' ? r : (r & 0x3 | 0x8);
-                                return v.toString(16);
-                            });
-                        }
-                    };
-                }
-                if (options.debug) {
-                    console.log('[WASM] Go runtime initialized with proper imports');
-                    console.log('[WASM] Memory size:', this.mem.buffer.byteLength, 'bytes');
-                }
-                // Run the Go program with error handling
-                try {
-                    if (instance.exports.run) {
-                        instance.exports.run();
-                    }
-                }
-                catch (error) {
-                    console.error('[WASM] Error running Go program:', error);
-                    throw error;
-                }
-            }
-        };
+        }
+        catch (error) {
+            console.warn(`[WASM] Error loading from ${wasmExecPath}:`, error.message);
+            continue;
+        }
+    }
+    throw new Error('[WASM] Could not find wasm_exec.js. Please ensure you have the Go WASM runtime file available.\n' +
+        'You can get it from: https://github.com/golang/go/blob/master/misc/wasm/wasm_exec.js\n' +
+        `Searched paths: ${possiblePaths.join(', ')}`);
+}
+/**
+ * Load a Go WASM module from a file path for server-side usage
+ */
+export async function loadGoWasmFromFile(wasmFilePath, options = {}) {
+    try {
+        // Initialize Node.js WASM environment
+        await initNodeWasm();
+        if (options.debug) {
+            console.log('[WASM] Loading WASM from file:', wasmFilePath);
+        }
+        // Load the standard Go runtime
+        const GoRuntime = await loadGoRuntime(options.goWasmPath);
+        const go = new GoRuntime();
         // Load WASM binary
         const wasmBuffer = await fs.readFile(wasmFilePath);
         const wasmModule = await WebAssembly.compile(wasmBuffer);
-        // Create Go instance
-        const go = new Go();
-        // Create imports object
+        // The standard wasm_exec.js provides imports under 'go' but some Go WASM modules expect 'gojs'
+        // Create imports object with both possible structures
+        const baseImports = go.importObject;
         const finalImportObject = {
-            ...go.importObject,
+            ...baseImports,
+            // Add gojs mapping for compatibility
+            gojs: baseImports.go || {},
             ...options.importObject
         };
+        if (options.debug) {
+            console.log('[WASM] Available import modules:', Object.keys(finalImportObject));
+            console.log('[WASM] Go import functions:', Object.keys(finalImportObject.go || {}));
+            console.log('[WASM] Gojs import functions:', Object.keys(finalImportObject.gojs || {}));
+        }
         // Instantiate the WASM module
         const instance = await WebAssembly.instantiate(wasmModule, finalImportObject);
-        // Initialize Go runtime
-        go.run(instance);
-        // Give the Go module more time to register global functions and handle initialization
+        // Initialize Go runtime (exactly like browser)
+        await go.run(instance);
+        // Give Go runtime time to initialize and register functions (like browser version)
         await new Promise(resolve => setTimeout(resolve, 1000));
-        // Extract exported functions
-        const exports = instance.exports;
+        // Extract exported functions from global scope (like browser version)
         const functions = {};
-        // Generate wrapper functions for all exports that are functions
-        for (const key in exports) {
-            if (typeof exports[key] === 'function') {
-                const exportedFunc = exports[key];
-                functions[key] = (...args) => exportedFunc(...args);
-                if (options.debug) {
-                    const originalFn = functions[key];
-                    functions[key] = (...args) => {
-                        console.log(`[WASM] Calling ${key}(${args.join(', ')})`);
-                        const result = originalFn(...args);
-                        console.log(`[WASM] ${key} returned:`, result);
-                        return result;
-                    };
-                }
-            }
-        }
-        // Also capture global functions exported by Go
-        for (const key in global) {
-            if (key.startsWith('go') && typeof global[key] === 'function') {
-                const globalFunc = global[key];
-                functions[key] = (...args) => globalFunc(...args);
+        // Look for Go functions in global scope
+        const globalObj = global;
+        for (const key in globalObj) {
+            if (typeof globalObj[key] === 'function' && key.startsWith('go')) {
+                functions[key] = globalObj[key];
                 if (options.debug) {
-                    const originalFn = functions[key];
-                    functions[key] = (...args) => {
-                        console.log(`[WASM] Calling global ${key}(${args.join(', ')})`);
-                        const result = originalFn(...args);
-                        console.log(`[WASM] ${key} returned:`, result);
-                        return result;
-                    };
+                    console.log(`[WASM] Found function: ${key}`);
                 }
             }
         }
         const wasmInstance = {
             instance,
             module: wasmModule,
-            exports,
+            exports: instance.exports,
             functions
         };
         // Run onLoad callback if provided
         if (options.onLoad) {
             options.onLoad(wasmInstance);
         }
+        if (options.debug) {
+            console.log(`[WASM] Module loaded successfully with ${Object.keys(functions).length} functions`);
+        }
         return wasmInstance;
     }
     catch (error) {
@@ -475,4 +154,28 @@ export async function loadGoWasmFromFile(wasmFilePath, options = {}) {
         throw error;
     }
 }
+/**
+ * Call a Go WASM function in Node.js environment
+ */
+export function callWasmFunction(funcName, ...args) {
+    const func = global[funcName];
+    if (typeof func !== 'function') {
+        throw new Error(`Function ${funcName} not found. Make sure the WASM module is loaded.`);
+    }
+    return func(...args);
+}
+/**
+ * Check if Go WASM is ready in Node.js
+ */
+export function isWasmReady() {
+    const globalObj = global;
+    return Object.keys(globalObj).some(key => key.startsWith('go') && typeof globalObj[key] === 'function');
+}
+/**
+ * Get all available Go WASM functions in Node.js
+ */
+export function getWasmFunctions() {
+    const globalObj = global;
+    return Object.keys(globalObj).filter(key => key.startsWith('go') && typeof globalObj[key] === 'function');
+}
 //# sourceMappingURL=wasm.js.map