@openfluke/welvet 0.1.3 → 0.1.4

package/dist/index.browser.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @openfluke/welvet - Browser Entry Point
+ *
+ * Browser-only build without Node.js dependencies
+ * Isomorphic wrapper that mirrors main.go WASM exports
+ */
+import { Network } from "./types.js";
+import { loadLoomWASMBrowser } from "./loader.browser.js";
+export * from "./types.js";
+export { loadLoomWASMBrowser };
+/**
+ * Initialize WASM for Browser environment
+ */
+export declare function initBrowser(): Promise<void>;
+/**
+ * Initialize - alias for initBrowser in browser context
+ */
+export declare function init(): Promise<void>;
+/**
+ * Create a network from JSON config
+ * Wrapper around the global createLoomNetwork function exposed by WASM
+ */
+export declare function createNetwork(config: object | string): Network;
+/**
+ * Default export with all functions
+ */
+declare const _default: {
+    init: typeof init;
+    initBrowser: typeof initBrowser;
+    createNetwork: typeof createNetwork;
+};
+export default _default;

package/dist/index.browser.js

@@ -0,0 +1,37 @@
+/**
+ * @openfluke/welvet - Browser Entry Point
+ *
+ * Browser-only build without Node.js dependencies
+ * Isomorphic wrapper that mirrors main.go WASM exports
+ */
+import { loadLoomWASMBrowser } from "./loader.browser.js";
+export * from "./types.js";
+export { loadLoomWASMBrowser };
+/**
+ * Initialize WASM for Browser environment
+ */
+export async function initBrowser() {
+    await loadLoomWASMBrowser();
+}
+/**
+ * Initialize - alias for initBrowser in browser context
+ */
+export async function init() {
+    return initBrowser();
+}
+/**
+ * Create a network from JSON config
+ * Wrapper around the global createLoomNetwork function exposed by WASM
+ */
+export function createNetwork(config) {
+    const jsonConfig = typeof config === 'string' ? config : JSON.stringify(config);
+    return createLoomNetwork(jsonConfig);
+}
+/**
+ * Default export with all functions
+ */
+export default {
+    init,
+    initBrowser,
+    createNetwork
+};

package/dist/index.d.ts

@@ -1,33 +1,33 @@
-import type { InitOptions, LoomAPI } from "./types.js";
 /**
- * Initialize the LOOM WASM module and return the API
+ * @openfluke/welvet - Isomorphic WASM Wrapper
  *
- * @example
- * ```typescript
- * import { initLoom, ActivationType } from '@openfluke/loom';
- *
- * const loom = await initLoom();
- *
- * // Create a network: 784 → 392 → 10
- * const network = loom.NewNetwork(784, 1, 1, 2);
- *
- * // Configure layers
- * const layer0 = loom.InitDenseLayer(784, 392, ActivationType.ReLU);
- * const layer1 = loom.InitDenseLayer(392, 10, ActivationType.Sigmoid);
- *
- * network.SetLayer(JSON.stringify([0, 0, 0, JSON.parse(layer0)]));
- * network.SetLayer(JSON.stringify([0, 0, 1, JSON.parse(layer1)]));
- *
- * // Forward pass
- * const input = new Array(784).fill(0).map(() => Math.random());
- * const resultJSON = network.ForwardCPU(JSON.stringify([input]));
- * const [output, duration] = JSON.parse(resultJSON);
- *
- * console.log('Output:', output);
- * ```
+ * Direct wrapper around Loom WASM that mirrors main.go exports exactly.
+ * Provides the same API in both Node.js and browser environments.
+ */
+import { Network } from "./types.js";
+import { loadLoomWASM } from "./loader.js";
+import { loadLoomWASMBrowser } from "./loader.browser.js";
+export * from "./types.js";
+export { loadLoomWASM, loadLoomWASMBrowser };
+/**
+ * Initialize WASM for Node.js environment
+ */
+export declare function init(): Promise<void>;
+/**
+ * Initialize WASM for Browser environment
+ */
+export declare function initBrowser(): Promise<void>;
+/**
+ * Create a network from JSON config
+ * Wrapper around the global createLoomNetwork function exposed by WASM
+ */
+export declare function createNetwork(config: object | string): Network;
+/**
+ * Default export with all functions
  */
