npm - @openfluke/welvet - Versions diffs - 0.3.0 → 0.75.0 - Mend

@openfluke/welvet 0.3.0 → 0.75.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (37) hide show

package/LICENSE +200 -200
package/README.md +64 -353
package/dist/benchmark_tiling.html +244 -0
package/dist/benchmark_training.html +249 -0
package/dist/benchmark_training_comparison.html +230 -0
package/dist/cabi_verify.html +360 -0
package/dist/coverage_check.html +298 -0
package/dist/dna_evo_benchmark.html +420 -0
package/dist/example.html +283 -0
package/dist/index.d.ts +152 -31
package/dist/index.js +170 -60
package/dist/loader.browser.d.ts +2 -2
package/dist/loader.browser.js +7 -8
package/dist/loader.d.ts +2 -2
package/dist/loader.js +12 -25
package/dist/main.wasm +0 -0
package/dist/src/index.d.ts +182 -0
package/dist/src/index.js +207 -0
package/dist/src/loader.browser.d.ts +5 -0
package/dist/src/loader.browser.js +24 -0
package/dist/src/loader.d.ts +5 -0
package/dist/src/loader.js +26 -0
package/dist/src/types.d.ts +354 -0
package/dist/src/types.js +65 -0
package/dist/tests/benchmark.d.ts +5 -0
package/dist/tests/benchmark.js +139 -0
package/dist/tests/benchmark.ts +148 -0
package/dist/tests/cabi_verify.d.ts +5 -0
package/dist/tests/cabi_verify.js +181 -0
package/dist/tests/cabi_verify.ts +192 -0
package/dist/tests/coverage.ts +113 -0
package/dist/types.d.ts +326 -169
package/dist/types.js +63 -2
package/dist/wasm_exec.js +575 -575
package/package.json +87 -88
package/dist/index.browser.d.ts +0 -32
package/dist/index.browser.js +0 -39

package/dist/example.html ADDED Viewed

