tci-client-node 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1182 @@
+"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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  TCI_STREAM_HEADER_BYTES: () => TCI_STREAM_HEADER_BYTES,
+  TciClient: () => TciClient,
+  TciCommandQueue: () => TciCommandQueue,
+  TciError: () => TciError,
+  TciSampleType: () => TciSampleType,
+  TciStreamType: () => TciStreamType,
+  buildStreamFrame: () => buildStreamFrame,
+  buildTxAudioFrame: () => buildTxAudioFrame,
+  commandKey: () => commandKey,
+  createTciClient: () => createTciClient,
+  deinterleaveChannels: () => deinterleaveChannels,
+  escapeTciText: () => escapeTciText,
+  float32ToPcm16: () => float32ToPcm16,
+  formatTciCommand: () => formatTciCommand,
+  isCommandReplyTo: () => isCommandReplyTo,
+  mixToMono: () => mixToMono,
+  normalizeCommandName: () => normalizeCommandName,
+  normalizeSampleType: () => normalizeSampleType,
+  normalizeStreamType: () => normalizeStreamType,
+  parseStreamFrame: () => parseStreamFrame,
+  parseTciCommand: () => parseTciCommand,
+  parseTciText: () => parseTciText,
+  payloadToFloat32: () => payloadToFloat32,
+  pcm16ToFloat32: () => pcm16ToFloat32,
+  sampleTypeBytes: () => sampleTypeBytes,
+  sampleTypeName: () => sampleTypeName,
+  samplesToPayload: () => samplesToPayload,
+  toTciError: () => toTciError,
+  unescapeTciText: () => unescapeTciText
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/errors.ts
+var TciError = class extends Error {
+  code;
+  details;
+  constructor(code, message, details) {
+    super(message);
+    this.name = "TciError";
+    this.code = code;
+    this.details = details;
+  }
+};
+function toTciError(error, fallbackCode = "protocol-error") {
+  if (error instanceof TciError) {
+    return error;
+  }
+  if (error instanceof Error) {
+    return new TciError(fallbackCode, error.message, error);
+  }
+  return new TciError(fallbackCode, String(error), error);
+}
+
+// src/client/TciClient.ts
+var import_eventemitter3 = require("eventemitter3");
+var import_ws = __toESM(require("ws"), 1);
+
+// src/audio/streamFrame.ts
+var TCI_STREAM_HEADER_BYTES = 16 * 4;
+var TciStreamType = /* @__PURE__ */ ((TciStreamType2) => {
+  TciStreamType2[TciStreamType2["IQ_STREAM"] = 0] = "IQ_STREAM";
+  TciStreamType2[TciStreamType2["RX_AUDIO_STREAM"] = 1] = "RX_AUDIO_STREAM";
+  TciStreamType2[TciStreamType2["TX_AUDIO_STREAM"] = 2] = "TX_AUDIO_STREAM";
+  TciStreamType2[TciStreamType2["TX_CHRONO"] = 3] = "TX_CHRONO";
+  TciStreamType2[TciStreamType2["LINEOUT_STREAM"] = 4] = "LINEOUT_STREAM";
+  return TciStreamType2;
+})(TciStreamType || {});
+var TciSampleType = /* @__PURE__ */ ((TciSampleType2) => {
+  TciSampleType2[TciSampleType2["INT16"] = 0] = "INT16";
+  TciSampleType2[TciSampleType2["INT24"] = 1] = "INT24";
+  TciSampleType2[TciSampleType2["INT32"] = 2] = "INT32";
+  TciSampleType2[TciSampleType2["FLOAT32"] = 3] = "FLOAT32";
+  return TciSampleType2;
+})(TciSampleType || {});
+function parseStreamFrame(input) {
+  const buffer = toBuffer(input);
+  if (buffer.byteLength < TCI_STREAM_HEADER_BYTES) {
+    throw new TciError("invalid-frame", `TCI stream frame is shorter than ${TCI_STREAM_HEADER_BYTES} bytes`);
+  }
+  const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  const header = Array.from({ length: 16 }, (_, index) => view.getUint32(index * 4, true));
+  const sampleType = normalizeSampleType(header[2]);
+  let channels = header[7];
+  const bytesPerSample = sampleTypeBytes(sampleType);
+  const sampleCount = header[5];
+  const actualPayloadLength = buffer.byteLength - TCI_STREAM_HEADER_BYTES;
+  if (channels <= 0) {
+    const inferredChannels = sampleCount > 0 ? actualPayloadLength / sampleCount / bytesPerSample : 1;
+    if (!Number.isInteger(inferredChannels) || inferredChannels <= 0) {
+      throw new TciError("invalid-frame", `Invalid TCI channel count: ${channels}`);
+    }
+    channels = inferredChannels;
+  }
+  const payloadLength = sampleCount * bytesPerSample * channels;
+  const expectedLength = TCI_STREAM_HEADER_BYTES + payloadLength;
+  if (buffer.byteLength !== expectedLength) {
+    throw new TciError(
+      "invalid-frame",
+      `TCI stream frame length mismatch: header says ${sampleCount} samples (${payloadLength} payload bytes), got ${buffer.byteLength - TCI_STREAM_HEADER_BYTES}`
+    );
+  }
+  if (payloadLength % (bytesPerSample * channels) !== 0) {
+    throw new TciError("invalid-frame", "TCI payload length is not aligned to sample type and channel count");
+  }
+  return {
+    receiver: header[0],
+    sampleRate: header[1],
+    sampleType,
+    codec: header[3],
+    crc: header[4],
+    payloadLength,
+    streamType: normalizeStreamType(header[6]),
+    channels,
+    reserved: header.slice(8),
+    payload: buffer.subarray(TCI_STREAM_HEADER_BYTES),
+    sampleCount
+  };
+}
+function buildStreamFrame(options) {
+  const sampleType = normalizeSampleType(options.sampleType);
+  const payload = options.payload ? toBuffer(options.payload) : samplesToPayload(options.samples ?? [], sampleType);
+  const channels = options.channels;
+  if (channels <= 0) {
+    throw new TciError("invalid-frame", `Invalid TCI channel count: ${channels}`);
+  }
+  const bytesPerSample = sampleTypeBytes(sampleType);
+  if (payload.byteLength % (bytesPerSample * channels) !== 0) {
+    throw new TciError("invalid-frame", "TCI payload length is not aligned to sample type and channel count");
+  }
+  const sampleCount = payload.byteLength / bytesPerSample / channels;
+  const frame = Buffer.alloc(TCI_STREAM_HEADER_BYTES + payload.byteLength);
+  const view = new DataView(frame.buffer, frame.byteOffset, frame.byteLength);
+  const reserved = options.reserved ?? [];
+  const header = [
+    options.receiver ?? 0,
+    options.sampleRate,
+    sampleType,
+    options.codec ?? 0,
+    options.crc ?? 0,
+    sampleCount,
+    options.streamType,
+    channels,
+    ...Array.from({ length: 8 }, (_, index) => reserved[index] ?? 0)
+  ];
+  header.forEach((value, index) => view.setUint32(index * 4, value >>> 0, true));
+  payload.copy(frame, TCI_STREAM_HEADER_BYTES);
+  return frame;
+}
+function buildTxAudioFrame(options) {
+  return buildStreamFrame({ ...options, streamType: 2 /* TX_AUDIO_STREAM */ });
+}
+function sampleTypeBytes(sampleType) {
+  switch (normalizeSampleType(sampleType)) {
+    case 0 /* INT16 */:
+      return 2;
+    case 1 /* INT24 */:
+      return 3;
+    case 2 /* INT32 */:
+    case 3 /* FLOAT32 */:
+      return 4;
+    default:
+      throw new TciError("invalid-frame", `Unsupported TCI sample type: ${sampleType}`);
+  }
+}
+function sampleTypeName(sampleType) {
+  switch (sampleType) {
+    case 0 /* INT16 */:
+      return "int16";
+    case 1 /* INT24 */:
+      return "int24";
+    case 2 /* INT32 */:
+      return "int32";
+    case 3 /* FLOAT32 */:
+      return "float32";
+    default:
+      throw new TciError("invalid-frame", `Unsupported TCI sample type: ${sampleType}`);
+  }
+}
+function normalizeSampleType(sampleType) {
+  if (typeof sampleType === "string") {
+    switch (sampleType.toLowerCase()) {
+      case "int16":
+        return 0 /* INT16 */;
+      case "int24":
+        return 1 /* INT24 */;
+      case "int32":
+        return 2 /* INT32 */;
+      case "float32":
+        return 3 /* FLOAT32 */;
+      default:
+        throw new TciError("invalid-frame", `Unsupported TCI sample type: ${sampleType}`);
+    }
+  }
+  if (sampleType >= 0 /* INT16 */ && sampleType <= 3 /* FLOAT32 */) {
+    return sampleType;
+  }
+  throw new TciError("invalid-frame", `Unsupported TCI sample type: ${sampleType}`);
+}
+function normalizeStreamType(streamType) {
+  if (streamType >= 0 /* IQ_STREAM */ && streamType <= 4 /* LINEOUT_STREAM */) {
+    return streamType;
+  }
+  throw new TciError("invalid-frame", `Unsupported TCI stream type: ${streamType}`);
+}
+function payloadToFloat32(frameOrPayload, sampleType) {
+  const payload = isFrame(frameOrPayload) ? frameOrPayload.payload : toBuffer(frameOrPayload);
+  const type = isFrame(frameOrPayload) ? frameOrPayload.sampleType : normalizeSampleType(sampleType ?? 3 /* FLOAT32 */);
+  const bytes = sampleTypeBytes(type);
+  if (payload.byteLength % bytes !== 0) {
+    throw new TciError("invalid-frame", "Payload length is not aligned to sample type");
+  }
+  const output = new Float32Array(payload.byteLength / bytes);
+  const view = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
+  for (let i = 0; i < output.length; i += 1) {
+    const offset = i * bytes;
+    switch (type) {
+      case 0 /* INT16 */:
+        output[i] = view.getInt16(offset, true) / 32768;
+        break;
+      case 1 /* INT24 */:
+        output[i] = readInt24(view, offset) / 8388608;
+        break;
+      case 2 /* INT32 */:
+        output[i] = view.getInt32(offset, true) / 2147483648;
+        break;
+      case 3 /* FLOAT32 */:
+        output[i] = view.getFloat32(offset, true);
+        break;
+    }
+  }
+  return output;
+}
+function samplesToPayload(samples, sampleType) {
+  const type = normalizeSampleType(sampleType);
+  const bytes = sampleTypeBytes(type);
+  const payload = Buffer.alloc(samples.length * bytes);
+  const view = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
+  for (let i = 0; i < samples.length; i += 1) {
+    const value = clampSample(samples[i] ?? 0);
+    const offset = i * bytes;
+    switch (type) {
+      case 0 /* INT16 */:
+        view.setInt16(offset, Math.round(value * 32767), true);
+        break;
+      case 1 /* INT24 */:
+        writeInt24(view, offset, Math.round(value * 8388607));
+        break;
+      case 2 /* INT32 */:
+        view.setInt32(offset, Math.round(value * 2147483647), true);
+        break;
+      case 3 /* FLOAT32 */:
+        view.setFloat32(offset, value, true);
+        break;
+    }
+  }
+  return payload;
+}
+function pcm16ToFloat32(input) {
+  if (input instanceof Int16Array) {
+    const output = new Float32Array(input.length);
+    for (let i = 0; i < input.length; i += 1) {
+      output[i] = input[i] / 32768;
+    }
+    return output;
+  }
+  return payloadToFloat32(toBuffer(input), 0 /* INT16 */);
+}
+function float32ToPcm16(samples) {
+  return samplesToPayload(samples, 0 /* INT16 */);
+}
+function deinterleaveChannels(samples, channels) {
+  if (channels <= 0 || samples.length % channels !== 0) {
+    throw new TciError("invalid-frame", "Cannot deinterleave samples with invalid channel count");
+  }
+  const frames = samples.length / channels;
+  const outputs = Array.from({ length: channels }, () => new Float32Array(frames));
+  for (let frame = 0; frame < frames; frame += 1) {
+    for (let channel = 0; channel < channels; channel += 1) {
+      outputs[channel][frame] = samples[frame * channels + channel];
+    }
+  }
+  return outputs;
+}
+function mixToMono(samples, channels) {
+  if (channels === 1) {
+    return samples;
+  }
+  const separated = deinterleaveChannels(samples, channels);
+  const mono = new Float32Array(separated[0]?.length ?? 0);
+  for (const channel of separated) {
+    for (let i = 0; i < mono.length; i += 1) {
+      mono[i] += channel[i] / channels;
+    }
+  }
+  return mono;
+}
+function toBuffer(input) {
+  if (Buffer.isBuffer(input)) {
+    return input;
+  }
+  if (input instanceof ArrayBuffer) {
+    return Buffer.from(input);
+  }
+  if (ArrayBuffer.isView(input)) {
+    return Buffer.from(input.buffer, input.byteOffset, input.byteLength);
+  }
+  return Buffer.from(input);
+}
+function isFrame(value) {
+  return Boolean(value && typeof value === "object" && "payload" in value && "sampleType" in value);
+}
+function clampSample(value) {
+  if (!Number.isFinite(value)) {
+    return 0;
+  }
+  return Math.max(-1, Math.min(1, value));
+}
+function readInt24(view, offset) {
+  const value = view.getUint8(offset) | view.getUint8(offset + 1) << 8 | view.getUint8(offset + 2) << 16;
+  return value & 8388608 ? value | 4278190080 : value;
+}
+function writeInt24(view, offset, value) {
+  const clamped = Math.max(-8388608, Math.min(8388607, value));
+  view.setUint8(offset, clamped & 255);
+  view.setUint8(offset + 1, clamped >> 8 & 255);
+  view.setUint8(offset + 2, clamped >> 16 & 255);
+}
+
+// src/protocol/text.ts
+var ESCAPE_TO_CHAR = {
+  "^": ":",
+  "~": ",",
+  "*": ";"
+};
+var CHAR_TO_ESCAPE = {
+  ":": "^",
+  ",": "~",
+  ";": "*"
+};
+function escapeTciText(value) {
+  return String(value).replace(/[:;,]/g, (char) => CHAR_TO_ESCAPE[char] ?? char);
+}
+function unescapeTciText(value) {
+  return value.replace(/[\^~*]/g, (char) => ESCAPE_TO_CHAR[char] ?? char);
+}
+function parseTciText(text) {
+  const source = normalizeTextInput(text);
+  const commands = [];
+  for (const fragment of source.split(";")) {
+    const raw = fragment.trim();
+    if (!raw) {
+      continue;
+    }
+    const colonIndex = raw.indexOf(":");
+    const originalName = (colonIndex >= 0 ? raw.slice(0, colonIndex) : raw).trim();
+    if (!originalName) {
+      continue;
+    }
+    const argsText = colonIndex >= 0 ? raw.slice(colonIndex + 1) : void 0;
+    commands.push({
+      name: originalName.toLowerCase(),
+      originalName,
+      args: argsText === void 0 ? [] : splitArgs(argsText),
+      raw
+    });
+  }
+  return commands;
+}
+function parseTciCommand(input) {
+  if (typeof input !== "string") {
+    return input;
+  }
+  const [command] = parseTciText(input);
+  if (!command) {
+    throw new Error(`Invalid TCI command: ${input}`);
+  }
+  return command;
+}
+function formatTciCommand(name, args = []) {
+  const commandName = name.trim().toUpperCase();
+  if (!commandName) {
+    throw new Error("TCI command name cannot be empty");
+  }
+  if (args.length === 0) {
+    return `${commandName};`;
+  }
+  return `${commandName}:${args.map(escapeTciText).join(",")};`;
+}
+function normalizeCommandName(name) {
+  return name.trim().toLowerCase();
+}
+function isCommandReplyTo(replyInput, requestInput) {
+  const reply = parseTciCommand(replyInput);
+  const request = parseTciCommand(requestInput);
+  if (reply.name !== request.name) {
+    return false;
+  }
+  if (request.args.length === 0) {
+    return true;
+  }
+  if (argsHavePrefix(reply.args, request.args)) {
+    return true;
+  }
+  return isKnownVariantReply(reply, request);
+}
+function commandKey(command) {
+  const parsed = parseTciCommand(command);
+  return `${parsed.name}:${parsed.args.join(",")}`;
+}
+function normalizeTextInput(text) {
+  if (typeof text === "string") {
+    return text;
+  }
+  if (Buffer.isBuffer(text)) {
+    return text.toString("utf8");
+  }
+  if (text instanceof ArrayBuffer) {
+    return Buffer.from(text).toString("utf8");
+  }
+  return Buffer.from(text.buffer, text.byteOffset, text.byteLength).toString("utf8");
+}
+function splitArgs(argsText) {
+  return argsText.split(",").map((arg) => unescapeTciText(arg.trim()));
+}
+function argsHavePrefix(args, prefix) {
+  if (args.length < prefix.length) {
+    return false;
+  }
+  return prefix.every((arg, index) => args[index]?.toLowerCase() === arg.toLowerCase());
+}
+function isKnownVariantReply(reply, request) {
+  if (reply.name === "modulation") {
+    if (request.args.length === 2 && reply.args.length >= 3) {
+      return reply.args[0] === request.args[0] && reply.args[2]?.toLowerCase() === request.args[1]?.toLowerCase();
+    }
+    if (request.args.length === 3 && reply.args.length === 2) {
+      return reply.args[0] === request.args[0] && reply.args[1]?.toLowerCase() === request.args[2]?.toLowerCase();
+    }
+  }
+  if (reply.name === "protocol") {
+    return request.args.length <= 1;
+  }
+  if (reply.name === "trx" && request.args.length >= 3 && reply.args.length >= 2) {
+    return reply.args[0] === request.args[0] && reply.args[1]?.toLowerCase() === request.args[1]?.toLowerCase();
+  }
+  return false;
+}
+
+// src/protocol/commandQueue.ts
+var TciCommandQueue = class {
+  send;
+  defaultTimeoutMs;
+  queue = [];
+  active;
+  connected = true;
+  constructor(options) {
+    this.send = options.send;
+    this.defaultTimeoutMs = options.timeoutMs ?? 1e3;
+  }
+  setConnected(connected) {
+    this.connected = connected;
+    if (!connected) {
+      this.cancelAll(new TciError("disconnected", "TCI connection closed"));
+    }
+  }
+  enqueue(command, options = {}) {
+    const request = parseTciCommand(command);
+    const raw = typeof command === "string" ? ensureSemicolon(command) : formatTciCommand(command.originalName, command.args);
+    if (!this.connected) {
+      return Promise.reject(new TciError("not-connected", "TCI socket is not connected"));
+    }
+    return new Promise((resolve, reject) => {
+      const pending = {
+        raw,
+        request,
+        timeoutMs: options.timeoutMs ?? this.defaultTimeoutMs,
+        matcher: options.matcher ?? ((reply, req) => isCommandReplyTo(reply, req)),
+        resolve,
+        reject
+      };
+      if (options.signal) {
+        if (options.signal.aborted) {
+          reject(new TciError("cancelled", "TCI command was cancelled"));
+          return;
+        }
+        const onAbort = () => this.rejectPending(pending, new TciError("cancelled", "TCI command was cancelled"));
+        options.signal.addEventListener("abort", onAbort, { once: true });
+        pending.abortCleanup = () => options.signal?.removeEventListener("abort", onAbort);
+      }
+      this.queue.push(pending);
+      void this.pump();
+    });
+  }
+  handleCommand(commandInput) {
+    const active = this.active;
+    if (!active) {
+      return false;
+    }
+    const reply = parseTciCommand(commandInput);
+    if (!active.matcher(reply, active.request)) {
+      return false;
+    }
+    this.finishActive(reply);
+    return true;
+  }
+  cancelAll(error = new TciError("cancelled", "TCI command queue cancelled")) {
+    const pending = [...this.queue];
+    this.queue = [];
+    if (this.active) {
+      pending.unshift(this.active);
+      this.active = void 0;
+    }
+    for (const item of pending) {
+      this.rejectPending(item, error);
+    }
+  }
+  get size() {
+    return this.queue.length + (this.active ? 1 : 0);
+  }
+  async pump() {
+    if (this.active || !this.connected) {
+      return;
+    }
+    const next = this.queue.shift();
+    if (!next) {
+      return;
+    }
+    this.active = next;
+    next.timer = setTimeout(() => {
+      this.rejectPending(next, new TciError("command-timeout", `Timed out waiting for TCI reply to ${next.raw}`));
+      if (this.active === next) {
+        this.active = void 0;
+      }
+      void this.pump();
+    }, next.timeoutMs);
+    try {
+      await this.send(next.raw);
+    } catch (error) {
+      this.rejectPending(next, new TciError("disconnected", error instanceof Error ? error.message : String(error), error));
+      if (this.active === next) {
+        this.active = void 0;
+      }
+      void this.pump();
+    }
+  }
+  finishActive(reply) {
+    const active = this.active;
+    if (!active) {
+      return;
+    }
+    this.active = void 0;
+    if (active.timer) {
+      clearTimeout(active.timer);
+    }
+    active.abortCleanup?.();
+    active.resolve({ request: active.request, reply });
+    void this.pump();
+  }
+  rejectPending(pending, error) {
+    if (pending.timer) {
+      clearTimeout(pending.timer);
+    }
+    pending.abortCleanup?.();
+    const wasActive = this.active === pending;
+    if (wasActive) {
+      this.active = void 0;
+    } else {
+      this.queue = this.queue.filter((item) => item !== pending);
+    }
+    pending.reject(error);
+    if (wasActive && this.connected) {
+      void this.pump();
+    }
+  }
+};
+function ensureSemicolon(command) {
+  return command.trim().endsWith(";") ? command.trim() : `${command.trim()};`;
+}
+
+// src/client/TciClient.ts
+var TciClient = class extends import_eventemitter3.EventEmitter {
+  options;
+  WebSocketImpl;
+  ws;
+  queue;
+  state;
+  constructor(options) {
+    super();
+    this.options = {
+      url: options.url,
+      receiver: options.receiver ?? 0,
+      trx: options.trx ?? 0,
+      vfo: options.vfo ?? 0,
+      connectTimeoutMs: options.connectTimeoutMs ?? 5e3,
+      commandTimeoutMs: options.commandTimeoutMs ?? 1e3
+    };
+    this.WebSocketImpl = options.WebSocketImpl ?? import_ws.default;
+    this.queue = new TciCommandQueue({
+      timeoutMs: this.options.commandTimeoutMs,
+      send: (raw) => this.sendRaw(raw)
+    });
+    this.queue.setConnected(false);
+    this.state = {
+      connected: false,
+      ready: false,
+      modulations: [],
+      frequencies: {},
+      modes: {},
+      ptt: {},
+      pttSource: {},
+      tune: {},
+      drive: {},
+      split: {},
+      rxSensors: {},
+      txSensors: {}
+    };
+  }
+  async connect() {
+    if (this.ws?.readyState === import_ws.default.OPEN) {
+      return;
+    }
+    if (this.ws && this.ws.readyState === import_ws.default.CONNECTING) {
+      await this.waitForOpen(this.ws);
+      return;
+    }
+    const ws = new this.WebSocketImpl(this.options.url);
+    this.ws = ws;
+    await this.waitForOpen(ws);
+  }
+  async disconnect(code = 1e3, reason = "client disconnect") {
+    const ws = this.ws;
+    if (!ws) {
+      return;
+    }
+    if (ws.readyState === import_ws.default.CLOSED) {
+      this.handleClose();
+      return;
+    }
+    await new Promise((resolve) => {
+      const cleanup = () => {
+        ws.off("close", onClose);
+        ws.off("error", onError);
+      };
+      const onClose = () => {
+        cleanup();
+        resolve();
+      };
+      const onError = () => {
+        cleanup();
+        resolve();
+      };
+      ws.once("close", onClose);
+      ws.once("error", onError);
+      ws.close(code, reason);
+      setTimeout(() => resolve(), 1e3).unref?.();
+    });
+    this.handleClose();
+  }
+  isConnected() {
+    return this.ws?.readyState === import_ws.default.OPEN;
+  }
+  getState() {
+    return cloneState(this.state);
+  }
+  async sendCommand(name, args = [], options = {}) {
+    const raw = formatTciCommand(name, args);
+    if (options.waitForReply === false) {
+      await this.sendRaw(raw);
+      return void 0;
+    }
+    const result = await this.queue.enqueue(raw, options);
+    return result.reply;
+  }
+  async request(name, args = [], options = {}) {
+    const reply = await this.sendCommand(name, args, { ...options, waitForReply: true });
+    if (!reply) {
+      throw new TciError("protocol-error", `No reply for ${name}`);
+    }
+    return reply;
+  }
+  async setFrequency(frequencyHz, receiver = this.options.receiver, vfo = this.options.vfo) {
+    await this.sendCommand("VFO", [receiver, vfo, Math.round(frequencyHz)]);
+  }
+  async getFrequency(receiver = this.options.receiver, vfo = this.options.vfo) {
+    const reply = await this.request("VFO", [receiver, vfo]);
+    return parseNumber(reply.args[2]) ?? this.state.frequencies[rxVfoKey(receiver, vfo)];
+  }
+  async setMode(mode, receiver = this.options.receiver) {
+    await this.sendCommand("MODULATION", [receiver, mode.toUpperCase()]);
+  }
+  async getMode(receiver = this.options.receiver) {
+    const reply = await this.request("MODULATION", [receiver]);
+    const mode = reply.args.length >= 3 ? reply.args[2] : reply.args[1];
+    return (mode ?? this.state.modes[rxVfoKey(receiver, this.options.vfo)])?.toLowerCase();
+  }
+  async setPtt(enabled, options = {}) {
+    const trx = options.trx ?? this.options.trx;
+    const args = options.source ? [trx, enabled, options.source] : [trx, enabled];
+    await this.sendCommand("TRX", args);
+  }
+  async getPtt(trx = this.options.trx) {
+    const reply = await this.request("TRX", [trx]);
+    return parseBoolean(reply.args[1]) ?? this.state.ptt[String(trx)];
+  }
+  async setTune(enabled, trx = this.options.trx) {
+    await this.sendCommand("TUNE", [trx, enabled]);
+  }
+  async setDrive(value, trx = this.options.trx) {
+    await this.sendCommand("DRIVE", [trx, value]);
+  }
+  async setSplit(enabled, trx = this.options.trx) {
+    await this.sendCommand("SPLIT_ENABLE", [trx, enabled]);
+  }
+  async configureAudio(config) {
+    const audio = {
+      sampleRate: config.sampleRate,
+      sampleType: normalizeSampleType(config.sampleType ?? 3 /* FLOAT32 */),
+      channels: config.channels ?? 1,
+      samplesPerFrame: config.samplesPerFrame ?? 512,
+      txBufferingMs: config.txBufferingMs,
+      running: this.state.audio?.running ?? false
+    };
+    this.state.audio = audio;
+    await this.sendCommand("AUDIO_SAMPLERATE", [audio.sampleRate], { waitForReply: false });
+    await this.sendCommand("AUDIO_STREAM_SAMPLE_TYPE", [sampleTypeName(audio.sampleType)], { waitForReply: false });
+    await this.sendCommand("AUDIO_STREAM_CHANNELS", [audio.channels], { waitForReply: false });
+    await this.sendCommand("AUDIO_STREAM_SAMPLES", [audio.samplesPerFrame], { waitForReply: false });
+    if (audio.txBufferingMs !== void 0) {
+      await this.sendCommand("TX_STREAM_AUDIO_BUFFERING", [audio.txBufferingMs], { waitForReply: false });
+    }
+    this.emitState();
+  }
+  async startAudio(receiver = this.options.receiver) {
+    await this.sendCommand("AUDIO_START", [receiver], { waitForReply: false });
+    if (this.state.audio) {
+      this.state.audio.running = true;
+      this.emitState();
+    }
+  }
+  async stopAudio(receiver = this.options.receiver) {
+    await this.sendCommand("AUDIO_STOP", [receiver], { waitForReply: false });
+    if (this.state.audio) {
+      this.state.audio.running = false;
+      this.emitState();
+    }
+  }
+  sendTxAudio(options) {
+    const frame = buildTxAudioFrame({ receiver: this.options.receiver, ...options });
+    this.sendRawBinary(frame);
+  }
+  async setRxSensorsEnabled(enabled, intervalMs) {
+    const args = intervalMs === void 0 ? [enabled] : [enabled, intervalMs];
+    await this.sendCommand("RX_SENSORS_ENABLE", args, { waitForReply: false });
+  }
+  async setTxSensorsEnabled(enabled, intervalMs) {
+    const args = intervalMs === void 0 ? [enabled] : [enabled, intervalMs];
+    await this.sendCommand("TX_SENSORS_ENABLE", args, { waitForReply: false });
+  }
+  async sendCwMacro(index) {
+    await this.sendCommand("CW_MACROS", [index]);
+  }
+  async sendCwMessage(message) {
+    await this.sendCommand("CW_MSG", [message]);
+  }
+  async stopCw() {
+    await this.sendCommand("CW_MACROS_STOP");
+  }
+  waitForOpen(ws) {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        cleanup();
+        try {
+          ws.terminate();
+        } catch {
+        }
+        reject(new TciError("connect-timeout", `Timed out connecting to ${this.options.url}`));
+      }, this.options.connectTimeoutMs);
+      const cleanup = () => {
+        clearTimeout(timer);
+        ws.off("open", onOpen);
+        ws.off("close", onClose);
+        ws.off("error", onError);
+      };
+      const onOpen = () => {
+        cleanup();
+        this.attachSocket(ws);
+        this.state.connected = true;
+        this.queue.setConnected(true);
+        this.emit("connected");
+        this.emitState();
+        resolve();
+      };
+      const onClose = () => {
+        cleanup();
+        this.handleClose();
+        reject(new TciError("disconnected", `Disconnected while connecting to ${this.options.url}`));
+      };
+      const onError = (error) => {
+        cleanup();
+        this.handleError(error);
+        reject(toTciError(error, "disconnected"));
+      };
+      ws.once("open", onOpen);
+      ws.once("close", onClose);
+      ws.once("error", onError);
+    });
+  }
+  attachSocket(ws) {
+    ws.on("message", (data, isBinary) => this.handleMessage(data, isBinary));
+    ws.on("close", () => this.handleClose());
+    ws.on("error", (error) => this.handleError(error));
+  }
+  async sendRaw(raw) {
+    const ws = this.ws;
+    if (!ws || ws.readyState !== import_ws.default.OPEN) {
+      throw new TciError("not-connected", "TCI socket is not connected");
+    }
+    await new Promise((resolve, reject) => {
+      ws.send(raw, (error) => error ? reject(error) : resolve());
+    });
+  }
+  sendRawBinary(raw) {
+    const ws = this.ws;
+    if (!ws || ws.readyState !== import_ws.default.OPEN) {
+      throw new TciError("not-connected", "TCI socket is not connected");
+    }
+    ws.send(raw, { binary: true });
+  }
+  handleMessage(data, isBinary) {
+    try {
+      if (isBinary) {
+        this.handleBinary(data);
+        return;
+      }
+      const commands = parseTciText(dataToBuffer(data));
+      for (const command of commands) {
+        this.queue.handleCommand(command);
+        this.applyCommand(command);
+        this.emit("command", command);
+      }
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  handleBinary(data) {
+    const frame = parseStreamFrame(dataToBuffer(data));
+    this.emit("binary", frame);
+    switch (frame.streamType) {
+      case 1 /* RX_AUDIO_STREAM */:
+        this.emit("rxAudioFrame", frame);
+        break;
+      case 3 /* TX_CHRONO */:
+        this.emit("txChrono", {
+          frame,
+          receiver: frame.receiver,
+          sampleRate: frame.sampleRate,
+          channels: frame.channels,
+          sampleType: frame.sampleType,
+          sampleCount: frame.sampleCount
+        });
+        break;
+      case 4 /* LINEOUT_STREAM */:
+        this.emit("lineoutAudioFrame", frame);
+        break;
+      default:
+        break;
+    }
+  }
+  applyCommand(command) {
+    const readyBefore = this.state.ready;
+    switch (command.name) {
+      case "ready":
+        this.state.ready = command.args.length === 0 ? true : parseBoolean(command.args[0]) ?? true;
+        break;
+      case "protocol":
+        this.state.protocol = command.args[0];
+        break;
+      case "device":
+        this.state.device = command.args.join(",");
+        break;
+      case "receive_only":
+        this.state.receiveOnly = parseBoolean(command.args[0]);
+        break;
+      case "trx_count":
+        this.state.trxCount = parseNumber(command.args[0]);
+        break;
+      case "channels_count":
+      case "channel_count":
+        this.state.channelCount = parseNumber(command.args[0]);
+        break;
+      case "vfo_limits":
+        this.state.vfoLimits = parseNumberPair(command.args);
+        break;
+      case "if_limits":
+        this.state.ifLimits = parseNumberPair(command.args);
+        break;
+      case "modulations_list":
+        this.state.modulations = command.args.map((mode) => mode.toLowerCase());
+        break;
+      case "vfo":
+        this.applyVfo(command.args);
+        break;
+      case "modulation":
+        this.applyModulation(command.args);
+        break;
+      case "trx":
+        this.applyTrx(command.args);
+        break;
+      case "tune":
+        this.applyBooleanByFirstArg(this.state.tune, command.args);
+        break;
+      case "drive":
+        this.applyDrive(command.args);
+        break;
+      case "split_enable":
+        this.applyBooleanByFirstArg(this.state.split, command.args);
+        break;
+      case "rx_channel_sensors":
+        this.applyRxChannelSensors(command.args);
+        break;
+      case "rx_sensors":
+        this.applyRxSensors(command.args);
+        break;
+      case "tx_sensors":
+        this.applyTxSensors(command.args);
+        break;
+      case "audio_samplerate":
+        this.state.audio = {
+          sampleRate: parseNumber(command.args[0]) ?? this.state.audio?.sampleRate ?? 12e3,
+          sampleType: this.state.audio?.sampleType ?? 3 /* FLOAT32 */,
+          channels: this.state.audio?.channels ?? 1,
+          samplesPerFrame: this.state.audio?.samplesPerFrame ?? 512,
+          txBufferingMs: this.state.audio?.txBufferingMs,
+          running: this.state.audio?.running ?? false
+        };
+        break;
+      default:
+        break;
+    }
+    if (!readyBefore && this.state.ready) {
+      this.emit("ready", this.getState());
+    }
+    this.emitState();
+  }
+  applyVfo(args) {
+    if (args.length < 3) {
+      return;
+    }
+    const receiver = parseNumber(args[0]);
+    const vfo = parseNumber(args[1]);
+    const frequency = parseNumber(args[2]);
+    if (receiver === void 0 || vfo === void 0 || frequency === void 0 || frequency < 0) {
+      return;
+    }
+    this.state.frequencies[rxVfoKey(receiver, vfo)] = frequency;
+  }
+  applyModulation(args) {
+    if (args.length < 2) {
+      return;
+    }
+    const receiver = parseNumber(args[0]);
+    if (receiver === void 0) {
+      return;
+    }
+    const vfo = args.length >= 3 ? parseNumber(args[1]) ?? this.options.vfo : this.options.vfo;
+    const mode = args.length >= 3 ? args[2] : args[1];
+    if (!mode) {
+      return;
+    }
+    this.state.modes[rxVfoKey(receiver, vfo)] = mode.toLowerCase();
+  }
+  applyTrx(args) {
+    if (args.length < 2) {
+      return;
+    }
+    const trx = args[0] ?? String(this.options.trx);
+    this.state.ptt[trx] = parseBoolean(args[1]) ?? false;
+    this.state.pttSource[trx] = args[2]?.toLowerCase();
+  }
+  applyBooleanByFirstArg(target, args) {
+    if (args.length < 2) {
+      return;
+    }
+    const key = args[0] ?? "0";
+    const value = parseBoolean(args[1]);
+    if (value !== void 0) {
+      target[key] = value;
+    }
+  }
+  applyDrive(args) {
+    if (args.length === 1) {
+      const value2 = parseNumber(args[0]);
+      if (value2 !== void 0) {
+        this.state.drive[String(this.options.trx)] = value2;
+      }
+      return;
+    }
+    const trx = args[0] ?? String(this.options.trx);
+    const value = parseNumber(args[1]);
+    if (value !== void 0) {
+      this.state.drive[trx] = value;
+    }
+  }
+  applyRxChannelSensors(args) {
+    if (args.length < 3) {
+      return;
+    }
+    const key = rxVfoKey(args[0], args[1]);
+    this.state.rxSensors[key] = {
+      receiver: args[0],
+      channel: args[1],
+      levelDbm: parseNumber(args[2]) ?? args[2]
+    };
+  }
+  applyRxSensors(args) {
+    if (args.length < 2) {
+      return;
+    }
+    this.state.rxSensors[String(args[0])] = {
+      receiver: args[0],
+      levelDbm: parseNumber(args[1]) ?? args[1],
+      deprecated: true
+    };
+  }
+  applyTxSensors(args) {
+    if (args.length < 2) {
+      return;
+    }
+    this.state.txSensors[String(args[0])] = {
+      trx: args[0],
+      micDbm: parseNumber(args[1]) ?? args[1],
+      rmsPowerW: parseNumber(args[2]) ?? args[2],
+      peakPowerW: parseNumber(args[3]) ?? args[3],
+      swr: parseNumber(args[4]) ?? args[4]
+    };
+  }
+  handleClose(reason) {
+    this.ws = void 0;
+    const wasConnected = this.state.connected;
+    this.state.connected = false;
+    this.state.ready = false;
+    this.queue.setConnected(false);
+    if (wasConnected) {
+      this.emit("disconnected", reason);
+      this.emitState();
+    }
+  }
+  handleError(error) {
+    const tciError = toTciError(error);
+    this.emit("error", tciError);
+  }
+  emitState() {
+    this.emit("state", this.getState());
+  }
+};
+function createTciClient(options) {
+  return new TciClient(options);
+}
+function dataToBuffer(data) {
+  if (Buffer.isBuffer(data)) {
+    return data;
+  }
+  if (data instanceof ArrayBuffer) {
+    return Buffer.from(data);
+  }
+  if (Array.isArray(data)) {
+    return Buffer.concat(data.map((item) => dataToBuffer(item)));
+  }
+  throw new TciError("protocol-error", "Unsupported WebSocket data type");
+}
+function rxVfoKey(receiver, vfo) {
+  return `${receiver}:${vfo}`;
+}
+function parseNumber(value) {
+  if (value === void 0 || value === "") {
+    return void 0;
+  }
+  const number = Number(value);
+  return Number.isFinite(number) ? number : void 0;
+}
+function parseBoolean(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const normalized = value.toLowerCase();
+  if (normalized === "true" || normalized === "1" || normalized === "on") {
+    return true;
+  }
+  if (normalized === "false" || normalized === "0" || normalized === "off") {
+    return false;
+  }
+  return void 0;
+}
+function parseNumberPair(args) {
+  const first = parseNumber(args[0]);
+  const second = parseNumber(args[1]);
+  return first === void 0 || second === void 0 ? void 0 : [first, second];
+}
+function cloneState(state) {
+  return {
+    ...state,
+    modulations: [...state.modulations],
+    frequencies: { ...state.frequencies },
+    modes: { ...state.modes },
+    ptt: { ...state.ptt },
+    pttSource: { ...state.pttSource },
+    tune: { ...state.tune },
+    drive: { ...state.drive },
+    split: { ...state.split },
+    rxSensors: cloneNested(state.rxSensors),
+    txSensors: cloneNested(state.txSensors),
+    audio: state.audio ? { ...state.audio } : void 0
+  };
+}
+function cloneNested(value) {
+  return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, { ...item }]));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TCI_STREAM_HEADER_BYTES,
+  TciClient,
+  TciCommandQueue,
+  TciError,
+  TciSampleType,
+  TciStreamType,
+  buildStreamFrame,
+  buildTxAudioFrame,
+  commandKey,
+  createTciClient,
+  deinterleaveChannels,
+  escapeTciText,
+  float32ToPcm16,
+  formatTciCommand,
+  isCommandReplyTo,
+  mixToMono,
+  normalizeCommandName,
+  normalizeSampleType,
+  normalizeStreamType,
+  parseStreamFrame,
+  parseTciCommand,
+  parseTciText,
+  payloadToFloat32,
+  pcm16ToFloat32,
+  sampleTypeBytes,
+  sampleTypeName,
+  samplesToPayload,
+  toTciError,
+  unescapeTciText
+});
+//# sourceMappingURL=index.cjs.map