tci-client-node 0.3.0 → 0.4.0

package/dist/index.d.cts

@@ -1,17 +1,23 @@
-import { Q as QueueCommandOptions, T as TciError } from './index-lbK6NGY4.cjs';
-export { a as QueuedCommandResult, b as TciCommandMatcher, c as TciCommandQueue, d as TciCommandQueueOptions, e as TciErrorCode, t as toTciError } from './index-lbK6NGY4.cjs';
+import { T as TciError } from './errors-CT3b8LLw.cjs';
+export { a as TciErrorCode, t as toTciError } from './errors-CT3b8LLw.cjs';
 import { EventEmitter } from 'eventemitter3';
 import WebSocket from 'ws';
 import { TciSampleType, TciSampleTypeName, TciStreamFrame, BuildTxAudioFrameOptions } from './audio/index.cjs';
 export { BuildStreamFrameOptions, ParseStreamFrameOptions, TCI_STREAM_HEADER_BYTES, TciStreamType, buildStreamFrame, buildTxAudioFrame, decodeInterleavedIq, deinterleaveChannels, float32ToPcm16, mixToMono, normalizeSampleType, normalizeStreamType, parseStreamFrame, payloadToFloat32, pcm16ToFloat32, sampleTypeBytes, sampleTypeName, samplesToPayload } from './audio/index.cjs';
 import { T as TciCommand } from './text-BwCWY1k1.cjs';
 export { a as TciCommandInput, c as commandKey, e as escapeTciText, f as formatTciCommand, i as isCommandReplyTo, n as normalizeCommandName, p as parseTciCommand, b as parseTciText, u as unescapeTciText } from './text-BwCWY1k1.cjs';
-import { T as TciWriteResult, a as TciDialectId, b as TciHandshakeResult, c as TciDialectSelection } from './types-1YXGwrgI.cjs';
-export { B as BuiltInTciDialectId, d as TciDialect, e as TciDialectDetection, f as TciDialectDetectionContext, g as TciDialectScore, h as TciDriveState, i as TciProtocolIdentity, j as TciStreamLengthSemantics } from './types-1YXGwrgI.cjs';
+import { QueueCommandOptions } from './protocol/index.cjs';
+export { QueuedCommandResult, TciCommandMatcher, TciCommandQueue, TciCommandQueueOptions } from './protocol/index.cjs';
+import { T as TciWriteResult, a as TciDialectId, b as TciHandshakeResult, c as TciDialectSelection } from './types-CYK_NOTz.cjs';
+export { B as BuiltInTciDialectId, d as TciDialect, e as TciDialectDetection, f as TciDialectDetectionContext, g as TciDialectScore, h as TciDriveState, i as TciProtocolIdentity, j as TciStreamLengthSemantics } from './types-CYK_NOTz.cjs';
 import { TciDialectRegistry } from './dialect/index.cjs';
 export { aetherSdrDialect, assertValidTciHandshake, builtInDialects, compareTciVersion, defaultTciDialectRegistry, expertSdr14Dialect, expertSdrLegacyDialect, expertSdrModernDialect, genericObservedDialect, parseProtocolIdentity, parseTciVersion, thetisDialect } from './dialect/index.cjs';
 import { TciTransportFactory } from './transport/index.cjs';
 export { TciTransport, TciTransportEvents, WebSocketTciTransport } from './transport/index.cjs';
