dspx 1.1.2 → 1.1.3

package/binding.gyp

@@ -26,7 +26,8 @@
         "src/native/utils/NapiUtils.cc",
         "src/native/utils/SlidingWindowFilter.cc",
         "src/native/utils/TimeSeriesBuffer.cc",
-        "src/native/adapters/FilterStage.cc"
+        "src/native/adapters/FilterStage.cc",
+        "src/native/adapters/FftStage.cc"
       ],
       "include_dirs": [
         "<!@(node -p \"require('node-addon-api').include\")",

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/ts/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAChE,OAAO,EACL,WAAW,EACX,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,sBAAsB,EACtB,uBAAuB,EACvB,iBAAiB,EACjB,uBAAuB,EACvB,oBAAoB,EACpB,oBAAoB,EACpB,iBAAiB,EACjB,0BAA0B,EAC1B,mBAAmB,EACnB,MAAM,EACN,aAAa,EACb,aAAa,EACb,iBAAiB,EACjB,cAAc,EACd,iBAAiB,EACjB,kBAAkB,EAClB,mBAAmB,EACnB,KAAK,SAAS,EACd,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,GACzB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,aAAa,EACb,UAAU,EACV,oBAAoB,EACpB,kBAAkB,GACnB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,YAAY,EACZ,kBAAkB,EAClB,QAAQ,EACR,KAAK,YAAY,EACjB,KAAK,UAAU,EACf,KAAK,OAAO,GACb,MAAM,UAAU,CAAC;AAClB,OAAO,EACL,SAAS,EACT,SAAS,EACT,iBAAiB,EACjB,KAAK,UAAU,EACf,KAAK,UAAU,EACf,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,wBAAwB,EAC7B,KAAK,sBAAsB,EAC3B,KAAK,mBAAmB,GACzB,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,yBAAyB,EACzB,yBAAyB,EACzB,wBAAwB,EACxB,qBAAqB,EACrB,yBAAyB,EACzB,uBAAuB,EACvB,sBAAsB,EACtB,2BAA2B,EAC3B,aAAa,EACb,uBAAuB,EACvB,cAAc,GACf,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAClD,YAAY,EACV,eAAe,EACf,oBAAoB,EACpB,aAAa,EACb,YAAY,EACZ,qBAAqB,EACrB,kBAAkB,GACnB,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EACV,cAAc,EACd,mBAAmB,EACnB,WAAW,EACX,SAAS,EACT,aAAa,EACb,cAAc,EACd,qBAAqB,EACrB,uBAAuB,EAGvB,iBAAiB,EACjB,QAAQ,EACR,UAAU,EACV,QAAQ,EACR,QAAQ,EACR,WAAW,EACX,WAAW,EACX,WAAW,EACX,oBAAoB,EACpB,YAAY,EAGZ,gBAAgB,EAChB,YAAY,EACZ,gBAAgB,EAChB,sBAAsB,EACtB,aAAa,EACb,mBAAmB,EACnB,wBAAwB,EACxB,cAAc,EACd,iBAAiB,EACjB,cAAc,EACd,iBAAiB,EAGjB,eAAe,EACf,eAAe,EAGf,WAAW,EACX,sBAAsB,EACtB,qBAAqB,GACtB,MAAM,YAAY,CAAC;AACpB,YAAY,EACV,YAAY,EACZ,KAAK,EACL,YAAY,EACZ,YAAY,EACZ,cAAc,GACf,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/ts/index.ts"],"names":[],"mappings":"AA8BA,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAChE,OAAO,EACL,WAAW,EACX,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,sBAAsB,EACtB,uBAAuB,EACvB,iBAAiB,EACjB,uBAAuB,EACvB,oBAAoB,EACpB,oBAAoB,EACpB,iBAAiB,EACjB,0BAA0B,EAC1B,mBAAmB,EACnB,MAAM,EACN,aAAa,EACb,aAAa,EACb,iBAAiB,EACjB,cAAc,EACd,iBAAiB,EACjB,kBAAkB,EAClB,mBAAmB,EACnB,KAAK,SAAS,EACd,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,GACzB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,aAAa,EACb,UAAU,EACV,oBAAoB,EACpB,kBAAkB,GACnB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,YAAY,EACZ,kBAAkB,EAClB,QAAQ,EACR,KAAK,YAAY,EACjB,KAAK,UAAU,EACf,KAAK,OAAO,GACb,MAAM,UAAU,CAAC;AAClB,OAAO,EACL,SAAS,EACT,SAAS,EACT,iBAAiB,EACjB,KAAK,UAAU,EACf,KAAK,UAAU,EACf,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,wBAAwB,EAC7B,KAAK,sBAAsB,EAC3B,KAAK,mBAAmB,GACzB,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,yBAAyB,EACzB,yBAAyB,EACzB,wBAAwB,EACxB,qBAAqB,EACrB,yBAAyB,EACzB,uBAAuB,EACvB,sBAAsB,EACtB,2BAA2B,EAC3B,aAAa,EACb,uBAAuB,EACvB,cAAc,GACf,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAClD,YAAY,EACV,eAAe,EACf,oBAAoB,EACpB,aAAa,EACb,YAAY,EACZ,qBAAqB,EACrB,kBAAkB,GACnB,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EACV,cAAc,EACd,mBAAmB,EACnB,WAAW,EACX,SAAS,EACT,aAAa,EACb,cAAc,EACd,qBAAqB,EACrB,uBAAuB,EAGvB,iBAAiB,EACjB,QAAQ,EACR,UAAU,EACV,QAAQ,EACR,QAAQ,EACR,WAAW,EACX,WAAW,EACX,WAAW,EACX,oBAAoB,EACpB,YAAY,EAGZ,gBAAgB,EAChB,YAAY,EACZ,gBAAgB,EAChB,sBAAsB,EACtB,aAAa,EACb,mBAAmB,EACnB,wBAAwB,EACxB,cAAc,EACd,iBAAiB,EACjB,cAAc,EACd,iBAAiB,EAGjB,eAAe,EACf,eAAe,EAGf,WAAW,EACX,sBAAsB,EACtB,qBAAqB,GACtB,MAAM,YAAY,CAAC;AACpB,YAAY,EACV,YAAY,EACZ,KAAK,EACL,YAAY,EACZ,YAAY,EACZ,cAAc,GACf,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC"}

package/dist/index.js

@@ -1,3 +1,28 @@
+// Global error handlers for unhandled promise rejections
+// This prevents the library from crashing Node.js processes with exit code 1
+if (typeof process !== "undefined" && process.on) {
+    // Only add handlers if they haven't been added yet (check for existing listeners)
+    const existingHandlers = process.listenerCount("unhandledRejection");
+    if (existingHandlers === 0) {
+        process.on("unhandledRejection", (reason, promise) => {
+            console.error("[dspx] Unhandled Promise Rejection:", reason);
+            if (reason instanceof Error) {
+                console.error("[dspx] Stack trace:", reason.stack);
+            }
+            // Don't crash the process - log and continue
+        });
+        // Handle uncaught exceptions gracefully
+        const existingExceptionHandlers = process.listenerCount("uncaughtException");
+        if (existingExceptionHandlers === 0) {
+            process.on("uncaughtException", (error) => {
+                console.error("[dspx] Uncaught Exception:", error.message);
+                console.error("[dspx] Stack trace:", error.stack);
+                // Exit with error code since this is more serious
+                process.exit(1);
+            });
+        }
+    }
+}
 // Export the main API
 export { createDspPipeline, DspProcessor } from "./bindings.js";
 export { TopicRouter, TopicRouterBuilder, createTopicRouter, } from "./TopicRouter.js";

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/ts/index.ts"],"names":[],"mappings":"AAAA,sBAAsB;AACtB,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAChE,OAAO,EACL,WAAW,EACX,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,sBAAsB,EACtB,uBAAuB,EACvB,iBAAiB,EACjB,uBAAuB,EACvB,oBAAoB,EACpB,oBAAoB,EACpB,iBAAiB,EACjB,0BAA0B,EAC1B,mBAAmB,EACnB,MAAM,EACN,aAAa,EACb,aAAa,EACb,iBAAiB,EACjB,cAAc,EACd,iBAAiB,EACjB,kBAAkB,EAClB,mBAAmB,GASpB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,aAAa,EACb,UAAU,EACV,oBAAoB,EACpB,kBAAkB,GACnB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,YAAY,EACZ,kBAAkB,EAClB,QAAQ,GAIT,MAAM,UAAU,CAAC;AAClB,OAAO,EACL,SAAS,EACT,SAAS,EACT,iBAAiB,GASlB,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,yBAAyB,EACzB,yBAAyB,EACzB,wBAAwB,EACxB,qBAAqB,EACrB,yBAAyB,EACzB,uBAAuB,EACvB,sBAAsB,EACtB,2BAA2B,EAC3B,aAAa,EACb,uBAAuB,EACvB,cAAc,GACf,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/ts/index.ts"],"names":[],"mappings":"AAAA,yDAAyD;AACzD,6EAA6E;AAC7E,IAAI,OAAO,OAAO,KAAK,WAAW,IAAI,OAAO,CAAC,EAAE,EAAE,CAAC;IACjD,kFAAkF;IAClF,MAAM,gBAAgB,GAAG,OAAO,CAAC,aAAa,CAAC,oBAAoB,CAAC,CAAC;IAErE,IAAI,gBAAgB,KAAK,CAAC,EAAE,CAAC;QAC3B,OAAO,CAAC,EAAE,CAAC,oBAAoB,EAAE,CAAC,MAAW,EAAE,OAAqB,EAAE,EAAE;YACtE,OAAO,CAAC,KAAK,CAAC,qCAAqC,EAAE,MAAM,CAAC,CAAC;YAC7D,IAAI,MAAM,YAAY,KAAK,EAAE,CAAC;gBAC5B,OAAO,CAAC,KAAK,CAAC,qBAAqB,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;YACrD,CAAC;YACD,6CAA6C;QAC/C,CAAC,CAAC,CAAC;QAEH,wCAAwC;QACxC,MAAM,yBAAyB,GAC7B,OAAO,CAAC,aAAa,CAAC,mBAAmB,CAAC,CAAC;QAC7C,IAAI,yBAAyB,KAAK,CAAC,EAAE,CAAC;YACpC,OAAO,CAAC,EAAE,CAAC,mBAAmB,EAAE,CAAC,KAAY,EAAE,EAAE;gBAC/C,OAAO,CAAC,KAAK,CAAC,4BAA4B,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;gBAC3D,OAAO,CAAC,KAAK,CAAC,qBAAqB,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;gBAClD,kDAAkD;gBAClD,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YAClB,CAAC,CAAC,CAAC;QACL,CAAC;IACH,CAAC;AACH,CAAC;AAED,sBAAsB;AACtB,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAChE,OAAO,EACL,WAAW,EACX,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,sBAAsB,EACtB,uBAAuB,EACvB,iBAAiB,EACjB,uBAAuB,EACvB,oBAAoB,EACpB,oBAAoB,EACpB,iBAAiB,EACjB,0BAA0B,EAC1B,mBAAmB,EACnB,MAAM,EACN,aAAa,EACb,aAAa,EACb,iBAAiB,EACjB,cAAc,EACd,iBAAiB,EACjB,kBAAkB,EAClB,mBAAmB,GASpB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,aAAa,EACb,UAAU,EACV,oBAAoB,EACpB,kBAAkB,GACnB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,YAAY,EACZ,kBAAkB,EAClB,QAAQ,GAIT,MAAM,UAAU,CAAC;AAClB,OAAO,EACL,SAAS,EACT,SAAS,EACT,iBAAiB,GASlB,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,yBAAyB,EACzB,yBAAyB,EACzB,wBAAwB,EACxB,qBAAqB,EACrB,yBAAyB,EACzB,uBAAuB,EACvB,sBAAsB,EACtB,2BAA2B,EAC3B,aAAa,EACb,uBAAuB,EACvB,cAAc,GACf,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dspx",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "description": "High-performance DSP library with native C++ acceleration and Redis state persistence",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/native/DspPipeline.cc

@@ -19,6 +19,7 @@
 #include "adapters/WaveletTransformStage.h"  // Wavelet Transform stage
 #include "adapters/HilbertEnvelopeStage.h"   // Hilbert Envelope stage
 #include "adapters/StftStage.h"              // STFT (Short-Time Fourier Transform) stage
+#include "adapters/FftStage.h"               // FFT (Fast Fourier Transform) stage
 #include "adapters/MelSpectrogramStage.h"    // Mel Spectrogram stage
 #include "adapters/MfccStage.h"              // MFCC (Mel-Frequency Cepstral Coefficients) stage
 #include "adapters/MatrixTransformStage.h"   // Matrix Transform stage (PCA/ICA/Whitening)
@@ -627,6 +628,43 @@ namespace dsp
                 windowSize, hopSize, method, type, forward, output, window);
         };
 