@@ -0,0 +1,283 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Loom Core | Browser AI Engine</title>
+    <style>
+        :root {
+            --bg: #0a0a0c;
+            --panel: rgba(255, 255, 255, 0.03);
+            --accent: #00f2ff;
+            --accent-glow: rgba(0, 242, 255, 0.3);
+            --text: #e0e0e6;
+            --dim: #888891;
+            --border: rgba(255, 255, 255, 0.1);
+        }
+        body {
+            background-color: var(--bg);
+            color: var(--text);
+            font-family: 'Inter', -apple-system, system-ui, sans-serif;
+            margin: 0;
+            display: flex;
+            height: 100vh;
+            overflow: hidden;
+        }
+        /* Sidebar Navigation */
+        nav {
+            width: 280px;
+            border-right: 1px solid var(--border);
+            padding: 40px 20px;
+            display: flex;
+            flex-direction: column;
+            gap: 12px;
+        }
+        .logo {
+            font-size: 20px;
+            font-weight: 800;
+            letter-spacing: -1px;
+            color: var(--accent);
+            margin-bottom: 40px;
+            display: flex;
+            align-items: center;
+            gap: 10px;
+        }
+        .nav-btn {
+            padding: 12px 16px;
+            border-radius: 8px;
+            cursor: pointer;
+            transition: 0.2s;
+            font-size: 14px;
+            color: var(--dim);
+            border: 1px solid transparent;
+        }
+        .nav-btn:hover {
+            background: var(--panel);
+            color: white;
+        }
+        .nav-btn.active {
+            background: var(--accent-glow);
+            color: var(--accent);
+            border-color: var(--border);
+        }
+        /* Main Content Area */
+        main {
+            flex: 1;
+            padding: 40px;
+            overflow-y: auto;
+            position: relative;
+        }
+        .card {
+            background: var(--panel);
+            border: 1px solid var(--border);
+            border-radius: 12px;
+            padding: 24px;
+            margin-bottom: 24px;
+            backdrop-filter: blur(10px);
+        }
+        h2 {
+            font-size: 18px;
+            margin-top: 0;
+            color: white;
+        }
+        p {
+            font-size: 14px;
+            color: var(--dim);
+            line-height: 1.6;
+        }
+        .status-badge {
+            display: inline-flex;
+            align-items: center;
+            gap: 6px;
+            padding: 4px 10px;
+            border-radius: 100px;
+            font-size: 11px;
+            text-transform: uppercase;
+            font-weight: 700;
+            background: rgba(255, 255, 255, 0.05);
+        }
+        .status-badge.ready {
+            color: #00ff88;
+            background: rgba(0, 255, 136, 0.1);
+        }
+        .terminal {
+            background: #000;
+            border-radius: 8px;
+            padding: 16px;
+            font-family: 'JetBrains Mono', monospace;
+            font-size: 12px;
+            color: #00ff88;
+            height: 200px;
+            overflow-y: auto;
+            border: 1px solid #111;
+        }
+        button.primary {
+            background: var(--accent);
+            color: black;
+            border: none;
+            padding: 12px 24px;
+            border-radius: 6px;
+            font-weight: 600;
+            cursor: pointer;
+            transition: 0.2s;
+        }
+        button.primary:hover {
+            box-shadow: 0 0 20px var(--accent-glow);
+            transform: translateY(-1px);
+        }
+        .grid {
+            display: grid;
+            grid-template-columns: repeat(2, 1fr);
+            gap: 20px;
+        }
+    </style>
+</head>
+<body>
+    <nav>
+        <div class="logo">
+            <svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="3">
+                <path d="M12 2L2 7l10 5 10-5-10-5zM2 17l10 5 10-5M2 12l10 5 10-5" />
+            </svg>
+            LOOM CORE
+        </div>
+        <div class="nav-btn active">Dashboard</div>
+        <div class="nav-btn">Engine Audit</div>
+        <div class="nav-btn">DNA Lab</div>
+        <div class="nav-btn">Weights Management</div>
+    </nav>
+    <main>
+        <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 32px;">
+            <div>
+                <h1 style="margin:0; font-size: 24px;">System Overview</h1>
+                <div class="status-badge ready" id="hw-status">Initializing...</div>
+            </div>
+            <button class="primary" onclick="runDemo()">Execute Full Forward Pass</button>
+        </div>
+        <div class="grid">
+            <div class="card">
+                <h2>Network Intelligence</h2>
+                <p>Constructing polymorphic networks directly from JSON definitions with strict DType enforcement.</p>
+                <div class="terminal" id="net-log">Waiting for engine...</div>
+            </div>
+            <div class="card">
+                <h2>Transformer Prefill</h2>
+                <p>Simulating 4096-seq/768-dim Transformer prefill using WebGPU resident context.</p>
+                <div class="terminal" id="gpu-log">GPU Idle</div>
+            </div>
+        </div>
+        <div class="card">
+            <h2>DNA Comparison (Crossover Analytics)</h2>
+            <div id="dna-chart" style="height: 100px; display: flex; align-items: flex-end; gap: 4px;">
+                <!-- Bars will go here -->
+            </div>
+            <p style="margin-top: 15px;">Genetic distance between Network Alpha and Network Beta: <span id="dna-dist"
+                    style="color:var(--accent)">0.00%</span></p>
+        </div>
+    </main>
+    <script src="wasm_exec.js"></script>
+    <script>
+        const go = new Go();
+        let engine;
+        // 1. Loading and Initializing the Engine
+        WebAssembly.instantiateStreaming(fetch("main.wasm"), go.importObject).then(async (result) => {
+            go.run(result.instance);
+            log("net-log", "LOOM v0.75-STABLE WASM Runtime Loaded.");
+            // Setup WebGPU
+            try {
+                const status = await window.setupWebGPU();
+                document.getElementById('hw-status').innerText = "WGPU ACCELERATION: ACTIVE";
+                log("gpu-log", "WebGPU Context initialized successfully.");
+            } catch (e) {
+                document.getElementById('hw-status').style.color = "#ff4444";
+                document.getElementById('hw-status').innerText = "WGPU ERROR: CPU FALLBACK";
+            }
+            initDemo();
+        });
+        function log(id, msg) {
+            const el = document.getElementById(id);
+            const time = new Date().toLocaleTimeString();
+            el.innerHTML += `<div><span style="color:#555">[${time}]</span> ${msg}</div>`;
+            el.scrollTop = el.scrollHeight;
+        }
+        async function initDemo() {
+            // Build a Network from JSON (Strict Functional Parity Check)
+            const config = {
+                depth: 1, rows: 1, cols: 1, layers_per_cell: 4,
+                layers: [
+                    { type: "Embedding", input_height: 32000, output_height: 768 },
+                    { type: "RMSNorm", input_height: 768 },
+                    { type: "MultiHeadAttention", d_model: 768, num_heads: 12, seq_length: 512 },
+                    { type: "Dense", input_height: 768, output_height: 32000, activation: "Softmax" }
+                ]
+            };
+            const net = window.BuildNetworkFromJSON(JSON.stringify(config));
+            log("net-log", "Network Alpha built successfully.");
+            // Extract DNA and compare
+            const dnaA = window.ExtractDNA(net._id);
+            const netAlt = window.BuildNetworkFromJSON(JSON.stringify(config));
+            const dnaB = window.ExtractDNA(netAlt._id);
+            const comparisonJSON = window.compareLoomDNA(dnaA, dnaB);
+            const comparison = JSON.parse(comparisonJSON);
+            const score = (comparison.OverallOverlap || 0) * 100;
+            document.getElementById('dna-dist').innerText = score.toFixed(2) + "%";
+            log("net-log", `DNA Hash Alpha: ${dnaA.substring(0, 32)}...`);
+        }
+        function runDemo() {
+            log("gpu-log", "Beginning Full Pass on WGPU context...");
+            requestAnimationFrame(() => {
+                setTimeout(() => {
+                    const input = new Float32Array(768).map(() => Math.random());
+                    const config = JSON.stringify({
+                        layers: [{ type: "Dense", input_height: 768, output_height: 768, activation: "ReLU" }]
+                    });
+                    const net = window.BuildNetworkFromJSON(config);
+                    const start = performance.now();
+                    const result = net.sequentialForward(input);
+                    const end = performance.now();
+                    log("gpu-log", `Inference complete in ${(end - start).toFixed(2)}ms.`);
+                    log("gpu-log", `Result Shape: [1, ${result.data.length}]`);
+                }, 100);
+            });
+        }
+    </script>
+</body>
+</html>

