@streaming-sortformer-node/darwin-arm64 0.1.0

package/index.js

@@ -0,0 +1 @@
+module.exports = require('./build/Release/sortformer-addon.node');

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@streaming-sortformer-node/darwin-arm64",
+  "version": "0.1.0",
+  "description": "Native bindings for SortFormer on macOS ARM64",
+  "os": [
+    "darwin"
+  ],
+  "cpu": [
+    "arm64"
+  ],
+  "main": "./index.js",
+  "files": [
+    "index.js",
+    "build/Release/sortformer-addon.node",
+    "src"
+  ],
+  "dependencies": {
+    "node-addon-api": "^7.0.0"
+  },
+  "devDependencies": {
+    "cmake-js": "^7.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "cmake-js build",
+    "clean": "cmake-js clean"
+  }
+}

package/src/DiarizeWorker.cpp

@@ -0,0 +1,194 @@
+#include "DiarizeWorker.h"
+#include <cmath>
+#include <cstring>
+
+// Number of speakers output by the model
+static constexpr int NUM_SPEAKERS = 4;
+
+// RTTM buffer size: ~1KB per minute of audio, plus safety margin
+// For 16kHz audio with 160-sample hop, 1 minute = 6000 frames
+// Estimate: 100 bytes per RTTM line, ~60 lines per minute per speaker = 24KB/min
+// Use 32KB per minute as safe estimate
+static constexpr int RTTM_BYTES_PER_MINUTE = 32 * 1024;
+
+DiarizeWorker::DiarizeWorker(
+    Napi::Env env,
+    sortformer_context* ctx,
+    std::vector<float> audio,
+    DiarizeOptions options,
+    Napi::Promise::Deferred deferred)
+    : Napi::AsyncWorker(env)
+    , ctx_(ctx)
+    , audio_(std::move(audio))
+    , options_(std::move(options))
+    , deferred_(deferred)
+{
+}
+
+void DiarizeWorker::Execute() {
+    // IMPORTANT: This runs on a worker thread - NO Napi calls allowed!
+    
+    if (ctx_ == nullptr) {
+        SetError("Model context is null or has been closed");
+        return;
+    }
+    
+    if (audio_.empty()) {
+        SetError("Audio data is empty");
+        return;
+    }
+    
+    // Calculate expected number of frames
+    // Formula: n_frames = (n_samples - 400) / 160 + 1, then subsampled by 8
+    // Simplified: n_frames ≈ n_samples / (160 * 8) = n_samples / 1280
+    // Add safety margin for padding
+    int n_samples = static_cast<int>(audio_.size());
+    int n_frames_max = (n_samples / 1280) + 100;  // Add margin for padding
+    
+    // Allocate output buffer for predictions (n_frames * 4 speakers)
+    predictions_.resize(n_frames_max * NUM_SPEAKERS);
+    
+    // Run diarization
+    n_frames_ = sortformer_diarize(
+        ctx_,
+        audio_.data(),
+        n_samples,
+        predictions_.data(),
+        n_frames_max);
+    
+    if (n_frames_ < 0) {
+        SetError("Diarization failed");
+        return;
+    }
+    
+    // Trim predictions to actual frame count
+    predictions_.resize(n_frames_ * NUM_SPEAKERS);
+    
+    // Calculate RTTM buffer size based on audio duration
+    // Audio duration in minutes = n_samples / (16000 * 60)
+    float duration_minutes = static_cast<float>(n_samples) / (16000.0f * 60.0f);
+    int rttm_size = static_cast<int>(std::ceil(duration_minutes + 1.0f) * RTTM_BYTES_PER_MINUTE);
+    rttm_size = std::max(rttm_size, 4096);  // Minimum 4KB
+    
+    // Allocate RTTM buffer
+    std::vector<char> rttm_buffer(rttm_size);
+    
+    // Convert predictions to RTTM format
+    int rttm_bytes = sortformer_to_rttm(
+        predictions_.data(),
+        n_frames_,
+        options_.threshold,
+        options_.median_filter,
+        options_.filename.c_str(),
+        rttm_buffer.data(),
+        rttm_size);
+    
+    if (rttm_bytes < 0) {
+        SetError("Failed to convert predictions to RTTM format");
+        return;
+    }
+    
+    // Store RTTM string (null-terminated by sortformer_to_rttm)
+    rttm_ = std::string(rttm_buffer.data(), rttm_bytes);
+}
+
+void DiarizeWorker::OnOK() {
+    Napi::Env env = Env();
+    Napi::HandleScope scope(env);
+    
+    // Create result object
+    Napi::Object result = Napi::Object::New(env);
+    
+    // Add RTTM string
+    result.Set("rttm", Napi::String::New(env, rttm_));
+    
+    // Create Float32Array for predictions
+    // Copy data to a new ArrayBuffer owned by JavaScript
+    Napi::ArrayBuffer buffer = Napi::ArrayBuffer::New(
+        env, 
+        predictions_.size() * sizeof(float));
+    
+    std::memcpy(buffer.Data(), predictions_.data(), predictions_.size() * sizeof(float));
+    
+    Napi::Float32Array predictions = Napi::Float32Array::New(
+        env,
+        predictions_.size(),
+        buffer,
+        0);
+    
+    result.Set("predictions", predictions);
+    
+    // Add frame count for convenience
+    result.Set("frameCount", Napi::Number::New(env, n_frames_));
+    
+    // Add speaker count
+    result.Set("speakerCount", Napi::Number::New(env, NUM_SPEAKERS));
+    
+    // Resolve the promise with the result
+    deferred_.Resolve(result);
+}
+
+void DiarizeWorker::OnError(const Napi::Error& e) {
+    // Reject the promise with the error
+    deferred_.Reject(e.Value());
+}
+
+LatencyPreset DiarizeWorker::ParsePreset(const std::string& preset) {
+    if (preset == "offline" || preset == "default") {
+        return LatencyPreset::Offline;
+    } else if (preset == "low") {
+        return LatencyPreset::Low;
+    } else if (preset == "2s") {
+        return LatencyPreset::TwoSecond;
+    } else if (preset == "3s") {
+        return LatencyPreset::ThreeSecond;
+    } else if (preset == "5s") {
+        return LatencyPreset::FiveSecond;
+    }
+    // Default to offline for unknown presets
+    return LatencyPreset::Offline;
+}
+
+void DiarizeWorker::ApplyPreset(sortformer_params& params, LatencyPreset preset) {
+    switch (preset) {
+        case LatencyPreset::Offline:
+            // Default/offline: chunk_len=188, right_context=1, fifo_len=0, spkcache_update_period=188
+            params.chunk_len = 188;
+            params.right_context = 1;
+            params.fifo_len = 0;
+            params.spkcache_update_period = 188;
+            break;
+            
+        case LatencyPreset::Low:
+            // Low latency: chunk_len=6, right_context=7, fifo_len=188, spkcache_update_period=144
+            params.chunk_len = 6;
+            params.right_context = 7;
+            params.fifo_len = 188;
+            params.spkcache_update_period = 144;
+            break;
+            
+        case LatencyPreset::TwoSecond:
+            // 2s latency: chunk_len=15, right_context=10, fifo_len=100, spkcache_update_period=144
+            params.chunk_len = 15;
+            params.right_context = 10;
+            params.fifo_len = 100;
+            params.spkcache_update_period = 144;
+            break;
+            
+        case LatencyPreset::ThreeSecond:
+            // 3s latency: chunk_len=30, right_context=7, fifo_len=100, spkcache_update_period=100
+            params.chunk_len = 30;
+            params.right_context = 7;
+            params.fifo_len = 100;
+            params.spkcache_update_period = 100;
+            break;
+            
+        case LatencyPreset::FiveSecond:
+            // 5s latency: chunk_len=55, right_context=7, fifo_len=100, spkcache_update_period=100
+            params.chunk_len = 55;
+            params.right_context = 7;
+            params.fifo_len = 100;
+            params.spkcache_update_period = 100;
+            break;
+    }
+}

