dspx 0.1.1-alpha.0

package/src/ts/easter-egg.ts

@@ -0,0 +1,42 @@
+/**
+ * Easter egg - ASCII art for curious developers
+ * @internal
+ */
+export function egg(): void {
+  const art = `
+                          ████████                          
+                      ████░░░░░░░░████                      
+                    ██░░░░░░░░░░░░░░░░██                    
+                  ██░░░░░░░░░░░░░░░░░░░░██                  
+                ██░░░░░░░░░░░░░░░░░░░░░░░░██                
+              ██░░░░░░░░░░░░░░░░░░░░░░░░░░░░██              
+            ██░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░██            
+            ██░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░██            
+          ██░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░██          
+          ██░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░██          
+        ██░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░██        
+        ██░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░██        
+        ██░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░██        
+        ██░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░██        
+        ██░░░░░░░░░░░░░░░░░░  FFT  ░░░░░░░░░░░░░░░██        
+        ██░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░██        
+        ██░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░██        
+        ██░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░██        
+        ██░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░██        
+          ██░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░██          
+          ██░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░██          
+            ██░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░██            
+            ██░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░██            
+              ██░░░░░░░░░░░░░░░░░░░░░░░░░░░░██              
+                ██░░░░░░░░░░░░░░░░░░░░░░░░██                
+                  ██░░░░░░░░░░░░░░░░░░░░██                  
+                    ██░░░░░░░░░░░░░░░░██                    
+                      ████░░░░░░░░████                      
+                          ████████                          
+
+    dspx - Digital Signal Processing for TypeScript
+    You found the Easter egg!
+  `;
+
+  console.log(art);
+}

package/src/ts/examples/MeanAbsoluteValue/test-state.ts

@@ -0,0 +1,99 @@
+/**
+ * Test script for Mean Absolute Value filter state management
+ * Demonstrates save/load/clear operations for stateful MAV processing
+ */
+
+import { createDspPipeline } from "../../bindings";
+
+async function testMavStateManagement() {
+  console.log("=== Testing MAV Filter State Management ===\n");
+
+  // 1. Create pipeline with MAV filter
+  const pipeline = createDspPipeline();
+  pipeline.MeanAbsoluteValue({ mode: "moving", windowSize: 3 });
+
+  console.log("Pipeline created with MAV filter (window=3)");
+
+  // 2. Process EMG-like signal data
+  const input1 = new Float32Array([1, -2, 3, -4, 5]);
+  console.log("\nProcessing first batch (simulated EMG):", Array.from(input1));
+
+  const output1 = await pipeline.processCopy(input1, {
+    sampleRate: 1000,
+    channels: 1,
+  });
+  console.log(
+    "MAV Output:",
+    Array.from(output1).map((v) => v.toFixed(2))
+  );
+
+  // 3. Save state to JSON
+  console.log("\n--- Saving State ---");
+  const stateJson = await pipeline.saveState();
+  const state = JSON.parse(stateJson);
+  console.log("State saved:");
+  console.log(JSON.stringify(state, null, 2));
+
+  // 4. Continue processing
+  const input2 = new Float32Array([-6, 7, -8]);
+  console.log("\nProcessing second batch:", Array.from(input2));
+
+  const output2 = await pipeline.processCopy(input2, {
+    sampleRate: 1000,
+    channels: 1,
+  });
+  console.log(
+    "MAV Output:",
+    Array.from(output2).map((v) => v.toFixed(2))
+  );
+
+  // 5. Save state again
+  const stateJson2 = await pipeline.saveState();
+  console.log("\nState after second batch:");
+  console.log(JSON.stringify(JSON.parse(stateJson2), null, 2));
+
+  // 6. Create new pipeline and load state
+  console.log("\n--- Creating New Pipeline ---");
+  const pipeline2 = createDspPipeline();
+  pipeline2.MeanAbsoluteValue({ mode: "moving", windowSize: 3 });
+
+  console.log("Loading previous state...");
+  const loaded = await pipeline2.loadState(stateJson2);
+  console.log("Load successful:", loaded);
+
+  // 7. Process with restored state
+  const input3 = new Float32Array([9, -10]);
+  console.log("\nProcessing with restored pipeline:", Array.from(input3));
+
+  const output3 = await pipeline2.processCopy(input3, {
+    sampleRate: 1000,
+    channels: 1,
+  });
+  console.log(
+    "MAV Output:",
+    Array.from(output3).map((v) => v.toFixed(2))
+  );
+
+  // 8. Clear state
+  console.log("\n--- Clearing State ---");
+  pipeline2.clearState();
+  console.log("State cleared");
+
+  // 9. Process after clear (should start fresh)
+  const input4 = new Float32Array([1, -2, 3]);
+  console.log("\nProcessing after clear:", Array.from(input4));
+
+  const output4 = await pipeline2.processCopy(input4, {
+    sampleRate: 1000,
+    channels: 1,
+  });
+  console.log(
+    "MAV Output (fresh start):",
+    Array.from(output4).map((v) => v.toFixed(2))
+  );
+
+  console.log("\n✓ State management test complete!");
+}
+
+// Run test
+testMavStateManagement().catch(console.error);