package/dist/index.d.ts CHANGED Viewed

@@ -1,69 +1,190 @@
 /**
- * @openfluke/welvet - Isomorphic WASM Wrapper
+ * @openfluke/welvet — M-POLY-VTD AI Engine
  *
- * Direct wrapper around Loom WASM that mirrors main.go exports exactly.
- * Provides the same API in both Node.js and browser environments.
+ * Isomorphic TypeScript wrapper for the Loom v0.75.0 WASM module.
+ * Supports Node.js and browser environments.
+ *
+ * @example
+ * ```ts
+ * import { init, createNetwork, DType } from "@openfluke/welvet";
+ *
+ * await init();
+ *
+ * const net = createNetwork({
+ *   layers: [
+ *     { type: "dense", input_height: 4, output_height: 8 },
+ *     { type: "dense", input_height: 8, output_height: 2 },
+ *   ]
+ * });
+ *
+ * const output = net.sequentialForward(new Float32Array([1, 0, 0, 1]));
+ * console.log(output); // Float32Array [...]
+ * ```
  */
-import { Network, GraftResult, KMeansResult, CorrelationResult, EnsembleMatch, AdaptationTracker } from "./types.js";
+import type { Network, NEATPopulation, SystolicState, TargetPropState, TrainingBatch, TrainingResult, DNACompareResult, Transformer } from "./types.js";
 import { loadLoomWASMBrowser } from "./loader.browser.js";
 export * from "./types.js";
 export { loadLoomWASMBrowser };
