tci-client-node 0.1.1 → 0.2.0

package/dist/index.cjs

@@ -33,30 +33,44 @@ __export(src_exports, {
   TCI_STREAM_HEADER_BYTES: () => TCI_STREAM_HEADER_BYTES,
   TciClient: () => TciClient,
   TciCommandQueue: () => TciCommandQueue,
+  TciDialectRegistry: () => TciDialectRegistry,
   TciError: () => TciError,
   TciSampleType: () => TciSampleType,
   TciStreamType: () => TciStreamType,
+  WebSocketTciTransport: () => WebSocketTciTransport,
+  aetherSdrDialect: () => aetherSdrDialect,
+  assertValidTciHandshake: () => assertValidTciHandshake,
   buildStreamFrame: () => buildStreamFrame,
   buildTxAudioFrame: () => buildTxAudioFrame,
+  builtInDialects: () => builtInDialects,
   commandKey: () => commandKey,
+  compareTciVersion: () => compareTciVersion,
   createTciClient: () => createTciClient,
+  defaultTciDialectRegistry: () => defaultTciDialectRegistry,
   deinterleaveChannels: () => deinterleaveChannels,
   escapeTciText: () => escapeTciText,
+  expertSdr14Dialect: () => expertSdr14Dialect,
+  expertSdrLegacyDialect: () => expertSdrLegacyDialect,
+  expertSdrModernDialect: () => expertSdrModernDialect,
   float32ToPcm16: () => float32ToPcm16,
   formatTciCommand: () => formatTciCommand,
+  genericObservedDialect: () => genericObservedDialect,
   isCommandReplyTo: () => isCommandReplyTo,
   mixToMono: () => mixToMono,
   normalizeCommandName: () => normalizeCommandName,
   normalizeSampleType: () => normalizeSampleType,
   normalizeStreamType: () => normalizeStreamType,
+  parseProtocolIdentity: () => parseProtocolIdentity,
   parseStreamFrame: () => parseStreamFrame,
   parseTciCommand: () => parseTciCommand,
   parseTciText: () => parseTciText,
+  parseTciVersion: () => parseTciVersion,
   payloadToFloat32: () => payloadToFloat32,
   pcm16ToFloat32: () => pcm16ToFloat32,
   sampleTypeBytes: () => sampleTypeBytes,
   sampleTypeName: () => sampleTypeName,
   samplesToPayload: () => samplesToPayload,
+  thetisDialect: () => thetisDialect,
   toTciError: () => toTciError,
   unescapeTciText: () => unescapeTciText
 });
@@ -84,8 +98,8 @@ function toTciError(error, fallbackCode = "protocol-error") {
 }
 
 // src/client/TciClient.ts
-var import_eventemitter3 = require("eventemitter3");
-var import_ws = __toESM(require("ws"), 1);
+var import_eventemitter32 = require("eventemitter3");
+var import_ws2 = __toESM(require("ws"), 1);
 
 // src/audio/streamFrame.ts
 var TCI_STREAM_HEADER_BYTES = 16 * 4;
@@ -104,7 +118,7 @@ var TciSampleType = /* @__PURE__ */ ((TciSampleType2) => {
   TciSampleType2[TciSampleType2["FLOAT32"] = 3] = "FLOAT32";
   return TciSampleType2;
 })(TciSampleType || {});