package/src/ts/examples/MeanAbsoluteValue/test-streaming.ts

@@ -0,0 +1,269 @@
+/**
+ * Test streaming MAV processing - ideal for EMG signal analysis
+ * Demonstrates real-time activity detection from streaming bioelectric signals
+ */
+
+import { createDspPipeline } from "../../bindings";
+
+// Simulate streaming EMG data
+async function* simulateEmgStream(
+  totalSamples: number,
+  chunkSize: number
+): AsyncGenerator<Float32Array> {
+  for (let i = 0; i < totalSamples; i += chunkSize) {
+    // Simulate data arriving over time (e.g., from EMG sensor)
+    await new Promise((resolve) => setTimeout(resolve, 50)); // 50ms delay
+
+    const remainingSamples = Math.min(chunkSize, totalSamples - i);
+    const chunk = new Float32Array(remainingSamples);
+
+    // Generate simulated EMG signal
+    // Low amplitude baseline + occasional bursts (muscle contractions)
+    for (let j = 0; j < remainingSamples; j++) {
+      const t = (i + j) / 1000;
+      // Baseline noise
+      let signal = (Math.random() - 0.5) * 0.1;
+
+      // Add muscle contraction bursts every ~200 samples
+      if (Math.floor((i + j) / 200) % 2 === 1) {
+        signal += Math.sin(2 * Math.PI * 100 * t) * 0.8; // High-frequency burst
+      }
+
+      chunk[j] = signal;
+    }
+
+    yield chunk;
+  }
+}
+
+async function testMavStreaming() {
+  console.log("=== Testing MAV for Streaming EMG Analysis ===\n");
+
+  const pipeline = createDspPipeline();
+  pipeline.MeanAbsoluteValue({ mode: "moving", windowSize: 20 }); // 20ms window at 1kHz
+
+  console.log("Pipeline created with MAV filter (20-sample window)");
+  console.log("Use case: Real-time muscle activity detection from EMG");
+  console.log("Simulating EMG stream (500 samples, 50 samples/chunk)\n");
+
+  let chunkNumber = 0;
+  let totalProcessed = 0;
+  const allOutputs: number[] = [];
+
+  // Process streaming EMG data
+  for await (const chunk of simulateEmgStream(500, 50)) {
+    chunkNumber++;
+    const chunkPreview = Array.from(chunk.slice(0, 3))
+      .map((v) => v.toFixed(3))
+      .join(", ");
+    console.log(
+      `Chunk ${chunkNumber}: Received ${chunk.length} samples [${chunkPreview}, ...]`
+    );
+
+    // Process chunk - MAV tracks activity level
+    const output = await pipeline.process(chunk, {
+      sampleRate: 1000,
+      channels: 1,
+    });
+
+    const mavPreview = Array.from(output.slice(0, 3))
+      .map((v) => v.toFixed(3))
+      .join(", ");
+    const maxMav = Math.max(...Array.from(output));
+    console.log(
+      `           MAV → [${mavPreview}, ...] (max: ${maxMav.toFixed(3)})\n`
+    );
+
+    allOutputs.push(...Array.from(output));
+    totalProcessed += chunk.length;
+  }
+
+  console.log(`Stream complete: ${totalProcessed} samples processed`);
+  console.log(
+    `   First 10 MAV: [${allOutputs
+      .slice(0, 10)
+      .map((v) => v.toFixed(3))
+      .join(", ")}]`
+  );
+  console.log(
+    `   Last 10 MAV:  [${allOutputs
+      .slice(-10)
+      .map((v) => v.toFixed(3))
+      .join(", ")}]`
+  );
+}
+
+// Test with state persistence across stream interruption
+async function testStreamInterruption() {
+  console.log("\n\n=== Testing Stream Interruption & Recovery ===\n");
+
+  const pipeline = createDspPipeline();
+  pipeline.MeanAbsoluteValue({ mode: "moving", windowSize: 5 });
+
+  console.log("Processing first part of EMG stream...");
+  let chunk1 = new Float32Array([0.1, -0.2, 0.3, -0.4, 0.5]);
+  let output1 = await pipeline.process(chunk1, {
+    sampleRate: 1000,
+    channels: 1,
+  });
+  console.log(
+    `Chunk 1: [${Array.from(chunk1).map((v) =>
+      v.toFixed(1)
+    )}] → MAV: [${Array.from(output1).map((v) => v.toFixed(2))}]`
+  );
+
+  let chunk2 = new Float32Array([-0.6, 0.7, -0.8]);
+  let output2 = await pipeline.process(chunk2, {
+    sampleRate: 1000,
+    channels: 1,
+  });
+  console.log(
+    `Chunk 2: [${Array.from(chunk2).map((v) =>
+      v.toFixed(1)
+    )}] → MAV: [${Array.from(output2).map((v) => v.toFixed(2))}]`
+  );
+
+  // Save state (simulate sensor disconnect/reconnect)
+  console.log("\nSaving state (simulating sensor reconnection)...");
+  const savedState = await pipeline.saveState();
+  const state = JSON.parse(savedState);
+  console.log(
+    "State saved - window contains:",
+    state.stages[0].state.channels[0].buffer.length,
+    "samples"
+  );
+
+  // Create new pipeline and restore
+  console.log("\nCreating new pipeline and restoring state...");
+  const pipeline2 = createDspPipeline();
+  pipeline2.MeanAbsoluteValue({ mode: "moving", windowSize: 5 });
+  await pipeline2.loadState(savedState);
+  console.log("State restored!");
+
+  // Continue processing
+  console.log("\nContinuing stream processing...");
+  let chunk3 = new Float32Array([0.9, -1.0, 1.1]);
+  let output3 = await pipeline2.process(chunk3, {
+    sampleRate: 1000,
+    channels: 1,
+  });
+  console.log(
+    `Chunk 3: [${Array.from(chunk3).map((v) =>
+      v.toFixed(1)
+    )}] → MAV: [${Array.from(output3).map((v) => v.toFixed(2))}]`
+  );
+
+  console.log("\nStream recovered seamlessly!");
+}
+
+// Test multi-channel streaming (e.g., multi-electrode EMG)
+async function testMultiChannelEmg() {
+  console.log("\n\n=== Testing Multi-Electrode EMG Streaming ===\n");
+
+  const pipeline = createDspPipeline();
+  pipeline.MeanAbsoluteValue({ mode: "moving", windowSize: 3 });
+
+  console.log("Processing 2-channel EMG data stream");
+  console.log("Channel 0: Biceps, Channel 1: Triceps");
+  console.log("Format: [biceps_s1, triceps_s1, biceps_s2, triceps_s2, ...]\n");
+
+  // Simulate 3 chunks of 2-channel EMG data
+  const chunks = [
+    new Float32Array([0.1, -0.05, -0.2, 0.1, 0.3, -0.15, -0.4, 0.2]), // Biceps active
+    new Float32Array([-0.05, 0.5, 0.1, -0.6, -0.15, 0.7, 0.2, -0.8]), // Triceps active
+    new Float32Array([0.3, 0.3, -0.4, -0.4, 0.5, 0.5, -0.6, -0.6]), // Both active
+  ];
+
+  const labels = [
+    "Biceps contraction",
+    "Triceps contraction",
+    "Co-contraction",
+  ];
+
+  for (let i = 0; i < chunks.length; i++) {
+    console.log(`\n${labels[i]}:`);
+    console.log(`  Input: [${Array.from(chunks[i]).map((v) => v.toFixed(2))}]`);
+
+    const output = await pipeline.process(chunks[i], {
+      sampleRate: 1000,
+      channels: 2,
+    });
+
+    console.log(`  MAV:   [${Array.from(output).map((v) => v.toFixed(2))}]`);
+
+    // Calculate average MAV per channel
+    const bicepsMav = [];
+    const tricepsMav = [];
+    for (let j = 0; j < output.length; j += 2) {
+      bicepsMav.push(output[j]);
+      tricepsMav.push(output[j + 1]);
+    }
+
+    const avgBiceps = bicepsMav.reduce((a, b) => a + b, 0) / bicepsMav.length;
+    const avgTriceps =
+      tricepsMav.reduce((a, b) => a + b, 0) / tricepsMav.length;
+
+    console.log(
+      `  Avg MAV → Biceps: ${avgBiceps.toFixed(
+        3
+      )}, Triceps: ${avgTriceps.toFixed(3)}`
+    );
+  }
+
+  console.log("\n✓ Each muscle maintains independent activity tracking!");
+}
+
+// Test batch vs moving mode comparison
+async function testBatchVsMovingMode() {
+  console.log("\n\n=== Batch vs Moving Mode Comparison ===\n");
+
+  const signal = new Float32Array([0.1, -0.5, 0.3, -0.8, 0.2, -0.6, 0.4, -0.7]);
+  console.log(
+    "Input signal:",
+    Array.from(signal).map((v) => v.toFixed(1))
+  );
+
+  // Batch mode - compute global MAV
+  const batchPipeline = createDspPipeline();
+  batchPipeline.MeanAbsoluteValue({ mode: "batch" });
+  const batchOutput = await batchPipeline.process(signal, {
+    sampleRate: 1000,
+    channels: 1,
+  });
+  console.log("\nBatch mode (global MAV):");
+  console.log(
+    "  Output:",
+    Array.from(batchOutput).map((v) => v.toFixed(3))
+  );
+  console.log("  → All values equal (entire signal average)");
+
+  // Moving mode - local sliding window
+  const movingPipeline = createDspPipeline();
+  movingPipeline.MeanAbsoluteValue({ mode: "moving", windowSize: 3 });
+  const movingOutput = await movingPipeline.process(signal, {
+    sampleRate: 1000,
+    channels: 1,
+  });
+  console.log("\nMoving mode (window=3):");
+  console.log(
+    "  Output:",
+    Array.from(movingOutput).map((v) => v.toFixed(3))
+  );
+  console.log("  → Local activity tracking (better for transient detection)");
+}
+
+// Run all tests
+async function runAllTests() {
+  try {
+    await testMavStreaming();
+    await testStreamInterruption();
+    await testMultiChannelEmg();
+    await testBatchVsMovingMode();
+    console.log("\n✓ All MAV streaming tests passed!");
+  } catch (error) {
+    console.error("Test failed:", error);
+    process.exit(1);
+  }
+}
+
+runAllTests();

