@openfluke/welvet 0.1.0

package/dist/index.js

@@ -0,0 +1,85 @@
+import { ensureGoRuntime, resolvePackagedWasmURL, instantiateGoWasm, } from "./loader";
+// 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);
+ *
+ * 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);
+ * ```
+ */
+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,
+        // 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 { ActivationType } from "./types";

package/dist/loader.d.ts

@@ -0,0 +1,3 @@
+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>;

package/dist/loader.js

@@ -0,0 +1,90 @@
+import { isBrowser } from "./env";
+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;
+}

package/dist/types.d.ts

@@ -0,0 +1,108 @@
+/**
+ * LOOM Network instance returned by NewNetwork()
+ * All Network methods are dynamically exposed via reflection
+ */
+export interface LoomNetwork {
+    ForwardCPU(inputJSON: string): string;
+    ForwardGPU?(inputJSON: string): string;
+    BackwardCPU(gradOutputJSON: string): string;
+    BackwardGPU?(gradOutputJSON: string): string;
+    UpdateWeights(learningRateJSON: string): string;
+    Train(batchesAndConfigJSON: string): string;
+    SetLayer(configJSON: string): string;
+    InitGPU?(argsJSON: string): string;
+    ReleaseGPU?(): string;
+    SaveModelToString(modelIDJSON: string): string;
+    SaveModel?(pathAndIDJSON: string): string;
+    GetMethods(): string;
+    ListMethods(): string;
+    GetMethodSignature(methodNameJSON: string): string;
+    HasMethod(methodName: string): boolean;
+    [key: string]: any;
+}
+/**
+ * Global WASM functions exposed by LOOM
+ */
+export interface LoomAPI {
+    /**
+     * Create a new neural network
+     * @param inputSize - Size of input layer
+     * @param gridRows - Number of grid rows
+     * @param gridCols - Number of grid columns
+     * @param layersPerCell - Number of layers per grid cell
+     * @returns LoomNetwork instance with all methods
+     */
+    NewNetwork: (inputSize: number, gridRows: number, gridCols: number, layersPerCell: number) => LoomNetwork;
+    /**
+     * Load a model from JSON string
+     * @param modelJSON - JSON string of the model
+     * @param modelID - Model identifier
+     * @returns LoomNetwork instance
+     */
+    LoadModelFromString: (modelJSON: string, modelID: string) => LoomNetwork;
+    /**
+     * Initialize a dense (fully-connected) layer configuration
+     * @param inputSize - Input dimension
+     * @param outputSize - Output dimension
+     * @param activation - Activation type (0=ReLU, 1=Sigmoid, 2=Tanh, 3=Linear)
+     * @returns JSON string of layer configuration
+     */
+    InitDenseLayer: (inputSize: number, outputSize: number, activation: number) => string;
+    /**
+     * Initialize a multi-head attention layer configuration
+     * @param dModel - Model dimension
+     * @param numHeads - Number of attention heads
+     * @param seqLength - Sequence length
+     * @param activation - Activation type
+     * @returns JSON string of layer configuration
+     */
+    InitMultiHeadAttentionLayer: (dModel: number, numHeads: number, seqLength: number, activation: number) => string;
+    /**
+     * Initialize a 2D convolutional layer configuration
+     * @param inputHeight - Input height
+     * @param inputWidth - Input width
+     * @param inputChannels - Number of input channels
+     * @param kernelSize - Kernel size
+     * @param stride - Stride
+     * @param padding - Padding
+     * @param filters - Number of filters
+     * @param activation - Activation type
+     * @returns JSON string of layer configuration
+     */
+    InitConv2DLayer: (inputHeight: number, inputWidth: number, inputChannels: number, kernelSize: number, stride: number, padding: number, filters: number, activation: number) => string;
+    /**
+     * Initialize an RNN layer configuration
+     * @param inputSize - Input size
+     * @param hiddenSize - Hidden size
+     * @param batchSize - Batch size
+     * @param seqLength - Sequence length
+     * @returns JSON string of layer configuration
+     */
+    InitRNNLayer: (inputSize: number, hiddenSize: number, batchSize: number, seqLength: number) => string;
+    /**
+     * Initialize an LSTM layer configuration
+     * @param inputSize - Input size
+     * @param hiddenSize - Hidden size
+     * @param batchSize - Batch size
+     * @param seqLength - Sequence length
+     * @returns JSON string of layer configuration
+     */
+    InitLSTMLayer: (inputSize: number, hiddenSize: number, batchSize: number, seqLength: number) => string;
+}
+export interface InitOptions {
+    /** Override where the WASM is read from. Useful in exotic deploys (Capacitor, CDN). */
+    wasmUrl?: string | URL;
+    /** Set false to skip injecting wasm_exec.js (e.g., if you already included it). Default: true */
+    injectGoRuntime?: boolean;
+}
+/**
+ * Activation function types
+ */
+export declare enum ActivationType {
+    ReLU = 0,
+    Sigmoid = 1,
+    Tanh = 2,
+    Softplus = 3,
+    LeakyReLU = 4,
+    Linear = 5
+}

package/dist/types.js

@@ -0,0 +1,12 @@
+/**
+ * Activation function types
+ */
+export var ActivationType;
+(function (ActivationType) {
+    ActivationType[ActivationType["ReLU"] = 0] = "ReLU";
+    ActivationType[ActivationType["Sigmoid"] = 1] = "Sigmoid";
+    ActivationType[ActivationType["Tanh"] = 2] = "Tanh";
+    ActivationType[ActivationType["Softplus"] = 3] = "Softplus";
+    ActivationType[ActivationType["LeakyReLU"] = 4] = "LeakyReLU";
+    ActivationType[ActivationType["Linear"] = 5] = "Linear";
+})(ActivationType || (ActivationType = {}));