@openfluke/welvet 0.1.0 → 0.1.2

package/README.md

@@ -42,6 +42,34 @@ bun add @openfluke/welvet
 
 ## 🚀 Quick Start
 
+### The Easy Way: Load Complete Models
+
+Instead of manually configuring layers, **load a complete model with ONE line**:
+
+```typescript
+import { initLoom } from "@openfluke/welvet";
+
+const loom = await initLoom();
+
+// Load model from JSON (architecture + weights all at once!)
+const modelJSON = await fetch("test.json").then((r) => r.json());
+const network = loom.LoadModelFromString(
+  JSON.stringify(modelJSON),
+  "all_layers_test"
+);
+
+// That's it! All 16 layers, weights, biases loaded automatically
+const input = new Array(10).fill(0).map(() => Math.random());
+const [output, duration] = JSON.parse(
+  network.ForwardCPU(JSON.stringify([input]))
+);
+console.log("Output:", output);
+```
+
+**Live Demo:** See `wasm/all_layers_test.html` for a complete working example that loads a 26.4KB model with 16 layers (Dense, Conv2D, Attention, RNN, LSTM) and runs inference in the browser!
+
+### Manual Configuration (for building models from scratch)
+
 ```typescript
 import { initLoom, ActivationType } from "@openfluke/welvet";
 
@@ -254,6 +282,28 @@ network.UpdateWeights(JSON.stringify([learningRate]));
 
 ### Model Persistence
 
+#### Load Model (The Easy Way - ONE LINE!)
+
+```typescript
+// Fetch model from server
+const savedModel = await fetch("model.json").then((r) => r.json());
+
+// Load complete network with ONE function call!
+const network = loom.LoadModelFromString(
+  JSON.stringify(savedModel),
+  "model_name"
+);
+
+// Or from localStorage
+const savedModel = JSON.parse(localStorage.getItem("my_model")!);
+const network = loom.LoadModelFromString(
+  JSON.stringify(savedModel),
+  "model_name"
+);
+```
+
+**That's it!** All layers, weights, biases, and configurations are automatically restored. No manual layer setup needed!
+
 #### Save Model
 
 ```typescript
@@ -264,16 +314,41 @@ const model = JSON.parse(JSON.parse(modelJSON)[0]);
 localStorage.setItem("my_model", JSON.stringify(model));
 ```
 
-#### Load Model
+#### Save Model
 
 ```typescript
-const savedModel = JSON.parse(localStorage.getItem("my_model")!);
-const network = loom.LoadModelFromString(
-  JSON.stringify(savedModel),
-  "model_name"
-);
+const modelJSON = network.SaveModelToString(JSON.stringify(["model_name"]));
+const model = JSON.parse(JSON.parse(modelJSON)[0]);
+
+// Store anywhere (localStorage, IndexedDB, backend API, etc.)
+localStorage.setItem("my_model", JSON.stringify(model));
+```
+
+#### Cross-Platform Model Loading
+
+The same JSON model file works across **all three platforms**:
+
+```typescript
+// JavaScript/WASM
+const network = loom.LoadModelFromString(modelJSON, "model_id");
+```
+
+```python
+# Python
+network = welvet.load_model_from_string(model_json, "model_id")
+```
+
+```go
+// Go
+network, _ := nn.LoadModelFromString(modelJSON, "model_id")
 ```
 
+See `examples/all_layers_validation.go` for a complete demo that generates test.json (26.4KB with 16 layers) and verifies all three platforms load it identically!
+
+#### Load Model (Legacy API)
+
+````
+
 ### Runtime Introspection
 
 #### Get All Methods
@@ -287,7 +362,7 @@ methods.forEach((method) => {
     `${method.method_name}(${method.parameters.map((p) => p.type).join(", ")})`
   );
 });
-```
+````
 
 #### Check Method Availability
 

package/dist/index.js

@@ -60,6 +60,7 @@ export async function initLoom(opts = {}) {
     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);

package/dist/types.d.ts

@@ -40,6 +40,13 @@ export interface LoomAPI {
      * @returns LoomNetwork instance
      */
     LoadModelFromString: (modelJSON: string, modelID: string) => LoomNetwork;
+    /**
+     * Call any layer initialization function from the registry
+     * @param functionName - Name of the layer init function (e.g., "InitDenseLayer")
+     * @param paramsJSON - JSON string of parameters array
+     * @returns JSON string of layer configuration
+     */
+    CallLayerInit: (functionName: string, paramsJSON: string) => string;
     /**
      * Initialize a dense (fully-connected) layer configuration
      * @param inputSize - Input dimension

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfluke/welvet",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "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",