-export declare function loadLoomWASM(): Promise<void>;
 /**
- * Initialize WASM
- * Auto-detects environment (Browser vs Node.js)
+ * Initialize the welvet WASM module.
+ * Auto-detects Node.js vs browser environment.
+ *
+ * @param wasmUrl Optional custom URL for browser WASM loading (default: /dist/main.wasm)
  */
 export declare function init(wasmUrl?: string): Promise<void>;
 /**
- * Initialize WASM for Browser environment
+ * Initialize explicitly for browser environments.
+ * @param wasmUrl Optional custom URL for WASM binary
  */
 export declare function initBrowser(wasmUrl?: string): Promise<void>;
 /**
- * Create a network from JSON config
- * Wrapper around the global createLoomNetwork function exposed by WASM
+ * Build a VolumetricNetwork from a JSON configuration object or string.
+ *
+ * @example
+ * ```ts
+ * const net = createNetwork({
+ *   layers: [
+ *     { type: "dense", input_height: 784, output_height: 256 },
+ *     { type: "dense", input_height: 256, output_height: 10, activation: "silu" },
+ *   ]
+ * });
+ * ```
  */
 export declare function createNetwork(config: object | string): Network;
 /**
- * Load a network from JSON string and ID
+ * Build a network from a JSON string.
  */
-export declare function loadNetwork(jsonString: string, modelID: string): Network;
+export declare function buildNetworkFromJSON(json: string): Network;
+/** Alias for buildNetworkFromJSON to match engine symbol */
+export declare const BuildNetworkFromJSON: typeof buildNetworkFromJSON;
 /**
- * Create a network handle for grafting
+ * Load a pre-trained network from a SafeTensors file path.
  */
-export declare function createKHandle(config: object | string): number;
+export declare function loadNetwork(path: string): Network;
 /**
- * Graft multiple networks together
+ * Initialize WebGPU (browser only).
+ * Sets window.webgpuAdapter, window.webgpuDevice, window.webgpuQueue.
  */
-export declare function graft(ids: number[], combineMode: string): GraftResult;
+export declare function setupWebGPU(): Promise<string>;
 /**
- * Perform K-Means Clustering
+ * Compare the architectural DNA of two networks.
+ *
+ * @param dnaA JSON string from network.extractDNA()
+ * @param dnaB JSON string from network.extractDNA()
+ * @returns DNACompareResult
+ */
+export declare function compareDNA(dnaA: string, dnaB: string): DNACompareResult;
+/**
+ * Get the default TargetPropConfig.
  */
-export declare function kmeans(data: number[][], k: number, iter: number): KMeansResult;
+export declare function defaultTargetPropConfig(): object;
 /**
- * Compute Correlation Matrix
+ * Get the internal parity symbol list from Go.
+ * Used for audits and verification.
+ */
+export declare function getInternalParity(): string[];
+/** Global accessor for extractNetworkBlueprint (engine parity) */
+export declare function ExtractNetworkBlueprint(network: Network, modelID?: string): string;
+/**
+ * Convenience wrapper for network.train() that handles JSON serialization.
+ *
+ * @param network The network to train
+ * @param batches Array of {input, target} training pairs
+ * @param epochs Number of training epochs
+ * @param lr Learning rate
  */
-export declare function correlation(matrixA: number[][], matrixB?: number[][]): CorrelationResult;
+export declare function trainNetwork(network: Network, batches: TrainingBatch[], epochs: number, lr: number): TrainingResult;
+/** Get the default SpliceConfig as a plain object. */
+export declare function getSpliceConfig(): object;
+/** Get the default NEATConfig as a plain object. */
+export declare function getNEATConfig(dModel: number): object;
 /**
- * Find Complementary Ensemble Matches
+ * Create a NEAT population from a seed network.
+ * @param network Seed network (its _id is used)
+ * @param size Population size
+ * @param cfg NEATConfig object or JSON string (defaults to getNEATConfig(64))
  */