-function parseStreamFrame(input) {
+function parseStreamFrame(input, options = {}) {
   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`);
@@ -112,28 +126,49 @@ function parseStreamFrame(input) {
   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 streamType = normalizeStreamType(header[6]);
+  let channels = header[7] || options.negotiatedChannels || 0;
   const bytesPerSample = sampleTypeBytes(sampleType);
-  const sampleCount = header[5];
+  const headerSampleCount = 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 (streamType === 3 /* TX_CHRONO */ && actualPayloadLength === 0) {
+      channels = 1;
+    } else {
+      const inferredChannels = headerSampleCount > 0 ? actualPayloadLength / headerSampleCount / bytesPerSample : 1;
+      if (!Number.isInteger(inferredChannels) || inferredChannels <= 0) {
+        throw new TciError("invalid-frame", `Invalid TCI channel count: ${channels}`);
+      }
+      channels = inferredChannels;
+    }
   }
-  if (payloadLength % (bytesPerSample * channels) !== 0) {
+  const payloadLength = actualPayloadLength;
+  const alignedFrameBytes = bytesPerSample * channels;
+  if (payloadLength % alignedFrameBytes !== 0) {
     throw new TciError("invalid-frame", "TCI payload length is not aligned to sample type and channel count");
   }
+  const actualScalarCount = payloadLength / bytesPerSample;
+  const requestedSemantics = options.lengthSemantics ?? "auto";
+  const lengthSemantics = resolveLengthSemantics(
+    requestedSemantics,
+    streamType,
+    headerSampleCount,
+    actualScalarCount,
+    channels
+  );
+  const sampleCount = lengthSemantics === "per-channel" ? headerSampleCount * channels : headerSampleCount;
+  if (streamType !== 3 /* TX_CHRONO */) {
+    const expectedPayloadLength = sampleCount * bytesPerSample;
+    if (payloadLength !== expectedPayloadLength) {
+      throw new TciError(
+        "invalid-frame",
+        `TCI stream frame length mismatch: header says ${headerSampleCount} samples using ${lengthSemantics} semantics (${expectedPayloadLength} payload bytes), got ${payloadLength}`
+      );
+    }
+  }
+  if (sampleCount % channels !== 0) {
+    throw new TciError("invalid-frame", `TCI scalar sample count ${sampleCount} is not divisible by ${channels} channels`);
+  }
   return {
     receiver: header[0],
     sampleRate: header[1],
@@ -141,11 +176,14 @@ function parseStreamFrame(input) {
     codec: header[3],
     crc: header[4],
     payloadLength,
-    streamType: normalizeStreamType(header[6]),
+    streamType,
     channels,
     reserved: header.slice(8),
     payload: buffer.subarray(TCI_STREAM_HEADER_BYTES),
-    sampleCount
+    headerSampleCount,
+    sampleCount,
+    frameCount: sampleCount / channels,
+    lengthSemantics
   };
 }
 function buildStreamFrame(options) {
@@ -159,7 +197,19 @@ function buildStreamFrame(options) {
   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 derivedSampleCount = payload.byteLength / bytesPerSample;
+  const sampleCount = options.sampleCount ?? derivedSampleCount;
+  if (!Number.isInteger(sampleCount) || sampleCount < 0) {
+    throw new TciError("invalid-frame", `Invalid TCI sample count: ${sampleCount}`);
+  }
+  if (payload.byteLength > 0 && sampleCount !== derivedSampleCount) {
+    throw new TciError("invalid-frame", `Explicit scalar sample count ${sampleCount} does not match payload count ${derivedSampleCount}`);
+  }
+  if (sampleCount % channels !== 0) {
+    throw new TciError("invalid-frame", `TCI scalar sample count ${sampleCount} is not divisible by ${channels} channels`);
+  }
+  const lengthSemantics = options.lengthSemantics === "per-channel" ? "per-channel" : "scalar";
+  const headerSampleCount = lengthSemantics === "per-channel" ? sampleCount / channels : sampleCount;
   const frame = Buffer.alloc(TCI_STREAM_HEADER_BYTES + payload.byteLength);
   const view = new DataView(frame.buffer, frame.byteOffset, frame.byteLength);
   const reserved = options.reserved ?? [];
@@ -169,7 +219,7 @@ function buildStreamFrame(options) {
     sampleType,
     options.codec ?? 0,
     options.crc ?? 0,
-    sampleCount,
+    headerSampleCount,
     options.streamType,
     channels,
     ...Array.from({ length: 8 }, (_, index) => reserved[index] ?? 0)
@@ -178,6 +228,13 @@ function buildStreamFrame(options) {
   payload.copy(frame, TCI_STREAM_HEADER_BYTES);
   return frame;
 }
+function resolveLengthSemantics(requested, streamType, headerSampleCount, actualScalarCount, channels) {
+  if (requested !== "auto") return requested;
+  if (streamType === 3 /* TX_CHRONO */ && actualScalarCount === 0) return "scalar";
+  if (actualScalarCount === headerSampleCount) return "scalar";
+  if (actualScalarCount === headerSampleCount * channels) return "per-channel";
+  return "scalar";
+}
 function buildTxAudioFrame(options) {
   return buildStreamFrame({ ...options, streamType: 2 /* TX_AUDIO_STREAM */ });
 }
@@ -609,13 +666,398 @@ function ensureSemicolon(command) {
   return command.trim().endsWith(";") ? command.trim() : `${command.trim()};`;
 }
 
+// src/dialect/builtins.ts
+var StandardTciDialect = class {
+  id;
+  label;
+  streamLengthSemantics;
+  supportsStreamChannels;
+  supportsTxAudioSource;
+  driveHasTrx;
+  detector;
+  resolver;
+  constructor(options) {
+    this.id = options.id;
+    this.label = options.label;
+    this.streamLengthSemantics = options.streamLengthSemantics;
+    this.supportsStreamChannels = options.supportsStreamChannels;
+    this.supportsTxAudioSource = options.supportsTxAudioSource;
+    this.driveHasTrx = options.driveHasTrx;
+    this.detector = options.detect;
+    this.resolver = options.resolve;
+  }
+  detect(context) {
+    return this.detector(context);
+  }
+  resolve(context) {
+    return this.resolver?.(context) ?? this;
+  }
+  buildDriveSetArgs(trx, value) {
+    return this.driveHasTrx ? [trx, value] : [value];
+  }
+  buildDriveReadArgs(trx) {
+    return this.driveHasTrx ? [trx] : [];
+  }
+  parseDrive(args, defaultTrx) {
+    return parseDriveState(args, defaultTrx, this.driveHasTrx);
+  }
+  buildTuneDriveSetArgs(trx, value) {
+    return this.driveHasTrx ? [trx, value] : [value];
+  }
+  buildTuneDriveReadArgs(trx) {
+    return this.driveHasTrx ? [trx] : [];
+  }
+  parseTuneDrive(args, defaultTrx) {
+    return parseDriveState(args, defaultTrx, this.driveHasTrx);
+  }
+};
+function parseDriveState(args, defaultTrx, hasTrx) {
+  const trx = hasTrx ? Number(args[0]) : defaultTrx;
+  const value = Number(args[hasTrx ? 1 : 0]);
+  if (!Number.isInteger(trx) || !Number.isFinite(value)) return void 0;
+  return { trx, value };
+}
+function version(context) {
+  return parseTciVersion(context.identity.protocolVersion);
+}
+function programIncludes(context, value) {
+  return context.identity.programName?.toLowerCase().includes(value) ?? false;
+}
+var expertSdr14Dialect = new StandardTciDialect({
+  id: "expertsdr-1.4",
+  label: "ExpertSDR / TCI 1.4",
+  streamLengthSemantics: "per-channel",
+  supportsStreamChannels: false,
+  supportsTxAudioSource: false,
+  driveHasTrx: false,
+  detect: (context) => {
+    const parsed = version(context);
+    if (!parsed || compareTciVersion(parsed, [1, 4]) > 0) return { score: 0, evidence: [] };
+    return { score: 80 + (programIncludes(context, "expert") ? 10 : 0), evidence: [`protocol ${formatVersion(parsed)} <= 1.4`] };
+  }
+});
+var expertSdrLegacyDialect = new StandardTciDialect({
+  id: "expertsdr-1.5-1.8",
+  label: "ExpertSDR / TCI 1.5-1.8",
+  streamLengthSemantics: "per-channel",
+  supportsStreamChannels: false,
+  supportsTxAudioSource: false,
+  driveHasTrx: true,
+  detect: (context) => {
+    const parsed = version(context);
+    if (!parsed || compareTciVersion(parsed, [1, 5]) < 0 || compareTciVersion(parsed, [1, 9]) >= 0) return { score: 0, evidence: [] };
+    return { score: 80 + (programIncludes(context, "expert") ? 10 : 0), evidence: [`protocol ${formatVersion(parsed)} is in 1.5-1.8`] };
+  }
+});
+var expertSdrModernDialect = new StandardTciDialect({
+  id: "expertsdr-1.9-2.0",
+  label: "ExpertSDR / TCI 1.9-2.0",
+  streamLengthSemantics: "scalar",
+  supportsStreamChannels: true,
+  supportsTxAudioSource: true,
+  driveHasTrx: true,
+  detect: (context) => {
+    const parsed = version(context);
+    if (!parsed || compareTciVersion(parsed, [1, 9]) < 0) return { score: 0, evidence: [] };
+    const future = compareTciVersion(parsed, [2, 0]) > 0;
+    return {
+      score: 70 + (programIncludes(context, "expert") ? 15 : 0),
+      evidence: [`protocol ${formatVersion(parsed)} uses modern stream negotiation`],
+      warnings: future ? [`Unknown future TCI version ${formatVersion(parsed)}; using the modern dialect`] : []
+    };
+  }
+});
+var thetisDialect = new StandardTciDialect({
+  id: "thetis-2.0",
+  label: "Thetis / TCI 2.0",
+  streamLengthSemantics: "scalar",
+  supportsStreamChannels: true,
+  supportsTxAudioSource: true,
+  driveHasTrx: true,
+  detect: (context) => {
+    const evidence = [];
+    let score = 0;
+    if (programIncludes(context, "thetis")) {
+      score += 120;
+      evidence.push("PROTOCOL program is Thetis");
+    }
+    const observed = ["tx_frequency_ex", "tx_profiles_ex", "tx_profile_ex", "calibration_ex"].filter((name) => context.commandNames.has(name));
+    if (observed.length > 0) {
+      score += 100;
+      evidence.push(`Thetis extension commands: ${observed.join(", ")}`);
+    }
+    if (/anan|hermes|orion|saturn/i.test(context.identity.device ?? "")) {
+      score += 30;
+      evidence.push(`Thetis-family device: ${context.identity.device}`);
+    }
+    return { score, evidence };
+  }
+});
+var aetherSdrDialect = new StandardTciDialect({
+  id: "aethersdr-1.5",
+  label: "AetherSDR / TCI 1.5 hybrid",
+  streamLengthSemantics: "scalar",
+  supportsStreamChannels: true,
+  supportsTxAudioSource: true,
+  driveHasTrx: true,
+  detect: (context) => {
+    if (!/^aethersdr$/i.test(context.identity.device ?? "")) return { score: 0, evidence: [] };
+    const evidence = [`AetherSDR device identity: ${context.identity.device}`];
+    const modernAudioCommands = ["audio_stream_sample_type", "audio_stream_channels", "audio_stream_samples"].filter((name) => context.commandNames.has(name));
+    if (modernAudioCommands.length > 0) evidence.push(`Modern audio negotiation: ${modernAudioCommands.join(", ")}`);
+    return {
+      score: 150,
+      evidence,
+      warnings: context.identity.protocolVersion === "1.5" ? ["AetherSDR reports TCI 1.5 but uses modern scalar audio stream semantics"] : []
+    };
+  }
+});
+var genericObservedDialect = new StandardTciDialect({
+  id: "generic-observed",
+  label: "Generic observed TCI",
+  streamLengthSemantics: "auto",
+  supportsStreamChannels: true,
+  supportsTxAudioSource: true,
+  driveHasTrx: true,
+  detect: (context) => ({
+    score: context.commandNames.has("ready") ? 10 : 0,
+    evidence: ["No vendor-specific match; using observed command shapes"],
+    warnings: ["Dialect identity is uncertain"]
+  }),
+  resolve: (context) => {
+    const drive = [...context.commands].reverse().find((command) => command.name === "drive");
+    const driveHasTrx = (drive?.args.length ?? 0) >= 2;
+    return new StandardTciDialect({
+      id: "generic-observed",
+      label: "Generic observed TCI",
+      streamLengthSemantics: "auto",
+      supportsStreamChannels: context.commandNames.has("audio_stream_channels"),
+      supportsTxAudioSource: compareTciVersion(version(context) ?? [0], [2, 0]) >= 0,
+      driveHasTrx,
+      detect: genericObservedDialect.detect.bind(genericObservedDialect)
+    });
+  }
+});
+var builtInDialects = [
+  aetherSdrDialect,
+  thetisDialect,
+  expertSdr14Dialect,
+  expertSdrLegacyDialect,
+  expertSdrModernDialect,
+  genericObservedDialect
+];
+function parseTciVersion(value) {
+  if (!value) return void 0;
+  const match = value.trim().match(/^(\d+)(?:\.(\d+))?(?:\.(\d+))?/);
+  if (!match) return void 0;
+  return match.slice(1).filter((part) => part !== void 0).map(Number);
+}
+function compareTciVersion(left, right) {
+  const length = Math.max(left.length, right.length);
+  for (let index = 0; index < length; index += 1) {
+    const difference = (left[index] ?? 0) - (right[index] ?? 0);
+    if (difference !== 0) return difference;
+  }
+  return 0;
+}
+function formatVersion(value) {
+  return value.join(".");
+}
+
+// src/dialect/registry.ts
+var TciDialectRegistry = class {
+  dialects = /* @__PURE__ */ new Map();
+  constructor(dialects = builtInDialects) {
+    for (const dialect of dialects) this.register(dialect);
+  }
+  register(dialect) {
+    this.dialects.set(dialect.id, dialect);
+  }
+  get(id) {
+    return this.dialects.get(id);
+  }
+  list() {
+    return [...this.dialects.values()];
+  }
+  select(context, selection = "auto") {
+    if (typeof selection === "object") {
+      return { dialect: selection, confidence: "manual", evidence: ["Custom dialect supplied by caller"], warnings: [] };
+    }
+    if (selection !== "auto") {
+      const dialect = this.get(selection);
+      if (!dialect) throw new TciError("unknown-dialect", `Unknown TCI dialect: ${selection}`);
+      return { dialect: dialect.resolve?.(context) ?? dialect, confidence: "manual", evidence: [`Dialect ${selection} selected by caller`], warnings: [] };
+    }
+    const candidates = this.list().map((dialect) => ({ dialect, result: dialect.detect(context) })).sort((left, right) => right.result.score - left.result.score);
+    const selected = candidates[0];
+    if (!selected || selected.result.score <= 0) {
+      throw new TciError("unknown-dialect", "Unable to identify the TCI server dialect");
+    }
+    return {
+      dialect: selected.dialect.resolve?.(context) ?? selected.dialect,
+      confidence: selected.result.score >= 100 ? "high" : selected.result.score >= 70 ? "medium" : "low",
+      evidence: selected.result.evidence,
+      warnings: selected.result.warnings ?? []
+    };
+  }
+};
+var defaultTciDialectRegistry = new TciDialectRegistry();
+
+// src/dialect/handshake.ts
+var IDENTITY_COMMANDS = /* @__PURE__ */ new Set(["protocol", "device", "trx_count", "channels_count", "channel_count"]);
+var STATE_COMMANDS = /* @__PURE__ */ new Set(["vfo", "modulation", "modulations_list", "trx", "drive"]);
+function parseProtocolIdentity(commands) {
+  const protocol = [...commands].reverse().find((command) => command.name === "protocol");
+  const device = [...commands].reverse().find((command) => command.name === "device");
+  const rawProtocolArgs = protocol?.args ?? [];
+  const firstLooksLikeVersion = /^\d+(?:\.\d+){0,2}/.test(rawProtocolArgs[0] ?? "");
+  return {
+    programName: firstLooksLikeVersion ? void 0 : rawProtocolArgs[0],
+    protocolVersion: firstLooksLikeVersion ? rawProtocolArgs[0] : rawProtocolArgs[1],
+    rawProtocolArgs: [...rawProtocolArgs],
+    device: device?.args.join(",")
+  };
+}
+function assertValidTciHandshake(commands) {
+  const names = new Set(commands.map((command) => command.name));
+  if (!names.has("ready")) throw new TciError("handshake-timeout", "TCI READY was not received");
+  const categories = [
+    [...IDENTITY_COMMANDS].some((name) => names.has(name)),
+    [...STATE_COMMANDS].some((name) => names.has(name))
+  ].filter(Boolean).length;
+  const identitySignals = [...IDENTITY_COMMANDS].filter((name) => names.has(name)).length;
+  if (categories < 2 && identitySignals < 2) {
+    throw new TciError("invalid-handshake", "WebSocket opened but did not provide enough TCI initialization evidence");
+  }
+}
+
+// src/transport/WebSocketTransport.ts
+var import_eventemitter3 = require("eventemitter3");
+var import_ws = __toESM(require("ws"), 1);
+var WebSocketTciTransport = class extends import_eventemitter3.EventEmitter {
+  constructor(url, WebSocketImpl = import_ws.default) {
+    super();
+    this.url = url;
+    this.WebSocketImpl = WebSocketImpl;
+  }
+  url;
+  WebSocketImpl;
+  socket;
+  async connect(timeoutMs) {
+    if (this.socket?.readyState === import_ws.default.OPEN) return;
+    const socket = new this.WebSocketImpl(this.url);
+    this.socket = socket;
+    await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        cleanup();
+        this.terminate();
+        reject(new TciError("connect-timeout", `Timed out connecting to ${this.url}`));
+      }, timeoutMs);
+      const cleanup = () => {
+        clearTimeout(timer);
+        socket.off("open", onOpen);
+        socket.off("close", onCloseBeforeOpen);
+        socket.off("error", onErrorBeforeOpen);
+      };
+      const onOpen = () => {
+        cleanup();
+        this.attach(socket);
+        this.emit("connected");
+        resolve();
+      };
+      const onCloseBeforeOpen = () => {
+        cleanup();
+        reject(new TciError("disconnected", `Disconnected while connecting to ${this.url}`));
+      };
+      const onErrorBeforeOpen = (error) => {
+        cleanup();
+        reject(toTciError(error, "disconnected"));
+      };
+      socket.once("open", onOpen);
+      socket.once("close", onCloseBeforeOpen);
+      socket.once("error", onErrorBeforeOpen);
+    });
+  }
+  async disconnect(code = 1e3, reason = "client disconnect") {
+    const socket = this.socket;
+    if (!socket || socket.readyState === import_ws.default.CLOSED) return;
+    await new Promise((resolve) => {
+      const timer = setTimeout(resolve, 1e3);
+      timer.unref?.();
+      socket.once("close", () => {
+        clearTimeout(timer);
+        resolve();
+      });
+      socket.once("error", () => {
+        clearTimeout(timer);
+        resolve();
+      });
+      socket.close(code, reason);
+    });
+  }
+  isConnected() {
+    return this.socket?.readyState === import_ws.default.OPEN;
+  }
+  async sendText(raw) {
+    await this.send(raw);
+  }
+  async sendBinary(raw) {
+    await this.send(raw, true);
+  }
+  terminate() {
+    try {
+      this.socket?.terminate();
+    } catch {
+    }
+  }
+  attach(socket) {
+    socket.on("message", (data, isBinary) => {
+      try {
+        const buffer = dataToBuffer(data);
+        if (isBinary) this.emit("binary", buffer);
+        else this.emit("text", buffer.toString("utf8"));
+      } catch (error) {
+        this.emit("error", error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+    socket.on("close", (code, reason) => {
+      if (this.socket === socket) this.socket = void 0;
+      this.emit("disconnected", { code, reason: reason.toString("utf8") });
+    });
+    socket.on("error", (error) => this.emit("error", error));
+  }
+  async send(data, binary = false) {
+    const socket = this.socket;
+    if (!socket || socket.readyState !== import_ws.default.OPEN) {
+      throw new TciError("not-connected", "TCI socket is not connected");
+    }
+    await new Promise((resolve, reject) => {
+      socket.send(data, { binary }, (error) => error ? reject(error) : resolve());
+    });
+  }
+};
+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");
+}
+
 // src/client/TciClient.ts
-var TciClient = class extends import_eventemitter3.EventEmitter {
+var TciClient = class extends import_eventemitter32.EventEmitter {
   options;
   WebSocketImpl;
-  ws;
+  transportFactory;
+  transport;
   queue;
   state;
+  stateReducers;
+  dialectRegistry;
+  activeDialect;
+  handshakeResult;
+  handshakeError;
+  initializationCommands = [];
+  handshakeWaiter;
   constructor(options) {
     super();
     this.options = {
@@ -624,13 +1066,17 @@ var TciClient = class extends import_eventemitter3.EventEmitter {
       trx: options.trx ?? 0,
       vfo: options.vfo ?? 0,
       connectTimeoutMs: options.connectTimeoutMs ?? 5e3,
+      handshakeTimeoutMs: options.handshakeTimeoutMs ?? 1e4,
       commandTimeoutMs: options.commandTimeoutMs ?? 1e3,
       writeAckMode: options.writeAckMode ?? "state",
       writeTimeoutMs: options.writeTimeoutMs ?? 3e3,
       writeSettleMs: options.writeSettleMs ?? 0,
-      frequencyWriteSettleMs: options.frequencyWriteSettleMs ?? 250
+      frequencyWriteSettleMs: options.frequencyWriteSettleMs ?? 250,
+      dialect: options.dialect ?? "auto"
     };
-    this.WebSocketImpl = options.WebSocketImpl ?? import_ws.default;
+    this.dialectRegistry = options.dialectRegistry ?? defaultTciDialectRegistry;
+    this.WebSocketImpl = options.WebSocketImpl ?? import_ws2.default;
+    this.transportFactory = options.transportFactory ?? ((url) => new WebSocketTciTransport(url, this.WebSocketImpl));
     this.queue = new TciCommandQueue({
       timeoutMs: this.options.commandTimeoutMs,
       send: (raw) => this.sendRaw(raw)
@@ -646,58 +1092,49 @@ var TciClient = class extends import_eventemitter3.EventEmitter {
       pttSource: {},
       tune: {},
       drive: {},
+      tuneDrive: {},
       split: {},
+      dialectWarnings: [],
       rxSensors: {},
       txSensors: {}
     };
+    this.stateReducers = this.createStateReducers();
   }
   async connect() {
-    if (this.ws?.readyState === import_ws.default.OPEN) {
-      return;
+    if (this.transport?.isConnected()) {
+      return this.handshakeResult ?? this.waitForHandshake();
     }
-    if (this.ws && this.ws.readyState === import_ws.default.CONNECTING) {
-      await this.waitForOpen(this.ws);
-      return;
+    this.resetHandshake();
+    const transport = this.transportFactory(this.options.url);
+    this.transport = transport;
+    this.attachTransport(transport);
+    await transport.connect(this.options.connectTimeoutMs);
+    this.state.connected = true;
+    this.queue.setConnected(true);
+    this.emit("connected");
+    this.emitState();
+    try {
+      return await this.waitForHandshake();
+    } catch (error) {
+      transport.terminate();
+      throw error;
     }
-    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?.();
-    });
+    const transport = this.transport;
+    if (!transport) return;
+    await transport.disconnect(code, reason);
     this.handleClose();
   }
   isConnected() {
-    return this.ws?.readyState === import_ws.default.OPEN;
+    return this.transport?.isConnected() ?? false;
   }
   getState() {
     return cloneState(this.state);
   }
+  getHandshakeResult() {
+    return this.handshakeResult ? cloneHandshake(this.handshakeResult) : void 0;
+  }
   async sendCommand(name, args = [], options = {}) {
     const raw = formatTciCommand(name, args);
     if (options.waitForReply === false) {
@@ -771,6 +1208,9 @@ var TciClient = class extends import_eventemitter3.EventEmitter {
   }
   async setPtt(enabled, options = {}) {
     const trx = options.trx ?? this.options.trx;
+    if (options.source && !this.requireDialect().supportsTxAudioSource) {
+      throw new TciError("protocol-error", `TCI dialect ${this.requireDialect().id} does not support a TRX audio source argument`);
+    }
     const args = options.source ? [trx, enabled, options.source] : [trx, enabled];
     await this.sendStateWrite(
       "TRX",
@@ -784,16 +1224,107 @@ var TciClient = class extends import_eventemitter3.EventEmitter {
     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 setTune(enabled, trx = this.options.trx, options = {}) {
+    try {
+      await this.sendStateWrite(
+        "TUNE",
+        [trx, enabled],
+        (state) => state.tune[String(trx)] === enabled,
+        `TUNE:${trx},${enabled}`,
+        options
+      );
+    } catch (error) {
+      if (!(error instanceof TciError) || error.code !== "command-timeout") throw error;
+      await this.request("TUNE", [trx], { timeoutMs: options.timeoutMs });
+      if (this.state.tune[String(trx)] !== enabled) throw error;
+    }
   }
   async setDrive(value, trx = this.options.trx) {
-    await this.sendCommand("DRIVE", [trx, value]);
+    await this.setDriveWithResult(value, trx);
   }
-  async setSplit(enabled, trx = this.options.trx) {
-    await this.sendCommand("SPLIT_ENABLE", [trx, enabled]);
+  async setDriveWithResult(value, trx = this.options.trx, options = {}) {
+    const requested = normalizePercent(value);
+    const dialect = this.requireDialect();
+    if (this.state.drive[String(trx)] === requested) {
+      return writeResult(requested, requested, "state");
+    }
+    const timeoutMs = options.timeoutMs ?? this.options.writeTimeoutMs;
+    const waiter = this.waitForCommand(
+      (command) => command.name === "drive" && dialect.parseDrive(command.args, trx)?.trx === trx,
+      Math.min(500, timeoutMs),
+      `DRIVE state for TRX ${trx}`
+    );
+    await this.sendCommand("DRIVE", dialect.buildDriveSetArgs(trx, requested), { waitForReply: false });
+    try {
+      const command = await waiter.promise;
+      const applied2 = dialect.parseDrive(command.args, trx)?.value;
+      if (applied2 !== void 0) return writeResult(requested, applied2, "state");
+    } catch (error) {
+      if (!(error instanceof TciError) || error.code !== "command-timeout") throw error;
+    } finally {
+      waiter.cancel();
+    }
+    const reply = await this.request("DRIVE", dialect.buildDriveReadArgs(trx), {
+      timeoutMs: Math.max(1, timeoutMs - Math.min(500, timeoutMs))
+    });
+    const applied = dialect.parseDrive(reply.args, trx)?.value;
+    if (applied === void 0) throw new TciError("protocol-error", `Invalid DRIVE readback: ${reply.raw}`);
+    return writeResult(requested, applied, "readback");
+  }
+  async getDrive(trx = this.options.trx) {
+    const dialect = this.requireDialect();
+    const reply = await this.request("DRIVE", dialect.buildDriveReadArgs(trx));
+    return dialect.parseDrive(reply.args, trx)?.value ?? this.state.drive[String(trx)];
+  }
+  async setTuneDrive(value, trx = this.options.trx, options = {}) {
+    const requested = normalizePercent(value);
+    const dialect = this.requireDialect();
+    if (this.state.tuneDrive[String(trx)] === requested) return writeResult(requested, requested, "state");
+    const timeoutMs = options.timeoutMs ?? this.options.writeTimeoutMs;
+    const waiter = this.waitForCommand(
+      (command) => command.name === "tune_drive" && dialect.parseTuneDrive(command.args, trx)?.trx === trx,
+      Math.min(500, timeoutMs),
+      `TUNE_DRIVE state for TRX ${trx}`
+    );
+    await this.sendCommand("TUNE_DRIVE", dialect.buildTuneDriveSetArgs(trx, requested), { waitForReply: false });
+    try {
+      const command = await waiter.promise;
+      const applied2 = dialect.parseTuneDrive(command.args, trx)?.value;
+      if (applied2 !== void 0) return writeResult(requested, applied2, "state");
+    } catch (error) {
+      if (!(error instanceof TciError) || error.code !== "command-timeout") throw error;
+    } finally {
+      waiter.cancel();
+    }
+    const reply = await this.request("TUNE_DRIVE", dialect.buildTuneDriveReadArgs(trx), {
+      timeoutMs: Math.max(1, timeoutMs - Math.min(500, timeoutMs))
+    });
+    const applied = dialect.parseTuneDrive(reply.args, trx)?.value;
+    if (applied === void 0) throw new TciError("protocol-error", `Invalid TUNE_DRIVE readback: ${reply.raw}`);
+    return writeResult(requested, applied, "readback");
+  }
+  async getTuneDrive(trx = this.options.trx) {
+    const dialect = this.requireDialect();
+    const reply = await this.request("TUNE_DRIVE", dialect.buildTuneDriveReadArgs(trx));
+    return dialect.parseTuneDrive(reply.args, trx)?.value ?? this.state.tuneDrive[String(trx)];
+  }
+  async setSplit(enabled, trx = this.options.trx, options = {}) {
+    try {
+      await this.sendStateWrite(
+        "SPLIT_ENABLE",
+        [trx, enabled],
+        (state) => state.split[String(trx)] === enabled,
+        `SPLIT_ENABLE:${trx},${enabled}`,
+        options
+      );
+    } catch (error) {
+      if (!(error instanceof TciError) || error.code !== "command-timeout") throw error;
+      await this.request("SPLIT_ENABLE", [trx], { timeoutMs: options.timeoutMs });
+      if (this.state.split[String(trx)] !== enabled) throw error;
+    }
   }
   async configureAudio(config) {
+    const dialect = this.requireDialect();
     const audio = {
       sampleRate: config.sampleRate,
       sampleType: normalizeSampleType(config.sampleType ?? 3 /* FLOAT32 */),
@@ -804,11 +1335,13 @@ var TciClient = class extends import_eventemitter3.EventEmitter {
     };
     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 });
+    if (dialect.supportsStreamChannels) {
+      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();
   }
@@ -827,9 +1360,27 @@ var TciClient = class extends import_eventemitter3.EventEmitter {
     }
   }
   sendTxAudio(options) {
-    const frame = buildTxAudioFrame({ receiver: this.options.receiver, ...options });
+    const frame = buildTxAudioFrame({
+      receiver: this.options.receiver,
+      lengthSemantics: this.requireDialect().streamLengthSemantics,
+      ...options
+    });
     this.sendRawBinary(frame);
   }
+  sendTxAudioForChrono(request, samples) {
+    const channels = Math.max(1, Math.floor(request.channels || 1));
+    const targetSampleLength = Math.max(0, Math.floor(request.sampleCount));
+    const output = new Float32Array(targetSampleLength);
+    const source = samples instanceof Float32Array ? samples : Float32Array.from(samples);
+    output.set(source.subarray(0, output.length));
+    this.sendTxAudio({
+      receiver: request.receiver,
+      sampleRate: request.sampleRate,
+      sampleType: request.sampleType,
+      channels,
+      samples: output
+    });
+  }
   async setRxSensorsEnabled(enabled, intervalMs) {
     const args = intervalMs === void 0 ? [enabled] : [enabled, intervalMs];
     await this.sendCommand("RX_SENSORS_ENABLE", args, { waitForReply: false });
@@ -916,78 +1467,147 @@ var TciClient = class extends import_eventemitter3.EventEmitter {
       cancel: cleanup
     };
   }
-  waitForOpen(ws) {
+  waitForCommand(predicate, timeoutMs, description) {
+    let timer;
+    let resolvePromise;
+    let rejectPromise;
+    const cleanup = () => {
+      if (timer) clearTimeout(timer);
+      timer = void 0;
+      this.off("command", onCommand);
+      this.off("disconnected", onDisconnected);
+    };
+    const onCommand = (command) => {
+      if (!predicate(command)) return;
+      cleanup();
+      resolvePromise(command);
+    };
+    const onDisconnected = () => {
+      cleanup();
+      rejectPromise(new TciError("disconnected", `Disconnected while waiting for ${description}`));
+    };
+    const promise = new Promise((resolve, reject) => {
+      resolvePromise = resolve;
+      rejectPromise = reject;
+      timer = setTimeout(() => {
+        cleanup();
+        reject(new TciError("command-timeout", `Timed out waiting for ${description}`));
+      }, timeoutMs);
+      this.on("command", onCommand);
+      this.on("disconnected", onDisconnected);
+    });
+    return { promise, cancel: cleanup };
+  }
+  resetHandshake() {
+    this.rejectHandshake(new TciError("cancelled", "TCI handshake replaced by a new connection"));
+    this.handshakeResult = void 0;
+    this.handshakeError = void 0;
+    this.activeDialect = void 0;
+    this.initializationCommands = [];
+    this.state.ready = false;
+    this.state.protocol = void 0;
+    this.state.protocolName = void 0;
+    this.state.protocolVersion = void 0;
+    this.state.dialectId = void 0;
+    this.state.dialectConfidence = void 0;
+    this.state.dialectWarnings = [];
+  }
+  waitForHandshake() {
+    if (this.handshakeResult) return Promise.resolve(cloneHandshake(this.handshakeResult));
+    if (this.handshakeError) return Promise.reject(this.handshakeError);
+    if (this.handshakeWaiter) {
+      return new Promise((resolve, reject) => {
+        const onHandshake = (result) => {
+          cleanup();
+          resolve(result);
+        };
+        const onError = (error) => {
+          cleanup();
+          reject(error);
+        };
+        const cleanup = () => {
+          this.off("handshake", onHandshake);
+          this.off("error", onError);
+        };
+        this.once("handshake", onHandshake);
+        this.once("error", onError);
+      });
+    }
     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);
+        const error = new TciError("handshake-timeout", `Timed out waiting for TCI READY from ${this.options.url}`);
+        this.handshakeWaiter = void 0;
+        reject(error);
+      }, this.options.handshakeTimeoutMs);
+      this.handshakeWaiter = { resolve, reject, timer };
     });
   }
-  attachSocket(ws) {
-    ws.on("message", (data, isBinary) => this.handleMessage(data, isBinary));
-    ws.on("close", () => this.handleClose());
-    ws.on("error", (error) => this.handleError(error));
+  finalizeHandshake() {
+    if (this.handshakeResult) return this.handshakeResult;
+    assertValidTciHandshake(this.initializationCommands);
+    const identity = parseProtocolIdentity(this.initializationCommands);
+    const commandNames = [...new Set(this.initializationCommands.map((command) => command.name))];
+    const dialect = this.dialectRegistry.select(
+      { identity, commands: this.initializationCommands, commandNames: new Set(commandNames) },
+      this.options.dialect
+    );
+    const result = { identity, dialect, ready: true, commandNames };
+    this.handshakeResult = result;
+    this.activeDialect = dialect.dialect;
+    this.state.protocolName = identity.programName;
+    this.state.protocolVersion = identity.protocolVersion;
+    this.state.protocol = identity.protocolVersion ?? identity.programName;
+    this.state.device = identity.device ?? this.state.device;
+    this.state.dialectId = dialect.dialect.id;
+    this.state.dialectConfidence = dialect.confidence;
+    this.state.dialectWarnings = [...dialect.warnings];
+    const waiter = this.handshakeWaiter;
+    this.handshakeWaiter = void 0;
+    if (waiter) {
+      clearTimeout(waiter.timer);
+      waiter.resolve(cloneHandshake(result));
+    }
+    this.emit("handshake", cloneHandshake(result));
+    return result;
+  }
+  rejectHandshake(error) {
+    const waiter = this.handshakeWaiter;
+    this.handshakeWaiter = void 0;
+    if (!waiter) return;
+    clearTimeout(waiter.timer);
+    waiter.reject(error);
+  }
+  requireDialect() {
+    if (!this.activeDialect) throw new TciError("invalid-handshake", "TCI dialect is not available before READY");
+    return this.activeDialect;
+  }
+  attachTransport(transport) {
+    transport.on("text", (raw) => this.handleText(raw));
+    transport.on("binary", (raw) => this.handleBinary(raw));
+    transport.on("disconnected", (reason) => this.handleClose(reason));
+    transport.on("error", (error) => this.handleError(error));
   }
   async sendRaw(raw) {
-    const ws = this.ws;
-    if (!ws || ws.readyState !== import_ws.default.OPEN) {
+    const transport = this.transport;
+    if (!transport?.isConnected()) {
       throw new TciError("not-connected", "TCI socket is not connected");
     }
     this.emit("tci:tx", raw);
-    await new Promise((resolve, reject) => {
-      ws.send(raw, (error) => error ? reject(error) : resolve());
-    });
+    await transport.sendText(raw);
   }
   sendRawBinary(raw) {
-    const ws = this.ws;
-    if (!ws || ws.readyState !== import_ws.default.OPEN) {
+    const transport = this.transport;
+    if (!transport?.isConnected()) {
       throw new TciError("not-connected", "TCI socket is not connected");
     }
-    ws.send(raw, { binary: true });
+    void transport.sendBinary(raw).catch((error) => this.handleError(error));
   }
-  handleMessage(data, isBinary) {
+  handleText(raw) {
     try {
-      if (isBinary) {
-        this.handleBinary(data);
-        return;
-      }
-      const raw = dataToBuffer(data).toString("utf8");
       const commands = parseTciText(raw);
       this.emit("tci:rx", raw, commands);
       for (const command of commands) {
+        if (!this.handshakeResult) this.initializationCommands.push(command);
         this.queue.handleCommand(command);
         this.applyCommand(command);
         this.emit("command", command);
@@ -997,7 +1617,10 @@ var TciClient = class extends import_eventemitter3.EventEmitter {
     }
   }
   handleBinary(data) {
-    const frame = parseStreamFrame(dataToBuffer(data));
+    const frame = parseStreamFrame(data, {
+      lengthSemantics: this.requireDialect().streamLengthSemantics,
+      negotiatedChannels: this.state.audio?.channels
+    });
     this.emit("tci:binary", frame);
     this.emit("binary", frame);
     switch (frame.streamType) {
@@ -1011,7 +1634,8 @@ var TciClient = class extends import_eventemitter3.EventEmitter {
           sampleRate: frame.sampleRate,
           channels: frame.channels,
           sampleType: frame.sampleType,
-          sampleCount: frame.sampleCount
+          sampleCount: frame.sampleCount,
+          frameCount: frame.frameCount
         });
         break;
       case 4 /* LINEOUT_STREAM */:
@@ -1023,80 +1647,78 @@ var TciClient = class extends import_eventemitter3.EventEmitter {
   }
   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;
-    }
+    this.stateReducers.get(command.name)?.(command.args);
     if (!readyBefore && this.state.ready) {
-      this.emit("ready", this.getState());
+      try {
+        this.finalizeHandshake();
+        this.emit("ready", this.getState());
+      } catch (error) {
+        const tciError = toTciError(error, "invalid-handshake");
+        this.handshakeError = tciError;
+        this.state.ready = false;
+        this.rejectHandshake(tciError);
+        this.handleError(tciError);
+      }
     }
     this.emitState();
   }
+  createStateReducers() {
+    const reducers = /* @__PURE__ */ new Map();
+    reducers.set("ready", (args) => {
+      this.state.ready = args.length === 0 ? true : parseBoolean(args[0]) ?? true;
+    });
+    reducers.set("protocol", (args) => {
+      if (/^\d+(?:\.\d+){0,2}/.test(args[0] ?? "")) {
+        this.state.protocol = args[0];
+        this.state.protocolVersion = args[0];
+      } else {
+        this.state.protocolName = args[0];
+        this.state.protocolVersion = args[1];
+        this.state.protocol = args[1] ?? args[0];
+      }
+    });
+    reducers.set("device", (args) => {
+      this.state.device = args.join(",");
+    });
+    reducers.set("receive_only", (args) => {
+      this.state.receiveOnly = parseBoolean(args[0]);
+    });
+    reducers.set("trx_count", (args) => {
+      this.state.trxCount = parseNumber(args[0]);
+    });
+    const channelCount = (args) => {
+      this.state.channelCount = parseNumber(args[0]);
+    };
+    reducers.set("channels_count", channelCount);
+    reducers.set("channel_count", channelCount);
+    reducers.set("vfo_limits", (args) => {
+      this.state.vfoLimits = parseNumberPair(args);
+    });
+    reducers.set("if_limits", (args) => {
+      this.state.ifLimits = parseNumberPair(args);
+    });
+    reducers.set("modulations_list", (args) => {
+      this.state.modulations = args.map((mode) => mode.toLowerCase());
+    });
+    reducers.set("vfo", (args) => this.applyVfo(args));
+    reducers.set("modulation", (args) => this.applyModulation(args));
+    reducers.set("trx", (args) => this.applyTrx(args));
+    reducers.set("tune", (args) => this.applyBooleanByFirstArg(this.state.tune, args));
+    reducers.set("drive", (args) => this.applyDrive(args));
+    reducers.set("tune_drive", (args) => this.applyTuneDrive(args));
+    reducers.set("split_enable", (args) => this.applyBooleanByFirstArg(this.state.split, args));
+    reducers.set("rx_channel_sensors", (args) => this.applyRxChannelSensors(args));
+    reducers.set("rx_sensors", (args) => this.applyRxSensors(args));
+    reducers.set("tx_sensors", (args) => this.applyTxSensors(args));
+    reducers.set("audio_samplerate", (args) => this.updateAudioState({ sampleRate: parseNumber(args[0]) }));
+    reducers.set("audio_stream_sample_type", (args) => this.updateAudioState({ sampleType: parseSampleType(args[0]) }));
+    reducers.set("audio_stream_channels", (args) => this.updateAudioState({ channels: parseNumber(args[0]) }));
+    reducers.set("audio_stream_samples", (args) => this.updateAudioState({ samplesPerFrame: parseNumber(args[0]) }));
+    reducers.set("tx_stream_audio_buffering", (args) => this.updateAudioState({ txBufferingMs: parseNumber(args[0]) }));
+    reducers.set("audio_start", () => this.updateAudioState({ running: true }));
+    reducers.set("audio_stop", () => this.updateAudioState({ running: false }));
+    return reducers;
+  }
   applyVfo(args) {
     if (args.length < 3) {
       return;
@@ -1143,18 +1765,22 @@ var TciClient = class extends import_eventemitter3.EventEmitter {
     }
   }
   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;
-    }
+    const parsed = this.activeDialect?.parseDrive(args, this.options.trx) ?? parseObservedDrive(args, this.options.trx);
+    if (parsed) this.state.drive[String(parsed.trx)] = parsed.value;
+  }
+  applyTuneDrive(args) {
+    const parsed = this.activeDialect?.parseTuneDrive(args, this.options.trx) ?? parseObservedDrive(args, this.options.trx);
+    if (parsed) this.state.tuneDrive[String(parsed.trx)] = parsed.value;
+  }
+  updateAudioState(update) {
+    this.state.audio = {
+      sampleRate: update.sampleRate ?? this.state.audio?.sampleRate ?? 12e3,
+      sampleType: update.sampleType ?? this.state.audio?.sampleType ?? 3 /* FLOAT32 */,
+      channels: update.channels ?? this.state.audio?.channels ?? 1,
+      samplesPerFrame: update.samplesPerFrame ?? this.state.audio?.samplesPerFrame ?? 512,
+      txBufferingMs: update.txBufferingMs ?? this.state.audio?.txBufferingMs,
+      running: update.running ?? this.state.audio?.running ?? false
+    };
   }
   applyRxChannelSensors(args) {
     if (args.length < 3) {
@@ -1190,11 +1816,14 @@ var TciClient = class extends import_eventemitter3.EventEmitter {
     };
   }
   handleClose(reason) {
-    this.ws = void 0;
+    const transport = this.transport;
+    this.transport = void 0;
+    transport?.removeAllListeners();
     const wasConnected = this.state.connected;
     this.state.connected = false;
     this.state.ready = false;
     this.queue.setConnected(false);
+    this.rejectHandshake(new TciError("disconnected", "TCI connection closed during handshake", reason));
     if (wasConnected) {
       this.emit("disconnected", reason);
       this.emitState();
@@ -1211,18 +1840,6 @@ var TciClient = class extends import_eventemitter3.EventEmitter {
 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}`;
 }
@@ -1246,6 +1863,27 @@ function parseBoolean(value) {
   }
   return void 0;
 }