-export declare function initLoom(opts?: InitOptions): Promise<LoomAPI>;
-export type { LoomAPI, LoomNetwork, InitOptions, TransformerAPI, } from "./types.js";
-export { ActivationType } from "./types.js";
-export { createTransformerAPI } from "./transformer.js";
-export type { TokenizerLoadResult, TransformerLoadResult, EncodeResult, DecodeResult, GenerateResult, NextTokenResult, } from "./types.js";
+declare const _default: {
+    init: typeof init;
+    initBrowser: typeof initBrowser;
+    createNetwork: typeof createNetwork;
+};
+export default _default;

package/dist/index.js

@@ -1,87 +1,38 @@
-import { ensureGoRuntime, resolvePackagedWasmURL, instantiateGoWasm, } from "./loader.js";
-// tiny helper that waits until WASM has placed symbols on globalThis
-async function waitForExports(keys, timeoutMs = 5000) {
-    const t0 = performance.now();
-    for (;;) {
-        const ok = keys.every((k) => globalThis[k]);
-        if (ok)
-            return;
-        if (performance.now() - t0 > timeoutMs) {
-            throw new Error(`loom: timed out waiting for exports: ${keys.join(", ")}`);
-        }
-        await new Promise((r) => setTimeout(r, 10));
-    }
-}
 /**
- * Initialize the LOOM WASM module and return the API
- *
- * @example
- * ```typescript
- * import { initLoom, ActivationType } from '@openfluke/loom';
- *
- * const loom = await initLoom();
- *
- * // Create a network: 784 → 392 → 10
- * const network = loom.NewNetwork(784, 1, 1, 2);
- *
- * // Configure layers
- * const layer0 = loom.InitDenseLayer(784, 392, ActivationType.ReLU);
- * const layer1 = loom.InitDenseLayer(392, 10, ActivationType.Sigmoid);
+ * @openfluke/welvet - Isomorphic WASM Wrapper
  *
- * network.SetLayer(JSON.stringify([0, 0, 0, JSON.parse(layer0)]));
- * network.SetLayer(JSON.stringify([0, 0, 1, JSON.parse(layer1)]));
- *
- * // Forward pass
- * const input = new Array(784).fill(0).map(() => Math.random());
- * const resultJSON = network.ForwardCPU(JSON.stringify([input]));
- * const [output, duration] = JSON.parse(resultJSON);
- *
- * console.log('Output:', output);
- * ```
+ * Direct wrapper around Loom WASM that mirrors main.go exports exactly.
+ * Provides the same API in both Node.js and browser environments.
+ */
+import { loadLoomWASM } from "./loader.js";
+import { loadLoomWASMBrowser } from "./loader.browser.js";
+export * from "./types.js";
+export { loadLoomWASM, loadLoomWASMBrowser };
+/**
+ * Initialize WASM for Node.js environment
  */
