dspx 0.1.1-alpha.0

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

@@ -0,0 +1,97 @@
+/**
+ * Test script for RMS state management (save/load/clear)
+ */
+
+import { createDspPipeline } from "../../bindings.js";
+
+async function testRmsStateManagement() {
+  console.log("=== Testing RMS Pipeline State Management ===\n");
+
+  // 1. Create pipeline and add RMS stage
+  const pipeline = createDspPipeline();
+  pipeline.Rms({ mode: "moving", windowSize: 3 });
+
+  console.log("Pipeline created with RMS filter (window=3)");
+
+  // 2. Process some data (sine wave samples)
+  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 (RMS values):",
+    Array.from(output1).map((v) => v.toFixed(4))
+  );
+
+  // 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 (RMS values):",
+    Array.from(output2).map((v) => v.toFixed(4))
+  );
+
+  // 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.Rms({ 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 (RMS values):",
+    Array.from(output3).map((v) => v.toFixed(4))
+  );
+
+  // 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).map((v) => v.toFixed(4))
+  );
+
+  console.log("\nRMS state management test complete!");
+}
+
+// Run test
+testRmsStateManagement().catch(console.error);

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

@@ -0,0 +1,253 @@
+/**
+ * Test streaming data processing with RMS and state continuity
+ */
+
+import { createDspPipeline } from "../../bindings.js";
+
+// Simulate streaming chunks of data (e.g., EMG signals, audio)
+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)
+    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 with varying amplitude + noise)
+    for (let j = 0; j < remainingSamples; j++) {
+      const t = (i + j) / 100;
+      const amplitude = 1 + 0.5 * Math.sin(2 * Math.PI * 0.5 * t); // Slow amplitude modulation
+      chunk[j] =
+        amplitude * Math.sin(2 * Math.PI * 10 * t) + Math.random() * 0.1; // 10Hz carrier + noise
+    }
+
+    yield chunk;
+  }
+}
+
+async function testStreamingRmsProcessing() {
+  console.log("=== Testing Streaming RMS Processing ===\n");
+
+  const pipeline = createDspPipeline();
+  pipeline.Rms({ mode: "moving", windowSize: 20 }); // Calculate RMS over 20-sample window
+
+  console.log("Pipeline created with 20-sample RMS window");
+  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(
+      `           RMS output → [${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 RMS values: [${allOutputs
+      .slice(0, 10)
+      .map((v) => v.toFixed(3))
+      .join(", ")}]`
+  );
+  console.log(
+    `   Last 10 RMS values:  [${allOutputs
+      .slice(-10)
+      .map((v) => v.toFixed(3))
+      .join(", ")}]`
+  );
+}
+
+// Test with state persistence across stream interruption
+async function testStreamInterruption() {
+  console.log("\n\n=== Testing RMS Stream Interruption & Recovery ===\n");
+
+  const pipeline = createDspPipeline();
+  pipeline.Rms({ 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(3)
+    )}]`
+  );
+
+  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(3)
+    )}]`
+  );
+
+  // Save state (simulate crash/restart)
+  console.log("\nSaving state (simulating service restart)...");
+  const savedState = await pipeline.saveState();
+  const parsedState = JSON.parse(savedState);
+  console.log("State saved:");
+  console.log("  - Window size:", parsedState.stages[0].state.windowSize);
+  console.log("  - Channels:", parsedState.stages[0].state.numChannels);
+  console.log(
+    "  - Buffer:",
+    parsedState.stages[0].state.channels[0].buffer.map((v: number) =>
+      v.toFixed(3)
+    )
+  );
+  console.log(
+    "  - Running sum of squares:",
+    parsedState.stages[0].state.channels[0].runningSumOfSquares.toFixed(3)
+  );
+
+  // Create new pipeline and restore
+  console.log("\nCreating new pipeline and restoring state...");
+  const pipeline2 = createDspPipeline();
+  pipeline2.Rms({ 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(3)
+    )}]`
+  );
+
+  console.log("\nRMS stream recovered seamlessly!");
+}
+
+// Test multi-channel streaming (e.g., stereo audio, multi-sensor EMG)
+async function testMultiChannelRmsStreaming() {
+  console.log("\n\n=== Testing Multi-Channel RMS Streaming ===\n");
+
+  const pipeline = createDspPipeline();
+  pipeline.Rms({ mode: "moving", windowSize: 3 });
+
+  console.log("Processing 2-channel interleaved data stream (RMS per channel)");
+  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)
+  // Channel 1: positive values, Channel 2: negative values
+  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} RMS output: [${Array.from(output).map((v) =>
+        v.toFixed(2)
+      )}]\n`
+    );
+  }
+
+  console.log("Each channel maintains independent RMS filter state!");
+  console.log(
+    "Note: RMS converts negative values to positive (magnitude only)"
+  );
+}
+
+// Test RMS with actual use case: envelope detection
+async function testEnvelopeDetection() {
+  console.log("\n\n=== Testing RMS for Envelope Detection ===\n");
+
+  const pipeline = createDspPipeline();
+  pipeline.Rms({ mode: "moving", windowSize: 10 }); // 10-sample RMS window for envelope
+
+  console.log("Use case: Detecting signal envelope/amplitude over time");
+  console.log("Input: Amplitude-modulated sine wave\n");
+
+  // Generate amplitude-modulated signal: carrier × envelope
+  const samples = 50;
+  const carrierFreq = 20; // Hz
+  const envelopeFreq = 2; // Hz (slow amplitude change)
+
+  const input = new Float32Array(samples);
+  for (let i = 0; i < samples; i++) {
+    const t = i / 100;
+    const envelope = 0.5 + 0.5 * Math.sin(2 * Math.PI * envelopeFreq * t);
+    const carrier = Math.sin(2 * Math.PI * carrierFreq * t);
+    input[i] = envelope * carrier;
+  }
+
+  console.log(
+    "First 10 input samples:",
+    Array.from(input.slice(0, 10)).map((v) => v.toFixed(3))
+  );
+
+  const output = await pipeline.process(input, {
+    sampleRate: 100,
+    channels: 1,
+  });
+
+  console.log(
+    "First 10 RMS values (envelope):",
+    Array.from(output.slice(0, 10)).map((v) => v.toFixed(3))
+  );
+  console.log(
+    "Last 10 RMS values (envelope):",
+    Array.from(output.slice(-10)).map((v) => v.toFixed(3))
+  );
+
+  console.log("\nRMS successfully tracks signal envelope!");
+}
+
+// Run all tests
+async function runAllTests() {
+  try {
+    await testStreamingRmsProcessing();
+    await testStreamInterruption();
+    await testMultiChannelRmsStreaming();
+    await testEnvelopeDetection();
+    console.log("\nAll RMS streaming tests passed!");
+  } catch (error) {
+    console.error("Test failed:", error);
+    process.exit(1);
+  }
+}
+
+runAllTests();

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