package/src/ts/examples/MovingAverage/test-state.ts

@@ -0,0 +1,85 @@
+/**
+ * Test script for state management (save/load/clear)
+ */
+
+import { createDspPipeline } from "../../bindings";
+
+async function testStateManagement() {
+  console.log("=== Testing DSP Pipeline State Management ===\n");
+
+  // 1. Create pipeline and add stages
+  const pipeline = createDspPipeline();
+  pipeline.MovingAverage({ mode: "moving", windowSize: 3 });
+
+  console.log("Pipeline created with moving average filter (window=3)");
+
+  // 2. Process some data
+  const input1 = new Float32Array([1, 2, 3, 4, 5]);
+  console.log("\nProcessing first batch:", Array.from(input1));
+
+  const output1 = await pipeline.processCopy(input1, {
+    sampleRate: 1000,
+    channels: 1,
+  });
+  console.log("Output:", Array.from(output1));
+
+  // 3. Save state to JSON
+  console.log("\n--- Saving State ---");
+  const stateJson = await pipeline.saveState();
+  console.log("State saved:");
+  console.log(JSON.stringify(JSON.parse(stateJson), null, 2));
+
+  // 4. Continue processing
+  const input2 = new Float32Array([6, 7, 8]);
+  console.log("\nProcessing second batch:", Array.from(input2));
+
+  const output2 = await pipeline.processCopy(input2, {
+    sampleRate: 1000,
+    channels: 1,
+  });
+  console.log("Output:", Array.from(output2));
+
+  // 5. Save state again
+  const stateJson2 = await pipeline.saveState();
+  console.log("\nState after second batch:");
+  console.log(JSON.stringify(JSON.parse(stateJson2), null, 2));
+
+  // 6. Create new pipeline and load state
+  console.log("\n--- Creating New Pipeline ---");
+  const pipeline2 = createDspPipeline();
+  pipeline2.MovingAverage({ mode: "moving", windowSize: 3 });
+
+  console.log("Loading previous state...");
+  const loaded = await pipeline2.loadState(stateJson2);
+  console.log("Load successful:", loaded);
+
+  // 7. Process with restored state
+  const input3 = new Float32Array([9, 10]);
+  console.log("\nProcessing with restored pipeline:", Array.from(input3));
+
+  const output3 = await pipeline2.processCopy(input3, {
+    sampleRate: 1000,
+    channels: 1,
+  });
+  console.log("Output:", Array.from(output3));
+
+  // 8. Clear state
+  console.log("\n--- Clearing State ---");
+  pipeline2.clearState();
+  console.log("State cleared");
+
+  // 9. Process after clear (should start fresh)
+  const input4 = new Float32Array([1, 2, 3]);
+  console.log("\nProcessing after clear:", Array.from(input4));
+
+  const output4 = await pipeline2.processCopy(input4, {
+    sampleRate: 1000,
+    channels: 1,
+  });
+  console.log("Output (fresh start):", Array.from(output4));
+
+  console.log("\nState management test complete!");
+}
+
+// Run test
+testStateManagement().catch(console.error);