-export async function initLoom(opts = {}) {
-    await ensureGoRuntime(opts.injectGoRuntime !== false);
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const go = new globalThis.Go();
-    const wasmUrl = await resolvePackagedWasmURL(opts.wasmUrl);
-    const instance = await instantiateGoWasm(go, wasmUrl);
-    // IMPORTANT: don't await this — it resolves when the Go program exits.
-    // Let it run; then poll for the exported symbols.
-    // no await:
-    // eslint-disable-next-line @typescript-eslint/no-floating-promises
-    Promise.resolve().then(() => go.run(instance));
-    // wait until your Go code has installed the globals
-    await waitForExports(["NewNetwork", "LoadModelFromString", "CallLayerInit"]);
-    const g = globalThis;
-    // Helper function to call layer init functions from the registry
-    const callLayerInit = (funcName, ...params) => {
-        return g.CallLayerInit(funcName, JSON.stringify(params));
-    };
-    const api = {
-        NewNetwork: g.NewNetwork,
-        LoadModelFromString: g.LoadModelFromString,
-        CallLayerInit: g.CallLayerInit, // Direct access to registry-based layer init
-        // Layer initialization functions using CallLayerInit (registry-based)
-        InitDenseLayer: (inputSize, outputSize, activation) => {
-            return callLayerInit("InitDenseLayer", inputSize, outputSize, activation);
-        },
-        InitConv2DLayer: (inChannels, outChannels, kernelSize, stride, padding, inputH, inputW, activation) => {
-            return callLayerInit("InitConv2DLayer", inChannels, outChannels, kernelSize, stride, padding, inputH, inputW, activation);
-        },
-        InitMultiHeadAttentionLayer: (dModel, numHeads, seqLength, activation) => {
-            return callLayerInit("InitMultiHeadAttentionLayer", dModel, numHeads, seqLength, activation);
-        },
-        InitRNNLayer: (inputSize, hiddenSize, seqLength, outputSize) => {
-            return callLayerInit("InitRNNLayer", inputSize, hiddenSize, seqLength, outputSize);
-        },
-        InitLSTMLayer: (inputSize, hiddenSize, seqLength, outputSize) => {
-            return callLayerInit("InitLSTMLayer", inputSize, hiddenSize, seqLength, outputSize);
-        },
-    };
-    if (!api.NewNetwork) {
-        throw new Error("loom: NewNetwork not found after WASM init");
-    }
-    return api;
+export async function init() {
+    await loadLoomWASM();
 }
-export { ActivationType } from "./types.js";
-export { createTransformerAPI } from "./transformer.js";
+/**
+ * Initialize WASM for Browser environment
+ */
+export async function initBrowser() {
+    await loadLoomWASMBrowser();
+}
+/**
+ * Create a network from JSON config
+ * Wrapper around the global createLoomNetwork function exposed by WASM
+ */
+export function createNetwork(config) {
+    const jsonConfig = typeof config === 'string' ? config : JSON.stringify(config);
+    return createLoomNetwork(jsonConfig);
+}
+/**
+ * Default export with all functions
+ */
+export default {
+    init,
+    initBrowser,
+    createNetwork
+};

package/dist/loader.browser.d.ts

@@ -0,0 +1,5 @@
+/**
+ * LOOM WASM Browser Loader
+ * Browser-only version without Node.js dependencies
+ */
+export declare function loadLoomWASMBrowser(): Promise<void>;

package/dist/loader.browser.js

@@ -0,0 +1,25 @@
+/**
+ * LOOM WASM Browser Loader
+ * Browser-only version without Node.js dependencies
+ */
+export async function loadLoomWASMBrowser() {
+    // For browser environments - load wasm_exec.js first if not already loaded
+    if (typeof globalThis.Go === "undefined") {
+        // Load wasm_exec.js dynamically from /dist/
+        const script = document.createElement("script");
+        script.src = "/dist/wasm_exec.js";
+        await new Promise((resolve, reject) => {
+            script.onload = () => resolve();
+            script.onerror = () => reject(new Error("Failed to load wasm_exec.js"));
+            document.head.appendChild(script);
+        });
+    }
+    const response = await fetch("/dist/main.wasm");
+    const wasmBuffer = await response.arrayBuffer();
+    // @ts-ignore - Go is defined by wasm_exec.js
+    const go = new Go();
+    const { instance } = await WebAssembly.instantiate(wasmBuffer, go.importObject);
+    go.run(instance);
+    // Wait for initialization
+    await new Promise((resolve) => setTimeout(resolve, 100));
+}

package/dist/loader.d.ts

@@ -1,3 +1,5 @@
-export declare function ensureGoRuntime(inject?: boolean): Promise<void>;
-export declare function resolvePackagedWasmURL(override?: string | URL): Promise<string | URL>;
-export declare function instantiateGoWasm(go: any, wasmUrl: string | URL): Promise<WebAssembly.Instance>;
+/**
+ * LOOM WASM Loader
+ * Loads and initializes the LOOM WebAssembly module (Node.js only)
+ */
+export declare function loadLoomWASM(): Promise<void>;

package/dist/loader.js

@@ -1,90 +1,26 @@
-import { isBrowser } from "./env.js";
-let goRuntimeInjected = false;
-let wasmExecTextBundled;
-let wasmUrlBundled;
-async function tryLoadBundlerAssets() {
-    try {
-        const raw = await import("./wasm_exec.js?raw");
-        wasmExecTextBundled = raw.default;
-    }
-    catch { }
-    try {
-        const url = await import("./loom.wasm?url");
-        wasmUrlBundled = url.default;
-    }
-    catch { }
-}
-export async function ensureGoRuntime(inject = true) {
-    if (!inject || goRuntimeInjected)
-        return;
-    if (isBrowser) {
-        if (!wasmExecTextBundled)
-            await tryLoadBundlerAssets();
-        if (wasmExecTextBundled) {
-            new Function(wasmExecTextBundled)(); // defines global Go
-            goRuntimeInjected = true;
-            return;
-        }
-        const url = new URL("./wasm_exec.js", import.meta.url);
-        const res = await fetch(url);
-        if (!res.ok)
-            throw new Error(`Failed to fetch wasm_exec.js (${res.status} ${res.statusText}) from ${url}`);
-        const jsText = await res.text();
-        new Function(jsText)();
-        goRuntimeInjected = true;
-        return;
-    }
-    const { readFile } = await import("node:fs/promises");
-    const { fileURLToPath } = await import("node:url");
-    const wasmExecUrl = new URL("./wasm_exec.js", import.meta.url);
-    const filePath = fileURLToPath(wasmExecUrl);
-    const jsText = await readFile(filePath, "utf8");
-    new Function(jsText)();
-    goRuntimeInjected = true;
-}
-export async function resolvePackagedWasmURL(override) {
-    if (override)
-        return override;
-    if (isBrowser) {
-        if (!wasmUrlBundled)
-            await tryLoadBundlerAssets();
-        if (wasmUrlBundled)
-            return wasmUrlBundled;
-        return new URL("./loom.wasm", import.meta.url);
-    }
-    return new URL("./loom.wasm", import.meta.url);
-}
-export async function instantiateGoWasm(go, wasmUrl) {
-    const asString = typeof wasmUrl === "string" ? wasmUrl : wasmUrl.toString();
-    if (isBrowser) {
-        if (typeof WebAssembly.instantiateStreaming === "function") {
-            const res = await fetch(asString);
-            try {
-                const { instance } = await WebAssembly.instantiateStreaming(res, go.importObject);
-                return instance;
-            }
-            catch {
-                const buf = await res.arrayBuffer();
-                const result = (await WebAssembly.instantiate(buf, go.importObject));
-                const instance = result.instance ?? result;
-                return instance;
-            }
-        }
-        else {
-            const res = await fetch(asString);
-            const buf = await res.arrayBuffer();
-            const result = (await WebAssembly.instantiate(buf, go.importObject));
-            const instance = result.instance ?? result;
-            return instance;
-        }
-    }
-    // Node/Bun
-    const { readFile } = await import("node:fs/promises");
-    const { fileURLToPath } = await import("node:url");
-    const url = typeof wasmUrl === "string" ? new URL(wasmUrl, import.meta.url) : wasmUrl;
-    const filePath = fileURLToPath(url);
-    const buf = await readFile(filePath);
-    const result = (await WebAssembly.instantiate(buf, go.importObject));
-    const instance = result.instance ?? result;
-    return instance;
+/**
+ * LOOM WASM Loader
+ * Loads and initializes the LOOM WebAssembly module (Node.js only)
+ */
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+export async function loadLoomWASM() {
+    // Load wasm_exec.js
+    const wasmExecPath = join(__dirname, "../assets/wasm_exec.js");
+    const wasmExecCode = readFileSync(wasmExecPath, "utf-8");
+    // Execute wasm_exec.js to get the Go runtime
+    eval(wasmExecCode);
+    // Load main.wasm
+    const wasmPath = join(__dirname, "../assets/main.wasm");
+    const wasmBuffer = readFileSync(wasmPath);
+    // @ts-ignore - Go is defined by wasm_exec.js
+    const go = new Go();
+    const { instance } = await WebAssembly.instantiate(wasmBuffer, go.importObject);
+    // Run the Go WASM module
+    go.run(instance);
+    // Wait a bit for initialization
+    await new Promise((resolve) => setTimeout(resolve, 100));
 }