@buley/neural 2.0.4 → 4.0.0

package/dist/neural.js

@@ -0,0 +1,539 @@
+var b = Object.defineProperty;
+var m = (c, e, i) => e in c ? b(c, e, { enumerable: !0, configurable: !0, writable: !0, value: i }) : c[e] = i;
+var r = (c, e, i) => m(c, typeof e != "symbol" ? e + "" : e, i);
+import { dash as h } from "@buley/dash";
+async function y() {
+  console.log("Initializing Neural Schema..."), await h.execute(`
+        CREATE TABLE IF NOT EXISTS neurons (
+            id TEXT PRIMARY KEY,
+            type TEXT NOT NULL,
+            bias REAL DEFAULT 0.0,
+            activation TEXT DEFAULT 'tanh',
+            created_at INTEGER DEFAULT (unixepoch())
+        )
+    `), await h.execute(`
+        CREATE TABLE IF NOT EXISTS synapses (
+            id TEXT PRIMARY KEY,
+            from_id TEXT NOT NULL,
+            to_id TEXT NOT NULL,
+            weight REAL DEFAULT 0.0,
+            created_at INTEGER DEFAULT (unixepoch()),
+            FOREIGN KEY(from_id) REFERENCES neurons(id),
+            FOREIGN KEY(to_id) REFERENCES neurons(id)
+        )
+    `), console.log("Schema initialized.");
+}
+class B {
+  async create(e) {
+    await h.execute(
+      "INSERT INTO neurons (id, type, bias, activation) VALUES (?, ?, ?, ?)",
+      [e.id, e.type, e.bias, e.activation]
+    );
+  }
+  // Feature: Add with semantic embedding
+  async createWithSemantics(e, i) {
+    await this.create(e), await h.addWithEmbedding(e.id, i);
+  }
+  async getAll() {
+    return await h.execute("SELECT * FROM neurons");
+  }
+  async delete(e) {
+    await h.execute("DELETE FROM neurons WHERE id = ?", [e]);
+  }
+}
+class _ {
+  async create(e) {
+    await h.execute(
+      "INSERT INTO synapses (id, from_id, to_id, weight) VALUES (?, ?, ?, ?)",
+      [e.id, e.from_id, e.to_id, e.weight]
+    );
+  }
+  async getAll() {
+    return await h.execute("SELECT * FROM synapses");
+  }
+  async delete(e) {
+    await h.execute("DELETE FROM synapses WHERE id = ?", [e]);
+  }
+}
+const v = `
+// Structure of our compute shader
+// Group 0: Bindings for data
+// Binding 0: Matrix W (Weights) - N x N flattened array
+// Binding 1: Vector X (Current Neuron Values) - N length array
+// Binding 2: Vector B (Biases) - N length array
+// Binding 3: Vector Y (Output Neuron Values) - N length array
+// Binding 4: Dimensions Uniform - Struct { size: u32 }
+
+struct Dimensions {
+    size: u32,
+}
+
+@group(0) @binding(0) var<storage, read> weights: array<f32>;
+@group(0) @binding(1) var<storage, read> input: array<f32>;
+@group(0) @binding(2) var<storage, read> biases: array<f32>;
+@group(0) @binding(3) var<storage, read_write> output: array<f32>;
+@group(0) @binding(4) var<uniform> dims: Dimensions;
+
+// Activation Functions
+fn tanh_approx(x: f32) -> f32 {
+    let e2x = exp(2.0 * x);
+    return (e2x - 1.0) / (e2x + 1.0);
+}
+
+@compute @workgroup_size(64, 1, 1)
+fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
+    let row = global_id.x;
+    let batch = global_id.z;
+    let size = dims.size;
+
+    if (row >= size) {
+        return;
+    }
+
+    // Dot product: Row of W * Vector X
+    var sum: f32 = 0.0;
+    
+    // Batch offset for input/output
+    let batch_offset = batch * size;
+
+    for (var col: u32 = 0u; col < size; col = col + 1u) {
+        // W is shared (not batched): weights[row * size + col]
+        let w_idx = row * size + col;
+        
+        // Input is batched: input[batch * size + col]
+        let input_idx = batch_offset + col;
+        
+        sum = sum + (weights[w_idx] * input[input_idx]);
+    }
+
+    // Add Bias (Shared)
+    sum = sum + biases[row];
+
+    // Activation
+    // Output is batched: output[batch * size + row]
+    let out_idx = batch_offset + row;
+    output[out_idx] = tanh_approx(sum);
+}
+`, E = `struct Dimensions {
+    size: u32,
+    batchSize: u32,
+}
+
+struct TrainingParams {
+    learningRate: f32,
+}
+
+@group(0) @binding(0) var<storage, read_write> weights: array<f32>;
+@group(0) @binding(1) var<storage, read> values: array<f32>; // Batched Activations (N * B)
+@group(0) @binding(2) var<storage, read> biases: array<f32>;
+@group(0) @binding(3) var<storage, read_write> deltas: array<f32>; // Batched Deltas (N * B)
+@group(0) @binding(4) var<storage, read> targets: array<f32>; // Batched Targets
+@group(0) @binding(5) var<uniform> dims: Dimensions;
+@group(0) @binding(6) var<uniform> params: TrainingParams;
+
+fn tanh_derivative(val: f32) -> f32 {
+    return 1.0 - (val * val);
+}
+
+// 1. Calculate Deltas (Backward Pass) - 3D Dispatched (64, 1, B)
+@compute @workgroup_size(64, 1, 1)
+fn calculate_deltas(@builtin(global_invocation_id) global_id: vec3<u32>) {
+    let index = global_id.x;
+    let batch = global_id.z;
+    let size = dims.size;
+    
+    if (index >= size) { return; }
+
+    let batch_offset = batch * size;
+    let neuron_idx = batch_offset + index;
+
+    let activation = values[neuron_idx];
+    let derivative = tanh_derivative(activation);
+    
+    var error_sum: f32 = 0.0;
+    
+    // Backpropagate error from "Next Layer" (all other neurons k)
+    // For each k (destination), we need delta_k.
+    // delta_k is also batched! deltas[batch * size + k]
+    for (var k: u32 = 0u; k < size; k = k + 1u) {
+        // Weight FROM index TO k
+        let w_idx = k * size + index; 
+        let weight_ki = weights[w_idx];
+        
+        let delta_k_idx = batch_offset + k;
+        let delta_k = deltas[delta_k_idx];
+        
+        error_sum = error_sum + (delta_k * weight_ki);
+    }
+
+    // Add immediate error (MSE derivative: y - t)
+    // targets[batch * size + index]
+    let target = targets[neuron_idx];
+    if (target > -998.0) {
+        error_sum = error_sum + (activation - target);
+    }
+
+    deltas[neuron_idx] = error_sum * derivative;
+}
+
+// 2. Update Weights (Optimizer Step) - 1D Dispatched (64, 1, 1) - Accumulates Gradients over Batch
+@compute @workgroup_size(64)
+fn update_weights(@builtin(global_invocation_id) global_id: vec3<u32>) {
+    let row = global_id.x; // Target neuron
+    let size = dims.size;
+    let batch_size = dims.batchSize;
+    
+    if (row >= size) { return; }
+
+    let lr = params.learningRate;
+
+    // Update incoming weights to this neuron 'row'
+    // W_ji (row, col)
+    for (var col: u32 = 0u; col < size; col = col + 1u) {
+        let w_idx = row * size + col;
+        
+        // Accumulate gradient over batch
+        var gradient_sum: f32 = 0.0;
+        
+        for (var b: u32 = 0u; b < batch_size; b = b + 1u) {
+            let batch_offset = b * size;
+            
+            // delta_j (for this batch item)
+            let delta_j = deltas[batch_offset + row];
+            
+            // input_i (activation of source col for this batch item)
+            let input_val = values[batch_offset + col];
+            
+            gradient_sum = gradient_sum + (delta_j * input_val);
+        }
+        
+        // SGD Update (Mean Gradient? Or Sum? Usually Mean for batch)
+        // Let's use Sum * (LearningRate / BatchSize) effectively, or just keep LR as is and user adjusts.
+        // Standard is Mean Gradient.
+        
+        let mean_gradient = gradient_sum / f32(batch_size);
+        
+        weights[w_idx] = weights[w_idx] - (lr * mean_gradient);
+    }
+}
+`;
+class S {
+  constructor() {
+    r(this, "device", null);
+    r(this, "pipeline", null);
+    r(this, "bindGroup", null);
+    // Training Buffers
+    r(this, "deltaBuffer", null);
+    r(this, "targetBuffer", null);
+    r(this, "paramBuffer", null);
+    r(this, "trainingPipeline", null);
+    r(this, "deltaPipeline", null);
+    r(this, "trainingBindGroup", null);
+    // Buffers
+    r(this, "weightBuffer", null);
+    r(this, "inputBuffer", null);
+    r(this, "biasBuffer", null);
+    r(this, "outputBuffer", null);
+    r(this, "uniformBuffer", null);
+    r(this, "networkSize", 0);
+    r(this, "batchSize", 1);
+    r(this, "subscribers", []);
+  }
+  async init() {
+    if (!navigator.gpu) throw new Error("WebGPU not supported");
+    const e = await navigator.gpu.requestAdapter();
+    if (!e) throw new Error("No GPU adapter found");
+    this.device = await e.requestDevice();
+    const i = this.device.createShaderModule({ code: v }), t = this.device.createShaderModule({ code: E });
+    this.pipeline = this.device.createComputePipeline({
+      layout: "auto",
+      compute: { module: i, entryPoint: "main" }
+    }), this.trainingPipeline = this.device.createComputePipeline({
+      layout: "auto",
+      compute: { module: t, entryPoint: "update_weights" }
+    }), this.deltaPipeline = this.device.createComputePipeline({
+      layout: "auto",
+      compute: { module: t, entryPoint: "calculate_deltas" }
+    }), console.log("GPUEngine initialized");
+  }
+  // Prepare buffers based on network size (N) and Batch Size (B)
+  prepareBuffers(e, i, t, n = 1) {
+    if (!this.device || !this.pipeline) throw new Error("GPUEngine not initialized");
+    this.networkSize = e, this.batchSize = n, this.weightBuffer = this.createBuffer(i, GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST), this.biasBuffer = this.createBuffer(t, GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST);
+    const a = e * n;
+    this.inputBuffer = this.createBuffer(new Float32Array(a), GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST), this.outputBuffer = this.createBuffer(new Float32Array(a), GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST);
+    const s = new Uint32Array([e, n]);
+    this.uniformBuffer = this.createBuffer(s, GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST), this.bindGroup = this.device.createBindGroup({
+      layout: this.pipeline.getBindGroupLayout(0),
+      entries: [
+        { binding: 0, resource: { buffer: this.weightBuffer } },
+        { binding: 1, resource: { buffer: this.inputBuffer } },
+        { binding: 2, resource: { buffer: this.biasBuffer } },
+        { binding: 3, resource: { buffer: this.outputBuffer } },
+        { binding: 4, resource: { buffer: this.uniformBuffer } }
+      ]
+    });
+  }
+  createBuffer(e, i) {
+    if (!this.device) throw new Error("Device null");
+    const t = this.device.createBuffer({
+      size: e.byteLength,
+      usage: i,
+      mappedAtCreation: !0
+    });
+    return e instanceof Float32Array ? new Float32Array(t.getMappedRange()).set(e) : new Uint32Array(t.getMappedRange()).set(e), t.unmap(), t;
+  }
+  async runTick(e) {
+    if (!this.device || !this.pipeline || !this.bindGroup || !this.inputBuffer || !this.outputBuffer)
+      throw new Error("GPU buffers not ready");
+    if (e.length !== this.networkSize * this.batchSize)
+      throw new Error(`Input size mismatch. Expected ${this.networkSize * this.batchSize}, got ${e.length}`);
+    this.device.queue.writeBuffer(this.inputBuffer, 0, e);
+    const i = this.device.createCommandEncoder(), t = i.beginComputePass();
+    t.setPipeline(this.pipeline), t.setBindGroup(0, this.bindGroup);
+    const a = Math.ceil(this.networkSize / 64);
+    t.dispatchWorkgroups(a, 1, this.batchSize), t.end();
+    const s = e.byteLength, o = this.device.createBuffer({
+      size: s,
+      usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
+    });
+    i.copyBufferToBuffer(this.outputBuffer, 0, o, 0, s);
+    const u = i.finish();
+    this.device.queue.submit([u]), await o.mapAsync(GPUMapMode.READ);
+    const d = new Float32Array(o.getMappedRange()), l = new Float32Array(d);
+    return o.unmap(), l;
+  }
+  prepareTrainingBuffers(e, i) {
+    if (!this.device || !this.trainingPipeline || !this.weightBuffer || !this.outputBuffer || !this.biasBuffer || !this.uniformBuffer)
+      throw new Error("GPU not ready for training");
+    if (e.length !== this.networkSize * this.batchSize)
+      throw new Error(`Target size mismatch. Expected ${this.networkSize * this.batchSize}, got ${e.length}`);
+    const t = this.networkSize * this.batchSize;
+    this.deltaBuffer = this.createBuffer(new Float32Array(t), GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC), this.targetBuffer = this.createBuffer(e, GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST), this.paramBuffer = this.createBuffer(new Float32Array([i]), GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST), this.trainingBindGroup = this.device.createBindGroup({
+      layout: this.trainingPipeline.getBindGroupLayout(0),
+      entries: [
+        { binding: 0, resource: { buffer: this.weightBuffer } },
+        { binding: 1, resource: { buffer: this.outputBuffer } },
+        { binding: 2, resource: { buffer: this.biasBuffer } },
+        { binding: 3, resource: { buffer: this.deltaBuffer } },
+        { binding: 4, resource: { buffer: this.targetBuffer } },
+        { binding: 5, resource: { buffer: this.uniformBuffer } },
+        { binding: 6, resource: { buffer: this.paramBuffer } }
+      ]
+    });
+  }
+  subscribe(e) {
+    return this.subscribers.push(e), () => {
+      this.subscribers = this.subscribers.filter((i) => i !== e);
+    };
+  }
+  emit(e) {
+    this.subscribers.forEach((i) => i(e));
+  }
+  async train(e, i) {
+    var s;
+    const t = await this.runTick(e);
+    let n = 0;
+    for (let o = 0; o < t.length; o++) {
+      const u = i[o];
+      if (u > -998) {
+        const d = t[o] - u;
+        n += 0.5 * d * d;
+      }
+    }
+    const a = n / this.batchSize;
+    return this.emit({ type: "loss", value: a }), this.targetBuffer && ((s = this.device) == null || s.queue.writeBuffer(this.targetBuffer, 0, i)), await this.trainTick(), this.emit({ type: "epoch", value: 1 }), t;
+  }
+  async trainTick(e) {
+    if (!this.device || !this.trainingPipeline || !this.deltaPipeline || !this.trainingBindGroup || !this.deltaBuffer)
+      throw new Error("Training not ready");
+    e && e.length > 0 && this.device.queue.writeBuffer(this.deltaBuffer, 0, e);
+    const i = this.device.createCommandEncoder(), t = i.beginComputePass();
+    t.setPipeline(this.deltaPipeline), t.setBindGroup(0, this.trainingBindGroup);
+    const a = Math.ceil(this.networkSize / 64);
+    t.dispatchWorkgroups(a, 1, this.batchSize), t.end();
+    const s = i.beginComputePass();
+    s.setPipeline(this.trainingPipeline), s.setBindGroup(0, this.trainingBindGroup), s.dispatchWorkgroups(a, 1, 1), s.end(), this.device.queue.submit([i.finish()]);
+  }
+  async injectInput(e) {
+    !this.device || !this.inputBuffer || this.device.queue.writeBuffer(this.inputBuffer, 0, e);
+  }
+}
+class T {
+  constructor() {
+    r(this, "context", null);
+    r(this, "builder", null);
+    r(this, "graph", null);
+    // Buffers/State
+    r(this, "networkSize", 0);
+    r(this, "batchSize", 1);
+    // We keep weights/biases in memory to rebuild graph if needed, 
+    // though for strict WebNN we bakw them into constants.
+    r(this, "weights", null);
+    r(this, "biases", null);
+    r(this, "isReady", !1);
+  }
+  async init() {
+    if (!navigator.ml) {
+      console.warn("WebNN: navigator.ml not supported");
+      return;
+    }
+    try {
+      this.context = await navigator.ml.createContext({ deviceType: "npu", powerPreference: "low-power" }), console.log("WebNN: NPU Context created"), this.builder = new window.MLGraphBuilder(this.context), this.isReady = !0;
+    } catch (e) {
+      console.error("WebNN Init Error (likely no NPU or flag disabled):", e);
+    }
+  }
+  async prepareModel(e, i, t, n = 1) {
+    if (!(!this.context || !this.builder)) {
+      this.networkSize = e, this.batchSize = n, this.weights = i, this.biases = t;
+      try {
+        const a = this.builder, s = {
+          dataType: "float32",
+          dimensions: [n, e]
+        }, o = a.input("input", s), u = {
+          dataType: "float32",
+          dimensions: [e, e]
+        }, d = a.constant(u, i), l = {
+          dataType: "float32",
+          dimensions: [e]
+          // 1D, will broadcast to [batch, size]
+        }, f = a.constant(l, t), p = a.matmul(o, d), g = a.add(p, f), w = a.tanh(g);
+        this.graph = await a.build({ output: w }), console.log("WebNN: Graph compiled successfully");
+      } catch (a) {
+        console.error("WebNN Build Error:", a);
+      }
+    }
+  }
+  async runTick(e) {
+    if (!this.context || !this.graph)
+      throw new Error("WebNN not ready");
+    if (e.length !== this.networkSize * this.batchSize)
+      throw new Error(`Input size mismatch. Expected ${this.networkSize * this.batchSize}, got ${e.length}`);
+    const i = new Float32Array(this.networkSize * this.batchSize), t = { input: e }, n = { output: i };
+    return await this.context.compute(this.graph, t, n), i;
+  }
+}
+class z {
+  constructor() {
+    // Maps Neuron logical IDs (UUIDs) to Matrix Indices (0...N)
+    r(this, "idToIndex", /* @__PURE__ */ new Map());
+    r(this, "indexToId", []);
+  }
+  // Converts Graph -> Dense Matrices
+  flatten(e, i) {
+    const t = e.length;
+    this.idToIndex.clear(), this.indexToId = new Array(t), e.forEach((o, u) => {
+      this.idToIndex.set(o.id, u), this.indexToId[u] = o.id;
+    });
+    const n = new Float32Array(t), a = new Float32Array(t);
+    e.forEach((o, u) => {
+      n[u] = o.bias;
+    });
+    const s = new Float32Array(t * t);
+    return i.forEach((o) => {
+      const u = this.idToIndex.get(o.from_id), d = this.idToIndex.get(o.to_id);
+      if (u !== void 0 && d !== void 0) {
+        const l = d * t + u;
+        s[l] = o.weight;
+      }
+    }), { size: t, weights: s, biases: n, initialValues: a };
+  }
+}
+class U {
+  constructor() {
+    r(this, "gpu");
+    r(this, "npu");
+    r(this, "neuronRepo");
+    r(this, "synapseRepo");
+    r(this, "translator");
+    r(this, "activeBackend", "gpu");
+    // Cache
+    r(this, "neurons", []);
+    r(this, "synapses", []);
+    this.gpu = new S(), this.npu = new T(), this.neuronRepo = new B(), this.synapseRepo = new _(), this.translator = new z();
+  }
+  async init() {
+    if (console.log("Neural 2.0 Engine Initializing..."), await h.ready(), await y(), await this.gpu.init(), this.gpu.batchSize = 2, await this.npu.init(), this.npu.isReady && (console.log("Neural Engine: NPU Accelerated Backend Available."), this.activeBackend = "npu"), this.neurons = await this.neuronRepo.getAll(), this.synapses = await this.synapseRepo.getAll(), this.neurons.length === 0) {
+      console.log("Seeding test network...");
+      const e = "n1-" + crypto.randomUUID(), i = "n2-" + crypto.randomUUID();
+      await this.neuronRepo.create({ id: e, type: "input", bias: 0, activation: "tanh" }), await this.neuronRepo.create({ id: i, type: "output", bias: 0.5, activation: "tanh" }), await this.synapseRepo.create({ id: crypto.randomUUID(), from_id: e, to_id: i, weight: 0.8 });
+      for (let n = 0; n < 50; n++)
+        await this.neuronRepo.create({ id: `auto-${n}`, type: "hidden", bias: 0, activation: "tanh" });
+      const t = await this.neuronRepo.getAll();
+      for (let n = 0; n < 50; n++) {
+        const a = t[Math.floor(Math.random() * t.length)].id, s = t[Math.floor(Math.random() * t.length)].id;
+        a !== s && await this.synapseRepo.create({ id: crypto.randomUUID(), from_id: a, to_id: s, weight: Math.random() });
+      }
+      this.neurons = await this.neuronRepo.getAll(), this.synapses = await this.synapseRepo.getAll();
+    }
+    return await this.compile(), console.log(`Engine Ready. Active Backend: ${this.activeBackend.toUpperCase()}`), this.getGraphData();
+  }
+  async compile() {
+    console.log(`Compiling graph: ${this.neurons.length} neurons, ${this.synapses.length} synapses`);
+    const e = this.translator.flatten(this.neurons, this.synapses);
+    return this.gpu.prepareBuffers(e.size, e.weights, e.biases, this.gpu.batchSize), this.gpu.prepareTrainingBuffers(new Float32Array(e.size * this.gpu.batchSize), 0.1), this.npu.isReady && await this.npu.prepareModel(e.size, e.weights, e.biases, 2), e;
+  }
+  async deployToCloud() {
+    console.log("Deploying heavy layers to Hybrid Cloud..."), this.neurons = this.neurons.map((e) => ({
+      ...e,
+      type: Math.random() > 0.8 ? "cloud" : e.type
+    }));
+    for (const e of this.neurons)
+      e.type;
+    return this.getGraphData();
+  }
+  getGraphData() {
+    const e = /* @__PURE__ */ new Map();
+    this.neurons.forEach((n, a) => e.set(n.id, a));
+    const i = this.synapses.map((n) => ({
+      id: n.id,
+      source: e.get(n.from_id) || 0,
+      target: e.get(n.to_id) || 0,
+      weight: n.weight
+    })), t = this.neurons.map((n, a) => ({
+      id: n.id,
+      index: a,
+      type: n.type
+    }));
+    return {
+      nodeCount: this.neurons.length,
+      nodes: t,
+      edges: i
+    };
+  }
+  async deleteSynapse(e) {
+    return console.log(`Lesioning synapse: ${e}`), await this.synapseRepo.delete(e), this.synapses = this.synapses.filter((i) => i.id !== e), await this.compile(), this.getGraphData();
+  }
+  exportGraph() {
+    return {
+      version: "2.0",
+      neurons: this.neurons,
+      synapses: this.synapses
+    };
+  }
+  async importGraph(e) {
+    if (!e.neurons || !e.synapses) throw new Error("Invalid graph data");
+    console.log("Importing graph...");
+    const i = await this.neuronRepo.getAll();
+    for (const n of i) await this.neuronRepo.delete(n.id);
+    const t = await this.synapseRepo.getAll();
+    for (const n of t) await this.synapseRepo.delete(n.id);
+    for (const n of e.neurons) await this.neuronRepo.create(n);
+    for (const n of e.synapses) await this.synapseRepo.create(n);
+    return this.neurons = await this.neuronRepo.getAll(), this.synapses = await this.synapseRepo.getAll(), console.log(`Compiling imported graph: ${this.neurons.length} neurons, ${this.synapses.length} synapses`), await this.compile(), this.getGraphData();
+  }
+  async injectInput(e) {
+    this.activeBackend === "npu" && this.npu.isReady || await this.gpu.injectInput(e);
+  }
+  async runTick(e) {
+    return this.activeBackend === "npu" && this.npu.isReady ? this.npu.runTick(e) : this.gpu.runTick(e);
+  }
+}
+async function P() {
+  return new U().init();
+}
+export {
+  U as NeuralEngine,
+  P as init
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buley/neural",
-  "version": "2.0.4",
+  "version": "4.0.0",
   "description": "A Transparent, Local-First, WebGPU-Accelerated Neural Graph Database.",
   "type": "module",
   "main": "./src/index.ts",
@@ -10,7 +10,7 @@
     "bench": "bun src/bench/benchmark.ts"
   },
   "dependencies": {
-    "@buley/dash": "2.1.4"
+    "@buley/dash": "4.0.0"
   },
   "devDependencies": {
     "@webgpu/types": "^0.1.69",

package/src/engine/webnn.ts

@@ -0,0 +1,118 @@
+
+/// <reference path="../webnn-types.d.ts" />
+
+export class WebNNEngine {
+    context: MLContext | null = null;
+    builder: MLGraphBuilder | null = null;
+    graph: MLGraph | null = null;
+
+    // Buffers/State
+    networkSize: number = 0;
+    batchSize: number = 1;
+    
+    // We keep weights/biases in memory to rebuild graph if needed, 
+    // though for strict WebNN we bakw them into constants.
+    weights: Float32Array | null = null;
+    biases: Float32Array | null = null;
+
+    isReady = false;
+
+    async init() {
+        if (!navigator.ml) {
+            console.warn("WebNN: navigator.ml not supported");
+            return;
+        }
+
+        try {
+            // Prefer NPU, fallback to GPU if NPU not available, though we really want NPU for "cool factor"
+            // Note: browser support for 'npu' deviceType is bleeding edge.
+            this.context = await navigator.ml.createContext({ deviceType: 'npu', powerPreference: 'low-power' });
+            console.log("WebNN: NPU Context created");
+            
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            this.builder = new (window as any).MLGraphBuilder(this.context);
+            this.isReady = true;
+        } catch (e) {
+            console.error("WebNN Init Error (likely no NPU or flag disabled):", e);
+            // Fallback? or just stay uninitialized
+        }
+    }
+
+    async prepareModel(size: number, weights: Float32Array, biases: Float32Array, batchSize: number = 1) {
+        if (!this.context || !this.builder) return;
+        this.networkSize = size;
+        this.batchSize = batchSize;
+        this.weights = weights;
+        this.biases = biases;
+
+        // Build the Computational Graph
+        // Model: Y = Tanh((X * W) + B)
+        // Shapes:
+        // X: [batchSize, networkSize]
+        // W: [networkSize, networkSize] 
+        // B: [networkSize] (Broadcasted)
+        // Y: [batchSize, networkSize]
+
+        try {
+            const builder = this.builder;
+
+            // 1. Input Operand (Variable)
+            const inputDesc: MLOperandDescriptor = {
+                dataType: 'float32',
+                dimensions: [batchSize, size] 
+            };
+            const input = builder.input('input', inputDesc);
+
+            // 2. Constants (Weights & Biases)
+            // Note: WebNN matmul expects typically [I, J] * [J, K] -> [I, K]
+            // Our weights are N*N flattened. 
+            const weightDesc: MLOperandDescriptor = {
+                dataType: 'float32',
+                dimensions: [size, size]
+            };
+            // WebNN might require specific buffer types, Float32Array is good.
+            const weightConstant = builder.constant(weightDesc, weights);
+
+            const biasDesc: MLOperandDescriptor = {
+                dataType: 'float32',
+                dimensions: [size] // 1D, will broadcast to [batch, size]
+            };
+            const biasConstant = builder.constant(biasDesc, biases);
+
+            // 3. Operations
+            // MatMul: [batch, size] * [size, size] -> [batch, size]
+            const matmul = builder.matmul(input, weightConstant);
+            
+            // Add Bias (Broadcast)
+            const added = builder.add(matmul, biasConstant);
+            
+            // Activation
+            const output = builder.tanh(added);
+
+            // 4. Build
+            this.graph = await builder.build({ 'output': output });
+            console.log("WebNN: Graph compiled successfully");
+
+        } catch (e) {
+            console.error("WebNN Build Error:", e);
+        }
+    }
+
+    async runTick(inputs: Float32Array): Promise<Float32Array> {
+        if (!this.context || !this.graph) {
+            throw new Error("WebNN not ready");
+        }
+        if (inputs.length !== this.networkSize * this.batchSize) {
+           throw new Error(`Input size mismatch. Expected ${this.networkSize * this.batchSize}, got ${inputs.length}`);
+        }
+
+        const outputs = new Float32Array(this.networkSize * this.batchSize);
+
+        const inputsMap = { 'input': inputs };
+        const outputsMap = { 'output': outputs };
+
+        await this.context.compute(this.graph, inputsMap, outputsMap);
+        
+        return outputs;
+    }
+}

package/src/index.ts

@@ -2,6 +2,7 @@ import { dash } from "@buley/dash";
 import { initializeSchema } from "./db/schema";
 import { NeuronRepository, SynapseRepository } from "./db/repository";
 import { GPUEngine } from "./engine/gpu";
+import { WebNNEngine } from "./engine/webnn";
 import { Translator } from "./engine/translator";
 import { Neuron, Synapse } from "./types";
 
@@ -9,12 +10,16 @@ export type { Neuron, Synapse } from "./types";
 
 export class NeuralEngine {
     gpu: GPUEngine;
+    npu: WebNNEngine;
     neuronRepo: NeuronRepository;
     synapseRepo: SynapseRepository;
     private translator: Translator;
 
+    activeBackend: 'gpu' | 'npu' = 'gpu';
+
     constructor() {
         this.gpu = new GPUEngine();
+        this.npu = new WebNNEngine();
         this.neuronRepo = new NeuronRepository();
         this.synapseRepo = new SynapseRepository();
         this.translator = new Translator();
@@ -35,6 +40,13 @@ export class NeuralEngine {
         await this.gpu.init();
         this.gpu.batchSize = 2; // Default to mini-batch of 2 for demo
 
+        // Try NPU
+        await this.npu.init();
+        if (this.npu.isReady) {
+            console.log("Neural Engine: NPU Accelerated Backend Available.");
+            this.activeBackend = 'npu'; 
+        }
+
         // 3. Hydration
         this.neurons = await this.neuronRepo.getAll();
         this.synapses = await this.synapseRepo.getAll();
@@ -64,17 +76,27 @@ export class NeuralEngine {
             this.synapses = await this.synapseRepo.getAll();
         }
 
-        // 4. Compile to GPU
+        // 4. Compile to Compute Backends
+        await this.compile();
+
+        console.log(`Engine Ready. Active Backend: ${this.activeBackend.toUpperCase()}`);
+        return this.getGraphData();
+    }
+
+    async compile() {
         console.log(`Compiling graph: ${this.neurons.length} neurons, ${this.synapses.length} synapses`);
         const data = this.translator.flatten(this.neurons, this.synapses);
 
+        // GPU
         this.gpu.prepareBuffers(data.size, data.weights, data.biases, this.gpu.batchSize);
-        // Also prepare training buffers!
-        // Init target buffer with zeros
         this.gpu.prepareTrainingBuffers(new Float32Array(data.size * this.gpu.batchSize), 0.1);
 
-        console.log("Engine Ready.");
-        return data;
+        // NPU
+        if (this.npu.isReady) {
+            await this.npu.prepareModel(data.size, data.weights, data.biases, 2); 
+        }
+        
+        return data; // Return data for init/others if needed
     }
 
     async deployToCloud() {
@@ -131,12 +153,7 @@ export class NeuralEngine {
         this.synapses = this.synapses.filter(s => s.id !== id);
         
         // Recompile (Heavy!)
-        // In a real app we'd just zero the weight in buffer
-        // But for "The Visible Brain" seeing it disappear is cooler.
-        const data = this.translator.flatten(this.neurons, this.synapses);
-        this.gpu.prepareBuffers(data.size, data.weights, data.biases, this.gpu.batchSize);
-        // Reset training buffers too to be safe/simple
-        this.gpu.prepareTrainingBuffers(new Float32Array(data.size * this.gpu.batchSize), 0.1);
+        await this.compile();
 
         return this.getGraphData();
     }
@@ -170,18 +187,25 @@ export class NeuralEngine {
         this.synapses = await this.synapseRepo.getAll();
         
         console.log(`Compiling imported graph: ${this.neurons.length} neurons, ${this.synapses.length} synapses`);
-        const graph = this.translator.flatten(this.neurons, this.synapses);
-        this.gpu.prepareBuffers(graph.size, graph.weights, graph.biases, this.gpu.batchSize);
-        this.gpu.prepareTrainingBuffers(new Float32Array(graph.size * this.gpu.batchSize), 0.1);
+        await this.compile();
         
         return this.getGraphData();
     }
 
     async injectInput(data: Float32Array) {
-        // Map data to input neurons
-        // In simulation, we assume first N neurons are inputs.
-        // Or we just overwrite the first N values of the input buffer.
-        await this.gpu.injectInput(data);
+        if (this.activeBackend === 'npu' && this.npu.isReady) {
+             // WebNN takes input at runTick
+        } else {
+            await this.gpu.injectInput(data);
+        }
+    }
+
+    async runTick(inputs: Float32Array): Promise<Float32Array> {
+        if (this.activeBackend === 'npu' && this.npu.isReady) {
+            return this.npu.runTick(inputs);
+        } else {
+            return this.gpu.runTick(inputs);
+        }
     }
 }
 

package/src/webnn-types.d.ts

@@ -0,0 +1,43 @@
+
+// Minimal WebNN Type Definitions for TypeScript
+// Based on W3C Web Neural Network API Draft
+
+interface MLContext {
+    compute(graph: MLGraph, inputs: Record<string, ArrayBufferView>, outputs: Record<string, ArrayBufferView>): Promise<MLComputeResult>;
+}
+
+interface MLComputeResult {
+    inputs: Record<string, ArrayBufferView>;
+    outputs: Record<string, ArrayBufferView>;
+}
+
+interface MLGraphBuilder {
+    input(name: string, descriptor: MLOperandDescriptor): MLOperand;
+    constant(descriptor: MLOperandDescriptor, buffer: ArrayBufferView): MLOperand;
+    matmul(a: MLOperand, b: MLOperand): MLOperand;
+    add(a: MLOperand, b: MLOperand): MLOperand;
+    tanh(x: MLOperand): MLOperand;
+    build(outputs: Record<string, MLOperand>): Promise<MLGraph>;
+}
+
+interface MLGraph {}
+
+interface MLOperand {}
+
+interface MLOperandDescriptor {
+    dataType: 'float32' | 'float16' | 'int32' | 'uint32' | 'int8' | 'uint8';
+    dimensions: number[];
+}
+
+interface MLContextOptions {
+    deviceType?: 'cpu' | 'gpu' | 'npu';
+    powerPreference?: 'default' | 'high-performance' | 'low-power';
+}
+
+interface NavigatorML {
+    createContext(options?: MLContextOptions): Promise<MLContext>;
+}
+
+interface Navigator {
+    ml?: NavigatorML;
+}