+function parseSampleType(value) {
+  if (!value) return void 0;
+  try {
+    return normalizeSampleType(value.toLowerCase());
+  } catch {
+    return void 0;
+  }
+}
+function parseObservedDrive(args, defaultTrx) {
+  const hasTrx = args.length >= 2;
+  const trx = hasTrx ? parseNumber(args[0]) : defaultTrx;
+  const value = parseNumber(args[hasTrx ? 1 : 0]);
+  return trx === void 0 || value === void 0 ? void 0 : { trx, value };
+}
+function normalizePercent(value) {
+  if (!Number.isFinite(value)) throw new TciError("protocol-error", `Invalid TCI percentage: ${value}`);
+  return Math.round(Math.max(0, Math.min(100, value)));
+}
+function writeResult(requested, applied, acknowledgement) {
+  return { requested, applied, outcome: requested === applied ? "applied" : "clamped", acknowledgement };
+}
 function parseNumberPair(args) {
   const first = parseNumber(args[0]);
   const second = parseNumber(args[1]);
@@ -1261,12 +1899,26 @@ function cloneState(state) {
     pttSource: { ...state.pttSource },
     tune: { ...state.tune },
     drive: { ...state.drive },
+    tuneDrive: { ...state.tuneDrive },
     split: { ...state.split },
+    dialectWarnings: [...state.dialectWarnings],
     rxSensors: cloneNested(state.rxSensors),
     txSensors: cloneNested(state.txSensors),
     audio: state.audio ? { ...state.audio } : void 0
   };
 }
