tci-client-node 0.2.0 → 0.3.0

package/dist/index.d.cts

@@ -3,11 +3,11 @@ export { a as QueuedCommandResult, b as TciCommandMatcher, c as TciCommandQueue,
 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, deinterleaveChannels, float32ToPcm16, mixToMono, normalizeSampleType, normalizeStreamType, parseStreamFrame, payloadToFloat32, pcm16ToFloat32, sampleTypeBytes, sampleTypeName, samplesToPayload } 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 TciDialectId, a as TciHandshakeResult, b as TciDialectSelection, c as TciWriteResult } from './types-xRotf9gW.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-xRotf9gW.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 { 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';
@@ -59,6 +59,49 @@ interface TciTxChronoRequest {
     sampleCount: number;
     frameCount: number;
 }
+interface TciIqCapabilities {
+    supported: boolean;
+    currentSampleRate?: number;
+    supportedSampleRates: readonly number[];
+}
+interface TciIqFrame {
+    frame: TciStreamFrame;
+    receiver: number;
+    sampleRate: number;
+    centerFrequency?: number;
+    complexSampleCount: number;
+}
+interface TciIqStreamOptions {
+    receiver?: number;
+    sampleRate?: number;
+    firstFrameTimeoutMs?: number;
+}
+interface IqSampleRateResult extends TciWriteResult<number> {
+}
+interface TciIqStreamEvents {
+    frame: (frame: TciIqFrame) => void;
+    error: (error: TciError) => void;
+    closed: () => void;
+}
+interface TciIqStreamCallbacks {
+    setSampleRate: (sampleRate: number) => Promise<IqSampleRateResult>;
+    close: () => Promise<void>;
+}
+declare class TciIqStreamSession extends EventEmitter<TciIqStreamEvents> {
+    readonly receiver: number;
+    private _appliedSampleRate;
+    private readonly callbacks;
+    private closed;
+    private firstFrame?;
+    constructor(receiver: number, appliedSampleRate: number, callbacks: TciIqStreamCallbacks);
+    get appliedSampleRate(): number;
+    setSampleRate(sampleRate: number): Promise<IqSampleRateResult>;
+    close(): Promise<void>;
+    waitForFirstFrame(timeoutMs: number): Promise<TciIqFrame>;
+    _acceptFrame(frame: TciIqFrame): void;
+    _fail(error: TciError): void;
+    private rejectFirstFrame;
+}
 interface TciClientState {
     connected: boolean;
     ready: boolean;
@@ -89,6 +132,11 @@ interface TciClientState {
         txBufferingMs?: number;
         running: boolean;
     };
+    iq: {
+        sampleRate?: number;
+        activeReceivers: Record<string, boolean>;
+    };
+    dds: Record<string, number>;
 }
 interface TciClientEvents {
     connected: () => void;
@@ -102,6 +150,7 @@ interface TciClientEvents {
     'tci:rx': (raw: string, commands: TciCommand[]) => void;
     'tci:binary': (frame: TciStreamFrame) => void;
     rxAudioFrame: (frame: TciStreamFrame) => void;
+    iqFrame: (frame: TciIqFrame) => void;
     lineoutAudioFrame: (frame: TciStreamFrame) => void;
     txChrono: (request: TciTxChronoRequest) => void;
     error: (error: TciError) => void;
@@ -125,12 +174,16 @@ declare class TciClient extends EventEmitter<TciClientEvents> {
     private handshakeError?;
     private initializationCommands;
     private handshakeWaiter?;
+    private activeIqSession?;
     constructor(options: TciClientOptions);
     connect(): Promise<TciHandshakeResult>;
     disconnect(code?: number, reason?: string): Promise<void>;
     isConnected(): boolean;
     getState(): TciClientState;
     getHandshakeResult(): TciHandshakeResult | undefined;
+    getIqCapabilities(): TciIqCapabilities;
+    setIqSampleRate(sampleRate: number, timeoutMs?: number): Promise<IqSampleRateResult>;
+    openIqStream(options?: TciIqStreamOptions): Promise<TciIqStreamSession>;
     sendCommand(name: string, args?: readonly unknown[], options?: SendCommandOptions): Promise<TciCommand | undefined>;
     request(name: string, args?: readonly unknown[], options?: QueueCommandOptions): Promise<TciCommand>;
     sendStateWrite(name: string, args: readonly unknown[], isApplied: (state: TciClientState) => boolean, description?: string, options?: TciWriteOptions): Promise<void>;
@@ -187,4 +240,4 @@ declare class TciClient extends EventEmitter<TciClientEvents> {
 }
 declare function createTciClient(options: TciClientOptions): TciClient;
 
-export { BuildTxAudioFrameOptions, QueueCommandOptions, type SendCommandOptions, type TciAudioConfig, TciClient, type TciClientEvents, type TciClientOptions, type TciClientState, TciCommand, TciDialectId, TciDialectRegistry, TciDialectSelection, TciError, TciHandshakeResult, 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, type TciPttOptions, TciSampleType, TciSampleTypeName, TciStreamFrame, TciTransportFactory, type TciTxChronoRequest, type TciWriteAckMode, type TciWriteOptions, TciWriteResult, createTciClient };

package/dist/index.d.ts

@@ -3,11 +3,11 @@ export { a as QueuedCommandResult, b as TciCommandMatcher, c as TciCommandQueue,
 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, deinterleaveChannels, float32ToPcm16, mixToMono, normalizeSampleType, normalizeStreamType, parseStreamFrame, payloadToFloat32, pcm16ToFloat32, sampleTypeBytes, sampleTypeName, samplesToPayload } 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 TciDialectId, a as TciHandshakeResult, b as TciDialectSelection, c as TciWriteResult } from './types-9seY9Th-.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-9seY9Th-.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 { 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';
@@ -59,6 +59,49 @@ interface TciTxChronoRequest {
     sampleCount: number;
     frameCount: number;
 }
+interface TciIqCapabilities {
+    supported: boolean;
+    currentSampleRate?: number;
+    supportedSampleRates: readonly number[];
+}
+interface TciIqFrame {
+    frame: TciStreamFrame;
+    receiver: number;
+    sampleRate: number;
+    centerFrequency?: number;
+    complexSampleCount: number;
+}
+interface TciIqStreamOptions {
+    receiver?: number;
+    sampleRate?: number;
+    firstFrameTimeoutMs?: number;
+}
+interface IqSampleRateResult extends TciWriteResult<number> {
+}
+interface TciIqStreamEvents {
+    frame: (frame: TciIqFrame) => void;
+    error: (error: TciError) => void;
+    closed: () => void;
+}
+interface TciIqStreamCallbacks {
+    setSampleRate: (sampleRate: number) => Promise<IqSampleRateResult>;
+    close: () => Promise<void>;
+}
+declare class TciIqStreamSession extends EventEmitter<TciIqStreamEvents> {
+    readonly receiver: number;
+    private _appliedSampleRate;
+    private readonly callbacks;
+    private closed;
+    private firstFrame?;
+    constructor(receiver: number, appliedSampleRate: number, callbacks: TciIqStreamCallbacks);
+    get appliedSampleRate(): number;
+    setSampleRate(sampleRate: number): Promise<IqSampleRateResult>;
+    close(): Promise<void>;
+    waitForFirstFrame(timeoutMs: number): Promise<TciIqFrame>;
+    _acceptFrame(frame: TciIqFrame): void;
+    _fail(error: TciError): void;
+    private rejectFirstFrame;
+}
 interface TciClientState {
     connected: boolean;
     ready: boolean;
@@ -89,6 +132,11 @@ interface TciClientState {
         txBufferingMs?: number;
         running: boolean;
     };
+    iq: {
+        sampleRate?: number;
+        activeReceivers: Record<string, boolean>;
+    };
+    dds: Record<string, number>;
 }
 interface TciClientEvents {
     connected: () => void;
@@ -102,6 +150,7 @@ interface TciClientEvents {
     'tci:rx': (raw: string, commands: TciCommand[]) => void;
     'tci:binary': (frame: TciStreamFrame) => void;
     rxAudioFrame: (frame: TciStreamFrame) => void;
+    iqFrame: (frame: TciIqFrame) => void;
     lineoutAudioFrame: (frame: TciStreamFrame) => void;
     txChrono: (request: TciTxChronoRequest) => void;
     error: (error: TciError) => void;
@@ -125,12 +174,16 @@ declare class TciClient extends EventEmitter<TciClientEvents> {
     private handshakeError?;
     private initializationCommands;
     private handshakeWaiter?;
+    private activeIqSession?;
     constructor(options: TciClientOptions);
     connect(): Promise<TciHandshakeResult>;
     disconnect(code?: number, reason?: string): Promise<void>;
     isConnected(): boolean;
     getState(): TciClientState;
     getHandshakeResult(): TciHandshakeResult | undefined;
+    getIqCapabilities(): TciIqCapabilities;
+    setIqSampleRate(sampleRate: number, timeoutMs?: number): Promise<IqSampleRateResult>;
+    openIqStream(options?: TciIqStreamOptions): Promise<TciIqStreamSession>;
     sendCommand(name: string, args?: readonly unknown[], options?: SendCommandOptions): Promise<TciCommand | undefined>;
     request(name: string, args?: readonly unknown[], options?: QueueCommandOptions): Promise<TciCommand>;
     sendStateWrite(name: string, args: readonly unknown[], isApplied: (state: TciClientState) => boolean, description?: string, options?: TciWriteOptions): Promise<void>;
@@ -187,4 +240,4 @@ declare class TciClient extends EventEmitter<TciClientEvents> {
 }
 declare function createTciClient(options: TciClientOptions): TciClient;
 
-export { BuildTxAudioFrameOptions, QueueCommandOptions, type SendCommandOptions, type TciAudioConfig, TciClient, type TciClientEvents, type TciClientOptions, type TciClientState, TciCommand, TciDialectId, TciDialectRegistry, TciDialectSelection, TciError, TciHandshakeResult, 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, type TciPttOptions, TciSampleType, TciSampleTypeName, TciStreamFrame, TciTransportFactory, type TciTxChronoRequest, type TciWriteAckMode, type TciWriteOptions, TciWriteResult, createTciClient };

package/dist/index.js

@@ -241,6 +241,15 @@ function payloadToFloat32(frameOrPayload, sampleType) {
   }
   return output;
 }
+function decodeInterleavedIq(frame) {
+  if (frame.streamType !== 0 /* IQ_STREAM */) {
+    throw new TciError("invalid-frame", "Expected a TCI IQ stream frame");
+  }
+  if (frame.channels !== 2 || frame.sampleCount % 2 !== 0) {
+    throw new TciError("invalid-frame", `TCI IQ frame must contain interleaved I/Q pairs, got ${frame.channels} channels`);
+  }
+  return payloadToFloat32(frame);
+}
 function samplesToPayload(samples, sampleType) {
   const type = normalizeSampleType(sampleType);
   const bytes = sampleTypeBytes(type);
@@ -595,6 +604,8 @@ var StandardTciDialect = class {
   streamLengthSemantics;
   supportsStreamChannels;
   supportsTxAudioSource;
+  supportsIqStream;
+  iqSampleRates;
   driveHasTrx;
   detector;
   resolver;
@@ -604,6 +615,8 @@ var StandardTciDialect = class {
     this.streamLengthSemantics = options.streamLengthSemantics;
     this.supportsStreamChannels = options.supportsStreamChannels;
     this.supportsTxAudioSource = options.supportsTxAudioSource;
+    this.supportsIqStream = options.supportsIqStream;
+    this.iqSampleRates = [...options.iqSampleRates];
     this.driveHasTrx = options.driveHasTrx;
     this.detector = options.detect;
     this.resolver = options.resolve;
@@ -651,6 +664,8 @@ var expertSdr14Dialect = new StandardTciDialect({
   streamLengthSemantics: "per-channel",
   supportsStreamChannels: false,
   supportsTxAudioSource: false,
+  supportsIqStream: true,
+  iqSampleRates: [48e3, 96e3, 192e3, 384e3],
   driveHasTrx: false,
   detect: (context) => {
     const parsed = version(context);
@@ -664,6 +679,8 @@ var expertSdrLegacyDialect = new StandardTciDialect({
   streamLengthSemantics: "per-channel",
   supportsStreamChannels: false,
   supportsTxAudioSource: false,
+  supportsIqStream: true,
+  iqSampleRates: [48e3, 96e3, 192e3, 384e3],
   driveHasTrx: true,
   detect: (context) => {
     const parsed = version(context);
@@ -677,6 +694,8 @@ var expertSdrModernDialect = new StandardTciDialect({
   streamLengthSemantics: "scalar",
   supportsStreamChannels: true,
   supportsTxAudioSource: true,
+  supportsIqStream: true,
+  iqSampleRates: [48e3, 96e3, 192e3, 384e3],
   driveHasTrx: true,
   detect: (context) => {
     const parsed = version(context);
@@ -695,6 +714,8 @@ var thetisDialect = new StandardTciDialect({
   streamLengthSemantics: "scalar",
   supportsStreamChannels: true,
   supportsTxAudioSource: true,
+  supportsIqStream: true,
+  iqSampleRates: [48e3, 96e3, 192e3, 384e3],
   driveHasTrx: true,
   detect: (context) => {
     const evidence = [];
@@ -721,6 +742,8 @@ var aetherSdrDialect = new StandardTciDialect({
   streamLengthSemantics: "scalar",
   supportsStreamChannels: true,
   supportsTxAudioSource: true,
+  supportsIqStream: true,
+  iqSampleRates: [24e3, 48e3, 96e3, 192e3],
   driveHasTrx: true,
   detect: (context) => {
     if (!/^aethersdr$/i.test(context.identity.device ?? "")) return { score: 0, evidence: [] };
@@ -740,6 +763,8 @@ var genericObservedDialect = new StandardTciDialect({
   streamLengthSemantics: "auto",
   supportsStreamChannels: true,
   supportsTxAudioSource: true,
+  supportsIqStream: false,
+  iqSampleRates: [],
   driveHasTrx: true,
   detect: (context) => ({
     score: context.commandNames.has("ready") ? 10 : 0,
@@ -755,6 +780,8 @@ var genericObservedDialect = new StandardTciDialect({
       streamLengthSemantics: "auto",
       supportsStreamChannels: context.commandNames.has("audio_stream_channels"),
       supportsTxAudioSource: compareTciVersion(version(context) ?? [0], [2, 0]) >= 0,
+      supportsIqStream: context.commandNames.has("iq_samplerate"),
+      iqSampleRates: context.commandNames.has("iq_samplerate") ? [48e3] : [],
       driveHasTrx,
       detect: genericObservedDialect.detect.bind(genericObservedDialect)
     });
@@ -966,6 +993,77 @@ function dataToBuffer(data) {
 }
 
 // src/client/TciClient.ts
+var TciIqStreamSession = class extends EventEmitter2 {
+  receiver;
+  _appliedSampleRate;
+  callbacks;
+  closed = false;
+  firstFrame;
+  constructor(receiver, appliedSampleRate, callbacks) {
+    super();
+    this.receiver = receiver;
+    this._appliedSampleRate = appliedSampleRate;
+    this.callbacks = callbacks;
+  }
+  get appliedSampleRate() {
+    return this._appliedSampleRate;
+  }
+  async setSampleRate(sampleRate) {
+    if (this.closed) throw new TciError("cancelled", "TCI IQ stream is closed");
+    const result = await this.callbacks.setSampleRate(sampleRate);
+    this._appliedSampleRate = result.applied;
+    return result;
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.rejectFirstFrame(new TciError("cancelled", "TCI IQ stream closed before its first frame"));
+    try {
+      await this.callbacks.close();
+    } finally {
+      this.emit("closed");
+      this.removeAllListeners();
+    }
+  }
+  waitForFirstFrame(timeoutMs) {
+    if (this.firstFrame) return this.firstFrame.promise;
+    let resolvePromise;
+    let rejectPromise;
+    const promise = new Promise((resolve, reject) => {
+      resolvePromise = resolve;
+      rejectPromise = reject;
+    });
+    const timer = setTimeout(() => {
+      this.firstFrame = void 0;
+      rejectPromise(new TciError("command-timeout", `Timed out waiting for TCI IQ frame for receiver ${this.receiver}`));
+    }, timeoutMs);
+    this.firstFrame = { promise, resolve: resolvePromise, reject: rejectPromise, timer };
+    return promise;
+  }
+  _acceptFrame(frame) {
+    if (this.closed || frame.receiver !== this.receiver) return;
+    this._appliedSampleRate = frame.sampleRate;
+    const firstFrame = this.firstFrame;
+    if (firstFrame) {
+      clearTimeout(firstFrame.timer);
+      this.firstFrame = void 0;
+      firstFrame.resolve(frame);
+    }
+    this.emit("frame", frame);
+  }
+  _fail(error) {
+    if (this.closed) return;
+    this.rejectFirstFrame(error);
+    this.emit("error", error);
+  }
+  rejectFirstFrame(error) {
+    const firstFrame = this.firstFrame;
+    if (!firstFrame) return;
+    clearTimeout(firstFrame.timer);
+    this.firstFrame = void 0;
+    firstFrame.reject(error);
+  }
+};
 var TciClient = class extends EventEmitter2 {
   options;
   WebSocketImpl;
@@ -980,6 +1078,7 @@ var TciClient = class extends EventEmitter2 {
   handshakeError;
   initializationCommands = [];
   handshakeWaiter;
+  activeIqSession;
   constructor(options) {
     super();
     this.options = {
@@ -1018,7 +1117,9 @@ var TciClient = class extends EventEmitter2 {
       split: {},
       dialectWarnings: [],
       rxSensors: {},
-      txSensors: {}
+      txSensors: {},
+      iq: { activeReceivers: {} },
+      dds: {}
     };
     this.stateReducers = this.createStateReducers();
   }
@@ -1057,6 +1158,68 @@ var TciClient = class extends EventEmitter2 {
   getHandshakeResult() {
     return this.handshakeResult ? cloneHandshake(this.handshakeResult) : void 0;
   }
+  getIqCapabilities() {
+    const dialect = this.requireDialect();
+    return {
+      supported: dialect.supportsIqStream,
+      currentSampleRate: this.state.iq.sampleRate,
+      supportedSampleRates: [...dialect.iqSampleRates]
+    };
+  }
+  async setIqSampleRate(sampleRate, timeoutMs = this.options.commandTimeoutMs) {
+    const capabilities = this.getIqCapabilities();
+    const requested = Math.round(sampleRate);
+    if (!capabilities.supported) throw new TciError("protocol-error", `TCI dialect ${this.requireDialect().id} does not support IQ streaming`);
+    if (!Number.isFinite(requested) || requested <= 0) throw new TciError("protocol-error", `Invalid TCI IQ sample rate: ${sampleRate}`);
+    if (capabilities.supportedSampleRates.length > 0 && !capabilities.supportedSampleRates.includes(requested)) {
+      throw new TciError("protocol-error", `TCI IQ sample rate ${requested} is not supported by dialect ${this.requireDialect().id}`);
+    }
+    if (this.state.iq.sampleRate === requested) return writeResult(requested, requested, "state");
+    const waiter = this.waitForCommand((command) => command.name === "iq_samplerate", timeoutMs, "IQ_SAMPLERATE readback");
+    try {
+      await this.sendCommand("IQ_SAMPLERATE", [requested], { waitForReply: false });
+      const reply = await waiter.promise;
+      const applied = parseNumber(reply.args[0]);
+      if (applied === void 0 || applied <= 0) throw new TciError("protocol-error", `Invalid IQ_SAMPLERATE readback: ${reply.raw}`);
+      return writeResult(requested, applied, "reply");
+    } finally {
+      waiter.cancel();
+    }
+  }
+  async openIqStream(options = {}) {
+    if (this.activeIqSession) throw new TciError("protocol-error", "This TCI client already has an active IQ stream session");
+    const capabilities = this.getIqCapabilities();
+    if (!capabilities.supported) throw new TciError("protocol-error", `TCI dialect ${this.requireDialect().id} does not support IQ streaming`);
+    const receiver = Math.floor(options.receiver ?? this.options.receiver);
+    if (!Number.isInteger(receiver) || receiver < 0) throw new TciError("protocol-error", `Invalid TCI IQ receiver: ${receiver}`);
+    const requestedRate = options.sampleRate ?? capabilities.currentSampleRate ?? capabilities.supportedSampleRates[0] ?? 48e3;
+    const rateResult = await this.setIqSampleRate(requestedRate);
+    let session;
+    session = new TciIqStreamSession(receiver, rateResult.applied, {
+      setSampleRate: (rate) => this.setIqSampleRate(rate),
+      close: async () => {
+        try {
+          if (this.isConnected()) await this.sendCommand("IQ_STOP", [receiver], { waitForReply: false });
+        } finally {
+          this.state.iq.activeReceivers[String(receiver)] = false;
+          if (this.activeIqSession === session) this.activeIqSession = void 0;
+          this.emitState();
+        }
+      }
+    });
+    this.activeIqSession = session;
+    const firstFrame = session.waitForFirstFrame(options.firstFrameTimeoutMs ?? 5e3);
+    try {
+      await this.sendCommand("IQ_START", [receiver], { waitForReply: false });
+      this.state.iq.activeReceivers[String(receiver)] = true;
+      this.emitState();
+      await firstFrame;
+      return session;
+    } catch (error) {
+      await session.close().catch(() => void 0);
+      throw error;
+    }
+  }
   async sendCommand(name, args = [], options = {}) {
     const raw = formatTciCommand(name, args);
     if (options.waitForReply === false) {
@@ -1546,6 +1709,22 @@ var TciClient = class extends EventEmitter2 {
     this.emit("tci:binary", frame);
     this.emit("binary", frame);
     switch (frame.streamType) {
+      case 0 /* IQ_STREAM */: {
+        if (frame.channels !== 2 || frame.sampleCount % 2 !== 0) {
+          throw new TciError("invalid-frame", "TCI IQ stream frame must contain interleaved I/Q pairs");
+        }
+        this.state.iq.sampleRate = frame.sampleRate;
+        const iqFrame = {
+          frame,
+          receiver: frame.receiver,
+          sampleRate: frame.sampleRate,
+          centerFrequency: this.state.dds[String(frame.receiver)],
+          complexSampleCount: frame.frameCount
+        };
+        this.emit("iqFrame", iqFrame);
+        this.activeIqSession?._acceptFrame(iqFrame);
+        break;
+      }
       case 1 /* RX_AUDIO_STREAM */:
         this.emit("rxAudioFrame", frame);
         break;
@@ -1623,6 +1802,11 @@ var TciClient = class extends EventEmitter2 {
       this.state.modulations = args.map((mode) => mode.toLowerCase());
     });
     reducers.set("vfo", (args) => this.applyVfo(args));
+    reducers.set("dds", (args) => {
+      const receiver = parseNumber(args[0]);
+      const frequency = parseNumber(args[1]);
+      if (receiver !== void 0 && frequency !== void 0 && frequency >= 0) this.state.dds[String(receiver)] = frequency;
+    });
     reducers.set("modulation", (args) => this.applyModulation(args));
     reducers.set("trx", (args) => this.applyTrx(args));
     reducers.set("tune", (args) => this.applyBooleanByFirstArg(this.state.tune, args));
@@ -1639,6 +1823,15 @@ var TciClient = class extends EventEmitter2 {
     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 }));
+    reducers.set("iq_samplerate", (args) => {
+      this.state.iq.sampleRate = parseNumber(args[0]);
+    });
+    reducers.set("iq_start", (args) => {
+      this.state.iq.activeReceivers[String(args[0] ?? this.options.receiver)] = true;
+    });
+    reducers.set("iq_stop", (args) => {
+      this.state.iq.activeReceivers[String(args[0] ?? this.options.receiver)] = false;
+    });
     return reducers;
   }
   applyVfo(args) {
@@ -1746,6 +1939,8 @@ var TciClient = class extends EventEmitter2 {
     this.state.ready = false;
     this.queue.setConnected(false);
     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;
     if (wasConnected) {
       this.emit("disconnected", reason);
       this.emitState();
@@ -1826,7 +2021,9 @@ function cloneState(state) {
     dialectWarnings: [...state.dialectWarnings],
     rxSensors: cloneNested(state.rxSensors),
     txSensors: cloneNested(state.txSensors),
-    audio: state.audio ? { ...state.audio } : void 0
+    audio: state.audio ? { ...state.audio } : void 0,
+    iq: { ...state.iq, activeReceivers: { ...state.iq.activeReceivers } },
+    dds: { ...state.dds }
   };
 }
 function cloneHandshake(result) {
@@ -1850,6 +2047,7 @@ export {
   TciCommandQueue,
   TciDialectRegistry,
   TciError,
+  TciIqStreamSession,
   TciSampleType,
   TciStreamType,
   WebSocketTciTransport,
@@ -1861,6 +2059,7 @@ export {
   commandKey,
   compareTciVersion,
   createTciClient,
+  decodeInterleavedIq,
   defaultTciDialectRegistry,
   deinterleaveChannels,
   escapeTciText,