package/src/ts/examples/MovingAverage/test-streaming.ts

@@ -0,0 +1,188 @@
+/**
+ * Test streaming data processing with state continuity
+ */
+
+import { createDspPipeline } from "../../bindings";
+
+// Simulate streaming chunks of data
+async function* simulateDataStream(
+  totalSamples: number,
+  chunkSize: number
+): AsyncGenerator<Float32Array> {
+  for (let i = 0; i < totalSamples; i += chunkSize) {
+    // Simulate data arriving over time (e.g., from sensor, audio device, network)
+    await new Promise((resolve) => setTimeout(resolve, 100)); // 100ms delay
+
+    const remainingSamples = Math.min(chunkSize, totalSamples - i);
+    const chunk = new Float32Array(remainingSamples);
+
+    // Generate sample data (e.g., sine wave + noise)
+    for (let j = 0; j < remainingSamples; j++) {
+      const t = (i + j) / 100;
+      chunk[j] = Math.sin(2 * Math.PI * 5 * t) + Math.random() * 0.2; // 5Hz sine + noise
+    }
+
+    yield chunk;
+  }
+}
+
+async function testStreamingProcessing() {
+  console.log("=== Testing Streaming Data Processing ===\n");
+
+  const pipeline = createDspPipeline();
+  pipeline.MovingAverage({ mode: "moving", windowSize: 10 }); // Smooth with 10-sample window
+
+  console.log("Pipeline created with 10-sample moving average");
+  console.log(
+    "Simulating real-time data stream (100 samples, 20 samples/chunk)\n"
+  );
+
+  let chunkNumber = 0;
+  let totalProcessed = 0;
+  const allOutputs: number[] = [];
+
+  // Process streaming data
+  for await (const chunk of simulateDataStream(100, 20)) {
+    chunkNumber++;
+    console.log(
+      `Chunk ${chunkNumber}: Received ${
+        chunk.length
+      } samples [${chunk[0].toFixed(3)}, ${chunk[1].toFixed(3)}, ...]`
+    );
+
+    // Process chunk - pipeline remembers state from previous chunks
+    const output = await pipeline.process(chunk, {
+      sampleRate: 100,
+      channels: 1,
+    });
+
+    console.log(
+      `           Processed → [${output[0].toFixed(3)}, ${output[1].toFixed(
+        3
+      )}, ...]\n`
+    );
+
+    allOutputs.push(...Array.from(output));
+    totalProcessed += chunk.length;
+  }
+
+  console.log(`Stream complete: ${totalProcessed} samples processed`);
+  console.log(
+    `   First 10 outputs: [${allOutputs
+      .slice(0, 10)
+      .map((v) => v.toFixed(3))
+      .join(", ")}]`
+  );
+  console.log(
+    `   Last 10 outputs:  [${allOutputs
+      .slice(-10)
+      .map((v) => v.toFixed(3))
+      .join(", ")}]`
+  );
+}
+
+// Test with state persistence across stream interruption
+async function testStreamInterruption() {
+  console.log("\n\n=== Testing Stream Interruption & Recovery ===\n");
+
+  const pipeline = createDspPipeline();
+  pipeline.MovingAverage({ mode: "moving", windowSize: 5 });
+
+  console.log("Processing first part of stream...");
+  let chunk1 = new Float32Array([1, 2, 3, 4, 5]);
+  let output1 = await pipeline.process(chunk1, {
+    sampleRate: 100,
+    channels: 1,
+  });
+  console.log(
+    `Chunk 1: [${Array.from(chunk1)}] → [${Array.from(output1).map((v) =>
+      v.toFixed(2)
+    )}]`
+  );
+
+  let chunk2 = new Float32Array([6, 7, 8]);
+  let output2 = await pipeline.process(chunk2, {
+    sampleRate: 100,
+    channels: 1,
+  });
+  console.log(
+    `Chunk 2: [${Array.from(chunk2)}] → [${Array.from(output2).map((v) =>
+      v.toFixed(2)
+    )}]`
+  );
+
+  // Save state (simulate crash/restart)
+  console.log("\nSaving state (simulating service restart)...");
+  const savedState = await pipeline.saveState();
+  console.log("State saved:", JSON.parse(savedState).stages[0].state);
+
+  // Create new pipeline and restore
+  console.log("\nCreating new pipeline and restoring state...");
+  const pipeline2 = createDspPipeline();
+  pipeline2.MovingAverage({ mode: "moving", windowSize: 5 });
+  await pipeline2.loadState(savedState);
+  console.log("State restored!");
+
+  // Continue processing
+  console.log("\nContinuing stream processing...");
+  let chunk3 = new Float32Array([9, 10, 11]);
+  let output3 = await pipeline2.process(chunk3, {
+    sampleRate: 100,
+    channels: 1,
+  });
+  console.log(
+    `Chunk 3: [${Array.from(chunk3)}] → [${Array.from(output3).map((v) =>
+      v.toFixed(2)
+    )}]`
+  );
+
+  console.log("\nStream recovered seamlessly!");
+}
+
+// Test multi-channel streaming (e.g., stereo audio, multi-sensor EMG)
+async function testMultiChannelStreaming() {
+  console.log("\n\n=== Testing Multi-Channel Streaming ===\n");
+
+  const pipeline = createDspPipeline();
+  pipeline.MovingAverage({ mode: "moving", windowSize: 3 });
+
+  console.log("Processing 2-channel interleaved data stream");
+  console.log("Format: [ch1_s1, ch2_s1, ch1_s2, ch2_s2, ...]\n");
+
+  // Simulate 3 chunks of 2-channel data (4 samples per chunk = 2 samples per channel)
+  const chunks = [
+    new Float32Array([1, 10, 2, 20, 3, 30, 4, 40]), // 4 samples × 2 channels
+    new Float32Array([5, 50, 6, 60, 7, 70, 8, 80]),
+    new Float32Array([9, 90, 10, 100, 11, 110, 12, 120]),
+  ];
+
+  for (let i = 0; i < chunks.length; i++) {
+    console.log(`Chunk ${i + 1} input: [${Array.from(chunks[i])}]`);
+    const output = await pipeline.process(chunks[i], {
+      sampleRate: 100,
+      channels: 2,
+    });
+    console.log(
+      `Chunk ${i + 1} output: [${Array.from(output).map((v) =>
+        v.toFixed(2)
+      )}]\n`
+    );
+  }
+
+  console.log("Each channel maintains independent filter state!");
+}
+
+// Run all tests
+async function runAllTests() {
+  try {
+    await testStreamingProcessing();
+    await testStreamInterruption();
+    await testMultiChannelStreaming();
+    console.log("\nAll streaming tests passed!");
+  } catch (error) {
+    console.error("Test failed:", error);
+    process.exit(1);
+  }
+}
+
+runAllTests();