wsjtx-lib 1.0.2 → 1.0.4

package/dist/test/wsjtx.basic.test.cjs

@@ -0,0 +1,759 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// test/wsjtx.basic.test.ts
+var import_node_test = require("test");
+var import_node_assert = __toESM(require("assert"), 1);
+
+// src/types.ts
+var WSJTXMode = /* @__PURE__ */ ((WSJTXMode2) => {
+  WSJTXMode2[WSJTXMode2["FT8"] = 0] = "FT8";
+  WSJTXMode2[WSJTXMode2["FT4"] = 1] = "FT4";
+  WSJTXMode2[WSJTXMode2["JT4"] = 2] = "JT4";
+  WSJTXMode2[WSJTXMode2["JT65"] = 3] = "JT65";
+  WSJTXMode2[WSJTXMode2["JT9"] = 4] = "JT9";
+  WSJTXMode2[WSJTXMode2["FST4"] = 5] = "FST4";
+  WSJTXMode2[WSJTXMode2["Q65"] = 6] = "Q65";
+  WSJTXMode2[WSJTXMode2["FST4W"] = 7] = "FST4W";
+  WSJTXMode2[WSJTXMode2["WSPR"] = 8] = "WSPR";
+  return WSJTXMode2;
+})(WSJTXMode || {});
+var WSJTXError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "WSJTXError";
+  }
+};
+
+// src/index.ts
+var import_node_module = require("module");
+var import_node_url = require("url");
+var import_node_path = __toESM(require("path"), 1);
+var import_node_fs = __toESM(require("fs"), 1);
+var import_meta = {};
+function getModuleContext() {
+  try {
+    if (typeof import_meta !== "undefined" && import_meta.url) {
+      return {
+        require: (0, import_node_module.createRequire)(import_meta.url),
+        __filename: (0, import_node_url.fileURLToPath)(import_meta.url),
+        __dirname: import_node_path.default.dirname((0, import_node_url.fileURLToPath)(import_meta.url))
+      };
+    }
+  } catch {
+  }
+  return {
+    require: typeof require2 !== "undefined" ? require2 : (0, import_node_module.createRequire)("file://"),
+    __filename: typeof __filename !== "undefined" ? __filename : "",
+    __dirname: typeof __dirname !== "undefined" ? __dirname : ""
+  };
+}
+var moduleContext = getModuleContext();
+var { require: require2, __filename, __dirname } = moduleContext;
+function findNativeModule() {
+  const platform = process.platform;
+  const arch = process.arch;
+  const isPkgEnvironment = !!process.pkg || __dirname.includes("/snapshot/") || __dirname.includes("\\snapshot\\");
+  if (isPkgEnvironment) {
+    console.log("Detected pkg packaged environment");
+    const execDir = import_node_path.default.dirname(process.execPath);
+    const pkgPaths = [
+      // 1. 与可执行文件同目录（最常见的打包方式）
+      import_node_path.default.join(execDir, "wsjtx_lib_nodejs.node"),
+      import_node_path.default.join(execDir, `wsjtx_lib_nodejs-${platform}-${arch}.node`),
+      // 2. prebuilds 子目录（保持结构的打包方式）
+      import_node_path.default.join(execDir, "prebuilds", `${platform}-${arch}`, "wsjtx_lib_nodejs.node"),
+      // 3. 相对于可执行文件的其他可能位置
+      import_node_path.default.join(execDir, "..", "prebuilds", `${platform}-${arch}`, "wsjtx_lib_nodejs.node"),
+      import_node_path.default.join(execDir, "lib", "wsjtx_lib_nodejs.node"),
+      import_node_path.default.join(execDir, "native", "wsjtx_lib_nodejs.node")
+    ];
+    console.log("PKG environment - searching for native module:");
+    pkgPaths.forEach((p) => console.log(`  - ${p}`));
+    for (const modulePath of pkgPaths) {
+      if (import_node_fs.default.existsSync(modulePath)) {
+        console.log(`Found native module at: ${modulePath}`);
+        return modulePath;
+      }
+    }
+    const pathList2 = pkgPaths.map((p) => `  - ${p}`).join("\n");
+    throw new Error(
+      `Native module not found in pkg packaged environment for ${platform}-${arch}.
+Searched in:
+${pathList2}
+
+Solutions:
+1. Ensure the native module is included in your pkg configuration
+2. Copy wsjtx_lib_nodejs.node to the same directory as your executable
+3. Check if the native module was properly bundled during packaging`
+    );
+  }
+  const moduleRoot = import_node_path.default.resolve(__dirname, "..");
+  const possiblePaths = [
+    // 1. Prebuilt binaries (npm packages) - highest priority
+    import_node_path.default.join(moduleRoot, "prebuilds", `${platform}-${arch}`, "wsjtx_lib_nodejs.node"),
+    // 2. GitHub Actions legacy format (for backward compatibility)
+    import_node_path.default.join(moduleRoot, "prebuilds", `${platform}-latest-${arch}`, "wsjtx_lib_nodejs.node"),
+    import_node_path.default.join(moduleRoot, "prebuilds", `ubuntu-latest-${arch}`, "wsjtx_lib_nodejs.node"),
+    // Linux
+    import_node_path.default.join(moduleRoot, "prebuilds", `macos-latest-${arch}`, "wsjtx_lib_nodejs.node"),
+    // macOS  
+    import_node_path.default.join(moduleRoot, "prebuilds", `windows-latest-${arch}`, "wsjtx_lib_nodejs.node"),
+    // Windows
+    // 3. Local development builds - third priority
+    import_node_path.default.join(moduleRoot, "build", "wsjtx_lib_nodejs.node"),
+    import_node_path.default.join(moduleRoot, "build", "Release", "wsjtx_lib_nodejs.node")
+  ];
+  console.log("Normal environment - searching for native module:");
+  possiblePaths.forEach((p) => console.log(`  - ${p}`));
+  for (const modulePath of possiblePaths) {
+    if (import_node_fs.default.existsSync(modulePath)) {
+      console.log(`Found native module at: ${modulePath}`);
+      return modulePath;
+    }
+  }
+  const pathList = possiblePaths.map((p) => `  - ${p}`).join("\n");
+  throw new Error(
+    `Native module not found for ${platform}-${arch}.
+Searched in:
+${pathList}
+
+Solutions:
+1. If you installed via npm, this may be a missing prebuilt binary
+2. For development, run "npm run build" to compile the native module
+3. Check if your platform/architecture is supported`
+  );
+}
+var nativeModulePath = findNativeModule();
+var { WSJTXLib: NativeWSJTXLib } = require2(nativeModulePath);
+var WSJTXLib = class _WSJTXLib {
+  native;
+  config;
+  /**
+   * Create a new WSJTX library instance
+   * 
+   * @param config Optional configuration options
+   * @throws {WSJTXError} If the native library fails to initialize
+   */
+  constructor(config = {}) {
+    this.config = {
+      maxThreads: 4,
+      debug: false,
+      ...config
+    };
+    try {
+      this.native = new NativeWSJTXLib();
+    } catch (error) {
+      throw new WSJTXError(
+        `Failed to initialize WSJTX library: ${error instanceof Error ? error.message : String(error)}`,
+        "INIT_ERROR"
+      );
+    }
+  }
+  /**
+   * Decode digital radio signals from audio data
+   * 
+   * This method processes audio samples and attempts to decode digital
+   * messages using the specified protocol mode. The operation is performed
+   * asynchronously to avoid blocking the Node.js event loop.
+   * 
+   * @param mode The digital mode to use for decoding
+   * @param audioData Audio samples (Float32Array or Int16Array)
+   * @param frequency Center frequency in Hz
+   * @param threads Number of threads to use (1-16, default: 4)
+   * @returns Promise that resolves when decoding is complete
+   * 
+   * @throws {WSJTXError} If parameters are invalid or decoding fails
+   * 
+   * @example
+   * ```typescript
+   * const audioData = new Float32Array(48000 * 13); // 13 seconds
+   * await lib.decode(WSJTXMode.FT8, audioData, 1500);
+   * const messages = lib.pullMessages();
+   * ```
+   */
+  async decode(mode, audioData, frequency, threads = this.config.maxThreads || 4) {
+    this.validateMode(mode);
+    this.validateFrequency(frequency);
+    this.validateThreads(threads);
+    this.validateAudioData(audioData);
+    if (!this.isDecodingSupported(mode)) {
+      throw new WSJTXError(`Decoding not supported for mode: ${WSJTXMode[mode]}`, "UNSUPPORTED_MODE");
+    }
+    return new Promise((resolve, reject) => {
+      const callback = (error, result) => {
+        if (error) {
+          reject(new WSJTXError(error.message, "DECODE_ERROR"));
+        } else {
+          resolve({ success: result });
+        }
+      };
+      try {
+        this.native.decode(mode, audioData, frequency, threads, callback);
+      } catch (error) {
+        reject(new WSJTXError(
+          `Decode operation failed: ${error instanceof Error ? error.message : String(error)}`,
+          "DECODE_ERROR"
+        ));
+      }
+    });
+  }
+  /**
+   * Encode a message into audio waveform for transmission
+   * 
+   * Generates the audio waveform that represents the specified message
+   * using the given digital mode. The resulting audio can be fed to
+   * a radio transmitter or audio interface.
+   * 
+   * @param mode The digital mode to use for encoding
+   * @param message The message text to encode (mode-specific format)
+   * @param frequency Center frequency in Hz
+   * @param threads Number of threads to use (1-16, default: 4)
+   * @returns Promise that resolves with encoded audio data and actual message sent
+   * 
+   * @throws {WSJTXError} If parameters are invalid or encoding fails
+   * 
+   * @example
+   * ```typescript
+   * const result = await lib.encode(WSJTXMode.FT8, 'CQ DX K1ABC FN20', 1500);
+   * console.log('Generated audio samples:', result.audioData.length);
+   * console.log('Actual message sent:', result.messageSent);
+   * ```
+   */
+  async encode(mode, message, frequency, threads = this.config.maxThreads || 4) {
+    this.validateMode(mode);
+    this.validateMessage(message);
+    this.validateFrequency(frequency);
+    this.validateThreads(threads);
+    if (!this.isEncodingSupported(mode)) {
+      throw new WSJTXError(`Encoding not supported for mode: ${WSJTXMode[mode]}`, "UNSUPPORTED_MODE");
+    }
+    return new Promise((resolve, reject) => {
+      const callback = (error, result) => {
+        if (error) {
+          reject(new WSJTXError(error.message, "ENCODE_ERROR"));
+        } else {
+          resolve(result);
+        }
+      };
+      try {
+        this.native.encode(mode, message, frequency, threads, callback);
+      } catch (error) {
+        reject(new WSJTXError(
+          `Encode operation failed: ${error instanceof Error ? error.message : String(error)}`,
+          "ENCODE_ERROR"
+        ));
+      }
+    });
+  }
+  /**
+   * Decode WSPR signals from IQ data
+   * 
+   * WSPR (Weak Signal Propagation Reporter) is a specialized protocol
+   * for studying radio propagation. This method takes IQ (complex)
+   * samples and attempts to decode WSPR transmissions.
+   * 
+   * @param iqData Interleaved I,Q samples as Float32Array
+   * @param options Decoder options (frequency, callsign, etc.)
+   * @returns Promise that resolves with array of decoded WSPR results
+   * 
+   * @throws {WSJTXError} If parameters are invalid or decoding fails
+   * 
+   * @example
+   * ```typescript
+   * const iqData = new Float32Array(2 * 12000 * 111); // 2 minutes of IQ data
+   * const options = {
+   *   dialFrequency: 14095600, // 20m WSPR frequency
+   *   callsign: 'K1ABC',
+   *   locator: 'FN20'
+   * };
+   * const results = await lib.decodeWSPR(iqData, options);
+   * ```
+   */
+  async decodeWSPR(iqData, options = {}) {
+    this.validateIQData(iqData);
+    const defaultOptions = {
+      dialFrequency: 14095600,
+      // 20m WSPR frequency
+      callsign: "",
+      locator: "",
+      quickMode: false,
+      useHashTable: true,
+      passes: 2,
+      subtraction: true,
+      ...options
+    };
+    return new Promise((resolve, reject) => {
+      const callback = (error, results) => {
+        if (error) {
+          reject(new WSJTXError(error.message, "WSPR_DECODE_ERROR"));
+        } else {
+          resolve(results);
+        }
+      };
+      try {
+        this.native.decodeWSPR(iqData, defaultOptions, callback);
+      } catch (error) {
+        reject(new WSJTXError(
+          `WSPR decode failed: ${error instanceof Error ? error.message : String(error)}`,
+          "WSPR_DECODE_ERROR"
+        ));
+      }
+    });
+  }
+  /**
+   * Retrieve decoded messages from the internal queue
+   * 
+   * Messages are added to an internal queue as they are decoded.
+   * This method retrieves and removes all pending messages from the queue.
+   * 
+   * @returns Array of decoded messages
+   * 
+   * @example
+   * ```typescript
+   * const messages = lib.pullMessages();
+   * messages.forEach(msg => {
+   *   console.log(`${msg.text} (SNR: ${msg.snr} dB, ΔT: ${msg.deltaTime}s)`);
+   * });
+   * ```
+   */
+  pullMessages() {
+    try {
+      return this.native.pullMessages();
+    } catch (error) {
+      throw new WSJTXError(
+        `Failed to pull messages: ${error instanceof Error ? error.message : String(error)}`,
+        "PULL_ERROR"
+      );
+    }
+  }
+  /**
+   * Check if encoding is supported for a specific mode
+   * 
+   * @param mode The mode to check
+   * @returns True if encoding is supported
+   */
+  isEncodingSupported(mode) {
+    return this.native.isEncodingSupported(mode);
+  }
+  /**
+   * Check if decoding is supported for a specific mode
+   * 
+   * @param mode The mode to check
+   * @returns True if decoding is supported
+   */
+  isDecodingSupported(mode) {
+    return this.native.isDecodingSupported(mode);
+  }
+  /**
+   * Get the required sample rate for a specific mode
+   * 
+   * @param mode The mode to query
+   * @returns Sample rate in Hz
+   */
+  getSampleRate(mode) {
+    return this.native.getSampleRate(mode);
+  }
+  /**
+   * Get the transmission duration for a specific mode
+   * 
+   * @param mode The mode to query
+   * @returns Duration in seconds
+   */
+  getTransmissionDuration(mode) {
+    return this.native.getTransmissionDuration(mode);
+  }
+  /**
+   * Get capabilities for all supported modes
+   * 
+   * @returns Array of mode capability information
+   */
+  getAllModeCapabilities() {
+    const modes = Object.values(WSJTXMode).filter((v) => typeof v === "number");
+    return modes.map((mode) => ({
+      mode,
+      encodingSupported: this.isEncodingSupported(mode),
+      decodingSupported: this.isDecodingSupported(mode),
+      sampleRate: this.getSampleRate(mode),
+      duration: this.getTransmissionDuration(mode)
+    }));
+  }
+  /**
+   * Convert audio format between Float32Array and Int16Array
+   * 
+   * @param audioData Input audio data
+   * @param targetFormat Target format ('float32' or 'int16')
+   * @returns Converted audio data
+   */
+  static convertAudioFormat(audioData, targetFormat) {
+    if (targetFormat !== "float32" && targetFormat !== "int16") {
+      throw new Error(`Invalid target format: ${targetFormat}. Must be 'float32' or 'int16'`);
+    }
+    if (targetFormat === "float32") {
+      if (audioData instanceof Float32Array) {
+        return audioData;
+      }
+      const result = new Float32Array(audioData.length);
+      for (let i = 0; i < audioData.length; i++) {
+        result[i] = audioData[i] / 32768;
+      }
+      return result;
+    } else {
+      if (audioData instanceof Int16Array) {
+        return audioData;
+      }
+      const result = new Int16Array(audioData.length);
+      for (let i = 0; i < audioData.length; i++) {
+        result[i] = Math.max(-32768, Math.min(32767, Math.round(audioData[i] * 32768)));
+      }
+      return result;
+    }
+  }
+  /**
+   * Static convenience helper for async audio format conversion.
+   */
+  static async convertAudioFormatAsync(audioData, targetFormat) {
+    const lib = new _WSJTXLib();
+    return lib.convertAudioFormatAsync(audioData, targetFormat);
+  }
+  /**
+   * Asynchronously convert audio data format without blocking the event loop
+   *
+   * Uses native thread pool to offload conversion.
+   */
+  async convertAudioFormatAsync(audioData, targetFormat) {
+    if (targetFormat !== "float32" && targetFormat !== "int16") {
+      throw new Error(`Invalid target format: ${targetFormat}. Must be 'float32' or 'int16'`);
+    }
+    this.validateAudioData(audioData);
+    return new Promise((resolve, reject) => {
+      const callback = (error, result) => {
+        if (error) {
+          reject(new WSJTXError(error.message ?? String(error), "CONVERT_ERROR"));
+        } else {
+          resolve(result);
+        }
+      };
+      try {
+        this.native.convertAudioAsync(audioData, targetFormat, callback);
+      } catch (error) {
+        reject(new WSJTXError(
+          `Convert operation failed: ${error instanceof Error ? error.message : String(error)}`,
+          "CONVERT_ERROR"
+        ));
+      }
+    });
+  }
+  // Validation methods
+  validateMode(mode) {
+    if (!Object.values(WSJTXMode).includes(mode)) {
+      throw new WSJTXError(`Invalid mode: ${mode}`, "INVALID_MODE");
+    }
+  }
+  validateFrequency(frequency) {
+    if (!Number.isInteger(frequency) || frequency < 0 || frequency > 3e7) {
+      throw new WSJTXError(
+        `Invalid frequency: ${frequency}. Must be between 0 and 30,000,000 Hz`,
+        "INVALID_FREQUENCY"
+      );
+    }
+  }
+  validateThreads(threads) {
+    if (!Number.isInteger(threads) || threads < 1 || threads > 16) {
+      throw new WSJTXError(
+        `Invalid thread count: ${threads}. Must be between 1 and 16`,
+        "INVALID_THREADS"
+      );
+    }
+  }
+  validateMessage(message) {
+    if (typeof message !== "string" || message.length === 0 || message.length > 22) {
+      throw new WSJTXError(
+        `Invalid message: "${message}". Must be 1-22 characters long`,
+        "INVALID_MESSAGE"
+      );
+    }
+  }
+  validateAudioData(audioData) {
+    if (!(audioData instanceof Float32Array) && !(audioData instanceof Int16Array)) {
+      throw new WSJTXError(
+        "Invalid audio data: must be Float32Array or Int16Array",
+        "INVALID_AUDIO_DATA"
+      );
+    }
+    if (audioData.length === 0) {
+      throw new WSJTXError("Audio data cannot be empty", "INVALID_AUDIO_DATA");
+    }
+  }
+  validateIQData(iqData) {
+    if (!(iqData instanceof Float32Array)) {
+      throw new WSJTXError(
+        "Invalid IQ data: must be Float32Array with interleaved I,Q samples",
+        "INVALID_IQ_DATA"
+      );
+    }
+    if (iqData.length === 0 || iqData.length % 2 !== 0) {
+      throw new WSJTXError(
+        "IQ data length must be even (interleaved I,Q samples)",
+        "INVALID_IQ_DATA"
+      );
+    }
+  }
+};
+
+// test/wsjtx.basic.test.ts
+(0, import_node_test.describe)("WSJTX Library Basic Tests", () => {
+  let lib;
+  (0, import_node_test.beforeEach)(() => {
+    lib = new WSJTXLib({
+      maxThreads: 4,
+      debug: true
+    });
+  });
+  (0, import_node_test.afterEach)(() => {
+  });
+  (0, import_node_test.describe)("Basic Functionality Tests", () => {
+    (0, import_node_test.it)("should create library instance", () => {
+      import_node_assert.default.ok(lib instanceof WSJTXLib);
+    });
+    (0, import_node_test.it)("should support custom configuration", () => {
+      const customLib = new WSJTXLib({
+        maxThreads: 8,
+        debug: false
+      });
+      import_node_assert.default.ok(customLib instanceof WSJTXLib);
+    });
+    (0, import_node_test.it)("should return correct FT8 sample rate", () => {
+      const sampleRate = lib.getSampleRate(0 /* FT8 */);
+      import_node_assert.default.strictEqual(sampleRate, 48e3);
+    });
+    (0, import_node_test.it)("should return correct FT8 transmission duration", () => {
+      const duration = lib.getTransmissionDuration(0 /* FT8 */);
+      import_node_assert.default.ok(Math.abs(duration - 12.64) < 0.1);
+    });
+    (0, import_node_test.it)("should correctly check encoding support", () => {
+      import_node_assert.default.strictEqual(lib.isEncodingSupported(0 /* FT8 */), true);
+      import_node_assert.default.strictEqual(lib.isDecodingSupported(0 /* FT8 */), true);
+    });
+    (0, import_node_test.it)("should return all mode capabilities", () => {
+      const capabilities = lib.getAllModeCapabilities();
+      import_node_assert.default.ok(capabilities.length > 0);
+      import_node_assert.default.ok("mode" in capabilities[0]);
+      import_node_assert.default.ok("encodingSupported" in capabilities[0]);
+      import_node_assert.default.ok("decodingSupported" in capabilities[0]);
+      import_node_assert.default.ok("sampleRate" in capabilities[0]);
+      import_node_assert.default.ok("duration" in capabilities[0]);
+    });
+  });
+  (0, import_node_test.describe)("Parameter Validation Tests", () => {
+    (0, import_node_test.it)("should validate mode parameter", async () => {
+      const audioData = new Float32Array(1e3);
+      await import_node_assert.default.rejects(
+        lib.decode(999, audioData, 1e3),
+        WSJTXError
+      );
+    });
+    (0, import_node_test.it)("should validate frequency parameter", async () => {
+      const audioData = new Float32Array(1e3);
+      await import_node_assert.default.rejects(
+        lib.decode(0 /* FT8 */, audioData, -1e3),
+        WSJTXError
+      );
+    });
+    (0, import_node_test.it)("should validate audio data parameter", async () => {
+      await import_node_assert.default.rejects(
+        lib.decode(0 /* FT8 */, new Float32Array(0), 1e3),
+        WSJTXError
+      );
+    });
+    (0, import_node_test.it)("should validate message parameter", async () => {
+      await import_node_assert.default.rejects(
+        lib.encode(0 /* FT8 */, "", 1e3),
+        WSJTXError
+      );
+      await import_node_assert.default.rejects(
+        lib.encode(0 /* FT8 */, "x".repeat(30), 1e3),
+        WSJTXError
+      );
+    });
+  });
+  (0, import_node_test.describe)("Message Queue Tests", () => {
+    (0, import_node_test.it)("should pull messages from queue", () => {
+      const messages = lib.pullMessages();
+      import_node_assert.default.ok(Array.isArray(messages));
+    });
+    (0, import_node_test.it)("should clear message queue", () => {
+      lib.pullMessages();
+      const messages = lib.pullMessages();
+      import_node_assert.default.strictEqual(messages.length, 0);
+    });
+  });
+  (0, import_node_test.describe)("Audio Format Conversion Tests", () => {
+    (0, import_node_test.it)("should convert Float32Array to Int16Array", () => {
+      const floatData = new Float32Array([0, 0.5, -0.5, 1, -1]);
+      const intData = WSJTXLib.convertAudioFormat(floatData, "int16");
+      import_node_assert.default.ok(intData instanceof Int16Array);
+      import_node_assert.default.strictEqual(intData.length, floatData.length);
+      import_node_assert.default.strictEqual(intData[0], 0);
+      import_node_assert.default.ok(Math.abs(intData[1] - 16384) < 10);
+      import_node_assert.default.ok(Math.abs(intData[2] + 16384) < 10);
+      import_node_assert.default.ok(Math.abs(intData[3] - 32767) < 10);
+      import_node_assert.default.ok(Math.abs(intData[4] + 32767) < 10);
+    });
+    (0, import_node_test.it)("should convert Int16Array to Float32Array", () => {
+      const intData = new Int16Array([0, 16384, -16384, 32767, -32767]);
+      const floatData = WSJTXLib.convertAudioFormat(intData, "float32");
+      import_node_assert.default.ok(floatData instanceof Float32Array);
+      import_node_assert.default.strictEqual(floatData.length, intData.length);
+      import_node_assert.default.ok(Math.abs(floatData[0] - 0) < 1e-3);
+      import_node_assert.default.ok(Math.abs(floatData[1] - 0.5) < 1e-3);
+      import_node_assert.default.ok(Math.abs(floatData[2] + 0.5) < 1e-3);
+      import_node_assert.default.ok(Math.abs(floatData[3] - 1) < 1e-3);
+      import_node_assert.default.ok(Math.abs(floatData[4] + 1) < 1e-3);
+    });
+    (0, import_node_test.it)("should handle edge cases in conversion", () => {
+      const emptyFloat = new Float32Array(0);
+      const emptyInt = WSJTXLib.convertAudioFormat(emptyFloat, "int16");
+      import_node_assert.default.strictEqual(emptyInt.length, 0);
+      const emptyInt16 = new Int16Array(0);
+      const emptyFloat32 = WSJTXLib.convertAudioFormat(emptyInt16, "float32");
+      import_node_assert.default.strictEqual(emptyFloat32.length, 0);
+    });
+    (0, import_node_test.it)("should maintain precision in round-trip conversion", () => {
+      const originalData = new Float32Array(1e3);
+      for (let i = 0; i < originalData.length; i++) {
+        originalData[i] = (Math.random() - 0.5) * 2;
+      }
+      const intData = WSJTXLib.convertAudioFormat(originalData, "int16");
+      const convertedData = WSJTXLib.convertAudioFormat(intData, "float32");
+      let maxError = 0;
+      for (let i = 0; i < originalData.length; i++) {
+        const error = Math.abs(originalData[i] - convertedData[i]);
+        maxError = Math.max(maxError, error);
+      }
+      import_node_assert.default.ok(maxError < 1e-3);
+    });
+    (0, import_node_test.it)("should handle invalid format parameter", () => {
+      const floatData = new Float32Array([0.5]);
+      import_node_assert.default.throws(() => {
+        WSJTXLib.convertAudioFormat(floatData, "invalid");
+      });
+    });
+  });
+  (0, import_node_test.describe)("TypeScript Type Safety Tests", () => {
+    (0, import_node_test.it)("should provide complete type support for basic types", () => {
+      const capabilities = lib.getAllModeCapabilities();
+      import_node_assert.default.ok(capabilities.length > 0);
+      capabilities.forEach((cap) => {
+        const modeName = WSJTXMode[cap.mode];
+        import_node_assert.default.strictEqual(typeof modeName, "string");
+        import_node_assert.default.strictEqual(typeof cap.sampleRate, "number");
+        import_node_assert.default.strictEqual(typeof cap.duration, "number");
+        import_node_assert.default.strictEqual(typeof cap.encodingSupported, "boolean");
+        import_node_assert.default.strictEqual(typeof cap.decodingSupported, "boolean");
+      });
+    });
+    (0, import_node_test.it)("should provide type-safe message objects", () => {
+      const messages = lib.pullMessages();
+      messages.forEach((msg) => {
+        import_node_assert.default.strictEqual(typeof msg.text, "string");
+        import_node_assert.default.strictEqual(typeof msg.snr, "number");
+        import_node_assert.default.strictEqual(typeof msg.deltaTime, "number");
+        import_node_assert.default.strictEqual(typeof msg.deltaFrequency, "number");
+      });
+    });
+    (0, import_node_test.it)("should enforce enum constraints", () => {
+      const validMode = 0 /* FT8 */;
+      import_node_assert.default.strictEqual(typeof validMode, "number");
+      import_node_assert.default.ok(validMode >= 0);
+    });
+  });
+  (0, import_node_test.describe)("Error Handling Tests", () => {
+    (0, import_node_test.it)("should throw WSJTXError for invalid operations (non-encode/decode)", async () => {
+      try {
+        await lib.decode(999, new Float32Array(1e3), 1e3);
+        import_node_assert.default.fail("Should have thrown WSJTXError for invalid mode");
+      } catch (error) {
+        import_node_assert.default.ok(error instanceof WSJTXError);
+        import_node_assert.default.strictEqual(typeof error.message, "string");
+        if (error instanceof WSJTXError) {
+          import_node_assert.default.strictEqual(typeof error.code, "string");
+        }
+      }
+    });
+    (0, import_node_test.it)("should provide meaningful error messages for basic errors", async () => {
+      try {
+        await lib.encode(0 /* FT8 */, "", 1e3);
+        import_node_assert.default.fail("Should have thrown WSJTXError for empty message");
+      } catch (error) {
+        import_node_assert.default.ok(error instanceof WSJTXError);
+        import_node_assert.default.ok(error.message.length > 0);
+        if (error instanceof WSJTXError && error.code) {
+          import_node_assert.default.ok(error.code.length > 0);
+        }
+      }
+    });
+    (0, import_node_test.it)("should validate all error codes are strings for basic errors", async () => {
+      const testCases = [
+        () => lib.decode(999, new Float32Array(1e3), 1e3),
+        // Invalid mode
+        () => lib.decode(0 /* FT8 */, new Float32Array(1e3), -1e3),
+        // Invalid frequency
+        () => lib.decode(0 /* FT8 */, new Float32Array(0), 1e3),
+        // Invalid audio data
+        () => lib.encode(0 /* FT8 */, "", 1e3),
+        // Empty message
+        () => lib.encode(0 /* FT8 */, "x".repeat(50), 1e3)
+        // Message too long
+      ];
+      for (const testCase of testCases) {
+        try {
+          await testCase();
+          import_node_assert.default.fail("Should have thrown WSJTXError");
+        } catch (error) {
+          import_node_assert.default.ok(error instanceof WSJTXError);
+          if (error instanceof WSJTXError && error.code) {
+            import_node_assert.default.strictEqual(typeof error.code, "string");
+            import_node_assert.default.ok(error.code.length > 0);
+          }
+        }
+      }
+    });
+  });
+});
+/**
+ * WSJTX Digital Radio Protocol Library for Node.js
+ * 
+ * This library provides encoding and decoding capabilities for various
+ * digital amateur radio protocols including FT8, FT4, WSPR, and others.
+ * 
+ * The library is a Node.js C++ extension that wraps the wsjtx_lib C library,
+ * providing high-performance digital signal processing capabilities with
+ * multi-platform support (Windows, macOS, Linux).
+ * 
+ * @version 1.0.0
+ * @author WSJTX Development Team
+ * @license GPL-3.0
+ */