@@ -0,0 +1,107 @@
+/**
+ * Test script for Rectify state management (save/load/clear)
+ */
+
+import { createDspPipeline } from "../../bindings.js";
+
+async function testRectifyStateManagement() {
+  console.log("=== Testing Rectify Pipeline State Management ===\n");
+
+  // Test 1: Full-wave rectification (default)
+  console.log("--- Test 1: Full-Wave Rectification (Default) ---");
+  const pipelineFull = createDspPipeline();
+  pipelineFull.Rectify(); // Default is full-wave
+
+  const inputFull = new Float32Array([1, -2, 3, -4, 5, -6]);
+  console.log("Input:", Array.from(inputFull));
+
+  const outputFull = await pipelineFull.processCopy(inputFull, {
+    sampleRate: 1000,
+    channels: 1,
+  });
+  console.log(
+    "Output (full-wave):",
+    Array.from(outputFull).map((v) => v.toFixed(1))
+  );
+  console.log(
+    "Expected: [1.0, 2.0, 3.0, 4.0, 5.0, 6.0] (all positive, absolute values)\n"
+  );
+
+  // Test 2: Half-wave rectification
+  console.log("--- Test 2: Half-Wave Rectification ---");
+  const pipelineHalf = createDspPipeline();
+  pipelineHalf.Rectify({ mode: "half" });
+
+  const inputHalf = new Float32Array([1, -2, 3, -4, 5, -6]);
+  console.log("Input:", Array.from(inputHalf));
+
+  const outputHalf = await pipelineHalf.processCopy(inputHalf, {
+    sampleRate: 1000,
+    channels: 1,
+  });
+  console.log(
+    "Output (half-wave):",
+    Array.from(outputHalf).map((v) => v.toFixed(1))
+  );
+  console.log(
+    "Expected: [1.0, 0.0, 3.0, 0.0, 5.0, 0.0] (negatives become zero)\n"
+  );
+
+  // Test 3: State serialization (full-wave)
+  console.log("--- Test 3: State Serialization (Full-Wave) ---");
+  const stateFull = await pipelineFull.saveState();
+  const parsedStateFull = JSON.parse(stateFull);
+  console.log("Saved state:");
+  console.log(JSON.stringify(parsedStateFull, null, 2));
+  console.log(`Mode: ${parsedStateFull.stages[0].state.mode}\n`);
+
+  // Test 4: State serialization (half-wave)
+  console.log("--- Test 4: State Serialization (Half-Wave) ---");
+  const stateHalf = await pipelineHalf.saveState();
+  const parsedStateHalf = JSON.parse(stateHalf);
+  console.log("Saved state:");
+  console.log(JSON.stringify(parsedStateHalf, null, 2));
+  console.log(`Mode: ${parsedStateHalf.stages[0].state.mode}\n`);
+
+  // Test 5: Load state and verify mode preservation
+  console.log("--- Test 5: Load State & Verify Mode ---");
+  const pipelineNew = createDspPipeline();
+  pipelineNew.Rectify(); // Start with full-wave
+
+  console.log("Loading half-wave state into new pipeline...");
+  await pipelineNew.loadState(stateHalf);
+
+  const testInput = new Float32Array([2, -3, 4, -5]);
+  const testOutput = await pipelineNew.processCopy(testInput, {
+    sampleRate: 1000,
+    channels: 1,
+  });
+  console.log("Input:", Array.from(testInput));
+  console.log(
+    "Output:",
+    Array.from(testOutput).map((v) => v.toFixed(1))
+  );
+  console.log("Expected: [2.0, 0.0, 4.0, 0.0] (half-wave mode preserved)\n");
+
+  // Test 6: Clear state (no effect on Rectify, but tests the interface)
+  console.log("--- Test 6: Clear State ---");
+  pipelineNew.clearState();
+  console.log("State cleared (Rectify has no internal buffers)\n");
+
+  // Process after clear - should still work with same mode
+  const afterClear = await pipelineNew.processCopy(new Float32Array([1, -2]), {
+    sampleRate: 1000,
+    channels: 1,
+  });
+  console.log("After clear, input: [1, -2]");
+  console.log(
+    "Output:",
+    Array.from(afterClear).map((v) => v.toFixed(1))
+  );
+  console.log("Mode still preserved after clear\n");
+
+  console.log("Rectify state management test complete!");
+}
+
+// Run test
+testRectifyStateManagement().catch(console.error);

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

