@buley/neural 4.1.1 → 4.2.0

package/src/bench/benchmark.ts

@@ -1,107 +0,0 @@
-
-import { GPUEngine } from "../engine/gpu";
-import { performance } from "perf_hooks";
-
-// Mock WebGPU types for Node environment if needed, likely handled by bun's specialized runtime or mocks if strictly node.
-// However, since we are using Bun, we might need a headless WebGPU implementation or we run this in a real browser.
-// REALITY CHECK: running WebGPU in a headless CI/Node environment usually requires 'headless-gl' or similar, but WebGPU is newer.
-// Bun does not support WebGPU native out of the box yet.
-// For this task, since the user is on Mac, we will assume they might run this via a browser test runner OR we simulate/mock for the "structure" of the benchmark 
-// if actual GPU access isn't available in the terminal.
-// BUT: The roadmap implies real GPU benchmarks.
-// Strategy: We will write the benchmark to be runnable. If it fails due to missing GPU in terminal, 
-// we'll note that it needs to be run in a browser context (e.g. via the web app or a test runner that supports it).
-// actually, for the purpose of this agent, I'll implement it assuming the environment *might* support it or I'll add a check.
-
-async function runBenchmark(label: string, networkSize: number, batchSize: number, iterations: number) {
-    console.log(`\n--- Benchmark: ${label} ---`);
-    console.log(`Network: ${networkSize} Neurons, Batch: ${batchSize}`);
-
-    const gpu = new GPUEngine();
-    
-    try {
-        await gpu.init();
-    } catch (e) {
-        console.error("WebGPU Initialize Failed (Expected in non-browser env):", e);
-        return;
-    }
-
-    // Prepare Data
-    const weights = new Float32Array(networkSize * networkSize); // Full connectivity
-    const biases = new Float32Array(networkSize);
-    const inputs = new Float32Array(networkSize * batchSize);
-    const targets = new Float32Array(networkSize * batchSize);
-
-    // Init Buffers
-    const startObj = performance.now();
-    gpu.prepareBuffers(networkSize, weights, biases, batchSize);
-    gpu.prepareTrainingBuffers(targets, 0.01);
-    const initTime = performance.now() - startObj;
-    console.log(`Initialization/Upload: ${initTime.toFixed(2)}ms`);
-
-    // Warmup
-    await gpu.runTick(inputs);
-
-    // Measure Inference
-    const startInf = performance.now();
-    for (let i = 0; i < iterations; i++) {
-        await gpu.runTick(inputs);
-    }
-    const endInf = performance.now();
-    const infTime = endInf - startInf;
-    const infOPS = (iterations * batchSize) / (infTime / 1000);
-    console.log(`Inference: ${infTime.toFixed(2)}ms for ${iterations} ticks`);
-    console.log(`Throughput: ${infOPS.toFixed(0)} samples/sec`);
-
-    // Measure Training
-    const startTrain = performance.now();
-    for (let i = 0; i < iterations; i++) {
-        await gpu.trainTick();
-    }
-    const endTrain = performance.now();
-    const trainTime = endTrain - startTrain;
-    const trainOPS = (iterations * batchSize) / (trainTime / 1000);
-    console.log(`Training: ${trainTime.toFixed(2)}ms for ${iterations} ticks`);
-    console.log(`Throughput: ${trainOPS.toFixed(0)} samples/sec`);
-}
-
-async function main() {
-    // Small
-    await runBenchmark("Small", 100, 1, 100);
-    
-    // Medium
-    await runBenchmark("Medium (Batched)", 1000, 32, 50);
-
-    // Large
-    await runBenchmark("Large (Batched)", 5000, 64, 20);
-}
-
-// Check for WebGPU polyfill or mock if running in Node without headers
-if (!global.navigator?.gpu) {
-    console.log("No WebGPU detected in global scope. Mocking for CLI structure verification...");
-    // @ts-ignore
-    global.navigator = { 
-        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:()=>{} } as unknown as GPUComputePassEncoder),
-                        copyBufferToBuffer: ()=>{},
-                        finish: ()=>(({} as any) as GPUCommandBuffer)
-                    } as unknown as GPUCommandEncoder),
-                    queue: { writeBuffer: ()=>{}, submit: ()=>{} } as unknown as GPUQueue
-                }) 
-            }) 
-        } 
-    };
-    // @ts-ignore
-    global.GPUBufferUsage = { STORAGE: 1, COPY_DST: 2, COPY_SRC: 4, UNIFORM: 8, MAP_READ: 16 };
-    // @ts-ignore
-    global.GPUMapMode = { READ: 1 };
-}
-
-main();

