hamlib 0.2.6 → 0.3.0

package/lib/index.js

@@ -1,4 +1,5 @@
 const path = require('path');
+const { EventEmitter } = require('events');
 const nodeGypBuild = require('node-gyp-build');
 // Ensure loader resolves from package root (contains prebuilds/ and build/)
 const nativeModule = nodeGypBuild(path.join(__dirname, '..'));
@@ -9,7 +10,7 @@ const nativeModule = nodeGypBuild(path.join(__dirname, '..'));
  * This is a wrapper around the native hamlib module that provides
  * a consistent interface for controlling amateur radio devices.
  */
-class HamLib {
+class HamLib extends EventEmitter {
   /**
    * Create a new HamLib instance
    * @param {number} model - Radio model number (run `rigctl -l` to find your device model)
@@ -18,7 +19,9 @@ class HamLib {
    *   - Network: 'localhost:4532' or '192.168.1.100:4532' (auto-switches to NETRIGCTL mode)
    */
   constructor(model, port) {
+    super();
     this._nativeInstance = new nativeModule.HamLib(model, port);
+    this._managedSpectrumRunning = false;
   }
 
   /**
@@ -187,6 +190,9 @@ class HamLib {
    * Connection can be re-established by calling open()
    */
   async close() {
+    if (this._managedSpectrumRunning) {
+      await this.stopManagedSpectrum();
+    }
     return this._nativeInstance.close();
   }
 
@@ -195,6 +201,9 @@ class HamLib {
    * Object reference should be deleted after calling this
    */
   async destroy() {
+    if (this._managedSpectrumRunning) {
+      await this.stopManagedSpectrum();
+    }
     return this._nativeInstance.destroy();
   }
 
@@ -1151,6 +1160,158 @@ class HamLib {
     return this._nativeInstance.sendRaw(data, replyMaxLen);
   }
 
+  /**
+   * Get official Hamlib spectrum capability metadata from the backend.
+   * @returns {Promise<Object>} Spectrum capability object.
+   */
+  async getSpectrumCapabilities() {
+    return this._nativeInstance.getSpectrumCapabilities();
+  }
+
+  /**
+   * Summarize whether official Hamlib spectrum streaming is usable for this rig.
+   * @returns {Promise<Object>} Product-oriented support summary.
+   */
+  async getSpectrumSupportSummary() {
+    const capabilities = await this.getSpectrumCapabilities();
+    const supportedFunctions = this.getSupportedFunctions();
+    const supportedLevels = this.getSupportedLevels();
+    const hasSpectrumFunction = supportedFunctions.includes('SPECTRUM');
+    const hasSpectrumHoldFunction = supportedFunctions.includes('SPECTRUM_HOLD');
+    const hasTransceiveFunction = supportedFunctions.includes('TRANSCEIVE');
+    const asyncDataSupported = capabilities.asyncDataSupported ?? hasSpectrumFunction;
+    const configurableLevels = ['SPECTRUM_MODE', 'SPECTRUM_SPAN', 'SPECTRUM_SPEED', 'SPECTRUM_REF', 'SPECTRUM_AVG']
+      .filter((name) => supportedLevels.includes(name));
+
+    return {
+      supported: Boolean(hasSpectrumFunction),
+      asyncDataSupported: Boolean(asyncDataSupported),
+      hasSpectrumFunction,
+      hasSpectrumHoldFunction,
+      hasTransceiveFunction,
+      configurableLevels,
+      scopes: capabilities.scopes ?? [],
+      modes: capabilities.modes ?? [],
+      spans: capabilities.spans ?? [],
+      avgModes: capabilities.avgModes ?? [],
+    };
+  }
+
+  /**
+   * Apply official Hamlib spectrum settings using high-level level/function APIs.
+   * Unsupported settings are skipped silently.
+   * @param {Object} [config]
+   */
+  async configureSpectrum(config = {}) {
+    const summary = await this.getSpectrumSupportSummary();
+    const applyLevel = async (name, value) => {
+      if (value === undefined || !summary.configurableLevels.includes(name)) return;
+      await this.setLevel(name, value);
+    };
+
+    if (summary.hasSpectrumHoldFunction && config.hold !== undefined) {
+      await this.setFunction('SPECTRUM_HOLD', Boolean(config.hold));
+    }
+
+    await applyLevel('SPECTRUM_MODE', config.mode);
+    await applyLevel('SPECTRUM_SPAN', config.spanHz);
+    await applyLevel('SPECTRUM_SPEED', config.speed);
+    await applyLevel('SPECTRUM_REF', config.referenceLevel);
+    await applyLevel('SPECTRUM_AVG', config.averageMode);
+
+    return summary;
+  }
+
+  /**
+   * Start the official Hamlib spectrum callback stream.
+   * @param {(line: Object) => void} [callback]
+   * @returns {Promise<boolean>}
+   */
+  async startSpectrumStream(callback) {
+    const listener = typeof callback === 'function'
+      ? callback
+      : (line) => this.emit('spectrumLine', line);
+    return this._nativeInstance.startSpectrumStream(listener);
+  }
+
+  /**
+   * Stop the official Hamlib spectrum callback stream.
+   * @returns {Promise<boolean>}
+   */
+  async stopSpectrumStream() {
+    return this._nativeInstance.stopSpectrumStream();
+  }
+
+  /**
+   * High-level managed spectrum startup for application use.
+   * @param {Object} [config]
+   */
+  async startManagedSpectrum(config = {}) {
+    const summary = await this.getSpectrumSupportSummary();
+    if (!summary.supported) {
+      throw new Error('Official Hamlib spectrum streaming is not supported by this rig/backend');
+    }
+
+    if (this._managedSpectrumRunning) {
+      return true;
+    }
+
+    await this.startSpectrumStream((line) => this.emit('spectrumLine', line));
+
+    try {
+      try {
+        await this.setConf('async', '1');
+      } catch (_) {
+        try {
+          await this.setConf('async', 'True');
+        } catch (_) {
+          // Not every backend accepts the config write even if async is supported.
+        }
+      }
+
+      await this.configureSpectrum({ hold: false, ...config });
+      await this.setFunction('SPECTRUM', true);
+      if (summary.hasTransceiveFunction) {
+        await this.setFunction('TRANSCEIVE', true);
+      }
+    } catch (error) {
+      try {
+        await this.stopManagedSpectrum();
+      } catch (_) {
+        // Ignore cleanup failures and surface the original startup error.
+      }
+      throw error;
+    }
+
+    this._managedSpectrumRunning = true;
+    this.emit('spectrumStateChanged', { active: true });
+    return true;
+  }
+
+  /**
+   * High-level managed spectrum shutdown for application use.
+   */
+  async stopManagedSpectrum() {
+    try {
+      const supportedFunctions = this.getSupportedFunctions();
+      if (supportedFunctions.includes('TRANSCEIVE')) {
+        await this.setFunction('TRANSCEIVE', false);
+      }
+      if (supportedFunctions.includes('SPECTRUM_HOLD')) {
+        await this.setFunction('SPECTRUM_HOLD', false);
+      }
+      if (supportedFunctions.includes('SPECTRUM')) {
+        await this.setFunction('SPECTRUM', false);
+      }
+    } finally {
+      await this.stopSpectrumStream();
+    }
+
+    this._managedSpectrumRunning = false;
+    this.emit('spectrumStateChanged', { active: false });
+    return true;
+  }
+
   /**
    * Set a backend configuration parameter
    * @param {string} name - Configuration token name

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hamlib",
-  "version": "0.2.6",
-  "description": "Node.js wrapper for hamlib radio control library",
+  "version": "0.3.0",
+  "description": "Node.js bindings for Hamlib rig control with official spectrum streaming support",
   "main": "index.js",
   "module": "lib/index.mjs",
   "types": "index.d.ts",
@@ -30,6 +30,7 @@
     "lib/",
     "prebuilds/",
     "src/",
+    "docs/",
     "index.js",
     "index.d.ts",
     "binding.gyp",
@@ -43,9 +44,11 @@
     "rebuild": "node-gyp rebuild",
     "clean": "node-gyp clean",
     "test": "node test/test_loader.js",
+    "test:version": "node test/test_version.js",
     "test:network": "node test/test_network.js",
     "test:dummy": "node test/test_dummy_complete.js",
     "test:serial": "node test/test_serial_config.js",
+    "test:spectrum": "node test/test_spectrum_stream.js",
     "prebuild": "prebuildify --napi --strip",
     "prepare": "",
     "bundle": "node scripts/bundle-deps.js",

package/src/hamlib.cpp

@@ -4,6 +4,9 @@
 #include <vector>
 #include <memory>
 #include <algorithm>
+#include <chrono>
+#include <cstdio>
+#include <exception>
 
 // 安全宏 - 检查RIG指针有效性，防止空指针解引用和已销毁对象访问
 #define CHECK_RIG_VALID() \
@@ -45,10 +48,13 @@ public:
         } else {
             shim_rig_set_freq_callback(hamlib_instance_->my_rig, NodeHamLib::freq_change_cb, hamlib_instance_);
             auto ppt_cb = +[](void* handle, int vfo, int ptt, void* arg) -> int {
-                printf("PPT pushed!");
+                (void)handle;
+                (void)vfo;
+                (void)ptt;
+                (void)arg;
                 return 0;
             };
-            int cb_result = shim_rig_set_ptt_callback(hamlib_instance_->my_rig, ppt_cb, NULL);
+            shim_rig_set_ptt_callback(hamlib_instance_->my_rig, ppt_cb, NULL);
             shim_rig_set_trn(hamlib_instance_->my_rig, SHIM_RIG_TRN_POLL);
             hamlib_instance_->rig_is_open = true;
         }
@@ -2170,7 +2176,7 @@ private:
 
 // Helper function to parse VFO parameter from JavaScript
 int parseVfoParameter(const Napi::CallbackInfo& info, int index, int defaultVfo = SHIM_RIG_VFO_CURR) {
-    if (info.Length() > index && info[index].IsString()) {
+    if (info.Length() > static_cast<size_t>(index) && info[index].IsString()) {
         std::string vfoStr = info[index].As<Napi::String>().Utf8Value();
         if (vfoStr == "VFO-A") {
             return SHIM_RIG_VFO_A;
@@ -2268,6 +2274,8 @@ NodeHamLib::NodeHamLib(const Napi::CallbackInfo & info): ObjectWrap(info) {
 
 // 析构函数 - 确保资源正确清理
 NodeHamLib::~NodeHamLib() {
+  StopSpectrumStreamInternal();
+
   // 如果rig指针存在，执行清理
   if (my_rig) {
     // 如果rig是打开状态，先关闭
@@ -2281,10 +2289,70 @@ NodeHamLib::~NodeHamLib() {
   }
 }
 
+int NodeHamLib::spectrum_line_cb(void* handle, const shim_spectrum_line_t* line, void* arg) {
+  (void)handle;
+  NodeHamLib* instance = static_cast<NodeHamLib*>(arg);
+  if (!instance || !line) {
+    return 0;
+  }
+  instance->EmitSpectrumLine(*line);
+  return 0;
+}
+
+void NodeHamLib::EmitSpectrumLine(const shim_spectrum_line_t& line) {
+  if (!spectrum_tsfn_) {
+    return;
+  }
+
+  auto* line_copy = new shim_spectrum_line_t(line);
+  napi_status status = spectrum_tsfn_.BlockingCall(
+    line_copy,
+    [](Napi::Env env, Napi::Function callback, shim_spectrum_line_t* data) {
+      Napi::Object lineObject = Napi::Object::New(env);
+      lineObject.Set("scopeId", Napi::Number::New(env, data->id));
+      lineObject.Set("dataLevelMin", Napi::Number::New(env, data->data_level_min));
+      lineObject.Set("dataLevelMax", Napi::Number::New(env, data->data_level_max));
+      lineObject.Set("signalStrengthMin", Napi::Number::New(env, data->signal_strength_min));
+      lineObject.Set("signalStrengthMax", Napi::Number::New(env, data->signal_strength_max));
+      lineObject.Set("mode", Napi::Number::New(env, data->spectrum_mode));
+      lineObject.Set("centerFreq", Napi::Number::New(env, data->center_freq));
+      lineObject.Set("spanHz", Napi::Number::New(env, data->span_freq));
+      lineObject.Set("lowEdgeFreq", Napi::Number::New(env, data->low_edge_freq));
+      lineObject.Set("highEdgeFreq", Napi::Number::New(env, data->high_edge_freq));
+      lineObject.Set("dataLength", Napi::Number::New(env, data->data_length));
+      lineObject.Set("timestamp", Napi::Number::New(env, static_cast<double>(std::chrono::duration_cast<std::chrono::milliseconds>(
+        std::chrono::system_clock::now().time_since_epoch()).count())));
+      lineObject.Set("data", Napi::Buffer<unsigned char>::Copy(env, data->data, static_cast<size_t>(data->data_length)));
+      callback.Call({ lineObject });
+      delete data;
+    });
+
+  if (status != napi_ok) {
+    delete line_copy;
+    return;
+  }
+}
+
+void NodeHamLib::StopSpectrumStreamInternal() {
+  std::lock_guard<std::mutex> lock(spectrum_mutex_);
+  if (spectrum_stream_running_) {
+    shim_rig_set_spectrum_callback(my_rig, nullptr, nullptr);
+    spectrum_stream_running_ = false;
+  }
+  if (spectrum_tsfn_) {
+    spectrum_tsfn_.Release();
+    spectrum_tsfn_ = Napi::ThreadSafeFunction();
+  }
+}
+
 int NodeHamLib::freq_change_cb(void *handle, int vfo, double freq, void* arg) {
+      (void)handle;
+      (void)vfo;
+      (void)freq;
       auto instance = static_cast<NodeHamLib*>(arg);
-      printf("Rig changed freq to %0.7f Hz\n", freq);
-      Napi::Env env = instance->m_currentInfo->Env();
+      if (!instance) {
+        return 0;
+      }
       //Napi::Function emit = instance->m_currentInfo[0].Get("emit").As<Napi::Function>();
 			// Napi::Function emit = instance->m_currentInfo[0]->This().As<Napi::Object>().Get("emit").As<Napi::Function>();
       //emit.Call(instance->m_currentInfo->This(), { Napi::String::New(env, "frequency_change"), Napi::Number::New(env, freq) });
@@ -2293,7 +2361,6 @@ int NodeHamLib::freq_change_cb(void *handle, int vfo, double freq, void* arg) {
         //auto fn = global.Get("process").As<Napi::Object>().Get("emit").As<Napi::Function>();
         //fn.Call({Napi::Number::New(env, freq)});
         return 0;
-  return 0;
 }
 
 Napi::Value NodeHamLib::Open(const Napi::CallbackInfo & info) {
@@ -2565,6 +2632,8 @@ Napi::Value NodeHamLib::Close(const Napi::CallbackInfo & info) {
       .ThrowAsJavaScriptException();
     return env.Null();
   }
+
+  StopSpectrumStreamInternal();
   
   CloseAsyncWorker* worker = new CloseAsyncWorker(env, this);
   worker->Queue();
@@ -2574,6 +2643,8 @@ Napi::Value NodeHamLib::Close(const Napi::CallbackInfo & info) {
 
 Napi::Value NodeHamLib::Destroy(const Napi::CallbackInfo & info) {
   Napi::Env env = info.Env();
+
+  StopSpectrumStreamInternal();
   
   DestroyAsyncWorker* worker = new DestroyAsyncWorker(env, this);
   worker->Queue();
@@ -2912,6 +2983,22 @@ Napi::Value NodeHamLib::SetLevel(const Napi::CallbackInfo & info) {
     levelType = SHIM_RIG_LEVEL_VOXDELAY;
   } else if (levelTypeStr == "ANTIVOX") {
     levelType = SHIM_RIG_LEVEL_ANTIVOX;
+  } else if (levelTypeStr == "SPECTRUM_MODE") {
+    levelType = SHIM_RIG_LEVEL_SPECTRUM_MODE;
+  } else if (levelTypeStr == "SPECTRUM_SPAN") {
+    levelType = SHIM_RIG_LEVEL_SPECTRUM_SPAN;
+  } else if (levelTypeStr == "SPECTRUM_EDGE_LOW") {
+    levelType = SHIM_RIG_LEVEL_SPECTRUM_EDGE_LOW;
+  } else if (levelTypeStr == "SPECTRUM_EDGE_HIGH") {
+    levelType = SHIM_RIG_LEVEL_SPECTRUM_EDGE_HIGH;
+  } else if (levelTypeStr == "SPECTRUM_SPEED") {
+    levelType = SHIM_RIG_LEVEL_SPECTRUM_SPEED;
+  } else if (levelTypeStr == "SPECTRUM_REF") {
+    levelType = SHIM_RIG_LEVEL_SPECTRUM_REF;
+  } else if (levelTypeStr == "SPECTRUM_AVG") {
+    levelType = SHIM_RIG_LEVEL_SPECTRUM_AVG;
+  } else if (levelTypeStr == "SPECTRUM_ATT") {
+    levelType = SHIM_RIG_LEVEL_SPECTRUM_ATT;
   } else {
     Napi::TypeError::New(env, "Invalid level type").ThrowAsJavaScriptException();
     return env.Null();
@@ -2962,6 +3049,8 @@ Napi::Value NodeHamLib::GetLevel(const Napi::CallbackInfo & info) {
     levelType = SHIM_RIG_LEVEL_RAWSTR;
   } else if (levelTypeStr == "RFPOWER_METER") {
     levelType = SHIM_RIG_LEVEL_RFPOWER_METER;
+  } else if (levelTypeStr == "RFPOWER_METER_WATTS") {
+    levelType = SHIM_RIG_LEVEL_RFPOWER_METER_WATTS;
   } else if (levelTypeStr == "COMP_METER") {
     levelType = SHIM_RIG_LEVEL_COMP_METER;
   } else if (levelTypeStr == "VD_METER") {
@@ -2970,6 +3059,50 @@ Napi::Value NodeHamLib::GetLevel(const Napi::CallbackInfo & info) {
     levelType = SHIM_RIG_LEVEL_ID_METER;
   } else if (levelTypeStr == "TEMP_METER") {
     levelType = SHIM_RIG_LEVEL_TEMP_METER;
+  } else if (levelTypeStr == "NR") {
+    levelType = SHIM_RIG_LEVEL_NR;
+  } else if (levelTypeStr == "AF") {
+    levelType = SHIM_RIG_LEVEL_AF;
+  } else if (levelTypeStr == "RF") {
+    levelType = SHIM_RIG_LEVEL_RF;
+  } else if (levelTypeStr == "SQL") {
+    levelType = SHIM_RIG_LEVEL_SQL;
+  } else if (levelTypeStr == "RFPOWER") {
+    levelType = SHIM_RIG_LEVEL_RFPOWER;
+  } else if (levelTypeStr == "MICGAIN") {
+    levelType = SHIM_RIG_LEVEL_MICGAIN;
+  } else if (levelTypeStr == "VOXDELAY") {
+    levelType = SHIM_RIG_LEVEL_VOXDELAY;
+  } else if (levelTypeStr == "PBT_IN") {
+    levelType = SHIM_RIG_LEVEL_PBT_IN;
+  } else if (levelTypeStr == "PBT_OUT") {
+    levelType = SHIM_RIG_LEVEL_PBT_OUT;
+  } else if (levelTypeStr == "CWPITCH") {
+    levelType = SHIM_RIG_LEVEL_CWPITCH;
+  } else if (levelTypeStr == "COMP") {
+    levelType = SHIM_RIG_LEVEL_COMP;
+  } else if (levelTypeStr == "AGC") {
+    levelType = SHIM_RIG_LEVEL_AGC;
+  } else if (levelTypeStr == "VOXGAIN") {
+    levelType = SHIM_RIG_LEVEL_VOXGAIN;
+  } else if (levelTypeStr == "ANTIVOX") {
+    levelType = SHIM_RIG_LEVEL_ANTIVOX;
+  } else if (levelTypeStr == "SPECTRUM_MODE") {
+    levelType = SHIM_RIG_LEVEL_SPECTRUM_MODE;
+  } else if (levelTypeStr == "SPECTRUM_SPAN") {
+    levelType = SHIM_RIG_LEVEL_SPECTRUM_SPAN;
+  } else if (levelTypeStr == "SPECTRUM_EDGE_LOW") {
+    levelType = SHIM_RIG_LEVEL_SPECTRUM_EDGE_LOW;
+  } else if (levelTypeStr == "SPECTRUM_EDGE_HIGH") {
+    levelType = SHIM_RIG_LEVEL_SPECTRUM_EDGE_HIGH;
+  } else if (levelTypeStr == "SPECTRUM_SPEED") {
+    levelType = SHIM_RIG_LEVEL_SPECTRUM_SPEED;
+  } else if (levelTypeStr == "SPECTRUM_REF") {
+    levelType = SHIM_RIG_LEVEL_SPECTRUM_REF;
+  } else if (levelTypeStr == "SPECTRUM_AVG") {
+    levelType = SHIM_RIG_LEVEL_SPECTRUM_AVG;
+  } else if (levelTypeStr == "SPECTRUM_ATT") {
+    levelType = SHIM_RIG_LEVEL_SPECTRUM_ATT;
   } else {
     Napi::TypeError::New(env, "Invalid level type").ThrowAsJavaScriptException();
     return env.Null();
@@ -3026,9 +3159,18 @@ Napi::Value NodeHamLib::GetSupportedLevels(const Napi::CallbackInfo & info) {
   if (levels & SHIM_RIG_LEVEL_SWR) levelArray[index++] = Napi::String::New(env, "SWR");
   if (levels & SHIM_RIG_LEVEL_ALC) levelArray[index++] = Napi::String::New(env, "ALC");
   if (levels & SHIM_RIG_LEVEL_RFPOWER_METER) levelArray[index++] = Napi::String::New(env, "RFPOWER_METER");
+  if (levels & SHIM_RIG_LEVEL_RFPOWER_METER_WATTS) levelArray[index++] = Napi::String::New(env, "RFPOWER_METER_WATTS");
   if (levels & SHIM_RIG_LEVEL_COMP_METER) levelArray[index++] = Napi::String::New(env, "COMP_METER");
   if (levels & SHIM_RIG_LEVEL_VD_METER) levelArray[index++] = Napi::String::New(env, "VD_METER");
   if (levels & SHIM_RIG_LEVEL_ID_METER) levelArray[index++] = Napi::String::New(env, "ID_METER");
+  if (levels & SHIM_RIG_LEVEL_SPECTRUM_MODE) levelArray[index++] = Napi::String::New(env, "SPECTRUM_MODE");
+  if (levels & SHIM_RIG_LEVEL_SPECTRUM_SPAN) levelArray[index++] = Napi::String::New(env, "SPECTRUM_SPAN");
+  if (levels & SHIM_RIG_LEVEL_SPECTRUM_EDGE_LOW) levelArray[index++] = Napi::String::New(env, "SPECTRUM_EDGE_LOW");
+  if (levels & SHIM_RIG_LEVEL_SPECTRUM_EDGE_HIGH) levelArray[index++] = Napi::String::New(env, "SPECTRUM_EDGE_HIGH");
+  if (levels & SHIM_RIG_LEVEL_SPECTRUM_SPEED) levelArray[index++] = Napi::String::New(env, "SPECTRUM_SPEED");
+  if (levels & SHIM_RIG_LEVEL_SPECTRUM_REF) levelArray[index++] = Napi::String::New(env, "SPECTRUM_REF");
+  if (levels & SHIM_RIG_LEVEL_SPECTRUM_AVG) levelArray[index++] = Napi::String::New(env, "SPECTRUM_AVG");
+  if (levels & SHIM_RIG_LEVEL_SPECTRUM_ATT) levelArray[index++] = Napi::String::New(env, "SPECTRUM_ATT");
   if (levels & SHIM_RIG_LEVEL_TEMP_METER) levelArray[index++] = Napi::String::New(env, "TEMP_METER");
   
   return levelArray;
@@ -3109,6 +3251,12 @@ Napi::Value NodeHamLib::SetFunction(const Napi::CallbackInfo & info) {
     funcType = SHIM_RIG_FUNC_RESUME;
   } else if (funcTypeStr == "TBURST") {
     funcType = SHIM_RIG_FUNC_TBURST;
+  } else if (funcTypeStr == "TRANSCEIVE") {
+    funcType = SHIM_RIG_FUNC_TRANSCEIVE;
+  } else if (funcTypeStr == "SPECTRUM") {
+    funcType = SHIM_RIG_FUNC_SPECTRUM;
+  } else if (funcTypeStr == "SPECTRUM_HOLD") {
+    funcType = SHIM_RIG_FUNC_SPECTRUM_HOLD;
   } else {
     Napi::TypeError::New(env, "Invalid function type").ThrowAsJavaScriptException();
     return env.Null();
@@ -3193,6 +3341,12 @@ Napi::Value NodeHamLib::GetFunction(const Napi::CallbackInfo & info) {
     funcType = SHIM_RIG_FUNC_RESUME;
   } else if (funcTypeStr == "TBURST") {
     funcType = SHIM_RIG_FUNC_TBURST;
+  } else if (funcTypeStr == "TRANSCEIVE") {
+    funcType = SHIM_RIG_FUNC_TRANSCEIVE;
+  } else if (funcTypeStr == "SPECTRUM") {
+    funcType = SHIM_RIG_FUNC_SPECTRUM;
+  } else if (funcTypeStr == "SPECTRUM_HOLD") {
+    funcType = SHIM_RIG_FUNC_SPECTRUM_HOLD;
   } else {
     Napi::TypeError::New(env, "Invalid function type").ThrowAsJavaScriptException();
     return env.Null();
@@ -3241,6 +3395,9 @@ Napi::Value NodeHamLib::GetSupportedFunctions(const Napi::CallbackInfo & info) {
   if (functions & SHIM_RIG_FUNC_SCOPE) funcArray[index++] = Napi::String::New(env, "SCOPE");
   if (functions & SHIM_RIG_FUNC_RESUME) funcArray[index++] = Napi::String::New(env, "RESUME");
   if (functions & SHIM_RIG_FUNC_TBURST) funcArray[index++] = Napi::String::New(env, "TBURST");
+  if (functions & SHIM_RIG_FUNC_TRANSCEIVE) funcArray[index++] = Napi::String::New(env, "TRANSCEIVE");
+  if (functions & SHIM_RIG_FUNC_SPECTRUM) funcArray[index++] = Napi::String::New(env, "SPECTRUM");
+  if (functions & SHIM_RIG_FUNC_SPECTRUM_HOLD) funcArray[index++] = Napi::String::New(env, "SPECTRUM_HOLD");
   
   return funcArray;
 }
@@ -3727,9 +3884,12 @@ Napi::Function NodeHamLib::GetClass(Napi::Env env) {
       // VFO Info (Hamlib >= 4.7.0)
       NodeHamLib::InstanceMethod("getVfoInfo", & NodeHamLib::GetVfoInfo),
 
-      // Rig Info / Raw / Conf (async)
+      // Rig Info / Spectrum / Conf (async)
       NodeHamLib::InstanceMethod("getInfo", & NodeHamLib::GetInfo),
       NodeHamLib::InstanceMethod("sendRaw", & NodeHamLib::SendRaw),
+      NodeHamLib::InstanceMethod("getSpectrumCapabilities", & NodeHamLib::GetSpectrumCapabilities),
+      NodeHamLib::InstanceMethod("startSpectrumStream", & NodeHamLib::StartSpectrumStream),
+      NodeHamLib::InstanceMethod("stopSpectrumStream", & NodeHamLib::StopSpectrumStream),
       NodeHamLib::InstanceMethod("setConf", & NodeHamLib::SetConf),
       NodeHamLib::InstanceMethod("getConf", & NodeHamLib::GetConf),
 
@@ -5806,6 +5966,55 @@ Napi::Value NodeHamLib::SendRaw(const Napi::CallbackInfo& info) {
   return asyncWorker->GetPromise();
 }
 
+Napi::Value NodeHamLib::GetSpectrumCapabilities(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::Object result = Napi::Object::New(env);
+
+  result.Set("asyncDataSupported", env.Undefined());
+  result.Set("scopes", Napi::Array::New(env));
+  result.Set("modes", Napi::Array::New(env));
+  result.Set("spans", Napi::Array::New(env));
+  result.Set("avgModes", Napi::Array::New(env));
+
+  return result;
+}
+
+Napi::Value NodeHamLib::StartSpectrumStream(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (!rig_is_open) {
+    Napi::TypeError::New(env, "Rig is not open!").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  if (info.Length() < 1 || !info[0].IsFunction()) {
+    Napi::TypeError::New(env, "Expected (callback: Function)").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  std::lock_guard<std::mutex> lock(spectrum_mutex_);
+  if (spectrum_stream_running_) {
+    Napi::Error::New(env, "Spectrum stream is already running").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  Napi::Function callback = info[0].As<Napi::Function>();
+  spectrum_tsfn_ = Napi::ThreadSafeFunction::New(env, callback, "HamLibSpectrumStream", 0, 1);
+  int ret = shim_rig_set_spectrum_callback(my_rig, &NodeHamLib::spectrum_line_cb, this);
+  if (ret != SHIM_RIG_OK) {
+    spectrum_tsfn_.Release();
+    spectrum_tsfn_ = Napi::ThreadSafeFunction();
+    Napi::Error::New(env, shim_rigerror(ret)).ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  spectrum_stream_running_ = true;
+  return Napi::Boolean::New(env, true);
+}
+
+Napi::Value NodeHamLib::StopSpectrumStream(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  StopSpectrumStreamInternal();
+  return Napi::Boolean::New(env, true);
+}
+
 // ===== SetConf (async) =====
 
 class SetConfAsyncWorker : public HamLibAsyncWorker {

package/src/hamlib.h

@@ -4,6 +4,10 @@
 #include "shim/hamlib_shim.h"
 #include <memory>
 #include <string>
+#include <atomic>
+#include <mutex>
+#include <vector>
+#include <cstdint>
 
 // Forward declaration
 class NodeHamLib;
@@ -173,6 +177,9 @@ class NodeHamLib : public Napi::ObjectWrap<NodeHamLib> {
   // Rig Info / Raw / Conf (async)
   Napi::Value GetInfo(const Napi::CallbackInfo&);
   Napi::Value SendRaw(const Napi::CallbackInfo&);
+  Napi::Value GetSpectrumCapabilities(const Napi::CallbackInfo&);
+  Napi::Value StartSpectrumStream(const Napi::CallbackInfo&);
+  Napi::Value StopSpectrumStream(const Napi::CallbackInfo&);
   Napi::Value SetConf(const Napi::CallbackInfo&);
   Napi::Value GetConf(const Napi::CallbackInfo&);
 
@@ -217,6 +224,7 @@ class NodeHamLib : public Napi::ObjectWrap<NodeHamLib> {
 
   // Frequency change callback (uses basic C types via shim)
   static int freq_change_cb(void* handle, int vfo, double freq, void* arg);
+  static int spectrum_line_cb(void* handle, const shim_spectrum_line_t* line, void* arg);
 
  public:
   hamlib_shim_handle_t my_rig;  // Opaque handle instead of RIG*
@@ -234,4 +242,10 @@ class NodeHamLib : public Napi::ObjectWrap<NodeHamLib> {
 
   // Static callback helper for shim_rig_list_foreach
   static int rig_list_callback(const shim_rig_info_t* info, void* data);
+
+  void EmitSpectrumLine(const shim_spectrum_line_t& line);
+  void StopSpectrumStreamInternal();
+  std::atomic<bool> spectrum_stream_running_{false};
+  Napi::ThreadSafeFunction spectrum_tsfn_;
+  std::mutex spectrum_mutex_;
 };