@@ -0,0 +1,242 @@
+/**
+ * Test streaming data processing with Rectify
+ */
+
+import { createDspPipeline } from "../../bindings.js";
+
+// Simulate streaming chunks of data (e.g., AC audio signal, EMG with negative artifacts)
+async function* simulateDataStream(
+  totalSamples: number,
+  chunkSize: number
+): AsyncGenerator<Float32Array> {
+  for (let i = 0; i < totalSamples; i += chunkSize) {
+    // Simulate data arriving over time
+    await new Promise((resolve) => setTimeout(resolve, 100)); // 100ms delay
+
+    const remainingSamples = Math.min(chunkSize, totalSamples - i);
+    const chunk = new Float32Array(remainingSamples);
+
+    // Generate bipolar signal (positive and negative values)
+    for (let j = 0; j < remainingSamples; j++) {
+      const t = (i + j) / 100;
+      chunk[j] = Math.sin(2 * Math.PI * 5 * t); // 5Hz sine wave (bipolar: -1 to +1)
+    }
+
+    yield chunk;
+  }
+}
+
+async function testStreamingFullWaveRectification() {
+  console.log("=== Testing Streaming Full-Wave Rectification ===\n");
+
+  const pipeline = createDspPipeline();
+  pipeline.Rectify({ mode: "full" }); // Full-wave: absolute value
+
+  console.log("Pipeline created with full-wave rectifier");
+  console.log(
+    "Simulating real-time bipolar signal 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 - rectify converts all to positive
+    const output = await pipeline.process(chunk, {
+      sampleRate: 100,
+      channels: 1,
+    });
+
+    console.log(
+      `           Rectified → [${output[0].toFixed(3)}, ${output[1].toFixed(
+        3
+      )}, ...] (all positive)\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(
+    `   All values ≥ 0: ${allOutputs.every((v) => v >= 0) ? "Yes" : "No"}`
+  );
+}
+
+async function testStreamingHalfWaveRectification() {
+  console.log("\n\n=== Testing Streaming Half-Wave Rectification ===\n");
+
+  const pipeline = createDspPipeline();
+  pipeline.Rectify({ mode: "half" }); // Half-wave: negatives → 0
+
+  console.log("Pipeline created with half-wave rectifier");
+  console.log("Simulating bipolar signal stream (zeros out negative half)\n");
+
+  let chunkNumber = 0;
+  const allOutputs: number[] = [];
+
+  for await (const chunk of simulateDataStream(100, 20)) {
+    chunkNumber++;
+    const output = await pipeline.process(chunk, {
+      sampleRate: 100,
+      channels: 1,
+    });
+
+    console.log(
+      `Chunk ${chunkNumber}: [${output[0].toFixed(3)}, ${output[1].toFixed(
+        3
+      )}, ...] (negatives → 0)`
+    );
+
+    allOutputs.push(...Array.from(output));
+  }
+
+  console.log(`\nStream complete`);
+  const zeroCount = allOutputs.filter((v) => v === 0).length;
+  const positiveCount = allOutputs.filter((v) => v > 0).length;
+  console.log(`   Zero values: ${zeroCount}`);
+  console.log(`   Positive values: ${positiveCount}`);
+  console.log(
+    `   All values ≥ 0: ${allOutputs.every((v) => v >= 0) ? "Yes" : "No"}`
+  );
+}
+
+// Test state persistence across stream interruption
+async function testStreamInterruption() {
+  console.log("\n\n=== Testing Rectify Stream Interruption & Recovery ===\n");
+
+  const pipeline = createDspPipeline();
+  pipeline.Rectify({ mode: "half" });
+
+  console.log("Processing first part of stream (half-wave)...");
+  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)}]`);
+
+  // Save state (simulate crash/restart)
+  console.log("\nSaving state (simulating service restart)...");
+  const savedState = await pipeline.saveState();
+  const parsedState = JSON.parse(savedState);
+  console.log("State saved:");
+  console.log(`  - Type: ${parsedState.stages[0].type}`);
+  console.log(`  - Mode: ${parsedState.stages[0].state.mode}`);
+
+  // Create new pipeline and restore
+  console.log("\nCreating new pipeline and restoring state...");
+  const pipeline2 = createDspPipeline();
+  pipeline2.Rectify({ mode: "full" }); // Start with different mode
+  await pipeline2.loadState(savedState); // Should restore to half-wave
+  console.log("State restored (mode should be 'half')!");
+
+  // Continue processing
+  console.log("\nContinuing stream processing...");
+  let chunk2 = new Float32Array([6, -7, 8, -9]);
+  let output2 = await pipeline2.process(chunk2, {
+    sampleRate: 100,
+    channels: 1,
+  });
+  console.log(`Chunk 2: [${Array.from(chunk2)}] → [${Array.from(output2)}]`);
+  console.log(`Expected: [6, 0, 8, 0] (half-wave mode restored)`);
+
+  console.log("\nRectify stream recovered seamlessly!");
+}
+
+// Test multi-channel rectification
+async function testMultiChannelRectify() {
+  console.log("\n\n=== Testing Multi-Channel Rectification ===\n");
+
+  const pipeline = createDspPipeline();
+  pipeline.Rectify({ mode: "full" });
+
+  console.log("Processing 2-channel interleaved data (full-wave)");
+  console.log("Format: [ch1_s1, ch2_s1, ch1_s2, ch2_s2, ...]\n");
+
+  // Channel 1: positive bias, Channel 2: negative bias
+  const chunks = [
+    new Float32Array([1, -10, 2, -20, -3, 30, -4, 40]),
+    new Float32Array([5, -50, -6, 60, 7, -70, -8, 80]),
+  ];
+
+  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)}]`);
+    console.log(
+      `           All positive: ${
+        Array.from(output).every((v) => v >= 0) ? "Yes" : "No"
+      }\n`
+    );
+  }
+
+  console.log("Multi-channel rectification works independently per sample!");
+}
+
+// Test practical use case: EMG signal pre-processing
+async function testEmgPreProcessing() {
+  console.log("\n\n=== Testing EMG Signal Pre-Processing ===\n");
+
+  console.log("Use case: Prepare EMG for envelope detection");
+  console.log("Pipeline: Full-wave Rectify (converts to magnitude)\n");
+
+  const pipeline = createDspPipeline();
+  pipeline.Rectify({ mode: "full" });
+
+  // Simulate raw EMG with positive and negative spikes
+  const rawEmg = new Float32Array([
+    0.1, -0.3, 0.5, -0.8, 1.2, -1.5, 0.9, -0.6, 0.3, -0.1,
+  ]);
+
+  console.log(
+    "Raw EMG (bipolar):",
+    Array.from(rawEmg).map((v) => v.toFixed(2))
+  );
+
+  const rectified = await pipeline.process(rawEmg, {
+    sampleRate: 2000,
+    channels: 1,
+  });
+
+  console.log(
+    "Rectified EMG (magnitude):",
+    Array.from(rectified).map((v) => v.toFixed(2))
+  );
+  console.log("\nRectified signal is ready for RMS/envelope detection!");
+}
+
+// Run all tests
+async function runAllTests() {
+  try {
+    await testStreamingFullWaveRectification();
+    await testStreamingHalfWaveRectification();
+    await testStreamInterruption();
+    await testMultiChannelRectify();
+    await testEmgPreProcessing();
+    console.log("\nAll Rectify streaming tests passed!");
+  } catch (error) {
+    console.error("Test failed:", error);
+    process.exit(1);
+  }
+}
+
+runAllTests();