+function cloneHandshake(result) {
+  return {
+    identity: { ...result.identity, rawProtocolArgs: [...result.identity.rawProtocolArgs] },
+    dialect: {
+      ...result.dialect,
+      evidence: [...result.dialect.evidence],
+      warnings: [...result.dialect.warnings]
+    },
+    ready: true,
+    commandNames: [...result.commandNames]
+  };
+}
 function cloneNested(value) {
   return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, { ...item }]));
 }
@@ -1275,30 +1927,44 @@ function cloneNested(value) {
   TCI_STREAM_HEADER_BYTES,
   TciClient,
   TciCommandQueue,
+  TciDialectRegistry,
   TciError,
   TciSampleType,
   TciStreamType,
+  WebSocketTciTransport,
+  aetherSdrDialect,
+  assertValidTciHandshake,
   buildStreamFrame,
   buildTxAudioFrame,
+  builtInDialects,
   commandKey,
+  compareTciVersion,
   createTciClient,
+  defaultTciDialectRegistry,
   deinterleaveChannels,
   escapeTciText,
+  expertSdr14Dialect,
+  expertSdrLegacyDialect,
+  expertSdrModernDialect,
   float32ToPcm16,
   formatTciCommand,
+  genericObservedDialect,
   isCommandReplyTo,
   mixToMono,
   normalizeCommandName,
   normalizeSampleType,
   normalizeStreamType,
+  parseProtocolIdentity,
   parseStreamFrame,
   parseTciCommand,
   parseTciText,
+  parseTciVersion,
   payloadToFloat32,
   pcm16ToFloat32,
   sampleTypeBytes,
   sampleTypeName,
   samplesToPayload,
+  thetisDialect,
   toTciError,
   unescapeTciText
 });