@openfluke/welvet 0.1.4 → 0.1.6

package/README.md

@@ -151,6 +151,57 @@ const [output2] = loadedNetwork.ForwardCPU(
 - ✅ Same behavior as Python, C#, C, and WASM
 
 See `example/grid-scatter.ts` for a complete working example.
+
+### ⚡ Stepping API - Fine-Grained Execution Control
+
+**NEW:** Execute networks one step at a time for online learning:
+
+```typescript
+import { init, createNetwork, StepState } from "@openfluke/welvet";
+
+await init();
+
+// Create network
+const config = { batch_size: 1, layers: [
+  { type: "dense", input_height: 4, output_height: 8, activation: "relu" },
+  { type: "lstm", input_size: 8, hidden_size: 12, seq_length: 1 },
+  { type: "dense", input_height: 12, output_height: 3, activation: "softmax" }
+]};
+const network = createNetwork(config);
+
+// Initialize stepping state
+const state: StepState = network.createStepState(4);
+
+// Training loop - update weights after EACH step
+for (let step = 0; step < 100000; step++) {
+  state.setInput(new Float32Array([0.1, 0.2, 0.1, 0.3]));
+  state.stepForward();
+  const output = state.getOutput();
+  
+  // Calculate gradients
+  const gradients = new Float32Array(output.length);
+  for (let i = 0; i < output.length; i++)
+    gradients[i] = output[i] - target[i];
+  
+  // Backward pass
+  state.stepBackward(gradients);
+  
+  // Update weights immediately
+  network.ApplyGradients(JSON.stringify([learningRate]));
+}
+```
+
+**Stepping API:**
+- `network.createStepState(inputSize)` - Initialize stepping state
+- `state.setInput(data)` - Set input for current step
+- `state.stepForward()` - Execute forward pass
+- `state.getOutput()` - Get output from last layer
+- `state.stepBackward(gradients)` - Execute backward pass
+- `network.ApplyGradients(paramsJSON)` - Update network weights
+
+See `example/step_train_v3.ts` for a complete example achieving 100% accuracy.
+
+
 {
 type: "parallel",
 combine_mode: "add",

package/dist/index.browser.js

@@ -24,7 +24,9 @@ export async function init() {
  * Wrapper around the global createLoomNetwork function exposed by WASM
  */
 export function createNetwork(config) {
-    const jsonConfig = typeof config === 'string' ? config : JSON.stringify(config);
+    const jsonConfig = typeof config === "string"
+        ? config
+        : JSON.stringify(config);
     return createLoomNetwork(jsonConfig);
 }
 /**

package/dist/index.js

@@ -25,7 +25,9 @@ export async function initBrowser() {
  * Wrapper around the global createLoomNetwork function exposed by WASM
  */
 export function createNetwork(config) {
-    const jsonConfig = typeof config === 'string' ? config : JSON.stringify(config);
+    const jsonConfig = typeof config === "string"
+        ? config
+        : JSON.stringify(config);
     return createLoomNetwork(jsonConfig);
 }
 /**

package/dist/loader.js

@@ -8,19 +8,31 @@ import { dirname, join } from "path";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 export async function loadLoomWASM() {
+    // __dirname points to:
+    // - dist/   → in production
+    // - src/    → when running via Bun, ts-node, or example files
+    let root;
+    if (__dirname.endsWith("dist")) {
+        // Normal production layout
+        root = __dirname;
+    }
+    else {
+        // Running from src/ or example/
+        // Point to project’s dist/ directory
+        root = join(__dirname, "..", "dist");
+    }
     // Load wasm_exec.js
-    const wasmExecPath = join(__dirname, "../assets/wasm_exec.js");
+    const wasmExecPath = join(root, "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 wasmPath = join(root, "main.wasm");
     const wasmBuffer = readFileSync(wasmPath);
-    // @ts-ignore - Go is defined by wasm_exec.js
+    // @ts-ignore - Go runtime from 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
+    // Wait for WASM runtime to finish bootstrapping
     await new Promise((resolve) => setTimeout(resolve, 100));
 }

package/dist/types.d.ts

@@ -95,6 +95,20 @@ export interface Network {
     ListMethods(paramsJSON: string): string;
     HasMethod(paramsJSON: string): string;
     GetMethodSignature(paramsJSON: string): string;
+    ApplyGradients(paramsJSON: string): string;
+    ApplyGradientsAdamW(paramsJSON: string): string;
+    ApplyGradientsRMSprop(paramsJSON: string): string;
+    ApplyGradientsSGDMomentum(paramsJSON: string): string;
+    createStepState(inputSize: number): StepState;
+}
+/**
+ * StepState interface for stepping execution
+ */
+export interface StepState {
+    setInput(data: Float32Array | number[]): void;
+    stepForward(): number;
+    getOutput(): Float32Array;
+    stepBackward(gradients: Float32Array | number[]): Float32Array;
 }
 /**
  * Global WASM functions exposed by main.go

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfluke/welvet",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "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",
@@ -58,4 +58,4 @@
     "@types/node": "^22.7.5",
     "typescript": "^5.6.3"
   }
-}
+}