package/src/db/repository.test.ts

@@ -1,67 +0,0 @@
-import { expect, test, describe, mock } from "bun:test";
-import { NeuronRepository, SynapseRepository } from "./repository";
-
-// Mock @buley/dash
-const mockDash = {
-    execute: mock((query, _params) => {
-        // Simple mock implementation
-        if (query.includes("INSERT")) return Promise.resolve();
-        if (query.includes("SELECT * FROM neurons")) return Promise.resolve([
-            { id: "n1", type: "input", bias: 0.1, activation: "tanh" }
-        ]);
-        if (query.includes("SELECT * FROM synapses")) return Promise.resolve([
-            { id: "s1", from_id: "n1", to_id: "n2", weight: 0.5 }
-        ]);
-        return Promise.resolve([]);
-    }),
-    addWithEmbedding: mock(() => Promise.resolve())
-};
-
-// Mock module
-mock.module("@buley/dash", () => ({
-    dash: mockDash
-}));
-
-describe("NeuronRepository", () => {
-    test("create() executes INSERT query", async () => {
-        const repo = new NeuronRepository();
-        await repo.create({ id: "n1", type: "input", bias: 0.1, activation: "tanh" });
-        expect(mockDash.execute).toHaveBeenCalled();
-        const call = mockDash.execute.mock.calls[0];
-        expect(call[0]).toContain("INSERT INTO neurons");
-        expect(call[1]).toEqual(["n1", "input", 0.1, "tanh"]);
-    });
-
-    test("createWithSemantics() calls addWithEmbedding", async () => {
-        const repo = new NeuronRepository();
-        await repo.createWithSemantics(
-            { id: "n2", type: "hidden", bias: 0, activation: "relu" },
-            "detects curves"
-        );
-        expect(mockDash.addWithEmbedding).toHaveBeenCalledWith("n2", "detects curves");
-    });
-
-    test("getAll() returns neurons", async () => {
-        mockDash.execute.mockClear();
-        const repo = new NeuronRepository();
-        const results = await repo.getAll();
-        expect(results.length).toBe(1);
-        expect(results[0].id).toBe("n1");
-    });
-});
-
-describe("SynapseRepository", () => {
-    test("create() executes INSERT query", async () => {
-        const repo = new SynapseRepository();
-        await repo.create({ id: "s1", from_id: "n1", to_id: "n2", weight: 0.5 });
-        expect(mockDash.execute).toHaveBeenCalled();
-        // Check latest call
-    });
-
-    test("getAll() returns synapses", async () => {
-        const repo = new SynapseRepository();
-        const results = await repo.getAll();
-        expect(results.length).toBe(1);
-        expect(results[0].weight).toBe(0.5);
-    });
-});

package/src/db/repository.ts