-export declare function ensemble(models: object[], minCoverage: number): EnsembleMatch[];
+export declare function createNEATPopulation(network: Network, size: number, cfg?: object | string): NEATPopulation;
 /**
- * Create Adaptation Tracker
+ * Create a Transformer wrapper.
+ * @param network Network to use as the base
+ * @param embeddings Float32Array of embedding weights
+ * @param lmHead Float32Array of LM head weights
+ * @param finalNorm Float32Array of final norm weights
  */
-export declare function tracker(windowMs: number, totalMs: number): AdaptationTracker;
+export declare function createTransformer(network: Network, embeddings: Float32Array | number[], lmHead: Float32Array | number[], finalNorm: Float32Array | number[]): Transformer;
 /**
- * Default export with all functions
+ * Save a network to a SafeTensors byte array.
  */
+export declare function saveNetwork(network: Network): Uint8Array;
 declare const _default: {
     init: typeof init;
     initBrowser: typeof initBrowser;
     createNetwork: typeof createNetwork;
+    buildNetworkFromJSON: typeof buildNetworkFromJSON;
     loadNetwork: typeof loadNetwork;
-    createKHandle: typeof createKHandle;
-    graft: typeof graft;
-    kmeans: typeof kmeans;
-    correlation: typeof correlation;
-    ensemble: typeof ensemble;
-    tracker: typeof tracker;
+    saveNetwork: typeof saveNetwork;
+    setupWebGPU: typeof setupWebGPU;
+    compareDNA: typeof compareDNA;
+    defaultTargetPropConfig: typeof defaultTargetPropConfig;
+    getInternalParity: typeof getInternalParity;
+    trainNetwork: typeof trainNetwork;
+    getSpliceConfig: typeof getSpliceConfig;
+    getNEATConfig: typeof getNEATConfig;
+    createNEATPopulation: typeof createNEATPopulation;
+    createTransformer: typeof createTransformer;
+    BuildNetworkFromJSON: typeof buildNetworkFromJSON;
+    ExtractNetworkBlueprint: typeof ExtractNetworkBlueprint;
+    DType: {
+        readonly FLOAT64: 0;
+        readonly FLOAT32: 1;
+        readonly FLOAT16: 2;
+        readonly BFLOAT16: 3;
+        readonly FP8_E4M3: 4;
+        readonly FP8_E5M2: 5;
+        readonly INT64: 6;
+        readonly INT32: 7;
+        readonly INT16: 8;
+        readonly INT8: 9;
+        readonly UINT64: 10;
+        readonly UINT32: 11;
+        readonly UINT16: 12;
+        readonly UINT8: 13;
+        readonly INT4: 14;
+        readonly UINT4: 15;
+        readonly FP4: 16;
+        readonly INT2: 17;
+        readonly UINT2: 18;
+        readonly TERNARY: 19;
+        readonly BINARY: 20;
+    };
+    LayerType: {
+        readonly DENSE: 0;
+        readonly RMS_NORM: 1;
+        readonly LAYER_NORM: 2;
+        readonly MHA: 3;
+        readonly SOFTMAX: 4;
+        readonly SWIGLU: 5;
+        readonly EMBEDDING: 6;
+        readonly RESIDUAL: 7;
+        readonly KMEANS: 8;
+        readonly RNN: 9;
+        readonly LSTM: 10;
+        readonly CNN1: 11;
+        readonly CNN2: 12;
+        readonly CNN3: 13;
+        readonly CONV_TRANSPOSED_1D: 14;
+        readonly CONV_TRANSPOSED_2D: 15;
+        readonly CONV_TRANSPOSED_3D: 16;
+    };
+    Activation: {
+        readonly RELU: 0;
+        readonly SILU: 1;
+        readonly GELU: 2;
+        readonly TANH: 3;
+        readonly SIGMOID: 4;
+        readonly LINEAR: 5;
+    };
 };
 export default _default;
+export type { Network, NEATPopulation, SystolicState, TargetPropState, TrainingBatch, TrainingResult, DNACompareResult };