package/src/DiarizeWorker.h

@@ -0,0 +1,90 @@
+#ifndef DIARIZE_WORKER_H
+#define DIARIZE_WORKER_H
+
+#include <napi.h>
+#include <vector>
+#include <string>
+
+#include "sortformer.h"
+
+// Latency preset enumeration
+enum class LatencyPreset {
+    Offline,    // Default: chunk_len=188, right_context=1, fifo_len=0, spkcache_update_period=188
+    Low,        // Low latency: chunk_len=6, right_context=7, fifo_len=188, spkcache_update_period=144
+    TwoSecond,  // 2s latency: chunk_len=15, right_context=10, fifo_len=100, spkcache_update_period=144
+    ThreeSecond,// 3s latency: chunk_len=30, right_context=7, fifo_len=100, spkcache_update_period=100
+    FiveSecond  // 5s latency: chunk_len=55, right_context=7, fifo_len=100, spkcache_update_period=100
+};
+
+// Diarization options passed from JavaScript
+struct DiarizeOptions {
+    LatencyPreset preset = LatencyPreset::Offline;
+    float threshold = 0.5f;
+    int median_filter = 11;
+    std::string filename = "audio";  // For RTTM output
+};
+
+/**
+ * AsyncWorker for non-blocking speaker diarization inference.
+ * 
+ * Runs sortformer_diarize() on a worker thread to avoid blocking the Node.js event loop.
+ * Returns a Promise that resolves with { rttm: string, predictions: Float32Array }.
+ */
+class DiarizeWorker : public Napi::AsyncWorker {
+public:
+    /**
+     * Create a new DiarizeWorker.
+     * 
+     * @param env The N-API environment
+     * @param ctx The sortformer context (must remain valid during execution)
+     * @param audio Audio samples (16kHz mono float32) - copied internally
+     * @param options Diarization options including latency preset
+     * @param deferred Promise deferred for async/await support
+     */
+    DiarizeWorker(
+        Napi::Env env,
+        sortformer_context* ctx,
+        std::vector<float> audio,
+        DiarizeOptions options,
+        Napi::Promise::Deferred deferred);
+    
+    /**
+     * Execute diarization on worker thread.
+     * IMPORTANT: Cannot use any Napi objects here - runs off main thread.
+     */
+    void Execute() override;
+    
+    /**
+     * Called on main thread when Execute() completes successfully.
+     * Creates the result object and resolves the promise.
+     */
+    void OnOK() override;
+    
+    /**
+     * Called on main thread when Execute() throws or SetError() is called.
+     * Rejects the promise with the error message.
+     */
+    void OnError(const Napi::Error& e) override;
+    
+    // Helper to parse latency preset from JavaScript string
+    static LatencyPreset ParsePreset(const std::string& preset);
+    
+    // Helper to apply preset to sortformer_params
+    static void ApplyPreset(sortformer_params& params, LatencyPreset preset);
+
+private:
+    // Input data (copied from JavaScript)
+    sortformer_context* ctx_;
+    std::vector<float> audio_;
+    DiarizeOptions options_;
+    
+    // Promise for async/await support
+    Napi::Promise::Deferred deferred_;
+    
+    // Results (populated in Execute, used in OnOK)
+    std::vector<float> predictions_;
+    std::string rttm_;
+    int n_frames_ = 0;
+};
+
+#endif // DIARIZE_WORKER_H

