tci-client-node 0.1.0

package/dist/testing/index.d.cts

@@ -0,0 +1,78 @@
+import WebSocket from 'ws';
+import { TciStreamFrame, BuildStreamFrameOptions } from '../audio/index.cjs';
+import { T as TciCommand } from '../text-BwCWY1k1.cjs';
+import { EventEmitter } from 'eventemitter3';
+
+interface MockTciServerOptions {
+    port?: number;
+    host?: string;
+    startupCommands?: string[];
+    echoUnknown?: boolean;
+    commandDelayMs?: number;
+}
+interface MockTciServerCommandContext {
+    server: MockTciServer;
+    socket: WebSocket;
+    command: TciCommand;
+}
+type MockTciServerCommandHandler = (context: MockTciServerCommandContext) => void | boolean | Promise<void | boolean>;
+declare class MockTciServer {
+    readonly receivedCommands: TciCommand[];
+    readonly receivedTxAudioFrames: TciStreamFrame[];
+    private readonly options;
+    private wss?;
+    private sockets;
+    private handler?;
+    private frequency;
+    private mode;
+    private ptt;
+    constructor(options?: MockTciServerOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    url(): string;
+    onCommand(handler: MockTciServerCommandHandler): void;
+    broadcast(command: string): void;
+    broadcastCommand(name: string, args?: readonly unknown[]): void;
+    sendRxAudioFrame(options?: Partial<BuildStreamFrameOptions> & {
+        samples?: Float32Array | readonly number[];
+    }): void;
+    sendTxChrono(options?: Partial<BuildStreamFrameOptions> & {
+        sampleCount?: number;
+    }): void;
+    closeClients(): void;
+    private handleConnection;
+    private handleMessage;
+    private defaultReply;
+    private broadcastBinary;
+    private delay;
+}
+
+interface FakeWebSocketSentMessage {
+    data: WebSocket.RawData | string;
+    isBinary: boolean;
+}
+type FakeWebSocketObserver = (socket: FakeWebSocket) => void;
+/**
+ * Minimal in-memory WebSocket implementation for deterministic TciClient tests.
+ * It auto-opens on the next microtask and exposes helpers to inject server data.
+ */
+declare class FakeWebSocket extends EventEmitter {
+    readonly url: string;
+    static readonly CONNECTING = 0;
+    static readonly OPEN = 1;
+    static readonly CLOSING = 2;
+    static readonly CLOSED = 3;
+    readonly sentMessages: FakeWebSocketSentMessage[];
+    readyState: number;
+    constructor(url: string);
+    send(data: WebSocket.RawData | string, optionsOrCallback?: {
+        binary?: boolean;
+    } | ((error?: Error) => void), callback?: (error?: Error) => void): void;
+    receive(data: WebSocket.RawData | string, isBinary?: boolean): void;
+    open(): void;
+    close(code?: number, reason?: string): void;
+    terminate(): void;
+}
+declare function createFakeWebSocketImpl(observer?: FakeWebSocketObserver): typeof WebSocket;
+
+export { FakeWebSocket, type FakeWebSocketObserver, type FakeWebSocketSentMessage, MockTciServer, type MockTciServerCommandContext, type MockTciServerCommandHandler, type MockTciServerOptions, createFakeWebSocketImpl };

package/dist/testing/index.d.ts

@@ -0,0 +1,78 @@
+import WebSocket from 'ws';
+import { TciStreamFrame, BuildStreamFrameOptions } from '../audio/index.js';
+import { T as TciCommand } from '../text-BwCWY1k1.js';
+import { EventEmitter } from 'eventemitter3';
+
+interface MockTciServerOptions {
+    port?: number;
+    host?: string;
+    startupCommands?: string[];
+    echoUnknown?: boolean;
+    commandDelayMs?: number;
+}
+interface MockTciServerCommandContext {
+    server: MockTciServer;
+    socket: WebSocket;
+    command: TciCommand;
+}
+type MockTciServerCommandHandler = (context: MockTciServerCommandContext) => void | boolean | Promise<void | boolean>;
+declare class MockTciServer {
+    readonly receivedCommands: TciCommand[];
+    readonly receivedTxAudioFrames: TciStreamFrame[];
+    private readonly options;
+    private wss?;
+    private sockets;
+    private handler?;
+    private frequency;
+    private mode;
+    private ptt;
+    constructor(options?: MockTciServerOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    url(): string;
+    onCommand(handler: MockTciServerCommandHandler): void;
+    broadcast(command: string): void;
+    broadcastCommand(name: string, args?: readonly unknown[]): void;
+    sendRxAudioFrame(options?: Partial<BuildStreamFrameOptions> & {
+        samples?: Float32Array | readonly number[];
+    }): void;
+    sendTxChrono(options?: Partial<BuildStreamFrameOptions> & {
+        sampleCount?: number;
+    }): void;
+    closeClients(): void;
+    private handleConnection;
+    private handleMessage;
+    private defaultReply;
+    private broadcastBinary;
+    private delay;
+}
+
+interface FakeWebSocketSentMessage {
+    data: WebSocket.RawData | string;
+    isBinary: boolean;
+}
+type FakeWebSocketObserver = (socket: FakeWebSocket) => void;
+/**
+ * Minimal in-memory WebSocket implementation for deterministic TciClient tests.
+ * It auto-opens on the next microtask and exposes helpers to inject server data.
+ */
+declare class FakeWebSocket extends EventEmitter {
+    readonly url: string;
+    static readonly CONNECTING = 0;
+    static readonly OPEN = 1;
+    static readonly CLOSING = 2;
+    static readonly CLOSED = 3;
+    readonly sentMessages: FakeWebSocketSentMessage[];
+    readyState: number;
+    constructor(url: string);
+    send(data: WebSocket.RawData | string, optionsOrCallback?: {
+        binary?: boolean;
+    } | ((error?: Error) => void), callback?: (error?: Error) => void): void;
+    receive(data: WebSocket.RawData | string, isBinary?: boolean): void;
+    open(): void;
+    close(code?: number, reason?: string): void;
+    terminate(): void;
+}
+declare function createFakeWebSocketImpl(observer?: FakeWebSocketObserver): typeof WebSocket;
+
+export { FakeWebSocket, type FakeWebSocketObserver, type FakeWebSocketSentMessage, MockTciServer, type MockTciServerCommandContext, type MockTciServerCommandHandler, type MockTciServerOptions, createFakeWebSocketImpl };

package/dist/testing/index.js

@@ -0,0 +1,533 @@
+// src/testing/MockTciServer.ts
+import WebSocket, { WebSocketServer } from "ws";
+
+// src/errors.ts
+var TciError = class extends Error {
+  code;
+  details;
+  constructor(code, message, details) {
+    super(message);
+    this.name = "TciError";
+    this.code = code;
+    this.details = details;
+  }
+};
+
+// src/audio/streamFrame.ts
+var TCI_STREAM_HEADER_BYTES = 16 * 4;
+function parseStreamFrame(input) {
+  const buffer = toBuffer(input);
+  if (buffer.byteLength < TCI_STREAM_HEADER_BYTES) {
+    throw new TciError("invalid-frame", `TCI stream frame is shorter than ${TCI_STREAM_HEADER_BYTES} bytes`);
+  }
+  const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  const header = Array.from({ length: 16 }, (_, index) => view.getUint32(index * 4, true));
+  const sampleType = normalizeSampleType(header[2]);
+  let channels = header[7];
+  const bytesPerSample = sampleTypeBytes(sampleType);
+  const sampleCount = header[5];
+  const actualPayloadLength = buffer.byteLength - TCI_STREAM_HEADER_BYTES;
+  if (channels <= 0) {
+    const inferredChannels = sampleCount > 0 ? actualPayloadLength / sampleCount / bytesPerSample : 1;
+    if (!Number.isInteger(inferredChannels) || inferredChannels <= 0) {
+      throw new TciError("invalid-frame", `Invalid TCI channel count: ${channels}`);
+    }
+    channels = inferredChannels;
+  }
+  const payloadLength = sampleCount * bytesPerSample * channels;
+  const expectedLength = TCI_STREAM_HEADER_BYTES + payloadLength;
+  if (buffer.byteLength !== expectedLength) {
+    throw new TciError(
+      "invalid-frame",
+      `TCI stream frame length mismatch: header says ${sampleCount} samples (${payloadLength} payload bytes), got ${buffer.byteLength - TCI_STREAM_HEADER_BYTES}`
+    );
+  }
+  if (payloadLength % (bytesPerSample * channels) !== 0) {
+    throw new TciError("invalid-frame", "TCI payload length is not aligned to sample type and channel count");
+  }
+  return {
+    receiver: header[0],
+    sampleRate: header[1],
+    sampleType,
+    codec: header[3],
+    crc: header[4],
+    payloadLength,
+    streamType: normalizeStreamType(header[6]),
+    channels,
+    reserved: header.slice(8),
+    payload: buffer.subarray(TCI_STREAM_HEADER_BYTES),
+    sampleCount
+  };
+}
+function buildStreamFrame(options) {
+  const sampleType = normalizeSampleType(options.sampleType);
+  const payload = options.payload ? toBuffer(options.payload) : samplesToPayload(options.samples ?? [], sampleType);
+  const channels = options.channels;
+  if (channels <= 0) {
+    throw new TciError("invalid-frame", `Invalid TCI channel count: ${channels}`);
+  }
+  const bytesPerSample = sampleTypeBytes(sampleType);
+  if (payload.byteLength % (bytesPerSample * channels) !== 0) {
+    throw new TciError("invalid-frame", "TCI payload length is not aligned to sample type and channel count");
+  }
+  const sampleCount = payload.byteLength / bytesPerSample / channels;
+  const frame = Buffer.alloc(TCI_STREAM_HEADER_BYTES + payload.byteLength);
+  const view = new DataView(frame.buffer, frame.byteOffset, frame.byteLength);
+  const reserved = options.reserved ?? [];
+  const header = [
+    options.receiver ?? 0,
+    options.sampleRate,
+    sampleType,
+    options.codec ?? 0,
+    options.crc ?? 0,
+    sampleCount,
+    options.streamType,
+    channels,
+    ...Array.from({ length: 8 }, (_, index) => reserved[index] ?? 0)
+  ];
+  header.forEach((value, index) => view.setUint32(index * 4, value >>> 0, true));
+  payload.copy(frame, TCI_STREAM_HEADER_BYTES);
+  return frame;
+}
+function sampleTypeBytes(sampleType) {
+  switch (normalizeSampleType(sampleType)) {
+    case 0 /* INT16 */:
+      return 2;
+    case 1 /* INT24 */:
+      return 3;
+    case 2 /* INT32 */:
+    case 3 /* FLOAT32 */:
+      return 4;
+    default:
+      throw new TciError("invalid-frame", `Unsupported TCI sample type: ${sampleType}`);
+  }
+}
+function normalizeSampleType(sampleType) {
+  if (typeof sampleType === "string") {
+    switch (sampleType.toLowerCase()) {
+      case "int16":
+        return 0 /* INT16 */;
+      case "int24":
+        return 1 /* INT24 */;
+      case "int32":
+        return 2 /* INT32 */;
+      case "float32":
+        return 3 /* FLOAT32 */;
+      default:
+        throw new TciError("invalid-frame", `Unsupported TCI sample type: ${sampleType}`);
+    }
+  }
+  if (sampleType >= 0 /* INT16 */ && sampleType <= 3 /* FLOAT32 */) {
+    return sampleType;
+  }
+  throw new TciError("invalid-frame", `Unsupported TCI sample type: ${sampleType}`);
+}
+function normalizeStreamType(streamType) {
+  if (streamType >= 0 /* IQ_STREAM */ && streamType <= 4 /* LINEOUT_STREAM */) {
+    return streamType;
+  }
+  throw new TciError("invalid-frame", `Unsupported TCI stream type: ${streamType}`);
+}
+function samplesToPayload(samples, sampleType) {
+  const type = normalizeSampleType(sampleType);
+  const bytes = sampleTypeBytes(type);
+  const payload = Buffer.alloc(samples.length * bytes);
+  const view = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
+  for (let i = 0; i < samples.length; i += 1) {
+    const value = clampSample(samples[i] ?? 0);
+    const offset = i * bytes;
+    switch (type) {
+      case 0 /* INT16 */:
+        view.setInt16(offset, Math.round(value * 32767), true);
+        break;
+      case 1 /* INT24 */:
+        writeInt24(view, offset, Math.round(value * 8388607));
+        break;
+      case 2 /* INT32 */:
+        view.setInt32(offset, Math.round(value * 2147483647), true);
+        break;
+      case 3 /* FLOAT32 */:
+        view.setFloat32(offset, value, true);
+        break;
+    }
+  }
+  return payload;
+}
+function toBuffer(input) {
+  if (Buffer.isBuffer(input)) {
+    return input;
+  }
+  if (input instanceof ArrayBuffer) {
+    return Buffer.from(input);
+  }
+  if (ArrayBuffer.isView(input)) {
+    return Buffer.from(input.buffer, input.byteOffset, input.byteLength);
+  }
+  return Buffer.from(input);
+}
+function clampSample(value) {
+  if (!Number.isFinite(value)) {
+    return 0;
+  }
+  return Math.max(-1, Math.min(1, value));
+}
+function writeInt24(view, offset, value) {
+  const clamped = Math.max(-8388608, Math.min(8388607, value));
+  view.setUint8(offset, clamped & 255);
+  view.setUint8(offset + 1, clamped >> 8 & 255);
+  view.setUint8(offset + 2, clamped >> 16 & 255);
+}
+
+// src/protocol/text.ts
+var ESCAPE_TO_CHAR = {
+  "^": ":",
+  "~": ",",
+  "*": ";"
+};
+var CHAR_TO_ESCAPE = {
+  ":": "^",
+  ",": "~",
+  ";": "*"
+};
+function escapeTciText(value) {
+  return String(value).replace(/[:;,]/g, (char) => CHAR_TO_ESCAPE[char] ?? char);
+}
+function unescapeTciText(value) {
+  return value.replace(/[\^~*]/g, (char) => ESCAPE_TO_CHAR[char] ?? char);
+}
+function parseTciText(text) {
+  const source = normalizeTextInput(text);
+  const commands = [];
+  for (const fragment of source.split(";")) {
+    const raw = fragment.trim();
+    if (!raw) {
+      continue;
+    }
+    const colonIndex = raw.indexOf(":");
+    const originalName = (colonIndex >= 0 ? raw.slice(0, colonIndex) : raw).trim();
+    if (!originalName) {
+      continue;
+    }
+    const argsText = colonIndex >= 0 ? raw.slice(colonIndex + 1) : void 0;
+    commands.push({
+      name: originalName.toLowerCase(),
+      originalName,
+      args: argsText === void 0 ? [] : splitArgs(argsText),
+      raw
+    });
+  }
+  return commands;
+}
+function formatTciCommand(name, args = []) {
+  const commandName = name.trim().toUpperCase();
+  if (!commandName) {
+    throw new Error("TCI command name cannot be empty");
+  }
+  if (args.length === 0) {
+    return `${commandName};`;
+  }
+  return `${commandName}:${args.map(escapeTciText).join(",")};`;
+}
+function normalizeTextInput(text) {
+  if (typeof text === "string") {
+    return text;
+  }
+  if (Buffer.isBuffer(text)) {
+    return text.toString("utf8");
+  }
+  if (text instanceof ArrayBuffer) {
+    return Buffer.from(text).toString("utf8");
+  }
+  return Buffer.from(text.buffer, text.byteOffset, text.byteLength).toString("utf8");
+}
+function splitArgs(argsText) {
+  return argsText.split(",").map((arg) => unescapeTciText(arg.trim()));
+}
+
+// src/testing/MockTciServer.ts
+var MockTciServer = class {
+  receivedCommands = [];
+  receivedTxAudioFrames = [];
+  options;
+  wss;
+  sockets = /* @__PURE__ */ new Set();
+  handler;
+  frequency = 14074e3;
+  mode = "DIGU";
+  ptt = false;
+  constructor(options = {}) {
+    this.options = {
+      port: options.port ?? 0,
+      host: options.host ?? "127.0.0.1",
+      startupCommands: options.startupCommands,
+      echoUnknown: options.echoUnknown ?? true,
+      commandDelayMs: options.commandDelayMs ?? 0
+    };
+  }
+  async start() {
+    if (this.wss) {
+      return;
+    }
+    this.wss = new WebSocketServer({ port: this.options.port, host: this.options.host });
+    this.wss.on("connection", (socket) => this.handleConnection(socket));
+    await new Promise((resolve, reject) => {
+      this.wss?.once("listening", () => resolve());
+      this.wss?.once("error", reject);
+    });
+  }
+  async stop() {
+    const sockets = [...this.sockets];
+    await Promise.all(
+      sockets.map(
+        (socket) => new Promise((resolve) => {
+          socket.once("close", () => resolve());
+          socket.close();
+          setTimeout(() => resolve(), 200).unref?.();
+        })
+      )
+    );
+    if (!this.wss) {
+      return;
+    }
+    await new Promise((resolve, reject) => {
+      this.wss?.close((error) => error ? reject(error) : resolve());
+    });
+    this.wss = void 0;
+  }
+  url() {
+    if (!this.wss) {
+      throw new Error("MockTciServer is not started");
+    }
+    const address = this.wss.address();
+    return `ws://${address.address}:${address.port}`;
+  }
+  onCommand(handler) {
+    this.handler = handler;
+  }
+  broadcast(command) {
+    for (const socket of this.sockets) {
+      if (socket.readyState === WebSocket.OPEN) {
+        socket.send(command.endsWith(";") ? command : `${command};`);
+      }
+    }
+  }
+  broadcastCommand(name, args = []) {
+    this.broadcast(formatTciCommand(name, args));
+  }
+  sendRxAudioFrame(options = {}) {
+    const frame = buildStreamFrame({
+      receiver: options.receiver ?? 0,
+      sampleRate: options.sampleRate ?? 12e3,
+      sampleType: options.sampleType ?? 3 /* FLOAT32 */,
+      streamType: 1 /* RX_AUDIO_STREAM */,
+      channels: options.channels ?? 1,
+      samples: options.samples ?? new Float32Array(512),
+      payload: options.payload
+    });
+    this.broadcastBinary(frame);
+  }
+  sendTxChrono(options = {}) {
+    const sampleType = options.sampleType ?? 3 /* FLOAT32 */;
+    const channels = options.channels ?? 1;
+    const sampleCount = options.sampleCount ?? 512;
+    const payload = options.payload ?? samplesToPayload(new Float32Array(sampleCount * channels), sampleType);
+    const frame = buildStreamFrame({
+      receiver: options.receiver ?? 0,
+      sampleRate: options.sampleRate ?? 12e3,
+      sampleType,
+      streamType: 3 /* TX_CHRONO */,
+      channels,
+      payload
+    });
+    this.broadcastBinary(frame);
+  }
+  closeClients() {
+    for (const socket of this.sockets) {
+      socket.close();
+    }
+  }
+  handleConnection(socket) {
+    this.sockets.add(socket);
+    socket.on("close", () => this.sockets.delete(socket));
+    socket.on("message", (data, isBinary) => void this.handleMessage(socket, data, isBinary));
+    const startupCommands = this.options.startupCommands ?? [
+      "PROTOCOL:2.0;",
+      "DEVICE:Mock ExpertSDR3;",
+      "MODULATIONS_LIST:LSB,USB,CW,AM,NFM,DIGU,DIGL;",
+      `VFO:0,0,${this.frequency};`,
+      `MODULATION:0,${this.mode};`,
+      `TRX:0,${this.ptt};`,
+      "READY:true;"
+    ];
+    queueMicrotask(() => {
+      for (const command of startupCommands) {
+        if (socket.readyState === WebSocket.OPEN) {
+          socket.send(command);
+        }
+      }
+    });
+  }
+  async handleMessage(socket, data, isBinary) {
+    if (isBinary) {
+      const frame = parseStreamFrame(dataToBuffer(data));
+      if (frame.streamType === 2 /* TX_AUDIO_STREAM */) {
+        this.receivedTxAudioFrames.push(frame);
+      }
+      return;
+    }
+    for (const command of parseTciText(dataToBuffer(data))) {
+      this.receivedCommands.push(command);
+      if (this.handler) {
+        const handled = await this.handler({ server: this, socket, command });
+        if (handled === true) {
+          continue;
+        }
+      }
+      await this.delay();
+      this.defaultReply(socket, command);
+    }
+  }
+  defaultReply(socket, command) {
+    if (socket.readyState !== WebSocket.OPEN) {
+      return;
+    }
+    switch (command.name) {
+      case "vfo": {
+        const receiver = command.args[0] ?? "0";
+        const vfo = command.args[1] ?? "0";
+        if (command.args[2] !== void 0) {
+          this.frequency = Number(command.args[2]);
+        }
+        socket.send(formatTciCommand("VFO", [receiver, vfo, this.frequency]));
+        break;
+      }
+      case "modulation": {
+        const receiver = command.args[0] ?? "0";
+        if (command.args[1] !== void 0) {
+          this.mode = command.args[command.args.length - 1]?.toUpperCase() ?? this.mode;
+        }
+        socket.send(formatTciCommand("MODULATION", [receiver, this.mode]));
+        break;
+      }
+      case "trx": {
+        const trx = command.args[0] ?? "0";
+        if (command.args[1] !== void 0) {
+          this.ptt = command.args[1]?.toLowerCase() === "true";
+        }
+        socket.send(formatTciCommand("TRX", [trx, this.ptt]));
+        break;
+      }
+      case "tune":
+      case "drive":
+      case "split_enable":
+      case "cw_macros":
+      case "cw_msg":
+      case "cw_macros_stop":
+      case "audio_samplerate":
+      case "tx_stream_audio_buffering":
+        socket.send(formatTciCommand(command.originalName, command.args));
+        break;
+      default:
+        if (this.options.echoUnknown) {
+          socket.send(formatTciCommand(command.originalName, command.args));
+        }
+        break;
+    }
+  }
+  broadcastBinary(frame) {
+    for (const socket of this.sockets) {
+      if (socket.readyState === WebSocket.OPEN) {
+        socket.send(frame, { binary: true });
+      }
+    }
+  }
+  async delay() {
+    if (this.options.commandDelayMs <= 0) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, this.options.commandDelayMs));
+  }
+};
+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 Error("Unsupported WebSocket data type");
+}
+
+// src/testing/FakeWebSocket.ts
+import { EventEmitter } from "eventemitter3";
+var FakeWebSocket = class _FakeWebSocket extends EventEmitter {
+  constructor(url) {
+    super();
+    this.url = url;
+    queueMicrotask(() => this.open());
+  }
+  url;
+  static CONNECTING = 0;
+  static OPEN = 1;
+  static CLOSING = 2;
+  static CLOSED = 3;
+  sentMessages = [];
+  readyState = _FakeWebSocket.CONNECTING;
+  send(data, optionsOrCallback, callback) {
+    const done = typeof optionsOrCallback === "function" ? optionsOrCallback : callback;
+    const isBinary = typeof optionsOrCallback === "object" ? Boolean(optionsOrCallback.binary) : typeof data !== "string";
+    if (this.readyState !== _FakeWebSocket.OPEN) {
+      done?.(new Error("FakeWebSocket is not open"));
+      return;
+    }
+    this.sentMessages.push({ data, isBinary });
+    this.emit("sent", data, isBinary);
+    done?.();
+  }
+  receive(data, isBinary = typeof data !== "string") {
+    if (this.readyState === _FakeWebSocket.OPEN) {
+      this.emit("message", typeof data === "string" ? Buffer.from(data) : data, isBinary);
+    }
+  }
+  open() {
+    if (this.readyState !== _FakeWebSocket.CONNECTING) {
+      return;
+    }
+    this.readyState = _FakeWebSocket.OPEN;
+    this.emit("open");
+  }
+  close(code = 1e3, reason = "fake close") {
+    if (this.readyState === _FakeWebSocket.CLOSED) {
+      return;
+    }
+    this.readyState = _FakeWebSocket.CLOSING;
+    queueMicrotask(() => {
+      this.readyState = _FakeWebSocket.CLOSED;
+      this.emit("close", code, Buffer.from(reason));
+    });
+  }
+  terminate() {
+    if (this.readyState === _FakeWebSocket.CLOSED) {
+      return;
+    }
+    this.readyState = _FakeWebSocket.CLOSED;
+    this.emit("close", 1006, Buffer.from("terminated"));
+  }
+};
+function createFakeWebSocketImpl(observer) {
+  return class FakeWebSocketImpl extends FakeWebSocket {
+    constructor(url) {
+      super(url);
+      observer?.(this);
+    }
+  };
+}
+export {
+  FakeWebSocket,
+  MockTciServer,
+  createFakeWebSocketImpl
+};
+//# sourceMappingURL=index.js.map