@buley/neural 2.0.0 → 2.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buley/neural",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "A Transparent, Local-First, WebGPU-Accelerated Neural Graph Database.",
   "type": "module",
   "main": "./src/index.ts",
@@ -10,10 +10,11 @@
     "bench": "bun src/bench/benchmark.ts"
   },
   "dependencies": {
-    "@buley/dash": "^1.1.0"
+    "@buley/dash": "2.1.4"
   },
   "devDependencies": {
     "@webgpu/types": "^0.1.69",
+    "bun-types": "^1.3.6",
     "typescript": "^5.3.3",
     "vite": "^5.0.0"
   }

package/src/bench/benchmark.ts

@@ -81,19 +81,19 @@ if (!global.navigator?.gpu) {
     console.log("No WebGPU detected in global scope. Mocking for CLI structure verification...");
     // @ts-ignore
     global.navigator = { 
-        gpu: { 
-            requestAdapter: async () => ({ 
-                requestDevice: async () => ({
-                    createShaderModule: () => ({}),
-                    createComputePipeline: () => ({ getBindGroupLayout: () => ({}) }),
-                    createBuffer: (d: any) => ({ getMappedRange: () => new ArrayBuffer(d.size), unmap: () => {}, mapAsync: async () => {} }),
-                    createBindGroup: () => ({}),
+        gpu: { ...({} as any) as GPU, 
+            requestAdapter: async () => ({ ...({} as any) as GPUAdapter, // Force cast for mock 
+                requestDevice: async () => ({ ...({} as any) as GPUDevice,
+                    createShaderModule: () => ({} as unknown as GPUShaderModule),
+                    createComputePipeline: () => ({ getBindGroupLayout: () => ({} as unknown as GPUBindGroupLayout) } as unknown as GPUComputePipeline),
+                    createBuffer: (d: any) => ({ getMappedRange: () => new ArrayBuffer(d.size), unmap: () => {}, mapAsync: async () => {} } as unknown as GPUBuffer),
+                    createBindGroup: () => ({} as unknown as GPUBindGroup),
                     createCommandEncoder: () => ({ 
-                        beginComputePass: () => ({ setPipeline:()=>{}, setBindGroup:()=>{}, dispatchWorkgroups:()=>{}, end:()=>{} }),
+                        beginComputePass: () => ({ setPipeline:()=>{}, setBindGroup:()=>{}, dispatchWorkgroups:()=>{}, end:()=>{} } as unknown as GPUComputePassEncoder),
                         copyBufferToBuffer: ()=>{},
-                        finish: ()=>({})
-                    }),
-                    queue: { writeBuffer: ()=>{}, submit: ()=>{} }
+                        finish: ()=>(({} as any) as GPUCommandBuffer)
+                    } as unknown as GPUCommandEncoder),
+                    queue: { writeBuffer: ()=>{}, submit: ()=>{} } as unknown as GPUQueue
                 }) 
             }) 
         } 

package/src/db/repository.test.ts

@@ -1,9 +1,9 @@
-import { expect, test, describe, mock, beforeAll } from "bun:test";
+import { expect, test, describe, mock } from "bun:test";
 import { NeuronRepository, SynapseRepository } from "./repository";
 
 // Mock @buley/dash
 const mockDash = {
-    execute: mock((query, params) => {
+    execute: mock((query, _params) => {
         // Simple mock implementation
         if (query.includes("INSERT")) return Promise.resolve();
         if (query.includes("SELECT * FROM neurons")) return Promise.resolve([

package/src/db/repository.ts

@@ -20,6 +20,10 @@ export class NeuronRepository {
     async getAll(): Promise<Neuron[]> {
         return await dash.execute("SELECT * FROM neurons") as Neuron[];
     }
+
+    async delete(id: string): Promise<void> {
+        await dash.execute("DELETE FROM neurons WHERE id = ?", [id]);
+    }
 }
 
 export class SynapseRepository {
@@ -33,4 +37,8 @@ export class SynapseRepository {
     async getAll(): Promise<Synapse[]> {
         return await dash.execute("SELECT * FROM synapses") as Synapse[];
     }
+
+    async delete(id: string): Promise<void> {
+        await dash.execute("DELETE FROM synapses WHERE id = ?", [id]);
+    }
 }

package/src/engine/gpu.test.ts

@@ -1,4 +1,4 @@
-import { expect, test, describe, mock, beforeAll } from "bun:test";
+import { expect, test, describe, mock } from "bun:test";
 import { GPUEngine } from "./gpu";
 
 // Mock WebGPU Globals
@@ -37,8 +37,8 @@ const mockAdapter = {
 // @ts-ignore
 global.navigator = {
     gpu: {
-        requestAdapter: mock(async () => mockAdapter)
-    }
+        requestAdapter: mock(async () => mockAdapter as unknown as GPUAdapter)
+    } as unknown as GPU
 };
 
 // Polyfill Globals

package/src/engine/gpu.ts

@@ -112,7 +112,7 @@ export class GPUEngine {
         }
 
         // Upload Input
-        this.device.queue.writeBuffer(this.inputBuffer, 0, inputs);
+        this.device.queue.writeBuffer(this.inputBuffer, 0, inputs as unknown as BufferSource);
 
         // Encode Command
         const commandEncoder = this.device.createCommandEncoder();
@@ -213,7 +213,7 @@ export class GPUEngine {
         // Let's assume prepareTrainingBuffers was called ONCE before loop.
         // We just need to update TARGETS buffer!
         if (this.targetBuffer) {
-           this.device?.queue.writeBuffer(this.targetBuffer, 0, targets);
+             this.device?.queue.writeBuffer(this.targetBuffer, 0, targets as unknown as BufferSource);
         }
         
         // Run Training Shaders
@@ -229,7 +229,7 @@ export class GPUEngine {
         }
 
         if (deltas && deltas.length > 0) {
-           this.device.queue.writeBuffer(this.deltaBuffer, 0, deltas);
+           this.device.queue.writeBuffer(this.deltaBuffer, 0, deltas as unknown as BufferSource);
         }
 
         const commandEncoder = this.device.createCommandEncoder();
@@ -252,4 +252,15 @@ export class GPUEngine {
 
         this.device.queue.submit([commandEncoder.finish()]);
     }
+
+    async injectInput(data: Float32Array): Promise<void> {
+        if (!this.device || !this.inputBuffer) return;
+        
+        // We only write what we are given, usually just the first N inputs (Microphone bins)
+        // If data is smaller than buffer, we use queue.writeBuffer which handles partial writes
+        this.device.queue.writeBuffer(this.inputBuffer, 0, data as unknown as BufferSource);
+        
+        // Trigger a tick? Or let the outer loop do it?
+        // Let's just update the buffer. The UI loop calls runTick() or similar.
+    }
 }

package/src/engine/training.test.ts

@@ -78,8 +78,9 @@ describe("Training Loop", () => {
         
         // Should dispatch twice (Delta Calc + Weight Update)
         // We can check calls to createCommandEncoder -> beginComputePass
-        const encoder = mockDevice.createCommandEncoder.mock.results.at(-1)?.value;
-        const pass = encoder?.beginComputePass.mock.results.at(-1)?.value;
+        // const encoder = mockDevice.createCommandEncoder.mock.results.at(-1)?.value;
+        // Check for pass calls if needed, otherwise ignore for now
+        // const pass = encoder?.beginComputePass.mock.results.at(-1)?.value;
         // mock logic is a bit simple, let's just check overall calls
         expect(mockDevice.queue.submit).toHaveBeenCalled();
     });

package/src/index.ts

@@ -74,6 +74,26 @@ export class NeuralEngine {
         return data;
     }
 
+    async deployToCloud() {
+        console.log("Deploying heavy layers to Hybrid Cloud...");
+        // Randomly tagging neurons as "cloud"
+        this.neurons = this.neurons.map(n => ({
+            ...n,
+            type: Math.random() > 0.8 ? 'cloud' : n.type
+        }));
+        // Update repo? For demo we might just keep in memory or update repo.
+        // Let's update repo for persistence
+        for (const n of this.neurons) {
+            if (n.type === 'cloud') {
+               // Assuming repo has update or we just overwrite. 
+               // Repo might not support update efficiently. 
+               // For demo/speed, we likely just keep in memory for this session
+               // unless we want it to persist. 
+            }
+        }
+        return this.getGraphData();
+    }
+
     getGraphData() {
         // Map ID -> Index
         const map = new Map<string, number>();
@@ -86,8 +106,16 @@ export class NeuralEngine {
             weight: s.weight
         }));
 
+        // Return full nodes for visualization customization
+        const nodes = this.neurons.map((n, i) => ({
+            id: n.id,
+            index: i,
+            type: n.type
+        }));
+
         return {
             nodeCount: this.neurons.length,
+            nodes,
             edges
         };
     }
@@ -109,6 +137,49 @@ export class NeuralEngine {
 
         return this.getGraphData();
     }
+
+    exportGraph() {
+        return {
+            version: "2.0",
+            neurons: this.neurons,
+            synapses: this.synapses
+        };
+    }
+
+    async importGraph(data: any) {
+        if (!data.neurons || !data.synapses) throw new Error("Invalid graph data");
+        
+        console.log("Importing graph...");
+        
+        // 1. Clear existing
+        const oldNeurons = await this.neuronRepo.getAll();
+        for (const n of oldNeurons) await this.neuronRepo.delete(n.id);
+        
+        const oldSynapses = await this.synapseRepo.getAll();
+        for (const s of oldSynapses) await this.synapseRepo.delete(s.id);
+        
+        // 2. Insert new
+        for (const n of data.neurons) await this.neuronRepo.create(n);
+        for (const s of data.synapses) await this.synapseRepo.create(s);
+        
+        // 3. Hydrate & Compile
+        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`);
+        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);
+        
+        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);
+    }
 }
 
 // Keep a standalone init for backward compatibility or simple scripts if needed

package/src/vite-env.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="vite/client" />
+
+declare module '*?raw' {
+  const content: string;
+  export default content;
+}

package/vite.config.ts

@@ -10,4 +10,13 @@ export default defineConfig({
   optimizeDeps: {
     exclude: ['@buley/dash', '@sqlite.org/sqlite-wasm'],
   },
+  build: {
+    lib: {
+      entry: './src/index.ts',
+      formats: ['es'],
+    },
+    rollupOptions: {
+      external: ['@buley/dash', '@webgpu/types'],
+    }
+  }
 });