package/src/SortformerModel.cpp

@@ -0,0 +1,138 @@
+#include "SortformerModel.h"
+#include "DiarizeWorker.h"
+
+// Static constructor reference
+Napi::FunctionReference SortformerModel::constructor;
+
+Napi::Object SortformerModel::Init(Napi::Env env, Napi::Object exports) {
+    Napi::HandleScope scope(env);
+    
+    Napi::Function func = DefineClass(env, "SortformerModel", {
+        InstanceMethod("close", &SortformerModel::Close),
+        InstanceMethod("diarize", &SortformerModel::Diarize),
+    });
+    
+    constructor = Napi::Persistent(func);
+    constructor.SuppressDestruct();
+    
+    exports.Set("SortformerModel", func);
+    return exports;
+}
+
+SortformerModel::SortformerModel(const Napi::CallbackInfo& info)
+    : Napi::ObjectWrap<SortformerModel>(info), ctx_(nullptr) {
+    
+    Napi::Env env = info.Env();
+    
+    // Validate arguments: expect exactly one string argument (model path)
+    if (info.Length() < 1) {
+        Napi::TypeError::New(env, "Model path is required").ThrowAsJavaScriptException();
+        return;
+    }
+    
+    if (!info[0].IsString()) {
+        Napi::TypeError::New(env, "Model path must be a string").ThrowAsJavaScriptException();
+        return;
+    }
+    
+    std::string modelPath = info[0].As<Napi::String>().Utf8Value();
+    
+    // Get default parameters
+    sortformer_params params = sortformer_default_params();
+    
+    // Initialize the sortformer context
+    ctx_ = sortformer_init(modelPath.c_str(), params);
+    
+    if (ctx_ == nullptr) {
+        Napi::Error::New(env, "Failed to load model from path: " + modelPath).ThrowAsJavaScriptException();
+        return;
+    }
+}
+
+SortformerModel::~SortformerModel() {
+    Cleanup();
+}
+
+void SortformerModel::Cleanup() {
+    if (ctx_ != nullptr) {
+        sortformer_free(ctx_);
+        ctx_ = nullptr;
+    }
+}
+
+Napi::Value SortformerModel::Close(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    Cleanup();
+    
+    return env.Undefined();
+}
+
+Napi::Value SortformerModel::Diarize(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    if (ctx_ == nullptr) {
+        Napi::Error::New(env, "Model is closed or not initialized").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+    
+    if (info.Length() < 1) {
+        Napi::TypeError::New(env, "Audio data is required").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+    
+    if (!info[0].IsTypedArray()) {
+        Napi::TypeError::New(env, "Audio must be a Float32Array").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+    
+    Napi::TypedArray typedArray = info[0].As<Napi::TypedArray>();
+    if (typedArray.TypedArrayType() != napi_float32_array) {
+        Napi::TypeError::New(env, "Audio must be a Float32Array").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+    
+    Napi::Float32Array audioArray = info[0].As<Napi::Float32Array>();
+    size_t audioLength = audioArray.ElementLength();
+    
+    if (audioLength == 0) {
+        Napi::Error::New(env, "Audio data cannot be empty").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+    
+    std::vector<float> audio(audioLength);
+    for (size_t i = 0; i < audioLength; i++) {
+        audio[i] = audioArray[i];
+    }
+    
+    DiarizeOptions options;
+    
+    if (info.Length() >= 2 && info[1].IsObject()) {
+        Napi::Object opts = info[1].As<Napi::Object>();
+        
+        if (opts.Has("threshold") && opts.Get("threshold").IsNumber()) {
+            options.threshold = opts.Get("threshold").As<Napi::Number>().FloatValue();
+        }
+        
+        if (opts.Has("medianFilter") && opts.Get("medianFilter").IsNumber()) {
+            options.median_filter = opts.Get("medianFilter").As<Napi::Number>().Int32Value();
+        }
+        
+        if (opts.Has("filename") && opts.Get("filename").IsString()) {
+            options.filename = opts.Get("filename").As<Napi::String>().Utf8Value();
+        }
+    }
+    
+    Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(env);
+    
+    DiarizeWorker* worker = new DiarizeWorker(
+        env,
+        ctx_,
+        std::move(audio),
+        options,
+        deferred);
+    
+    worker->Queue();
+    
+    return deferred.Promise();
+}

package/src/SortformerModel.h

@@ -0,0 +1,41 @@
+#ifndef SORTFORMER_MODEL_H
+#define SORTFORMER_MODEL_H
+
+#include <napi.h>
+#include "sortformer.h"
+
+class SortformerModel : public Napi::ObjectWrap<SortformerModel> {
+public:
+    // Initialize the class and register with N-API
+    static Napi::Object Init(Napi::Env env, Napi::Object exports);
+    
+    // Constructor - takes model path string
+    SortformerModel(const Napi::CallbackInfo& info);
+    
+    // Destructor - frees sortformer context
+    ~SortformerModel();
+    
+    // Get the underlying context pointer (for DiarizeWorker)
+    sortformer_context* GetContext() { return ctx_; }
+    
+    // Check if context is valid
+    bool IsValid() const { return ctx_ != nullptr; }
+
+private:
+    // Static constructor reference for N-API
+    static Napi::FunctionReference constructor;
+    
+    // The underlying sortformer context
+    sortformer_context* ctx_;
+    
+    // Explicit cleanup method (callable from JavaScript)
+    Napi::Value Close(const Napi::CallbackInfo& info);
+    
+    // Diarization method - runs async inference via DiarizeWorker
+    Napi::Value Diarize(const Napi::CallbackInfo& info);
+    
+    // Internal cleanup helper
+    void Cleanup();
+};
+
+#endif // SORTFORMER_MODEL_H

package/src/StreamingSession.cpp

@@ -0,0 +1,210 @@
+#include "StreamingSession.h"
+#include "SortformerModel.h"
+
+Napi::FunctionReference StreamingSession::constructor;
+
+Napi::Object StreamingSession::Init(Napi::Env env, Napi::Object exports) {
+    Napi::HandleScope scope(env);
+    
+    Napi::Function func = DefineClass(env, "StreamingSession", {
+        InstanceMethod("feed", &StreamingSession::Feed),
+        InstanceMethod("flush", &StreamingSession::Flush),
+        InstanceMethod("reset", &StreamingSession::Reset),
+        InstanceMethod("close", &StreamingSession::Close),
+        InstanceMethod("getTotalFrames", &StreamingSession::GetTotalFrames),
+        InstanceMethod("isClosed", &StreamingSession::IsClosed),
+    });
+    
+    constructor = Napi::Persistent(func);
+    constructor.SuppressDestruct();
+    
+    exports.Set("StreamingSession", func);
+    return exports;
+}
+
+StreamingSession::StreamingSession(const Napi::CallbackInfo& info)
+    : Napi::ObjectWrap<StreamingSession>(info), stream_(nullptr), ctx_(nullptr), closed_(false), total_frames_(0) {
+    
+    Napi::Env env = info.Env();
+    
+    // Expect: new StreamingSession(model, preset)
+    // model: SortformerModel instance
+    // preset: number (0=low, 1=2s, 2=3s, 3=5s)
+    
+    if (info.Length() < 2) {
+        Napi::TypeError::New(env, "Expected (model, preset) arguments").ThrowAsJavaScriptException();
+        return;
+    }
+    
+    // Get model context from SortformerModel
+    if (!info[0].IsObject()) {
+        Napi::TypeError::New(env, "First argument must be a SortformerModel").ThrowAsJavaScriptException();
+        return;
+    }
+    
+    Napi::Object modelObj = info[0].As<Napi::Object>();
+    SortformerModel* model = Napi::ObjectWrap<SortformerModel>::Unwrap(modelObj);
+    
+    if (!model || !model->IsValid()) {
+        Napi::Error::New(env, "Model is closed or invalid").ThrowAsJavaScriptException();
+        return;
+    }
+    
+    ctx_ = model->GetContext();
+    
+    // Get preset
+    if (!info[1].IsNumber()) {
+        Napi::TypeError::New(env, "Second argument must be a preset number").ThrowAsJavaScriptException();
+        return;
+    }
+    
+    int preset_num = info[1].As<Napi::Number>().Int32Value();
+    sortformer_stream_preset preset = static_cast<sortformer_stream_preset>(preset_num);
+    
+    // Initialize streaming session
+    stream_ = sortformer_stream_init(ctx_, preset);
+    
+    if (stream_ == nullptr) {
+        Napi::Error::New(env, "Failed to create streaming session").ThrowAsJavaScriptException();
+        return;
+    }
+}
+
+StreamingSession::~StreamingSession() {
+    Cleanup();
+}
+
+void StreamingSession::Cleanup() {
+    if (stream_ != nullptr) {
+        sortformer_stream_free(stream_);
+        stream_ = nullptr;
+    }
+    closed_ = true;
+}
+
+Napi::Value StreamingSession::Feed(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    if (closed_ || stream_ == nullptr) {
+        Napi::Error::New(env, "Session is closed").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+    
+    if (info.Length() < 1 || !info[0].IsTypedArray()) {
+        Napi::TypeError::New(env, "Expected Float32Array argument").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+    
+    Napi::TypedArray typedArray = info[0].As<Napi::TypedArray>();
+    if (typedArray.TypedArrayType() != napi_float32_array) {
+        Napi::TypeError::New(env, "Audio must be a Float32Array").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+    
+    Napi::Float32Array audioArray = info[0].As<Napi::Float32Array>();
+    size_t audioLength = audioArray.ElementLength();
+    
+    if (audioLength == 0) {
+        // Return empty result
+        Napi::Object result = Napi::Object::New(env);
+        result.Set("predictions", Napi::Float32Array::New(env, 0));
+        result.Set("frameCount", Napi::Number::New(env, 0));
+        return result;
+    }
+    
+    // Get audio data pointer
+    float* audioData = audioArray.Data();
+    
+    // Allocate output buffer (generous size)
+    int max_frames = (audioLength / 160) + 100;  // hop=160, plus margin
+    std::vector<float> probs_out(max_frames * 4);
+    
+    // Feed to streaming pipeline
+    int n_frames = sortformer_stream_feed(stream_, audioData, audioLength, 
+                                           probs_out.data(), max_frames);
+    
+    if (n_frames < 0) {
+        Napi::Error::New(env, "Stream feed failed").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+    
+    total_frames_ += n_frames;
+    
+    // Create result object
+    Napi::Object result = Napi::Object::New(env);
+    
+    // Copy predictions to Float32Array
+    Napi::Float32Array predictions = Napi::Float32Array::New(env, n_frames * 4);
+    for (int i = 0; i < n_frames * 4; i++) {
+        predictions[i] = probs_out[i];
+    }
+    
+    result.Set("predictions", predictions);
+    result.Set("frameCount", Napi::Number::New(env, n_frames));
+    
+    return result;
+}
+
+Napi::Value StreamingSession::Flush(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    if (closed_ || stream_ == nullptr) {
+        Napi::Error::New(env, "Session is closed").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+    
+    int max_frames = 1000;
+    std::vector<float> probs_out(max_frames * 4);
+    
+    int n_frames = sortformer_stream_flush(stream_, probs_out.data(), max_frames);
+    
+    if (n_frames < 0) {
+        Napi::Error::New(env, "Stream flush failed").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+    
+    total_frames_ += n_frames;
+    
+    Napi::Object result = Napi::Object::New(env);
+    Napi::Float32Array predictions = Napi::Float32Array::New(env, n_frames * 4);
+    for (int i = 0; i < n_frames * 4; i++) {
+        predictions[i] = probs_out[i];
+    }
+    
+    result.Set("predictions", predictions);
+    result.Set("frameCount", Napi::Number::New(env, n_frames));
+    
+    return result;
+}
+
+Napi::Value StreamingSession::Reset(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    if (closed_ || stream_ == nullptr) {
+        Napi::Error::New(env, "Session is closed").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+    
+    sortformer_stream_reset(stream_);
+    total_frames_ = 0;
+    
+    return env.Undefined();
+}
+
+Napi::Value StreamingSession::Close(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    Cleanup();
+    
+    return env.Undefined();
+}
+
+Napi::Value StreamingSession::GetTotalFrames(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    return Napi::Number::New(env, static_cast<double>(total_frames_));
+}
+
+Napi::Value StreamingSession::IsClosed(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    return Napi::Boolean::New(env, closed_);
+}

package/src/StreamingSession.h

@@ -0,0 +1,56 @@
+#ifndef STREAMING_SESSION_H
+#define STREAMING_SESSION_H
+
+#include <napi.h>
+#include "sortformer.h"
+
+class StreamingSession : public Napi::ObjectWrap<StreamingSession> {
+public:
+    // Initialize the class and register with N-API
+    static Napi::Object Init(Napi::Env env, Napi::Object exports);
+    
+    // Constructor - takes SortformerModel and preset
+    StreamingSession(const Napi::CallbackInfo& info);
+    
+    // Destructor
+    ~StreamingSession();
+
+private:
+    // Static constructor reference for N-API
+    static Napi::FunctionReference constructor;
+    
+    // The underlying streaming state (owned)
+    sortformer_stream_state* stream_;
+    
+    // Reference to the model context (not owned - must outlive session)
+    sortformer_context* ctx_;
+    
+    // Whether the session has been closed
+    bool closed_;
+    
+    // Total frames output so far
+    int64_t total_frames_;
+    
+    // Feed audio samples, get predictions
+    Napi::Value Feed(const Napi::CallbackInfo& info);
+    
+    // Flush remaining buffered audio
+    Napi::Value Flush(const Napi::CallbackInfo& info);
+    
+    // Reset streaming state
+    Napi::Value Reset(const Napi::CallbackInfo& info);
+    
+    // Close and free resources
+    Napi::Value Close(const Napi::CallbackInfo& info);
+    
+    // Get total frames output
+    Napi::Value GetTotalFrames(const Napi::CallbackInfo& info);
+    
+    // Check if closed
+    Napi::Value IsClosed(const Napi::CallbackInfo& info);
+    
+    // Internal cleanup
+    void Cleanup();
+};
+
+#endif // STREAMING_SESSION_H

package/src/addon.cpp

@@ -0,0 +1,11 @@
+#include <napi.h>
+#include "SortformerModel.h"
+#include "StreamingSession.h"
+
+Napi::Object Init(Napi::Env env, Napi::Object exports) {
+    SortformerModel::Init(env, exports);
+    StreamingSession::Init(env, exports);
+    return exports;
+}
+
+NODE_API_MODULE(sortformer, Init)