@@ -1,44 +0,0 @@
-import { dash } from "@buley/dash";
-import { Neuron, Synapse } from "../types";
-
-export class NeuronRepository {
-    async create(neuron: Neuron): Promise<void> {
-        await dash.execute(
-            "INSERT INTO neurons (id, type, bias, activation) VALUES (?, ?, ?, ?)", 
-            [neuron.id, neuron.type, neuron.bias, neuron.activation]
-        );
-    }
-    
-    // Feature: Add with semantic embedding
-    async createWithSemantics(neuron: Neuron, description: string): Promise<void> {
-        // We store the structured data normally
-        await this.create(neuron);
-        // And we map the ID to a semantic embedding in dash's hidden semantic store
-        await dash.addWithEmbedding(neuron.id, description);
-    }
-
-    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 {
-    async create(synapse: Synapse): Promise<void> {
-        await dash.execute(
-            "INSERT INTO synapses (id, from_id, to_id, weight) VALUES (?, ?, ?, ?)",
-            [synapse.id, synapse.from_id, synapse.to_id, synapse.weight]
-        );
-    }
-
-    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/db/schema.ts

@@ -1,40 +0,0 @@
-
-import { dash } from "@buley/dash";
-
-export async function initializeSchema() {
-    console.log("Initializing Neural Schema...");
-
-    // Neurons Table
-    // id: UUID
-    // type: input, hidden, output
-    // bias: float
-    // activation: string (tanh, relu, sigmoid)
-    await dash.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())
-        )
-    `);
-
-    // Synapses Table
-    // id: UUID
-    // from_id: neuron UUID
-    // to_id: neuron UUID
-    // weight: float
-    await dash.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.");
-}

package/src/engine/gpu.test.ts

@@ -1,120 +0,0 @@
-import { expect, test, describe, mock } from "bun:test";
-import { GPUEngine } from "./gpu";
-
-// Mock WebGPU Globals
-const mockDevice = {
-    createShaderModule: mock(() => ({})),
-    createComputePipeline: mock(() => ({
-        getBindGroupLayout: mock(() => ({}))
-    })),
-    createBuffer: mock((desc: any) => ({
-        getMappedRange: () => new ArrayBuffer(desc.size),
-        unmap: () => {},
-        mapAsync: async () => {}
-    })),
-    createBindGroup: mock(() => ({})),
-    createCommandEncoder: mock(() => ({
-        beginComputePass: mock(() => ({
-            setPipeline: mock(() => {}),
-            setBindGroup: mock(() => {}),
-            dispatchWorkgroups: mock(() => {}),
-            end: mock(() => {})
-        })),
-        copyBufferToBuffer: mock(() => {}),
-        finish: mock(() => ({}))
-    })),
-    queue: {
-        writeBuffer: mock(() => {}),
-        submit: mock(() => {})
-    }
-};
-
-const mockAdapter = {
-    requestDevice: mock(async () => mockDevice)
-};
-
-// Polyfill navigator.gpu
-// @ts-ignore
-global.navigator = {
-    gpu: {
-        requestAdapter: mock(async () => mockAdapter as unknown as GPUAdapter)
-    } as unknown as GPU
-};
-
-// Polyfill Globals
-// @ts-ignore
-global.GPUBufferUsage = {
-    MAP_READ: 1,
-    MAP_WRITE: 2,
-    COPY_SRC: 4,
-    COPY_DST: 8,
-    INDEX: 16,
-    VERTEX: 32,
-    UNIFORM: 64,
-    STORAGE: 128,
-    INDIRECT: 256,
-    QUERY_RESOLVE: 512
-};
-// @ts-ignore
-global.GPUMapMode = {
-    READ: 1,
-    WRITE: 2
-};
-
-describe("GPUEngine", () => {
-    test("init() requests adapter and device", async () => {
-        const gpu = new GPUEngine();
-        await gpu.init();
-        expect(navigator.gpu.requestAdapter).toHaveBeenCalled();
-        expect(mockAdapter.requestDevice).toHaveBeenCalled();
-        expect(gpu.device).toBeDefined();
-    });
-
-    test("prepareBuffers() creates GPU buffers", async () => {
-        const gpu = new GPUEngine();
-        await gpu.init();
-
-        const weights = new Float32Array([1, 2, 3, 4]);
-        const biases = new Float32Array([0, 0]);
-        
-        gpu.prepareBuffers(2, weights, biases);
-
-        expect(mockDevice.createBuffer).toHaveBeenCalledTimes(5); // W, I, B, O, Uniforms
-        expect(mockDevice.createBindGroup).toHaveBeenCalled();
-    });
-
-    test("runTick() dispatches compute shader", async () => {
-        const gpu = new GPUEngine();
-        await gpu.init();
-        gpu.prepareBuffers(2, new Float32Array(4), new Float32Array(2));
-
-        const inputs = new Float32Array([1, 0]);
-        await gpu.runTick(inputs);
-
-        expect(mockDevice.queue.writeBuffer).toHaveBeenCalled();
-        expect(mockDevice.createCommandEncoder).toHaveBeenCalled();
-        // Check dispatch
-        // We can't easily check the nested mock calls count without storing the mock, 
-        // but if no error threw, the flow worked.
-    });
-
-    test("prepareBuffers() and runTick() with Batch Size > 1", async () => {
-        const gpu = new GPUEngine();
-        await gpu.init();
-        
-        const N = 4;
-        const B = 2; // Batch Size 2
-        
-        gpu.prepareBuffers(N, new Float32Array(N), new Float32Array(N), B);
-        
-        // Input size = N * B = 8
-        const inputs = new Float32Array(N * B);
-        await gpu.runTick(inputs);
-        
-        expect(mockDevice.createBuffer).toHaveBeenCalled();
-        expect(mockDevice.queue.writeBuffer).toHaveBeenCalled();
-        
-        // Verify buffer size in mock? Mock doesn't store state.
-        // But verifying it runs without throwing "Input size mismatch" proves validation worked.
-    });
-});

package/src/engine/gpu.ts

@@ -1,266 +0,0 @@
-import shaderCode from './shaders/brain.wgsl?raw';
-import trainingShaderCode from './shaders/training.wgsl?raw';
-// import trainingShaderCode from './shaders/training.wgsl?raw'; // Handled in replace block above, this is safety check
-
-export class GPUEngine {
-    device: GPUDevice | null = null;
-    pipeline: GPUComputePipeline | null = null;
-    bindGroup: GPUBindGroup | null = null;
-
-    // Training Buffers
-    deltaBuffer: GPUBuffer | null = null;
-    targetBuffer: GPUBuffer | null = null;
-    paramBuffer: GPUBuffer | null = null;
-
-    trainingPipeline: GPUComputePipeline | null = null;
-    deltaPipeline: GPUComputePipeline | null = null;
-    trainingBindGroup: GPUBindGroup | null = null;
-    
-    // Buffers
-    weightBuffer: GPUBuffer | null = null;
-    inputBuffer: GPUBuffer | null = null;
-    biasBuffer: GPUBuffer | null = null;
-    outputBuffer: GPUBuffer | null = null;
-    uniformBuffer: GPUBuffer | null = null;
-
-    networkSize: number = 0;
-    batchSize: number = 1;
-
-    async init() {
-        if (!navigator.gpu) throw new Error("WebGPU not supported");
-        const adapter = await navigator.gpu.requestAdapter();
-        if (!adapter) throw new Error("No GPU adapter found");
-        this.device = await adapter.requestDevice();
-
-        const shaderModule = this.device.createShaderModule({ code: shaderCode });
-        const trainingModule = this.device.createShaderModule({ code: trainingShaderCode });
-
-        this.pipeline = this.device.createComputePipeline({
-            layout: 'auto',
-            compute: { module: shaderModule, entryPoint: 'main' }
-        });
-
-        this.trainingPipeline = this.device.createComputePipeline({
-            layout: 'auto',
-            compute: { module: trainingModule, entryPoint: 'update_weights' }
-        });
-
-        this.deltaPipeline = this.device.createComputePipeline({
-            layout: 'auto',
-            compute: { module: trainingModule, entryPoint: 'calculate_deltas' }
-        });
-        
-        console.log("GPUEngine initialized");
-    }
-
-    // Prepare buffers based on network size (N) and Batch Size (B)
-    prepareBuffers(size: number, weights: Float32Array, biases: Float32Array, batchSize: number = 1) {
-        if (!this.device || !this.pipeline) throw new Error("GPUEngine not initialized");
-        this.networkSize = size;
-        this.batchSize = batchSize;
-
-        // Create Buffers
-        // Weights & Biases are shared (Size N or N*N)
-        this.weightBuffer = this.createBuffer(weights, GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST);
-        this.biasBuffer = this.createBuffer(biases, GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST);
-        
-        // Inputs & Outputs are Batched (Size N * B)
-        const batchedSize = size * batchSize;
-        this.inputBuffer = this.createBuffer(new Float32Array(batchedSize), GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST);
-        this.outputBuffer = this.createBuffer(new Float32Array(batchedSize), GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST);
-        
-        // Dimensions Uniform: [Size, BatchSize]
-        const dimArray = new Uint32Array([size, batchSize]);
-        this.uniformBuffer = this.createBuffer(dimArray, GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST);
-
-        // Bind Group
-        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 } },
-            ]
-        });
-    }
-
-    private createBuffer(data: Float32Array | Uint32Array, usage: number): GPUBuffer {
-        if (!this.device) throw new Error("Device null");
-        const buffer = this.device.createBuffer({
-            size: data.byteLength,
-            usage: usage,
-            mappedAtCreation: true
-        });
-        if (data instanceof Float32Array) {
-            new Float32Array(buffer.getMappedRange()).set(data);
-        } else {
-            new Uint32Array(buffer.getMappedRange()).set(data);
-        }
-        buffer.unmap();
-        return buffer;
-    }
-
-    async runTick(inputs: Float32Array): Promise<Float32Array> {
-        if (!this.device || !this.pipeline || !this.bindGroup || !this.inputBuffer || !this.outputBuffer) {
-            throw new Error("GPU buffers not ready");
-        }
-        
-        if (inputs.length !== this.networkSize * this.batchSize) {
-           throw new Error(`Input size mismatch. Expected ${this.networkSize * this.batchSize}, got ${inputs.length}`);
-        }
-
-        // Upload Input
-        this.device.queue.writeBuffer(this.inputBuffer, 0, inputs as BufferSource);
-
-        // Encode Command
-        const commandEncoder = this.device.createCommandEncoder();
-        const passEncoder = commandEncoder.beginComputePass();
-        passEncoder.setPipeline(this.pipeline);
-        passEncoder.setBindGroup(0, this.bindGroup);
-        
-        // Dispatch (Size / WorkgroupSize, 1, BatchSize)
-        const workgroupSize = 64;
-        const workgroupCount = Math.ceil(this.networkSize / workgroupSize);
-        passEncoder.dispatchWorkgroups(workgroupCount, 1, this.batchSize);
-        passEncoder.end();
-
-        // Read Output
-        const size = inputs.byteLength;
-        const gpuReadBuffer = this.device.createBuffer({
-            size: size,
-            usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
-        });
-        
-        commandEncoder.copyBufferToBuffer(this.outputBuffer, 0, gpuReadBuffer, 0, size);
-        
-        const gpuCommands = commandEncoder.finish();
-        this.device.queue.submit([gpuCommands]);
-
-        await gpuReadBuffer.mapAsync(GPUMapMode.READ);
-        const result = new Float32Array(gpuReadBuffer.getMappedRange());
-        const output = new Float32Array(result); // Copy
-        gpuReadBuffer.unmap();
-        
-        return output;
-    }
-
-    prepareTrainingBuffers(targets: Float32Array, learningRate: number) {
-        if (!this.device || !this.trainingPipeline || !this.weightBuffer || !this.outputBuffer || !this.biasBuffer || !this.uniformBuffer) {
-            throw new Error("GPU not ready for training");
-        }
-        
-        if (targets.length !== this.networkSize * this.batchSize) {
-            throw new Error(`Target size mismatch. Expected ${this.networkSize * this.batchSize}, got ${targets.length}`);
-        }
-
-        // Deltas & Targets are Batched (Size N * B)
-        const batchedSize = this.networkSize * this.batchSize;
-        this.deltaBuffer = this.createBuffer(new Float32Array(batchedSize), GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC);
-        this.targetBuffer = this.createBuffer(targets, GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST);
-        this.paramBuffer = this.createBuffer(new Float32Array([learningRate]), 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 } }
-            ]
-        });
-    }
-
-    private subscribers: ((event: { type: 'loss' | 'epoch', value: number }) => void)[] = [];
-
-    subscribe(callback: (event: { type: 'loss' | 'epoch', value: number }) => void) {
-        this.subscribers.push(callback);
-        return () => {
-            this.subscribers = this.subscribers.filter(s => s !== callback);
-        };
-    }
-
-    private emit(event: { type: 'loss' | 'epoch', value: number }) {
-        this.subscribers.forEach(cb => cb(event));
-    }
-
-    async train(inputs: Float32Array, targets: Float32Array): Promise<Float32Array> {
-        // 1. Forward Pass
-        const outputs = await this.runTick(inputs);
-        
-        // 2. Calculate Loss (MSE) on CPU for UI Feedback
-        // Only feasible if batch size is small or we sample. 
-        // For demo, we just calc full MSE.
-        let totalLoss = 0;
-        for (let i = 0; i < outputs.length; i++) {
-             // Only if target is valid? Assuming targets cover all neurons logic as per shader
-             const t = targets[i];
-             if (t > -998) {
-                 const diff = outputs[i] - t;
-                 totalLoss += 0.5 * diff * diff;
-             }
-        }
-        const meanLoss = totalLoss / this.batchSize; // Approx
-        this.emit({ type: 'loss', value: meanLoss });
-
-        // 3. Backward Pass
-        // Ensure buffers (deltas, targets) are ready?
-        // Reuse prepareTrainingBuffers or assume already called?
-        // 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 as BufferSource);
-        }
-        
-        // Run Training Shaders
-        await this.trainTick();
-
-        this.emit({ type: 'epoch', value: 1 }); // Just tick count really
-        return outputs;
-    }
-
-    async trainTick(deltas?: Float32Array): Promise<void> {
-        if (!this.device || !this.trainingPipeline || !this.deltaPipeline || !this.trainingBindGroup || !this.deltaBuffer) {
-            throw new Error("Training not ready");
-        }
-
-        if (deltas && deltas.length > 0) {
-           this.device.queue.writeBuffer(this.deltaBuffer, 0, deltas as BufferSource);
-        }
-
-        const commandEncoder = this.device.createCommandEncoder();
-        const passEncoder = commandEncoder.beginComputePass();
-        
-        // Pass 1: Calculate Deltas (Batched)
-        passEncoder.setPipeline(this.deltaPipeline);
-        passEncoder.setBindGroup(0, this.trainingBindGroup);
-        const workgroupSize = 64;
-        const workgroupCount = Math.ceil(this.networkSize / workgroupSize);
-        passEncoder.dispatchWorkgroups(workgroupCount, 1, this.batchSize);
-
-        passEncoder.end();
-        
-        const updatePass = commandEncoder.beginComputePass();
-        updatePass.setPipeline(this.trainingPipeline);
-        updatePass.setBindGroup(0, this.trainingBindGroup); // Re-bind for new pass
-        updatePass.dispatchWorkgroups(workgroupCount, 1, 1); // Not batched
-        updatePass.end();
-
-        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 BufferSource);
-        
-        // Trigger a tick? Or let the outer loop do it?
-        // Let's just update the buffer. The UI loop calls runTick() or similar.
-    }
-}