+import { T as TciMeterCapabilities, a as TciMeterStreamOptions } from './types-C4MtLKoy.cjs';
+export { b as TciMeterAdapter, c as TciMeterCommand, d as TciMeterDecodeResult, e as TciMeterDecodedFrame, f as TciMeterInterval, g as TciMeterSupport, h as TciRxMeterFrame, i as TciRxMeterSource, j as TciTxMeterFrame, U as UNKNOWN_TCI_METER_CAPABILITIES, k as cloneMeterCapabilities } from './types-C4MtLKoy.cjs';
+import { TciMeterStreamSession } from './meter/index.cjs';
+export { StandardTciMeterAdapter, TciMeterStreamEvents, createUnknownTciMeterAdapter } from './meter/index.cjs';
 
 interface TciClientOptions {
     url: string;
@@ -175,6 +181,7 @@ declare class TciClient extends EventEmitter<TciClientEvents> {
     private initializationCommands;
     private handshakeWaiter?;
     private activeIqSession?;
+    private activeMeterSession?;
     constructor(options: TciClientOptions);
     connect(): Promise<TciHandshakeResult>;
     disconnect(code?: number, reason?: string): Promise<void>;
@@ -182,6 +189,8 @@ declare class TciClient extends EventEmitter<TciClientEvents> {
     getState(): TciClientState;
     getHandshakeResult(): TciHandshakeResult | undefined;
     getIqCapabilities(): TciIqCapabilities;
+    getMeterCapabilities(): TciMeterCapabilities;
+    openMeterStream(options?: TciMeterStreamOptions): Promise<TciMeterStreamSession>;
     setIqSampleRate(sampleRate: number, timeoutMs?: number): Promise<IqSampleRateResult>;
     openIqStream(options?: TciIqStreamOptions): Promise<TciIqStreamSession>;
     sendCommand(name: string, args?: readonly unknown[], options?: SendCommandOptions): Promise<TciCommand | undefined>;
@@ -240,4 +249,4 @@ declare class TciClient extends EventEmitter<TciClientEvents> {
 }
 declare function createTciClient(options: TciClientOptions): TciClient;
 
-export { BuildTxAudioFrameOptions, type IqSampleRateResult, QueueCommandOptions, type SendCommandOptions, type TciAudioConfig, TciClient, type TciClientEvents, type TciClientOptions, type TciClientState, TciCommand, TciDialectId, TciDialectRegistry, TciDialectSelection, TciError, TciHandshakeResult, type TciIqCapabilities, type TciIqFrame, type TciIqStreamEvents, type TciIqStreamOptions, TciIqStreamSession, type TciPttOptions, TciSampleType, TciSampleTypeName, TciStreamFrame, TciTransportFactory, type TciTxChronoRequest, type TciWriteAckMode, type TciWriteOptions, TciWriteResult, createTciClient };
+export { BuildTxAudioFrameOptions, type IqSampleRateResult, QueueCommandOptions, type SendCommandOptions, type TciAudioConfig, TciClient, type TciClientEvents, type TciClientOptions, type TciClientState, TciCommand, TciDialectId, TciDialectRegistry, TciDialectSelection, TciError, TciHandshakeResult, type TciIqCapabilities, type TciIqFrame, type TciIqStreamEvents, type TciIqStreamOptions, TciIqStreamSession, TciMeterCapabilities, TciMeterStreamOptions, TciMeterStreamSession, type TciPttOptions, TciSampleType, TciSampleTypeName, TciStreamFrame, TciTransportFactory, type TciTxChronoRequest, type TciWriteAckMode, type TciWriteOptions, TciWriteResult, createTciClient };

package/dist/index.d.ts

@@ -1,17 +1,23 @@
-import { Q as QueueCommandOptions, T as TciError } from './index-paj1AOJY.js';
-export { a as QueuedCommandResult, b as TciCommandMatcher, c as TciCommandQueue, d as TciCommandQueueOptions, e as TciErrorCode, t as toTciError } from './index-paj1AOJY.js';
+import { T as TciError } from './errors-CT3b8LLw.js';
+export { a as TciErrorCode, t as toTciError } from './errors-CT3b8LLw.js';
 import { EventEmitter } from 'eventemitter3';
 import WebSocket from 'ws';
 import { TciSampleType, TciSampleTypeName, TciStreamFrame, BuildTxAudioFrameOptions } from './audio/index.js';
 export { BuildStreamFrameOptions, ParseStreamFrameOptions, TCI_STREAM_HEADER_BYTES, TciStreamType, buildStreamFrame, buildTxAudioFrame, decodeInterleavedIq, deinterleaveChannels, float32ToPcm16, mixToMono, normalizeSampleType, normalizeStreamType, parseStreamFrame, payloadToFloat32, pcm16ToFloat32, sampleTypeBytes, sampleTypeName, samplesToPayload } from './audio/index.js';
 import { T as TciCommand } from './text-BwCWY1k1.js';
 export { a as TciCommandInput, c as commandKey, e as escapeTciText, f as formatTciCommand, i as isCommandReplyTo, n as normalizeCommandName, p as parseTciCommand, b as parseTciText, u as unescapeTciText } from './text-BwCWY1k1.js';
-import { T as TciWriteResult, a as TciDialectId, b as TciHandshakeResult, c as TciDialectSelection } from './types-BtPh4Dbd.js';
-export { B as BuiltInTciDialectId, d as TciDialect, e as TciDialectDetection, f as TciDialectDetectionContext, g as TciDialectScore, h as TciDriveState, i as TciProtocolIdentity, j as TciStreamLengthSemantics } from './types-BtPh4Dbd.js';
+import { QueueCommandOptions } from './protocol/index.js';
+export { QueuedCommandResult, TciCommandMatcher, TciCommandQueue, TciCommandQueueOptions } from './protocol/index.js';
+import { T as TciWriteResult, a as TciDialectId, b as TciHandshakeResult, c as TciDialectSelection } from './types-DVIPU-VR.js';
+export { B as BuiltInTciDialectId, d as TciDialect, e as TciDialectDetection, f as TciDialectDetectionContext, g as TciDialectScore, h as TciDriveState, i as TciProtocolIdentity, j as TciStreamLengthSemantics } from './types-DVIPU-VR.js';
 import { TciDialectRegistry } from './dialect/index.js';
 export { aetherSdrDialect, assertValidTciHandshake, builtInDialects, compareTciVersion, defaultTciDialectRegistry, expertSdr14Dialect, expertSdrLegacyDialect, expertSdrModernDialect, genericObservedDialect, parseProtocolIdentity, parseTciVersion, thetisDialect } from './dialect/index.js';
 import { TciTransportFactory } from './transport/index.js';
 export { TciTransport, TciTransportEvents, WebSocketTciTransport } from './transport/index.js';
+import { T as TciMeterCapabilities, a as TciMeterStreamOptions } from './types-C0qVJVSO.js';
+export { b as TciMeterAdapter, c as TciMeterCommand, d as TciMeterDecodeResult, e as TciMeterDecodedFrame, f as TciMeterInterval, g as TciMeterSupport, h as TciRxMeterFrame, i as TciRxMeterSource, j as TciTxMeterFrame, U as UNKNOWN_TCI_METER_CAPABILITIES, k as cloneMeterCapabilities } from './types-C0qVJVSO.js';
+import { TciMeterStreamSession } from './meter/index.js';
+export { StandardTciMeterAdapter, TciMeterStreamEvents, createUnknownTciMeterAdapter } from './meter/index.js';
 
 interface TciClientOptions {
     url: string;
@@ -175,6 +181,7 @@ declare class TciClient extends EventEmitter<TciClientEvents> {
     private initializationCommands;
     private handshakeWaiter?;
     private activeIqSession?;
+    private activeMeterSession?;
     constructor(options: TciClientOptions);
     connect(): Promise<TciHandshakeResult>;
     disconnect(code?: number, reason?: string): Promise<void>;
@@ -182,6 +189,8 @@ declare class TciClient extends EventEmitter<TciClientEvents> {
     getState(): TciClientState;
     getHandshakeResult(): TciHandshakeResult | undefined;
     getIqCapabilities(): TciIqCapabilities;
+    getMeterCapabilities(): TciMeterCapabilities;
+    openMeterStream(options?: TciMeterStreamOptions): Promise<TciMeterStreamSession>;
     setIqSampleRate(sampleRate: number, timeoutMs?: number): Promise<IqSampleRateResult>;
     openIqStream(options?: TciIqStreamOptions): Promise<TciIqStreamSession>;
     sendCommand(name: string, args?: readonly unknown[], options?: SendCommandOptions): Promise<TciCommand | undefined>;
@@ -240,4 +249,4 @@ declare class TciClient extends EventEmitter<TciClientEvents> {
 }
 declare function createTciClient(options: TciClientOptions): TciClient;
 
-export { BuildTxAudioFrameOptions, type IqSampleRateResult, QueueCommandOptions, type SendCommandOptions, type TciAudioConfig, TciClient, type TciClientEvents, type TciClientOptions, type TciClientState, TciCommand, TciDialectId, TciDialectRegistry, TciDialectSelection, TciError, TciHandshakeResult, type TciIqCapabilities, type TciIqFrame, type TciIqStreamEvents, type TciIqStreamOptions, TciIqStreamSession, type TciPttOptions, TciSampleType, TciSampleTypeName, TciStreamFrame, TciTransportFactory, type TciTxChronoRequest, type TciWriteAckMode, type TciWriteOptions, TciWriteResult, createTciClient };
+export { BuildTxAudioFrameOptions, type IqSampleRateResult, QueueCommandOptions, type SendCommandOptions, type TciAudioConfig, TciClient, type TciClientEvents, type TciClientOptions, type TciClientState, TciCommand, TciDialectId, TciDialectRegistry, TciDialectSelection, TciError, TciHandshakeResult, type TciIqCapabilities, type TciIqFrame, type TciIqStreamEvents, type TciIqStreamOptions, TciIqStreamSession, TciMeterCapabilities, TciMeterStreamOptions, TciMeterStreamSession, type TciPttOptions, TciSampleType, TciSampleTypeName, TciStreamFrame, TciTransportFactory, type TciTxChronoRequest, type TciWriteAckMode, type TciWriteOptions, TciWriteResult, createTciClient };

package/dist/index.js

@@ -20,7 +20,7 @@ function toTciError(error, fallbackCode = "protocol-error") {
 }
 
 // src/client/TciClient.ts
-import { EventEmitter as EventEmitter2 } from "eventemitter3";
+import { EventEmitter as EventEmitter3 } from "eventemitter3";
 import WebSocket2 from "ws";
 
 // src/audio/streamFrame.ts
@@ -597,6 +597,302 @@ function ensureSemicolon(command) {
   return command.trim().endsWith(";") ? command.trim() : `${command.trim()};`;
 }
 
+// src/meter/types.ts
+var UNKNOWN_TCI_METER_CAPABILITIES = {
+  rxLevel: "unknown",
+  rxAverageLevel: "unknown",
+  rxPeakBin: "unknown",
+  txMicLevel: "unknown",
+  txRmsPower: "unknown",
+  txPeakPower: "unknown",
+  txSwr: "unknown",
+  txAlcDbfs: "unknown"
+};
+function cloneMeterCapabilities(capabilities) {
+  return { ...capabilities };
+}
+
+// src/meter/adapters.ts
+var StandardTciMeterAdapter = class {
+  declaredCapabilities;
+  options;
+  constructor(options = {}) {
+    this.options = options;
+    this.declaredCapabilities = {
+      ...UNKNOWN_TCI_METER_CAPABILITIES,
+      rxLevel: "declared",
+      txMicLevel: "declared",
+      txRmsPower: "declared",
+      txPeakPower: "declared",
+      txSwr: "declared",
+      rxAverageLevel: options.supportsRxExtended ? "declared" : "unknown",
+      rxPeakBin: options.supportsRxExtended ? "declared" : "unknown",
+      txAlcDbfs: options.txAlcUnit === "dbfs" ? "declared" : "unknown",
+      ...options.capabilities
+    };
+  }
+  normalizeInterval(intervalMs) {
+    const requestedMs = Math.round(intervalMs);
+    if (this.options.interval?.fixedMs !== void 0) {
+      return { requestedMs, appliedMs: this.options.interval.fixedMs };
+    }
+    const minMs = this.options.interval?.minMs ?? requestedMs;
+    const maxMs = this.options.interval?.maxMs ?? requestedMs;
+    const normalized = Math.max(minMs, Math.min(maxMs, requestedMs));
+    return {
+      requestedMs,
+      appliedMs: this.options.interval?.reportsApplied === false ? void 0 : normalized
+    };
+  }
+  buildEnableCommand(kind, enabled, intervalMs) {
+    return {
+      name: kind === "rx" ? "RX_SENSORS_ENABLE" : "TX_SENSORS_ENABLE",
+      args: enabled ? [true, intervalMs] : [false]
+    };
+  }
+  decode(command, receivedAtMs) {
+    switch (command.name) {
+      case "rx_sensors":
+        return decodeRx(command, receivedAtMs, "rx_sensors");
+      case "rx_channel_sensors":
+        return decodeRx(command, receivedAtMs, "rx_channel_sensors");
+      case "rx_channel_sensors_ex":
+        return decodeRx(command, receivedAtMs, "rx_channel_sensors_ex");
+      case "tx_sensors":
+        return decodeTx(command, receivedAtMs, this.options.txAlcUnit);
+      default:
+        return void 0;
+    }
+  }
+};
+function createUnknownTciMeterAdapter() {
+  return new StandardTciMeterAdapter({
+    capabilities: cloneMeterCapabilities(UNKNOWN_TCI_METER_CAPABILITIES),
+    interval: { reportsApplied: false }
+  });
+}
+function decodeRx(command, receivedAtMs, source) {
+  const receiver = integer(command.args[0]);
+  const hasChannel = source !== "rx_sensors";
+  const channel = hasChannel ? integer(command.args[1]) : 0;
+  const levelIndex = hasChannel ? 2 : 1;
+  const levelDbm = finite(command.args[levelIndex]);
+  if (receiver === void 0 || receiver < 0 || channel === void 0 || channel < 0 || levelDbm === void 0) {
+    return { issue: `Invalid ${command.originalName} meter frame: ${command.raw}` };
+  }
+  const frame = { receiver, channel, levelDbm, source, receivedAtMs };
+  if (source === "rx_channel_sensors_ex") {
+    const averageLevelDbm = finite(command.args[3]);
+    const peakBinDbm = finite(command.args[4]);
+    if (averageLevelDbm === void 0 || peakBinDbm === void 0) {
+      return { issue: `Invalid ${command.originalName} extended meter frame: ${command.raw}` };
+    }
+    frame.averageLevelDbm = averageLevelDbm;
+    frame.peakBinDbm = peakBinDbm;
+    if (command.args.length > 5) frame.extraArgs = command.args.slice(5);
+  } else if (command.args.length > levelIndex + 1) {
+    frame.extraArgs = command.args.slice(levelIndex + 1);
+  }
+  return { decoded: { kind: "rx", frame } };
+}
+function decodeTx(command, receivedAtMs, alcUnit) {
+  const trx = integer(command.args[0]);
+  if (trx === void 0 || trx < 0) {
+    return { issue: `Invalid ${command.originalName} transmitter index: ${command.raw}` };
+  }
+  const micLevelDbm = optionalFinite(command.args[1]);
+  const rmsPowerWatts = optionalFinite(command.args[2]);
+  const peakPowerWatts = optionalFinite(command.args[3]);
+  const swr = optionalFinite(command.args[4]);
+  const alcValue = alcUnit ? optionalFinite(command.args[5]) : void 0;
+  if (micLevelDbm.invalid || rmsPowerWatts.invalid || peakPowerWatts.invalid || swr.invalid || alcValue?.invalid) {
+    return { issue: `Invalid ${command.originalName} numeric meter frame: ${command.raw}` };
+  }
+  if (rmsPowerWatts.value !== void 0 && rmsPowerWatts.value < 0 || peakPowerWatts.value !== void 0 && peakPowerWatts.value < 0 || swr.value !== void 0 && swr.value < 1) {
+    return { issue: `Out-of-range ${command.originalName} meter frame: ${command.raw}` };
+  }
+  if (micLevelDbm.value === void 0 && rmsPowerWatts.value === void 0 && peakPowerWatts.value === void 0 && swr.value === void 0 && alcValue?.value === void 0) {
+    return { issue: `Empty ${command.originalName} meter frame: ${command.raw}` };
+  }
+  const frame = {
+    trx,
+    micLevelDbm: micLevelDbm.value,
+    rmsPowerWatts: rmsPowerWatts.value,
+    peakPowerWatts: peakPowerWatts.value,
+    swr: swr.value,
+    receivedAtMs
+  };
+  if (alcUnit && alcValue?.value !== void 0) frame.alc = { value: alcValue.value, unit: alcUnit };
+  const knownArgs = alcUnit ? 6 : 5;
+  if (command.args.length > knownArgs) frame.extraArgs = command.args.slice(knownArgs);
+  return { decoded: { kind: "tx", frame } };
+}
+function finite(value) {
+  if (value === void 0 || value === "") return void 0;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function integer(value) {
+  const parsed = finite(value);
+  return parsed !== void 0 && Number.isInteger(parsed) ? parsed : void 0;
+}
+function optionalFinite(value) {
+  if (value === void 0 || value === "") return { invalid: false };
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? { value: parsed, invalid: false } : { invalid: true };
+}
+
+// src/meter/TciMeterStreamSession.ts
+import { EventEmitter } from "eventemitter3";
+var RX_COALESCE_MS = 20;
+var TciMeterStreamSession = class extends EventEmitter {
+  receiver;
+  channel;
+  trx;
+  requestedIntervalMs;
+  appliedIntervalMs;
+  rxEnabled;
+  txEnabled;
+  adapter;
+  callbacks;
+  capabilities;
+  pendingRx = /* @__PURE__ */ new Map();
+  closed = false;
+  constructor(options) {
+    super();
+    this.receiver = options.receiver;
+    this.channel = options.channel;
+    this.trx = options.trx;
+    this.requestedIntervalMs = options.requestedIntervalMs;
+    this.appliedIntervalMs = options.appliedIntervalMs;
+    this.rxEnabled = options.rxEnabled;
+    this.txEnabled = options.txEnabled;
+    this.adapter = options.adapter;
+    this.callbacks = options.callbacks;
+    this.capabilities = cloneMeterCapabilities(options.adapter.declaredCapabilities);
+  }
+  getCapabilities() {
+    return cloneMeterCapabilities(this.capabilities);
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.clearPendingRx();
+    try {
+      await this.callbacks.close();
+    } finally {
+      this.emit("closed");
+      this.removeAllListeners();
+    }
+  }
+  _acceptCommand(command, receivedAtMs) {
+    if (this.closed) return;
+    this.acceptEnableAcknowledgement(command);
+    const result = this.adapter.decode(command, receivedAtMs);
+    if (!result) return;
+    if (result.issue) {
+      this.emit("error", new TciError("protocol-error", result.issue));
+      return;
+    }
+    if (result.decoded?.kind === "rx") this.acceptRxFrame(result.decoded.frame);
+    if (result.decoded?.kind === "tx") this.acceptTxFrame(result.decoded.frame);
+  }
+  _fail(error) {
+    if (this.closed) return;
+    this.closed = true;
+    this.clearPendingRx();
+    this.emit("error", error);
+    this.emit("closed");
+    this.removeAllListeners();
+  }
+  acceptRxFrame(frame) {
+    if (!this.rxEnabled || frame.receiver !== this.receiver || frame.channel !== this.channel) return;
+    this.observe("rxLevel");
+    if (frame.averageLevelDbm !== void 0) this.observe("rxAverageLevel");
+    if (frame.peakBinDbm !== void 0) this.observe("rxPeakBin");
+    const key = `${frame.receiver}:${frame.channel}`;
+    const pending = this.pendingRx.get(key);
+    if (pending) {
+      const sameReading = Math.abs(pending.frame.levelDbm - frame.levelDbm) < 0.05;
+      if (sameReading && rxPriority(frame) >= rxPriority(pending.frame)) {
+        clearTimeout(pending.timer);
+        this.pendingRx.delete(key);
+      } else if (sameReading) {
+        return;
+      } else {
+        this.flushRx(key, pending);
+      }
+    }
+    const timer = setTimeout(() => {
+      const current = this.pendingRx.get(key);
+      if (current?.frame === frame) this.flushRx(key, current);
+    }, RX_COALESCE_MS);
+    this.pendingRx.set(key, { frame, timer });
+  }
+  acceptTxFrame(frame) {
+    if (!this.txEnabled || frame.trx !== this.trx) return;
+    if (frame.micLevelDbm !== void 0) this.observe("txMicLevel");
+    if (frame.rmsPowerWatts !== void 0) this.observe("txRmsPower");
+    if (frame.peakPowerWatts !== void 0) this.observe("txPeakPower");
+    if (frame.swr !== void 0) this.observe("txSwr");
+    if (frame.alc?.unit === "dbfs") this.observe("txAlcDbfs");
+    this.emit("txFrame", frame);
+  }
+  acceptEnableAcknowledgement(command) {
+    const enabled = command.args[0]?.toLowerCase();
+    if (enabled !== "true" && enabled !== "1" && enabled !== "on") return;
+    if (command.name === "rx_sensors_enable" && this.rxEnabled) {
+      this.acknowledge(["rxLevel"]);
+    }
+    if (command.name === "tx_sensors_enable" && this.txEnabled) {
+      this.acknowledge(["txMicLevel", "txRmsPower", "txPeakPower", "txSwr"]);
+    }
+  }
+  acknowledge(keys) {
+    let changed = false;
+    for (const key of keys) {
+      if (supportRank(this.capabilities[key]) < supportRank("acknowledged")) {
+        this.capabilities[key] = "acknowledged";
+        changed = true;
+      }
+    }
+    if (changed) this.emit("capabilitiesChanged", this.getCapabilities());
+  }
+  observe(key) {
+    if (this.capabilities[key] === "observed") return;
+    this.capabilities[key] = "observed";
+    this.emit("capabilitiesChanged", this.getCapabilities());
+  }
+  flushRx(key, pending) {
+    clearTimeout(pending.timer);
+    if (this.pendingRx.get(key) === pending) this.pendingRx.delete(key);
+    this.emit("rxFrame", pending.frame);
+  }
+  clearPendingRx() {
+    for (const pending of this.pendingRx.values()) clearTimeout(pending.timer);
+    this.pendingRx.clear();
+  }
+};
+function rxPriority(frame) {
+  if (frame.source === "rx_channel_sensors_ex") return 3;
+  if (frame.source === "rx_channel_sensors") return 2;
+  return 1;
+}
+function supportRank(value) {
+  switch (value) {
+    case "unsupported":
+      return -1;
+    case "unknown":
+      return 0;
+    case "declared":
+      return 1;
+    case "acknowledged":
+      return 2;
+    case "observed":
+      return 3;
+  }
+}
+
 // src/dialect/builtins.ts
 var StandardTciDialect = class {
   id;
@@ -606,6 +902,7 @@ var StandardTciDialect = class {
   supportsTxAudioSource;
   supportsIqStream;
   iqSampleRates;
+  meterAdapter;
   driveHasTrx;
   detector;
   resolver;
@@ -617,6 +914,7 @@ var StandardTciDialect = class {
     this.supportsTxAudioSource = options.supportsTxAudioSource;
     this.supportsIqStream = options.supportsIqStream;
     this.iqSampleRates = [...options.iqSampleRates];
+    this.meterAdapter = options.meterAdapter;
     this.driveHasTrx = options.driveHasTrx;
     this.detector = options.detect;
     this.resolver = options.resolve;
@@ -667,6 +965,7 @@ var expertSdr14Dialect = new StandardTciDialect({
   supportsIqStream: true,
   iqSampleRates: [48e3, 96e3, 192e3, 384e3],
   driveHasTrx: false,
+  meterAdapter: new StandardTciMeterAdapter({ interval: { reportsApplied: false } }),
   detect: (context) => {
     const parsed = version(context);
     if (!parsed || compareTciVersion(parsed, [1, 4]) > 0) return { score: 0, evidence: [] };
@@ -682,6 +981,7 @@ var expertSdrLegacyDialect = new StandardTciDialect({
   supportsIqStream: true,
   iqSampleRates: [48e3, 96e3, 192e3, 384e3],
   driveHasTrx: true,
+  meterAdapter: new StandardTciMeterAdapter({ interval: { reportsApplied: false } }),
   detect: (context) => {
     const parsed = version(context);
     if (!parsed || compareTciVersion(parsed, [1, 5]) < 0 || compareTciVersion(parsed, [1, 9]) >= 0) return { score: 0, evidence: [] };
@@ -697,6 +997,7 @@ var expertSdrModernDialect = new StandardTciDialect({
   supportsIqStream: true,
   iqSampleRates: [48e3, 96e3, 192e3, 384e3],
   driveHasTrx: true,
+  meterAdapter: new StandardTciMeterAdapter({ interval: { reportsApplied: false } }),
   detect: (context) => {
     const parsed = version(context);
     if (!parsed || compareTciVersion(parsed, [1, 9]) < 0) return { score: 0, evidence: [] };
@@ -717,6 +1018,10 @@ var thetisDialect = new StandardTciDialect({
   supportsIqStream: true,
   iqSampleRates: [48e3, 96e3, 192e3, 384e3],
   driveHasTrx: true,
+  meterAdapter: new StandardTciMeterAdapter({
+    interval: { minMs: 30, maxMs: 1e3 },
+    supportsRxExtended: true
+  }),
   detect: (context) => {
     const evidence = [];
     let score = 0;
@@ -745,6 +1050,10 @@ var aetherSdrDialect = new StandardTciDialect({
   supportsIqStream: true,
   iqSampleRates: [24e3, 48e3, 96e3, 192e3],
   driveHasTrx: true,
+  meterAdapter: new StandardTciMeterAdapter({
+    interval: { fixedMs: 200 },
+    txAlcUnit: "dbfs"
+  }),
   detect: (context) => {
     if (!/^aethersdr$/i.test(context.identity.device ?? "")) return { score: 0, evidence: [] };
     const evidence = [`AetherSDR device identity: ${context.identity.device}`];
@@ -766,6 +1075,7 @@ var genericObservedDialect = new StandardTciDialect({
   supportsIqStream: false,
   iqSampleRates: [],
   driveHasTrx: true,
+  meterAdapter: createUnknownTciMeterAdapter(),
   detect: (context) => ({
     score: context.commandNames.has("ready") ? 10 : 0,
     evidence: ["No vendor-specific match; using observed command shapes"],
@@ -783,6 +1093,7 @@ var genericObservedDialect = new StandardTciDialect({
       supportsIqStream: context.commandNames.has("iq_samplerate"),
       iqSampleRates: context.commandNames.has("iq_samplerate") ? [48e3] : [],
       driveHasTrx,
+      meterAdapter: createUnknownTciMeterAdapter(),
       detect: genericObservedDialect.detect.bind(genericObservedDialect)
     });
   }
@@ -881,9 +1192,9 @@ function assertValidTciHandshake(commands) {
 }
 
 // src/transport/WebSocketTransport.ts
-import { EventEmitter } from "eventemitter3";
+import { EventEmitter as EventEmitter2 } from "eventemitter3";
 import WebSocket from "ws";
-var WebSocketTciTransport = class extends EventEmitter {
+var WebSocketTciTransport = class extends EventEmitter2 {
   constructor(url, WebSocketImpl = WebSocket) {
     super();
     this.url = url;
@@ -993,7 +1304,7 @@ function dataToBuffer(data) {
 }
 
 // src/client/TciClient.ts
-var TciIqStreamSession = class extends EventEmitter2 {
+var TciIqStreamSession = class extends EventEmitter3 {
   receiver;
   _appliedSampleRate;
   callbacks;
@@ -1064,7 +1375,7 @@ var TciIqStreamSession = class extends EventEmitter2 {
     firstFrame.reject(error);
   }
 };
-var TciClient = class extends EventEmitter2 {
+var TciClient = class extends EventEmitter3 {
   options;
   WebSocketImpl;
   transportFactory;
@@ -1079,6 +1390,7 @@ var TciClient = class extends EventEmitter2 {
   initializationCommands = [];
   handshakeWaiter;
   activeIqSession;
+  activeMeterSession;
   constructor(options) {
     super();
     this.options = {
@@ -1144,6 +1456,7 @@ var TciClient = class extends EventEmitter2 {
     }
   }
   async disconnect(code = 1e3, reason = "client disconnect") {
+    await this.activeMeterSession?.close().catch(() => void 0);
     const transport = this.transport;
     if (!transport) return;
     await transport.disconnect(code, reason);
@@ -1166,6 +1479,71 @@ var TciClient = class extends EventEmitter2 {
       supportedSampleRates: [...dialect.iqSampleRates]
     };
   }
+  getMeterCapabilities() {
+    if (this.activeMeterSession) return this.activeMeterSession.getCapabilities();
+    const adapter = this.activeDialect?.meterAdapter;
+    return adapter ? cloneMeterCapabilities(adapter.declaredCapabilities) : cloneMeterCapabilities(UNKNOWN_TCI_METER_CAPABILITIES);
+  }
+  async openMeterStream(options = {}) {
+    if (this.activeMeterSession) throw new TciError("protocol-error", "This TCI client already has an active meter stream session");
+    this.requireDialect();
+    const receiver = normalizeNonNegativeInteger(options.receiver ?? this.options.receiver, "meter receiver");
+    const channel = normalizeNonNegativeInteger(options.channel ?? this.options.vfo, "meter channel");
+    const trx = normalizeNonNegativeInteger(options.trx ?? this.options.trx, "meter transmitter");
+    const rxEnabled = options.rx ?? true;
+    const txEnabled = options.tx ?? true;
+    if (!rxEnabled && !txEnabled) throw new TciError("protocol-error", "TCI meter stream must enable RX, TX, or both");
+    const requestedIntervalMs = Math.round(options.intervalMs ?? 300);
+    if (!Number.isFinite(requestedIntervalMs) || requestedIntervalMs <= 0) {
+      throw new TciError("protocol-error", `Invalid TCI meter interval: ${options.intervalMs}`);
+    }
+    const adapter = this.activeDialect?.meterAdapter ?? createUnknownTciMeterAdapter();
+    const interval = adapter.normalizeInterval(requestedIntervalMs);
+    let session;
+    session = new TciMeterStreamSession({
+      receiver,
+      channel,
+      trx,
+      requestedIntervalMs: interval.requestedMs,
+      appliedIntervalMs: interval.appliedMs,
+      rxEnabled,
+      txEnabled,
+      adapter,
+      callbacks: {
+        close: async () => {
+          try {
+            if (this.isConnected()) {
+              if (rxEnabled) {
+                const command = adapter.buildEnableCommand("rx", false, interval.appliedMs ?? interval.requestedMs);
+                await this.sendCommand(command.name, command.args, { waitForReply: false }).catch(() => void 0);
+              }
+              if (txEnabled) {
+                const command = adapter.buildEnableCommand("tx", false, interval.appliedMs ?? interval.requestedMs);
+                await this.sendCommand(command.name, command.args, { waitForReply: false }).catch(() => void 0);
+              }
+            }
+          } finally {
+            if (this.activeMeterSession === session) this.activeMeterSession = void 0;
+          }
+        }
+      }
+    });
+    this.activeMeterSession = session;
+    try {
+      if (rxEnabled) {
+        const command = adapter.buildEnableCommand("rx", true, interval.appliedMs ?? interval.requestedMs);
+        await this.sendCommand(command.name, command.args, { waitForReply: false });
+      }
+      if (txEnabled) {
+        const command = adapter.buildEnableCommand("tx", true, interval.appliedMs ?? interval.requestedMs);
+        await this.sendCommand(command.name, command.args, { waitForReply: false });
+      }
+      return session;
+    } catch (error) {
+      await session.close().catch(() => void 0);
+      throw error;
+    }
+  }
   async setIqSampleRate(sampleRate, timeoutMs = this.options.commandTimeoutMs) {
     const capabilities = this.getIqCapabilities();
     const requested = Math.round(sampleRate);
@@ -1690,11 +2068,13 @@ var TciClient = class extends EventEmitter2 {
   handleText(raw) {
     try {
       const commands = parseTciText(raw);
+      const receivedAtMs = Date.now();
       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.activeMeterSession?._acceptCommand(command, receivedAtMs);
         this.emit("command", command);
       }
     } catch (error) {
@@ -1814,6 +2194,7 @@ var TciClient = class extends EventEmitter2 {
     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_channel_sensors_ex", (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]) }));
@@ -1941,6 +2322,8 @@ var TciClient = class extends EventEmitter2 {
     this.rejectHandshake(new TciError("disconnected", "TCI connection closed during handshake", reason));
     this.activeIqSession?._fail(new TciError("disconnected", "TCI connection closed while IQ stream was active", reason));
     this.activeIqSession = void 0;
+    this.activeMeterSession?._fail(new TciError("disconnected", "TCI connection closed while meter stream was active", reason));
+    this.activeMeterSession = void 0;
     if (wasConnected) {
       this.emit("disconnected", reason);
       this.emitState();
@@ -1967,6 +2350,12 @@ function parseNumber(value) {
   const number = Number(value);
   return Number.isFinite(number) ? number : void 0;
 }
+function normalizeNonNegativeInteger(value, description) {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new TciError("protocol-error", `Invalid TCI ${description}: ${value}`);
+  }
+  return value;
+}
 function parseBoolean(value) {
   if (value === void 0) {
     return void 0;
@@ -2042,23 +2431,28 @@ function cloneNested(value) {
   return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, { ...item }]));
 }
 export {
+  StandardTciMeterAdapter,
   TCI_STREAM_HEADER_BYTES,
   TciClient,
   TciCommandQueue,
   TciDialectRegistry,
   TciError,
   TciIqStreamSession,
+  TciMeterStreamSession,
   TciSampleType,
   TciStreamType,
+  UNKNOWN_TCI_METER_CAPABILITIES,
   WebSocketTciTransport,
   aetherSdrDialect,
   assertValidTciHandshake,
   buildStreamFrame,
   buildTxAudioFrame,
   builtInDialects,
+  cloneMeterCapabilities,
   commandKey,
   compareTciVersion,
   createTciClient,
+  createUnknownTciMeterAdapter,
   decodeInterleavedIq,
   defaultTciDialectRegistry,
   deinterleaveChannels,