+        // Factory for FFT (Fast Fourier Transform) stage
+        m_stageFactories["fft"] = [](const Napi::Object &params)
+        {
+            if (!params.Has("size"))
+            {
+                throw std::invalid_argument("FFT: 'size' is required");
+            }
+            size_t size = params.Get("size").As<Napi::Number>().Uint32Value();
+
+            // Parse transform type (fft, dft, rfft, rdft, etc.)
+            std::string typeStr = "rfft"; // Default: real FFT
+            if (params.Has("type"))
+            {
+                typeStr = params.Get("type").As<Napi::String>().Utf8Value();
+            }
+            dsp::adapters::FftStage::TransformType type =
+                dsp::adapters::FftStage::parseTransformType(typeStr);
+
+            // Parse forward/inverse
+            bool forward = true; // Default: forward
+            if (params.Has("forward"))
+            {
+                forward = params.Get("forward").As<Napi::Boolean>().Value();
+            }
+
+            // Parse output format
+            std::string outputStr = "magnitude"; // Default: magnitude
+            if (params.Has("output"))
+            {
+                outputStr = params.Get("output").As<Napi::String>().Utf8Value();
+            }
+            dsp::adapters::FftStage::OutputFormat output =
+                dsp::adapters::FftStage::parseOutputFormat(outputStr);
+
+            return std::make_unique<dsp::adapters::FftStage>(size, type, forward, output);
+        };
+
         // Factory for Mel Spectrogram stage
         m_stageFactories["melSpectrogram"] = [](const Napi::Object &params)
         {

package/src/native/adapters/FftStage.cc

@@ -0,0 +1,441 @@
+/**
+ * FFT Stage Implementation
+ */
+
+#include "FftStage.h"
+#include <cstring>
+#include <stdexcept>
+
+namespace dsp
+{
+    namespace adapters
+    {
+
+        FftStage::FftStage(size_t size, TransformType type, bool forward, OutputFormat format)
+            : m_fftSize(size), m_type(type), m_forward(forward), m_format(format)
+        {
+            if (m_fftSize == 0)
+            {
+                throw std::invalid_argument("FFT size must be greater than 0");
+            }
+
+            // Create FFT engine
+            m_engine = std::make_unique<core::FftEngine<float>>(m_fftSize);
+
+            // Check power-of-2 requirement for FFT/RFFT
+            if ((m_type == TransformType::FFT || m_type == TransformType::RFFT) && !m_engine->isPowerOfTwo())
+            {
+                throw std::invalid_argument("FFT/RFFT requires power-of-2 size. Use DFT/RDFT for arbitrary sizes.");
+            }
+
+            // Allocate working buffers
+            m_complexBuffer.resize(m_fftSize);
+            m_tempComplexBuffer.resize(m_fftSize);
+            m_realBuffer.resize(m_fftSize);
+        }
+
+        size_t FftStage::calculateOutputSize(size_t inputSize) const
+        {
+            // Determine transform direction
+            bool isInverseComplex = (m_type == TransformType::IFFT || m_type == TransformType::IDFT) ||
+                                    ((m_type == TransformType::FFT || m_type == TransformType::DFT) && !m_forward);
+            bool isInverseReal = (m_type == TransformType::IRFFT || m_type == TransformType::IRDFT) ||
+                                 ((m_type == TransformType::RFFT || m_type == TransformType::RDFT) && !m_forward);
+            bool isForwardReal = (m_type == TransformType::RFFT || m_type == TransformType::RDFT) && m_forward;
+
+            // Calculate input size per frame
+            size_t inputSizePerFrame;
+            if (isInverseComplex)
+            {
+                inputSizePerFrame = m_fftSize * 2; // Complex input
+            }
+            else if (isInverseReal)
+            {
+                inputSizePerFrame = m_engine->getHalfSize() * 2; // Half-spectrum complex input
+            }
+            else
+            {
+                inputSizePerFrame = m_fftSize; // Real input
+            }
+
+            size_t numFrames = inputSize / inputSizePerFrame;
+
+            // Calculate output size per frame
+            size_t outputSizePerFrame;
+            if (isForwardReal)
+            {
+                outputSizePerFrame = m_engine->getHalfSize();
+                if (m_format == OutputFormat::COMPLEX)
+                {
+                    outputSizePerFrame *= 2;
+                }
+            }
+            else if (isInverseReal || isInverseComplex)
+            {
+                // All inverse transforms output real time-domain values
+                outputSizePerFrame = m_fftSize;
+            }
+            else if (m_format == OutputFormat::COMPLEX)
+            {
+                // Forward complex transforms
+                outputSizePerFrame = m_fftSize * 2;
+            }
+            else
+            {
+                outputSizePerFrame = m_fftSize;
+            }
+
+            return numFrames * outputSizePerFrame;
+        }
+
+        void FftStage::process(
+            float *buffer,
+            size_t numSamples,
+            int numChannels,
+            const float *timestamps)
+        {
+            // FFT is a resizing stage - this shouldn't be called
+            // Pipeline will call processResizing() instead
+            throw std::runtime_error("FFT stage requires processResizing(), not process()");
+        }
+
+        void FftStage::processResizing(
+            const float *inputBuffer,
+            size_t inputSize,
+            float *outputBuffer,
+            size_t &outputSize,
+            int numChannels,
+            const float *timestamps)
+        {
+            // Determine transform direction
+            bool isInverseComplex = (m_type == TransformType::IFFT || m_type == TransformType::IDFT) ||
+                                    ((m_type == TransformType::FFT || m_type == TransformType::DFT) && !m_forward);
+            bool isInverseReal = (m_type == TransformType::IRFFT || m_type == TransformType::IRDFT) ||
+                                 ((m_type == TransformType::RFFT || m_type == TransformType::RDFT) && !m_forward);
+            bool isForwardReal = (m_type == TransformType::RFFT || m_type == TransformType::RDFT) && m_forward;
+
+            // Calculate input/output sizes per frame
+            size_t inputSizePerFrame;
+            if (isInverseComplex)
+            {
+                inputSizePerFrame = m_fftSize * 2; // Complex input
+            }
+            else if (isInverseReal)
+            {
+                inputSizePerFrame = m_engine->getHalfSize() * 2; // Half-spectrum complex input
+            }
+            else
+            {
+                inputSizePerFrame = m_fftSize; // Real input
+            }
+
+            size_t numFrames = inputSize / (inputSizePerFrame * numChannels);
+
+            // Calculate output size per frame
+            size_t outputSizePerFrame;
+            if (isForwardReal)
+            {
+                outputSizePerFrame = m_engine->getHalfSize();
+                if (m_format == OutputFormat::COMPLEX)
+                {
+                    outputSizePerFrame *= 2;
+                }
+            }
+            else if (isInverseReal || isInverseComplex)
+            {
+                // All inverse transforms output real values only
+                outputSizePerFrame = m_fftSize;
+            }
+            else if (m_format == OutputFormat::COMPLEX)
+            {
+                // Forward complex transforms only
+                outputSizePerFrame = m_fftSize * 2;
+            }
+            else
+            {
+                outputSizePerFrame = m_fftSize;
+            }
+
+            outputSize = numFrames * outputSizePerFrame * numChannels;
+
+            for (size_t frame = 0; frame < numFrames; ++frame)
+            {
+                for (size_t ch = 0; ch < static_cast<size_t>(numChannels); ++ch)
+                {
+                    const float *frameInput = inputBuffer + (frame * inputSizePerFrame * numChannels) + ch;
+                    float *frameOutput = outputBuffer + (frame * outputSizePerFrame * numChannels) + ch;
+
+                    // Load input based on transform direction
+                    if (isInverseComplex)
+                    {
+                        // Input is complex interleaved: [real0, imag0, real1, imag1, ...]
+                        for (size_t i = 0; i < m_fftSize; ++i)
+                        {
+                            m_complexBuffer[i] = std::complex<float>(
+                                frameInput[(i * 2) * numChannels],      // real part
+                                frameInput[(i * 2 + 1) * numChannels]); // imag part
+                        }
+                    }
+                    else if (isInverseReal)
+                    {
+                        // Input is half-spectrum complex
+                        size_t halfSize = m_engine->getHalfSize();
+                        for (size_t i = 0; i < halfSize; ++i)
+                        {
+                            m_complexBuffer[i] = std::complex<float>(
+                                frameInput[(i * 2) * numChannels],
+                                frameInput[(i * 2 + 1) * numChannels]);
+                        }
+                    }
+                    else
+                    {
+                        // Deinterleave real channel data
+                        for (size_t i = 0; i < m_fftSize; ++i)
+                        {
+                            m_realBuffer[i] = frameInput[i * numChannels];
+                        }
+                    }
+
+                    // Perform transform based on type and direction
+                    switch (m_type)
+                    {
+                    case TransformType::FFT:
+                    {
+                        if (m_forward)
+                        {
+                            // Forward FFT: real to complex
+                            for (size_t i = 0; i < m_fftSize; ++i)
+                            {
+                                m_complexBuffer[i] = std::complex<float>(m_realBuffer[i], 0.0f);
+                            }
+                            m_engine->fft(m_complexBuffer.data(), m_complexBuffer.data());
+                        }
+                        else
+                        {
+                            // Inverse FFT: complex input already loaded
+                            m_engine->ifft(m_complexBuffer.data(), m_complexBuffer.data());
+                        }
+                        break;
+                    }
+                    case TransformType::IFFT:
+                    {
+                        // Complex input already loaded into m_complexBuffer
+                        m_engine->ifft(m_complexBuffer.data(), m_complexBuffer.data());
+                        break;
+                    }
+                    case TransformType::DFT:
+                    {
+                        if (m_forward)
+                        {
+                            // Forward DFT: real to complex
+                            for (size_t i = 0; i < m_fftSize; ++i)
+                            {
+                                m_complexBuffer[i] = std::complex<float>(m_realBuffer[i], 0.0f);
+                            }
+                            m_engine->dft(m_complexBuffer.data(), m_tempComplexBuffer.data());
+                            std::copy(m_tempComplexBuffer.begin(), m_tempComplexBuffer.end(), m_complexBuffer.begin());
+                        }
+                        else
+                        {
+                            // Inverse DFT: complex input already loaded
+                            m_engine->idft(m_complexBuffer.data(), m_tempComplexBuffer.data());
+                            std::copy(m_tempComplexBuffer.begin(), m_tempComplexBuffer.end(), m_complexBuffer.begin());
+                        }
+                        break;
+                    }
+                    case TransformType::IDFT:
+                    {
+                        // Complex input already loaded into m_complexBuffer
+                        m_engine->idft(m_complexBuffer.data(), m_tempComplexBuffer.data());
+                        std::copy(m_tempComplexBuffer.begin(), m_tempComplexBuffer.end(), m_complexBuffer.begin());
+                        break;
+                    }
+                    case TransformType::RFFT:
+                    {
+                        if (m_forward)
+                        {
+                            m_engine->rfft(m_realBuffer.data(), m_complexBuffer.data());
+                        }
+                        else
+                        {
+                            // Inverse RFFT: half-spectrum complex input already loaded
+                            m_engine->irfft(m_complexBuffer.data(), m_realBuffer.data());
+                        }
+                        break;
+                    }
+                    case TransformType::IRFFT:
+                    {
+                        // Half-spectrum complex input already loaded into m_complexBuffer
+                        m_engine->irfft(m_complexBuffer.data(), m_realBuffer.data());
+                        break;
+                    }
+                    case TransformType::RDFT:
+                    {
+                        if (m_forward)
+                        {
+                            m_engine->rdft(m_realBuffer.data(), m_complexBuffer.data());
+                        }
+                        else
+                        {
+                            // Inverse RDFT: half-spectrum complex input already loaded
+                            m_engine->irdft(m_complexBuffer.data(), m_realBuffer.data());
+                        }
+                        break;
+                    }
+                    case TransformType::IRDFT:
+                    {
+                        // Half-spectrum complex input already loaded into m_complexBuffer
+                        m_engine->irdft(m_complexBuffer.data(), m_realBuffer.data());
+                        break;
+                    }
+                    }
+
+                    // Convert to output format
+                    if (isInverseReal || isInverseComplex)
+                    {
+                        // ALL inverse transforms output real time-domain values
+                        if (isInverseReal)
+                        {
+                            // Real inverse transforms: use m_realBuffer directly
+                            for (size_t i = 0; i < m_fftSize; ++i)
+                            {
+                                frameOutput[i * numChannels] = m_realBuffer[i];
+                            }
+                        }
+                        else
+                        {
+                            // IFFT/IDFT: extract real parts from complex result
+                            for (size_t i = 0; i < m_fftSize; ++i)
+                            {
+                                frameOutput[i * numChannels] = m_complexBuffer[i].real();
+                            }
+                        }
+                    }
+                    else
+                    {
+                        // Forward transforms only
+                        switch (m_format)
+                        {
+                        case OutputFormat::COMPLEX:
+                        {
+                            // Interleave real/imag
+                            for (size_t i = 0; i < m_fftSize; ++i)
+                            {
+                                frameOutput[(i * 2) * numChannels] = m_complexBuffer[i].real();
+                                frameOutput[(i * 2 + 1) * numChannels] = m_complexBuffer[i].imag();
+                            }
+                            break;
+                        }
+                        case OutputFormat::MAGNITUDE:
+                        {
+                            size_t numBins = (m_type == TransformType::RFFT || m_type == TransformType::RDFT)
+                                                 ? m_engine->getHalfSize()
+                                                 : m_fftSize;
+                            std::vector<float> magnitudes(numBins);
+                            m_engine->getMagnitude(m_complexBuffer.data(), magnitudes.data(), numBins);
+                            for (size_t i = 0; i < numBins; ++i)
+                            {
+                                frameOutput[i * numChannels] = magnitudes[i];
+                            }
+                            break;
+                        }
+                        case OutputFormat::POWER:
+                        {
+                            size_t numBins = (m_type == TransformType::RFFT || m_type == TransformType::RDFT)
+                                                 ? m_engine->getHalfSize()
+                                                 : m_fftSize;
+                            std::vector<float> power(numBins);
+                            m_engine->getPower(m_complexBuffer.data(), power.data(), numBins);
+                            for (size_t i = 0; i < numBins; ++i)
+                            {
+                                frameOutput[i * numChannels] = power[i];
+                            }
+                            break;
+                        }
+                        case OutputFormat::PHASE:
+                        {
+                            size_t numBins = (m_type == TransformType::RFFT || m_type == TransformType::RDFT)
+                                                 ? m_engine->getHalfSize()
+                                                 : m_fftSize;
+                            std::vector<float> phases(numBins);
+                            m_engine->getPhase(m_complexBuffer.data(), phases.data(), numBins);
+                            for (size_t i = 0; i < numBins; ++i)
+                            {
+                                frameOutput[i * numChannels] = phases[i];
+                            }
+                            break;
+                        }
+                        }
+                    }
+                }
+            }
+        }
+
+        void FftStage::reset()
+        {
+            // FFT is stateless, nothing to reset
+        }
+
+        Napi::Object FftStage::serializeState(Napi::Env env) const
+        {
+            // FFT is stateless, save configuration only
+            Napi::Object state = Napi::Object::New(env);
+            state.Set("fftSize", Napi::Number::New(env, m_fftSize));
+            state.Set("type", Napi::Number::New(env, static_cast<int>(m_type)));
+            state.Set("forward", Napi::Boolean::New(env, m_forward));
+            state.Set("format", Napi::Number::New(env, static_cast<int>(m_format)));
+            return state;
+        }
+
+        void FftStage::deserializeState(const Napi::Object &state)
+        {
+            size_t fftSize = state.Get("fftSize").As<Napi::Number>().Uint32Value();
+
+            if (fftSize != m_fftSize)
+            {
+                throw std::runtime_error("FFT size mismatch during state deserialization");
+            }
+
+            m_type = static_cast<TransformType>(state.Get("type").As<Napi::Number>().Int32Value());
+            m_forward = state.Get("forward").As<Napi::Boolean>().Value();
+            m_format = static_cast<OutputFormat>(state.Get("format").As<Napi::Number>().Int32Value());
+        }
+
+        FftStage::TransformType FftStage::parseTransformType(const std::string &typeStr)
+        {
+            if (typeStr == "fft")
+                return TransformType::FFT;
+            if (typeStr == "ifft")
+                return TransformType::IFFT;
+            if (typeStr == "dft")
+                return TransformType::DFT;
+            if (typeStr == "idft")
+                return TransformType::IDFT;
+            if (typeStr == "rfft")
+                return TransformType::RFFT;
+            if (typeStr == "irfft")
+                return TransformType::IRFFT;
+            if (typeStr == "rdft")
+                return TransformType::RDFT;
+            if (typeStr == "irdft")
+                return TransformType::IRDFT;
+
+            throw std::invalid_argument("Unknown transform type: " + typeStr);
+        }
+
+        FftStage::OutputFormat FftStage::parseOutputFormat(const std::string &formatStr)
+        {
+            if (formatStr == "complex")
+                return OutputFormat::COMPLEX;
+            if (formatStr == "magnitude")
+                return OutputFormat::MAGNITUDE;
+            if (formatStr == "power")
+                return OutputFormat::POWER;
+            if (formatStr == "phase")
+                return OutputFormat::PHASE;
+
+            throw std::invalid_argument("Unknown output format: " + formatStr);
+        }
+
+    } // namespace adapters
+} // namespace dsp

package/src/native/adapters/FftStage.h

@@ -0,0 +1,103 @@
+/**
+ * FFT Stage Adapter
+ *
+ * Wraps FftEngine for use in the DSP pipeline.
+ * Supports forward/inverse transforms with multiple output formats.
+ */
+
+#ifndef DSP_ADAPTERS_FFT_STAGE_H
+#define DSP_ADAPTERS_FFT_STAGE_H
+
+#include "../IDspStage.h"
+#include "../core/FftEngine.h"
+#include <memory>
+#include <string>
+
+namespace dsp
+{
+    namespace adapters
+    {
+
+        class FftStage : public IDspStage
+        {
+        public:
+            enum class TransformType
+            {
+                FFT,   // Complex FFT (power-of-2 only)
+                IFFT,  // Inverse FFT
+                DFT,   // Direct FT (any size)
+                IDFT,  // Inverse DFT
+                RFFT,  // Real FFT (power-of-2 only)
+                IRFFT, // Inverse RFFT
+                RDFT,  // Real DFT (any size)
+                IRDFT  // Inverse RDFT
+            };
+
+            enum class OutputFormat
+            {
+                COMPLEX,   // Full complex output (interleaved real/imag)
+                MAGNITUDE, // |X[k]|
+                POWER,     // |X[k]|²
+                PHASE      // ∠X[k]
+            };
+
+            /**
+             * Constructor
+             * @param size FFT size
+             * @param type Transform type (fft, dft, rfft, rdft, etc.)
+             * @param forward True for forward, false for inverse
+             * @param format Output format (complex, magnitude, power, phase)
+             */
+            FftStage(size_t size, TransformType type, bool forward, OutputFormat format);
+
+            ~FftStage() override = default;
+
+            const char *getType() const override { return "fft"; }
+
+            bool isResizing() const override { return true; }
+
+            size_t calculateOutputSize(size_t inputSize) const override;
+
+            void process(
+                float *buffer,
+                size_t numSamples,
+                int numChannels,
+                const float *timestamps = nullptr) override;
+
+            void processResizing(
+                const float *inputBuffer,
+                size_t inputSize,
+                float *outputBuffer,
+                size_t &outputSize,
+                int numChannels,
+                const float *timestamps = nullptr) override;
+
+            void reset() override;
+
+            // State serialization
+            Napi::Object serializeState(Napi::Env env) const override;
+            void deserializeState(const Napi::Object &state) override;
+
+            // Helper to parse transform type from string
+            static TransformType parseTransformType(const std::string &typeStr);
+            static OutputFormat parseOutputFormat(const std::string &formatStr);
+
+        private:
+            size_t m_fftSize;
+            TransformType m_type;
+            bool m_forward;
+            OutputFormat m_format;
+
+            // FFT engine instance
+            std::unique_ptr<core::FftEngine<float>> m_engine;
+
+            // Working buffers
+            std::vector<std::complex<float>> m_complexBuffer;
+            std::vector<std::complex<float>> m_tempComplexBuffer; // For DFT/IDFT in-place issue
+            std::vector<float> m_realBuffer;
+        };
+
+    } // namespace adapters
+} // namespace dsp
+
+#endif // DSP_ADAPTERS_FFT_STAGE_H