@buley/neural 3.0.0 → 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": "3.0.0",
+  "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",