@dtelecom/server-sdk-node 0.1.0

package/dist/index.js

@@ -0,0 +1,2908 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AudioFrame: () => AudioFrame,
+  AudioSource: () => AudioSource,
+  AudioStream: () => AudioStream,
+  ConnectionQuality: () => ConnectionQuality,
+  DataPacket_Kind: () => DataPacket_Kind,
+  DisconnectReason: () => DisconnectReason,
+  LocalAudioTrack: () => LocalAudioTrack,
+  LocalParticipant: () => LocalParticipant,
+  LocalTrackPublication: () => LocalTrackPublication,
+  LogLevel: () => LogLevel,
+  Participant: () => Participant,
+  ParticipantInfo_State: () => ParticipantInfo_State,
+  RemoteAudioTrack: () => RemoteAudioTrack,
+  RemoteParticipant: () => RemoteParticipant,
+  RemoteTrackPublication: () => RemoteTrackPublication,
+  Room: () => Room,
+  TrackPublication: () => TrackPublication,
+  TrackSource: () => TrackSource,
+  TrackType: () => TrackType,
+  createTextMessage: () => createTextMessage,
+  decodeDataPacket: () => decodeDataPacket,
+  downsample: () => downsample,
+  encodeDataPacket: () => encodeDataPacket,
+  resample: () => resample,
+  setLogLevel: () => setLogLevel,
+  upsample: () => upsample
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/utils/events.ts
+var import_events = require("events");
+var TypedEmitter = class {
+  emitter = new import_events.EventEmitter();
+  constructor() {
+    this.emitter.setMaxListeners(50);
+  }
+  on(event, listener) {
+    this.emitter.on(event, listener);
+    return this;
+  }
+  once(event, listener) {
+    this.emitter.once(event, listener);
+    return this;
+  }
+  off(event, listener) {
+    this.emitter.off(event, listener);
+    return this;
+  }
+  emit(event, ...args) {
+    return this.emitter.emit(event, ...args);
+  }
+  removeAllListeners(event) {
+    if (event) {
+      this.emitter.removeAllListeners(event);
+    } else {
+      this.emitter.removeAllListeners();
+    }
+    return this;
+  }
+  listenerCount(event) {
+    return this.emitter.listenerCount(event);
+  }
+};
+
+// src/utils/logger.ts
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["TRACE"] = 0] = "TRACE";
+  LogLevel2[LogLevel2["DEBUG"] = 1] = "DEBUG";
+  LogLevel2[LogLevel2["INFO"] = 2] = "INFO";
+  LogLevel2[LogLevel2["WARN"] = 3] = "WARN";
+  LogLevel2[LogLevel2["ERROR"] = 4] = "ERROR";
+  LogLevel2[LogLevel2["SILENT"] = 5] = "SILENT";
+  return LogLevel2;
+})(LogLevel || {});
+var levelNames = {
+  [0 /* TRACE */]: "TRACE",
+  [1 /* DEBUG */]: "DEBUG",
+  [2 /* INFO */]: "INFO",
+  [3 /* WARN */]: "WARN",
+  [4 /* ERROR */]: "ERROR",
+  [5 /* SILENT */]: "SILENT"
+};
+var globalLevel = 2 /* INFO */;
+function setLogLevel(level) {
+  globalLevel = level;
+}
+function createLogger(component) {
+  const log12 = (level, msg, args) => {
+    if (level < globalLevel) return;
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    const prefix = `${ts} [${levelNames[level]}] [${component}]`;
+    if (args.length > 0) {
+      console.log(prefix, msg, ...args);
+    } else {
+      console.log(prefix, msg);
+    }
+  };
+  return {
+    trace: (msg, ...args) => log12(0 /* TRACE */, msg, args),
+    debug: (msg, ...args) => log12(1 /* DEBUG */, msg, args),
+    info: (msg, ...args) => log12(2 /* INFO */, msg, args),
+    warn: (msg, ...args) => log12(3 /* WARN */, msg, args),
+    error: (msg, ...args) => log12(4 /* ERROR */, msg, args)
+  };
+}
+
+// src/engine.ts
+var import_werift = require("werift");
+
+// src/signal.ts
+var import_ws = __toESM(require("ws"));
+
+// src/proto/signal.ts
+var _m0 = __toESM(require("protobufjs/minimal"));
+function writeMessage(writer, fieldNumber, encodeFn) {
+  encodeFn(writer.uint32(fieldNumber << 3 | 2).fork()).ldelim();
+}
+function writeString(writer, fieldNumber, value) {
+  if (value !== "") {
+    writer.uint32(fieldNumber << 3 | 2).string(value);
+  }
+}
+function writeInt32(writer, fieldNumber, value) {
+  if (value !== 0) {
+    writer.uint32(fieldNumber << 3 | 0).int32(value);
+  }
+}
+function writeUint32(writer, fieldNumber, value) {
+  if (value !== 0) {
+    writer.uint32(fieldNumber << 3 | 0).uint32(value);
+  }
+}
+function writeBool(writer, fieldNumber, value) {
+  if (value) {
+    writer.uint32(fieldNumber << 3 | 0).bool(value);
+  }
+}
+var SessionDescription = {
+  encode(message, writer = _m0.Writer.create()) {
+    writeString(writer, 1, message.type);
+    writeString(writer, 2, message.sdp);
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = { type: "", sdp: "" };
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.type = reader.string();
+          break;
+        case 2:
+          message.sdp = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  }
+};
+var TrickleRequest = {
+  encode(message, writer = _m0.Writer.create()) {
+    writeString(writer, 1, message.candidateInit);
+    writeInt32(writer, 2, message.target);
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = { candidateInit: "", target: 0 };
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.candidateInit = reader.string();
+          break;
+        case 2:
+          message.target = reader.int32();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  }
+};
+var AddTrackRequest = {
+  encode(message, writer = _m0.Writer.create()) {
+    writeString(writer, 1, message.cid);
+    writeString(writer, 2, message.name);
+    writeInt32(writer, 3, message.type);
+    writeUint32(writer, 4, message.width);
+    writeUint32(writer, 5, message.height);
+    writeBool(writer, 6, message.muted);
+    writeBool(writer, 7, message.disableDtx);
+    writeInt32(writer, 8, message.source);
+    writeString(writer, 10, message.sid);
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = {
+      cid: "",
+      name: "",
+      type: 0,
+      width: 0,
+      height: 0,
+      muted: false,
+      disableDtx: false,
+      source: 0,
+      layers: [],
+      sid: ""
+    };
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.cid = reader.string();
+          break;
+        case 2:
+          message.name = reader.string();
+          break;
+        case 3:
+          message.type = reader.int32();
+          break;
+        case 4:
+          message.width = reader.uint32();
+          break;
+        case 5:
+          message.height = reader.uint32();
+          break;
+        case 6:
+          message.muted = reader.bool();
+          break;
+        case 7:
+          message.disableDtx = reader.bool();
+          break;
+        case 8:
+          message.source = reader.int32();
+          break;
+        case 10:
+          message.sid = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  }
+};
+var MuteTrackRequest = {
+  encode(message, writer = _m0.Writer.create()) {
+    writeString(writer, 1, message.sid);
+    writeBool(writer, 2, message.muted);
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = { sid: "", muted: false };
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.sid = reader.string();
+          break;
+        case 2:
+          message.muted = reader.bool();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  }
+};
+var LeaveRequest = {
+  encode(message, writer = _m0.Writer.create()) {
+    writeBool(writer, 1, message.canReconnect);
+    writeInt32(writer, 2, message.reason);
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = { canReconnect: false, reason: 0 };
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.canReconnect = reader.bool();
+          break;
+        case 2:
+          message.reason = reader.int32();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  }
+};
+var UpdateSubscription = {
+  encode(message, writer = _m0.Writer.create()) {
+    for (const v of message.trackSids) {
+      writeString(writer, 1, v);
+    }
+    writeBool(writer, 2, message.subscribe);
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = { trackSids: [], subscribe: false, participantTracks: [] };
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.trackSids.push(reader.string());
+          break;
+        case 2:
+          message.subscribe = reader.bool();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  }
+};
+var Room_decode = (reader, length) => {
+  const end = reader.pos + length;
+  const msg = {
+    sid: "",
+    name: "",
+    emptyTimeout: 0,
+    maxParticipants: 0,
+    creationTime: 0,
+    turnPassword: "",
+    enabledCodecs: [],
+    metadata: "",
+    numParticipants: 0,
+    activeRecording: false
+  };
+  while (reader.pos < end) {
+    const tag = reader.uint32();
+    switch (tag >>> 3) {
+      case 1:
+        msg.sid = reader.string();
+        break;
+      case 2:
+        msg.name = reader.string();
+        break;
+      case 3:
+        msg.emptyTimeout = reader.uint32();
+        break;
+      case 4:
+        msg.maxParticipants = reader.uint32();
+        break;
+      case 5:
+        msg.creationTime = reader.int64();
+        break;
+      case 6:
+        msg.turnPassword = reader.string();
+        break;
+      case 7: {
+        const codec = { mime: "", fmtpLine: "" };
+        const cEnd = reader.pos + reader.uint32();
+        while (reader.pos < cEnd) {
+          const cTag = reader.uint32();
+          switch (cTag >>> 3) {
+            case 1:
+              codec.mime = reader.string();
+              break;
+            case 2:
+              codec.fmtpLine = reader.string();
+              break;
+            default:
+              reader.skipType(cTag & 7);
+              break;
+          }
+        }
+        msg.enabledCodecs.push(codec);
+        break;
+      }
+      case 8:
+        msg.metadata = reader.string();
+        break;
+      case 9:
+        msg.numParticipants = reader.uint32();
+        break;
+      case 10:
+        msg.activeRecording = reader.bool();
+        break;
+      default:
+        reader.skipType(tag & 7);
+        break;
+    }
+  }
+  return msg;
+};
+var ICEServer_decode = (reader, length) => {
+  const end = reader.pos + length;
+  const msg = { urls: [], username: "", credential: "" };
+  while (reader.pos < end) {
+    const tag = reader.uint32();
+    switch (tag >>> 3) {
+      case 1:
+        msg.urls.push(reader.string());
+        break;
+      case 2:
+        msg.username = reader.string();
+        break;
+      case 3:
+        msg.credential = reader.string();
+        break;
+      default:
+        reader.skipType(tag & 7);
+        break;
+    }
+  }
+  return msg;
+};
+var TrackInfo_decode = (reader, length) => {
+  const end = reader.pos + length;
+  const msg = {
+    sid: "",
+    type: 0,
+    name: "",
+    muted: false,
+    width: 0,
+    height: 0,
+    simulcast: false,
+    disableDtx: false,
+    source: 0,
+    layers: [],
+    mimeType: "",
+    mid: ""
+  };
+  while (reader.pos < end) {
+    const tag = reader.uint32();
+    switch (tag >>> 3) {
+      case 1:
+        msg.sid = reader.string();
+        break;
+      case 2:
+        msg.type = reader.int32();
+        break;
+      case 3:
+        msg.name = reader.string();
+        break;
+      case 4:
+        msg.muted = reader.bool();
+        break;
+      case 5:
+        msg.width = reader.uint32();
+        break;
+      case 6:
+        msg.height = reader.uint32();
+        break;
+      case 7:
+        msg.simulcast = reader.bool();
+        break;
+      case 8:
+        msg.disableDtx = reader.bool();
+        break;
+      case 9:
+        msg.source = reader.int32();
+        break;
+      case 11:
+        msg.mimeType = reader.string();
+        break;
+      case 12:
+        msg.mid = reader.string();
+        break;
+      default:
+        reader.skipType(tag & 7);
+        break;
+    }
+  }
+  return msg;
+};
+var ParticipantInfo_decode = (reader, length) => {
+  const end = reader.pos + length;
+  const msg = {
+    sid: "",
+    identity: "",
+    state: 0,
+    tracks: [],
+    metadata: "",
+    joinedAt: 0,
+    name: "",
+    version: 0,
+    region: "",
+    isPublisher: false
+  };
+  while (reader.pos < end) {
+    const tag = reader.uint32();
+    switch (tag >>> 3) {
+      case 1:
+        msg.sid = reader.string();
+        break;
+      case 2:
+        msg.identity = reader.string();
+        break;
+      case 3:
+        msg.state = reader.int32();
+        break;
+      case 4:
+        msg.tracks.push(TrackInfo_decode(reader, reader.uint32()));
+        break;
+      case 5:
+        msg.metadata = reader.string();
+        break;
+      case 6:
+        msg.joinedAt = reader.int64();
+        break;
+      case 7:
+        msg.name = reader.string();
+        break;
+      case 10:
+        msg.version = reader.uint32();
+        break;
+      case 11: {
+        const pEnd = reader.pos + reader.uint32();
+        const perm = {
+          canSubscribe: false,
+          canPublish: false,
+          canPublishData: false,
+          hidden: false,
+          recorder: false
+        };
+        while (reader.pos < pEnd) {
+          const pTag = reader.uint32();
+          switch (pTag >>> 3) {
+            case 1:
+              perm.canSubscribe = reader.bool();
+              break;
+            case 2:
+              perm.canPublish = reader.bool();
+              break;
+            case 3:
+              perm.canPublishData = reader.bool();
+              break;
+            case 7:
+              perm.hidden = reader.bool();
+              break;
+            case 8:
+              perm.recorder = reader.bool();
+              break;
+            default:
+              reader.skipType(pTag & 7);
+              break;
+          }
+        }
+        msg.permission = perm;
+        break;
+      }
+      case 12:
+        msg.region = reader.string();
+        break;
+      case 13:
+        msg.isPublisher = reader.bool();
+        break;
+      default:
+        reader.skipType(tag & 7);
+        break;
+    }
+  }
+  return msg;
+};
+var SpeakerInfo_decode = (reader, length) => {
+  const end = reader.pos + length;
+  const msg = { sid: "", level: 0, active: false };
+  while (reader.pos < end) {
+    const tag = reader.uint32();
+    switch (tag >>> 3) {
+      case 1:
+        msg.sid = reader.string();
+        break;
+      case 2:
+        msg.level = reader.float();
+        break;
+      case 3:
+        msg.active = reader.bool();
+        break;
+      default:
+        reader.skipType(tag & 7);
+        break;
+    }
+  }
+  return msg;
+};
+var JoinResponse = {
+  decode(input, length) {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = {
+      otherParticipants: [],
+      serverVersion: "",
+      iceServers: [],
+      subscriberPrimary: false,
+      alternativeUrl: "",
+      serverRegion: "",
+      pingTimeout: 0,
+      pingInterval: 0
+    };
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.room = Room_decode(reader, reader.uint32());
+          break;
+        case 2:
+          message.participant = ParticipantInfo_decode(reader, reader.uint32());
+          break;
+        case 3:
+          message.otherParticipants.push(ParticipantInfo_decode(reader, reader.uint32()));
+          break;
+        case 4:
+          message.serverVersion = reader.string();
+          break;
+        case 5:
+          message.iceServers.push(ICEServer_decode(reader, reader.uint32()));
+          break;
+        case 6:
+          message.subscriberPrimary = reader.bool();
+          break;
+        case 7:
+          message.alternativeUrl = reader.string();
+          break;
+        case 9:
+          message.serverRegion = reader.string();
+          break;
+        case 10:
+          message.pingTimeout = reader.int32();
+          break;
+        case 11:
+          message.pingInterval = reader.int32();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  }
+};
+var TrackPublishedResponse = {
+  decode(input, length) {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = { cid: "" };
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.cid = reader.string();
+          break;
+        case 2:
+          message.track = TrackInfo_decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  }
+};
+var ParticipantUpdate = {
+  decode(input, length) {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = { participants: [] };
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.participants.push(ParticipantInfo_decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  }
+};
+var SpeakersChanged = {
+  decode(input, length) {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = { speakers: [] };
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.speakers.push(SpeakerInfo_decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  }
+};
+var RoomUpdate = {
+  decode(input, length) {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = {};
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.room = Room_decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  }
+};
+var TrackUnpublishedResponse = {
+  decode(input, length) {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = { trackSid: "" };
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.trackSid = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  }
+};
+var ConnectionQualityUpdate = {
+  decode(input, length) {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = { updates: [] };
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          const cEnd = reader.pos + reader.uint32();
+          const info = { participantSid: "", quality: 0, score: 0 };
+          while (reader.pos < cEnd) {
+            const cTag = reader.uint32();
+            switch (cTag >>> 3) {
+              case 1:
+                info.participantSid = reader.string();
+                break;
+              case 2:
+                info.quality = reader.int32();
+                break;
+              case 3:
+                info.score = reader.float();
+                break;
+              default:
+                reader.skipType(cTag & 7);
+                break;
+            }
+          }
+          message.updates.push(info);
+          break;
+        }
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  }
+};
+var StreamStateUpdate = {
+  decode(input, length) {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = { streamStates: [] };
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          const sEnd = reader.pos + reader.uint32();
+          const info = { participantSid: "", trackSid: "", state: 0 };
+          while (reader.pos < sEnd) {
+            const sTag = reader.uint32();
+            switch (sTag >>> 3) {
+              case 1:
+                info.participantSid = reader.string();
+                break;
+              case 2:
+                info.trackSid = reader.string();
+                break;
+              case 3:
+                info.state = reader.int32();
+                break;
+              default:
+                reader.skipType(sTag & 7);
+                break;
+            }
+          }
+          message.streamStates.push(info);
+          break;
+        }
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  }
+};
+var SignalRequest = {
+  encode(message, writer = _m0.Writer.create()) {
+    if (message.offer !== void 0) {
+      writeMessage(writer, 1, (w) => SessionDescription.encode(message.offer, w));
+    }
+    if (message.answer !== void 0) {
+      writeMessage(writer, 2, (w) => SessionDescription.encode(message.answer, w));
+    }
+    if (message.trickle !== void 0) {
+      writeMessage(writer, 3, (w) => TrickleRequest.encode(message.trickle, w));
+    }
+    if (message.addTrack !== void 0) {
+      writeMessage(writer, 4, (w) => AddTrackRequest.encode(message.addTrack, w));
+    }
+    if (message.mute !== void 0) {
+      writeMessage(writer, 5, (w) => MuteTrackRequest.encode(message.mute, w));
+    }
+    if (message.subscription !== void 0) {
+      writeMessage(writer, 6, (w) => UpdateSubscription.encode(message.subscription, w));
+    }
+    if (message.leave !== void 0) {
+      writeMessage(writer, 8, (w) => LeaveRequest.encode(message.leave, w));
+    }
+    if (message.ping !== void 0) {
+      writer.uint32(72).int64(message.ping);
+    }
+    return writer;
+  }
+};
+var SignalResponse = {
+  decode(input, length) {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = {};
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.join = JoinResponse.decode(reader, reader.uint32());
+          break;
+        case 2:
+          message.answer = SessionDescription.decode(reader, reader.uint32());
+          break;
+        case 3:
+          message.offer = SessionDescription.decode(reader, reader.uint32());
+          break;
+        case 4:
+          message.trickle = TrickleRequest.decode(reader, reader.uint32());
+          break;
+        case 5:
+          message.update = ParticipantUpdate.decode(reader, reader.uint32());
+          break;
+        case 6:
+          message.trackPublished = TrackPublishedResponse.decode(reader, reader.uint32());
+          break;
+        case 8:
+          message.leave = LeaveRequest.decode(reader, reader.uint32());
+          break;
+        case 9:
+          message.mute = MuteTrackRequest.decode(reader, reader.uint32());
+          break;
+        case 10:
+          message.speakersChanged = SpeakersChanged.decode(reader, reader.uint32());
+          break;
+        case 11:
+          message.roomUpdate = RoomUpdate.decode(reader, reader.uint32());
+          break;
+        case 12:
+          message.connectionQuality = ConnectionQualityUpdate.decode(reader, reader.uint32());
+          break;
+        case 13:
+          message.streamStateUpdate = StreamStateUpdate.decode(reader, reader.uint32());
+          break;
+        case 15:
+          message.refreshToken = reader.string();
+          break;
+        case 17:
+          message.trackUnpublished = TrackUnpublishedResponse.decode(reader, reader.uint32());
+          break;
+        case 18:
+          message.pong = reader.int64();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  }
+};
+
+// src/proto/models.ts
+var _m02 = __toESM(require("protobufjs/minimal"));
+var TrackType = /* @__PURE__ */ ((TrackType2) => {
+  TrackType2[TrackType2["AUDIO"] = 0] = "AUDIO";
+  TrackType2[TrackType2["VIDEO"] = 1] = "VIDEO";
+  TrackType2[TrackType2["DATA"] = 2] = "DATA";
+  return TrackType2;
+})(TrackType || {});
+var TrackSource = /* @__PURE__ */ ((TrackSource2) => {
+  TrackSource2[TrackSource2["UNKNOWN"] = 0] = "UNKNOWN";
+  TrackSource2[TrackSource2["CAMERA"] = 1] = "CAMERA";
+  TrackSource2[TrackSource2["MICROPHONE"] = 2] = "MICROPHONE";
+  TrackSource2[TrackSource2["SCREEN_SHARE"] = 3] = "SCREEN_SHARE";
+  TrackSource2[TrackSource2["SCREEN_SHARE_AUDIO"] = 4] = "SCREEN_SHARE_AUDIO";
+  return TrackSource2;
+})(TrackSource || {});
+var ParticipantInfo_State = /* @__PURE__ */ ((ParticipantInfo_State2) => {
+  ParticipantInfo_State2[ParticipantInfo_State2["JOINING"] = 0] = "JOINING";
+  ParticipantInfo_State2[ParticipantInfo_State2["JOINED"] = 1] = "JOINED";
+  ParticipantInfo_State2[ParticipantInfo_State2["ACTIVE"] = 2] = "ACTIVE";
+  ParticipantInfo_State2[ParticipantInfo_State2["DISCONNECTED"] = 3] = "DISCONNECTED";
+  return ParticipantInfo_State2;
+})(ParticipantInfo_State || {});
+var DataPacket_Kind = /* @__PURE__ */ ((DataPacket_Kind2) => {
+  DataPacket_Kind2[DataPacket_Kind2["RELIABLE"] = 0] = "RELIABLE";
+  DataPacket_Kind2[DataPacket_Kind2["LOSSY"] = 1] = "LOSSY";
+  return DataPacket_Kind2;
+})(DataPacket_Kind || {});
+var ConnectionQuality = /* @__PURE__ */ ((ConnectionQuality2) => {
+  ConnectionQuality2[ConnectionQuality2["POOR"] = 0] = "POOR";
+  ConnectionQuality2[ConnectionQuality2["GOOD"] = 1] = "GOOD";
+  ConnectionQuality2[ConnectionQuality2["EXCELLENT"] = 2] = "EXCELLENT";
+  return ConnectionQuality2;
+})(ConnectionQuality || {});
+var DisconnectReason = /* @__PURE__ */ ((DisconnectReason2) => {
+  DisconnectReason2[DisconnectReason2["UNKNOWN_REASON"] = 0] = "UNKNOWN_REASON";
+  DisconnectReason2[DisconnectReason2["CLIENT_INITIATED"] = 1] = "CLIENT_INITIATED";
+  DisconnectReason2[DisconnectReason2["DUPLICATE_IDENTITY"] = 2] = "DUPLICATE_IDENTITY";
+  DisconnectReason2[DisconnectReason2["SERVER_SHUTDOWN"] = 3] = "SERVER_SHUTDOWN";
+  DisconnectReason2[DisconnectReason2["PARTICIPANT_REMOVED"] = 4] = "PARTICIPANT_REMOVED";
+  DisconnectReason2[DisconnectReason2["ROOM_DELETED"] = 5] = "ROOM_DELETED";
+  DisconnectReason2[DisconnectReason2["STATE_MISMATCH"] = 6] = "STATE_MISMATCH";
+  DisconnectReason2[DisconnectReason2["JOIN_FAILURE"] = 7] = "JOIN_FAILURE";
+  return DisconnectReason2;
+})(DisconnectReason || {});
+var DataPacket = {
+  encode(message, writer = _m02.Writer.create()) {
+    if (message.kind !== 0) {
+      writer.uint32(8).int32(message.kind);
+    }
+    if (message.user !== void 0) {
+      UserPacket.encode(message.user, writer.uint32(18).fork()).ldelim();
+    }
+    if (message.speaker !== void 0) {
+      ActiveSpeakerUpdate.encode(message.speaker, writer.uint32(26).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof _m02.Reader ? input : _m02.Reader.create(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = { kind: 0 };
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.kind = reader.int32();
+          break;
+        case 2:
+          message.user = UserPacket.decode(reader, reader.uint32());
+          break;
+        case 3:
+          message.speaker = ActiveSpeakerUpdate.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  }
+};
+var UserPacket = {
+  encode(message, writer = _m02.Writer.create()) {
+    if (message.participantSid !== "") {
+      writer.uint32(10).string(message.participantSid);
+    }
+    if (message.payload.length !== 0) {
+      writer.uint32(18).bytes(message.payload);
+    }
+    for (const v of message.destinationSids) {
+      writer.uint32(26).string(v);
+    }
+    if (message.topic !== void 0) {
+      writer.uint32(34).string(message.topic);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof _m02.Reader ? input : _m02.Reader.create(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = {
+      participantSid: "",
+      payload: new Uint8Array(),
+      destinationSids: []
+    };
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.participantSid = reader.string();
+          break;
+        case 2:
+          message.payload = reader.bytes();
+          break;
+        case 3:
+          message.destinationSids.push(reader.string());
+          break;
+        case 4:
+          message.topic = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  }
+};
+var ActiveSpeakerUpdate = {
+  encode(message, writer = _m02.Writer.create()) {
+    for (const v of message.speakers) {
+      SpeakerInfo.encode(v, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof _m02.Reader ? input : _m02.Reader.create(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = { speakers: [] };
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.speakers.push(SpeakerInfo.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  }
+};
+var SpeakerInfo = {
+  encode(message, writer = _m02.Writer.create()) {
+    if (message.sid !== "") {
+      writer.uint32(10).string(message.sid);
+    }
+    if (message.level !== 0) {
+      writer.uint32(21).float(message.level);
+    }
+    if (message.active) {
+      writer.uint32(24).bool(message.active);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof _m02.Reader ? input : _m02.Reader.create(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = { sid: "", level: 0, active: false };
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.sid = reader.string();
+          break;
+        case 2:
+          message.level = reader.float();
+          break;
+        case 3:
+          message.active = reader.bool();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  }
+};
+
+// src/signal.ts
+var log = createLogger("SignalClient");
+var PROTOCOL_VERSION = 8;
+var SDK_NAME = "node";
+var SDK_VERSION = "0.1.0";
+var SignalClient = class extends TypedEmitter {
+  ws = null;
+  pingInterval = null;
+  _isConnected = false;
+  joinResponse = null;
+  get isConnected() {
+    return this._isConnected;
+  }
+  /**
+   * Connect to the dTelecom SFU signaling server.
+   * Returns JoinResponse on successful connection.
+   */
+  async connect(url, token, options = {}) {
+    const autoSubscribe = options.autoSubscribe ?? true;
+    const connectTimeout = options.connectTimeout ?? 1e4;
+    const wsUrl = this.buildUrl(url, token, autoSubscribe);
+    log.info(`Connecting to ${wsUrl.replace(/access_token=[^&]+/, "access_token=***")}`);
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.close();
+        reject(new Error(`Signal connection timed out after ${connectTimeout}ms`));
+      }, connectTimeout);
+      try {
+        this.ws = new import_ws.default(wsUrl, {
+          headers: {
+            Authorization: `Bearer ${token}`
+          }
+        });
+        this.ws.binaryType = "arraybuffer";
+      } catch (err) {
+        clearTimeout(timeout);
+        reject(err);
+        return;
+      }
+      this.ws.on("open", () => {
+        log.debug("WebSocket connected");
+      });
+      this.ws.on("message", (data) => {
+        try {
+          const bytes = data instanceof ArrayBuffer ? new Uint8Array(data) : new Uint8Array(data);
+          const response = SignalResponse.decode(bytes);
+          this.handleResponse(response);
+          if (response.join) {
+            clearTimeout(timeout);
+            this.joinResponse = response.join;
+            this._isConnected = true;
+            if (response.join.pingInterval > 0) {
+              this.startPing(response.join.pingInterval);
+            }
+            resolve(response.join);
+          }
+        } catch (err) {
+          log.error("Failed to decode signal response", err);
+        }
+      });
+      this.ws.on("error", (err) => {
+        log.error("WebSocket error", err);
+        clearTimeout(timeout);
+        this.emit("error", err instanceof Error ? err : new Error(String(err)));
+        reject(err);
+      });
+      this.ws.on("close", (code, reason) => {
+        clearTimeout(timeout);
+        this._isConnected = false;
+        this.stopPing();
+        const reasonStr = reason?.toString() || `code ${code}`;
+        log.info(`WebSocket closed: ${reasonStr}`);
+        this.emit("close", reasonStr);
+        if (!this.joinResponse) {
+          reject(new Error(`WebSocket closed before join: ${reasonStr}`));
+        }
+      });
+    });
+  }
+  /** Send an SDP offer (publisher → server) */
+  sendOffer(sd) {
+    this.sendRequest({ offer: sd });
+  }
+  /** Send an SDP answer (subscriber → server) */
+  sendAnswer(sd) {
+    this.sendRequest({ answer: sd });
+  }
+  /** Send an ICE candidate */
+  sendIceCandidate(candidate, target) {
+    this.sendRequest({
+      trickle: { candidateInit: candidate, target }
+    });
+  }
+  /** Request to add (publish) a track */
+  sendAddTrack(request) {
+    this.sendRequest({ addTrack: request });
+  }
+  /** Mute/unmute a track */
+  sendMuteTrack(trackSid, muted) {
+    this.sendRequest({ mute: { sid: trackSid, muted } });
+  }
+  /** Update track subscription */
+  sendSubscription(update) {
+    this.sendRequest({ subscription: update });
+  }
+  /** Send leave request */
+  sendLeave() {
+    this.sendRequest({
+      leave: { canReconnect: false, reason: 1 /* CLIENT_INITIATED */ }
+    });
+  }
+  /** Close the WebSocket connection */
+  close() {
+    this.stopPing();
+    this._isConnected = false;
+    if (this.ws) {
+      this.ws.removeAllListeners();
+      if (this.ws.readyState === import_ws.default.OPEN || this.ws.readyState === import_ws.default.CONNECTING) {
+        this.ws.close();
+      }
+      this.ws = null;
+    }
+  }
+  // ─── Private ────────────────────────────────────────────────────────────
+  buildUrl(url, token, autoSubscribe) {
+    let wsUrl = url;
+    if (wsUrl.startsWith("http://")) {
+      wsUrl = wsUrl.replace("http://", "ws://");
+    } else if (wsUrl.startsWith("https://")) {
+      wsUrl = wsUrl.replace("https://", "wss://");
+    } else if (!wsUrl.startsWith("ws://") && !wsUrl.startsWith("wss://")) {
+      wsUrl = `wss://${wsUrl}`;
+    }
+    if (!wsUrl.includes("/rtc")) {
+      wsUrl = wsUrl.replace(/\/?$/, "/rtc");
+    }
+    const params = new URLSearchParams({
+      protocol: String(PROTOCOL_VERSION),
+      sdk: SDK_NAME,
+      version: SDK_VERSION,
+      auto_subscribe: autoSubscribe ? "1" : "0",
+      access_token: token
+    });
+    return `${wsUrl}?${params.toString()}`;
+  }
+  sendRequest(request) {
+    if (!this.ws || this.ws.readyState !== import_ws.default.OPEN) {
+      log.warn("Cannot send: WebSocket not open");
+      return;
+    }
+    try {
+      const bytes = SignalRequest.encode(request).finish();
+      this.ws.send(bytes);
+    } catch (err) {
+      log.error("Failed to encode signal request", err);
+    }
+  }
+  handleResponse(response) {
+    if (response.offer) {
+      log.debug(`Received OFFER from server (type=${response.offer.type})`);
+      this.emit("offer", response.offer);
+    }
+    if (response.answer) {
+      log.debug(`Received ANSWER from server (type=${response.answer.type})`);
+      this.emit("answer", response.answer);
+    }
+    if (response.trickle) {
+      this.emit("trickle", response.trickle);
+    }
+    if (response.update) {
+      this.emit("participantUpdate", response.update);
+    }
+    if (response.trackPublished) {
+      log.debug("Track published confirmed:", response.trackPublished.cid);
+      this.emit("trackPublished", response.trackPublished);
+    }
+    if (response.trackUnpublished) {
+      this.emit("trackUnpublished", response.trackUnpublished);
+    }
+    if (response.speakersChanged) {
+      this.emit("speakersChanged", response.speakersChanged);
+    }
+    if (response.roomUpdate) {
+      this.emit("roomUpdate", response.roomUpdate);
+    }
+    if (response.connectionQuality) {
+      this.emit("connectionQuality", response.connectionQuality);
+    }
+    if (response.streamStateUpdate) {
+      this.emit("streamStateUpdate", response.streamStateUpdate);
+    }
+    if (response.leave) {
+      log.info("Server requested leave", response.leave.reason);
+      this.emit("leave", response.leave);
+    }
+    if (response.refreshToken) {
+      this.emit("tokenRefresh", response.refreshToken);
+    }
+    if (response.mute) {
+    }
+    if (response.pong !== void 0) {
+    }
+  }
+  startPing(intervalSec) {
+    this.stopPing();
+    const intervalMs = intervalSec * 1e3;
+    this.pingInterval = setInterval(() => {
+      this.sendRequest({ ping: Date.now() });
+    }, intervalMs);
+  }
+  stopPing() {
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+      this.pingInterval = null;
+    }
+  }
+};
+
+// src/engine.ts
+var log2 = createLogger("RTCEngine");
+var RTCEngine = class extends TypedEmitter {
+  signal;
+  publisher = null;
+  subscriber = null;
+  reliableChannel = null;
+  lossyChannel = null;
+  subscriberReliableChannel = null;
+  subscriberLossyChannel = null;
+  subscriberPrimary = true;
+  _isConnected = false;
+  pendingCandidates = [];
+  joinResponse = null;
+  publishWaiters = /* @__PURE__ */ new Map();
+  get isConnected() {
+    return this._isConnected;
+  }
+  get publisherPC() {
+    return this.publisher;
+  }
+  get subscriberPC() {
+    return this.subscriber;
+  }
+  get reliableDataChannel() {
+    return this.reliableChannel;
+  }
+  get lossyDataChannel() {
+    return this.lossyChannel;
+  }
+  constructor() {
+    super();
+    this.signal = new SignalClient();
+  }
+  async connect(url, token, options = {}) {
+    const joinResponse = await this.signal.connect(url, token, {
+      autoSubscribe: options.autoSubscribe ?? true,
+      connectTimeout: options.connectTimeout ?? 1e4
+    });
+    this.joinResponse = joinResponse;
+    this.subscriberPrimary = joinResponse.subscriberPrimary;
+    log2.info(`Joined room "${joinResponse.room?.name}", subscriber_primary=${this.subscriberPrimary}`);
+    log2.debug(`ICE servers: ${joinResponse.iceServers.length}, participants: ${joinResponse.otherParticipants.length}`);
+    const iceServers = this.buildIceServers(joinResponse.iceServers);
+    this.createPublisher(iceServers);
+    this.createSubscriber(iceServers);
+    this.setupSignalHandlers();
+    this.createDataChannels();
+    if (!this.subscriberPrimary) {
+      await this.negotiate();
+    }
+    return joinResponse;
+  }
+  async addTransceiver(track) {
+    if (!this.publisher) {
+      throw new Error("Publisher PC not initialized");
+    }
+    const transceiver = this.publisher.addTransceiver(track, { direction: "sendonly" });
+    return transceiver;
+  }
+  async requestPublishTrack(cid, name, type, source, options) {
+    const request = {
+      cid,
+      name,
+      type,
+      source,
+      width: 0,
+      height: 0,
+      muted: options?.muted ?? false,
+      disableDtx: options?.disableDtx ?? false,
+      layers: [],
+      sid: ""
+    };
+    return new Promise((resolve) => {
+      this.publishWaiters.set(cid, resolve);
+      this.signal.sendAddTrack(request);
+    });
+  }
+  async negotiate() {
+    if (!this.publisher) {
+      throw new Error("Publisher PC not initialized");
+    }
+    log2.debug(`Publisher signaling state before negotiate: ${this.publisher.signalingState}`);
+    const offer = await this.publisher.createOffer();
+    await this.publisher.setLocalDescription(offer);
+    log2.debug("Sending publisher offer");
+    this.signal.sendOffer({
+      type: offer.type,
+      sdp: offer.sdp
+    });
+  }
+  sendData(data, kind) {
+    const channel = kind === "reliable" ? this.reliableChannel : this.lossyChannel;
+    if (!channel || channel.readyState !== "open") {
+      log2.warn(`Data channel ${kind} not open`);
+      return;
+    }
+    channel.send(Buffer.from(data));
+  }
+  async disconnect() {
+    this._isConnected = false;
+    try {
+      this.signal.sendLeave();
+    } catch {
+    }
+    this.reliableChannel?.close();
+    this.lossyChannel?.close();
+    this.publisher?.close();
+    this.subscriber?.close();
+    this.signal.close();
+    this.publisher = null;
+    this.subscriber = null;
+    this.reliableChannel = null;
+    this.lossyChannel = null;
+    this.subscriberReliableChannel = null;
+    this.subscriberLossyChannel = null;
+    this.publishWaiters.clear();
+    log2.info("Disconnected");
+    this.emit("disconnected", "client_initiated");
+  }
+  // ─── Private ────────────────────────────────────────────────────────────
+  buildIceServers(servers) {
+    const result = [];
+    for (const s of servers) {
+      for (const url of s.urls) {
+        result.push({
+          urls: url,
+          username: s.username || void 0,
+          credential: s.credential || void 0
+        });
+      }
+    }
+    return result;
+  }
+  createPublisher(iceServers) {
+    this.publisher = new import_werift.RTCPeerConnection({
+      iceServers,
+      iceTransportPolicy: "all"
+    });
+    this.publisher.onIceCandidate.subscribe((candidate) => {
+      if (candidate) {
+        const init = JSON.stringify(candidate.toJSON());
+        this.signal.sendIceCandidate(init, 0 /* PUBLISHER */);
+      }
+    });
+    this.publisher.iceConnectionStateChange.subscribe((state) => {
+      log2.debug(`Publisher ICE state: ${state}`);
+    });
+    log2.debug("Publisher PC created");
+  }
+  createSubscriber(iceServers) {
+    this.subscriber = new import_werift.RTCPeerConnection({
+      iceServers,
+      iceTransportPolicy: "all"
+    });
+    this.subscriber.onIceCandidate.subscribe((candidate) => {
+      if (candidate) {
+        const init = JSON.stringify(candidate.toJSON());
+        this.signal.sendIceCandidate(init, 1 /* SUBSCRIBER */);
+      }
+    });
+    this.subscriber.on("track", (event) => {
+      const track = event.track;
+      const transceiver = event.transceiver;
+      log2.debug(`Subscriber received track: mid=${transceiver?.mid}, kind=${track?.kind}`);
+      if (track) {
+        this.emit("remoteTrack", track, transceiver);
+      }
+    });
+    this.subscriber.onDataChannel.subscribe((channel) => {
+      log2.debug(`Subscriber data channel: "${channel.label}"`);
+      if (channel.label === "_reliable") {
+        this.subscriberReliableChannel = channel;
+        this.setupSubscriberDataChannel(channel, "reliable");
+      } else if (channel.label === "_lossy") {
+        this.subscriberLossyChannel = channel;
+        this.setupSubscriberDataChannel(channel, "lossy");
+      }
+    });
+    this.subscriber.iceConnectionStateChange.subscribe((state) => {
+      log2.debug(`Subscriber ICE state: ${state}`);
+      if (state === "connected") {
+        if (!this._isConnected) {
+          this._isConnected = true;
+          this.emit("connected");
+        }
+      } else if (state === "disconnected" || state === "failed") {
+        this._isConnected = false;
+        this.emit("disconnected", `ICE ${state}`);
+      }
+    });
+    log2.debug("Subscriber PC created");
+  }
+  createDataChannels() {
+    if (!this.publisher) return;
+    this.reliableChannel = this.publisher.createDataChannel("_reliable", {
+      ordered: true
+    });
+    this.lossyChannel = this.publisher.createDataChannel("_lossy", {
+      ordered: true,
+      maxRetransmits: 1
+    });
+    let readyCount = 0;
+    const checkReady = () => {
+      readyCount++;
+      if (readyCount >= 2) {
+        log2.debug("Publisher data channels ready");
+        this.emit("dataChannelReady");
+      }
+    };
+    this.reliableChannel.stateChanged.subscribe((state) => {
+      if (state === "open") {
+        log2.debug("Reliable data channel opened");
+        checkReady();
+      }
+    });
+    this.lossyChannel.stateChanged.subscribe((state) => {
+      if (state === "open") {
+        log2.debug("Lossy data channel opened");
+        checkReady();
+      }
+    });
+    log2.debug("Data channels created on publisher");
+  }
+  setupSubscriberDataChannel(channel, kind) {
+    channel.onMessage.subscribe((event) => {
+      let data;
+      if (event instanceof Buffer) {
+        data = new Uint8Array(event);
+      } else if (typeof event === "string") {
+        data = new TextEncoder().encode(event);
+      } else {
+        data = new Uint8Array(event);
+      }
+      this.emit("dataMessage", data, kind);
+    });
+  }
+  setupSignalHandlers() {
+    this.signal.on("offer", async (sd) => {
+      if (!this.subscriber) return;
+      try {
+        await this.subscriber.setRemoteDescription(
+          new import_werift.RTCSessionDescription(sd.sdp, sd.type)
+        );
+        const answer = await this.subscriber.createAnswer();
+        await this.subscriber.setLocalDescription(answer);
+        this.signal.sendAnswer({
+          type: answer.type,
+          sdp: answer.sdp
+        });
+        log2.debug("Sent subscriber answer");
+      } catch (err) {
+        log2.error("Failed to handle subscriber offer", err);
+      }
+    });
+    this.signal.on("answer", async (sd) => {
+      if (!this.publisher) return;
+      try {
+        await this.publisher.setRemoteDescription(
+          new import_werift.RTCSessionDescription(sd.sdp, sd.type)
+        );
+        log2.debug("Set publisher remote description");
+        this.flushPendingCandidates(0 /* PUBLISHER */);
+      } catch (err) {
+        log2.error("Failed to handle publisher answer", err);
+      }
+    });
+    this.signal.on("trickle", async (trickle) => {
+      try {
+        const candidateInit = JSON.parse(trickle.candidateInit);
+        const candidate = new import_werift.RTCIceCandidate(candidateInit);
+        const pc = trickle.target === 0 /* PUBLISHER */ ? this.publisher : this.subscriber;
+        if (!pc) return;
+        if (pc.remoteDescription) {
+          await pc.addIceCandidate(candidate);
+        } else {
+          this.pendingCandidates.push({ candidate, target: trickle.target });
+        }
+      } catch (err) {
+        log2.error("Failed to add ICE candidate", err);
+      }
+    });
+    this.signal.on("trackPublished", (response) => {
+      const waiter = this.publishWaiters.get(response.cid);
+      if (waiter) {
+        this.publishWaiters.delete(response.cid);
+        waiter(response);
+      }
+      this.emit("trackPublished", response);
+    });
+    this.signal.on("leave", () => {
+      this.disconnect();
+    });
+    this.signal.on("close", (reason) => {
+      if (this._isConnected) {
+        this._isConnected = false;
+        this.emit("disconnected", reason);
+      }
+    });
+  }
+  flushPendingCandidates(target) {
+    const pc = target === 0 /* PUBLISHER */ ? this.publisher : this.subscriber;
+    if (!pc) return;
+    const toFlush = this.pendingCandidates.filter((c) => c.target === target);
+    this.pendingCandidates = this.pendingCandidates.filter((c) => c.target !== target);
+    for (const { candidate } of toFlush) {
+      pc.addIceCandidate(candidate).catch((err) => {
+        log2.error("Failed to flush ICE candidate", err);
+      });
+    }
+  }
+};
+
+// src/track.ts
+var import_werift2 = require("werift");
+
+// src/audio/audio-frame.ts
+var AudioFrame = class _AudioFrame {
+  /** PCM16 samples (interleaved if stereo) */
+  data;
+  /** Sample rate in Hz (e.g. 16000, 48000) */
+  sampleRate;
+  /** Number of channels (1 = mono, 2 = stereo) */
+  channels;
+  /** Number of samples per channel */
+  samplesPerChannel;
+  constructor(data, sampleRate, channels, samplesPerChannel) {
+    this.data = data;
+    this.sampleRate = sampleRate;
+    this.channels = channels;
+    this.samplesPerChannel = samplesPerChannel;
+  }
+  /** Create an empty (silent) AudioFrame */
+  static create(sampleRate, channels, samplesPerChannel) {
+    const data = new Int16Array(samplesPerChannel * channels);
+    return new _AudioFrame(data, sampleRate, channels, samplesPerChannel);
+  }
+  /** Duration of this frame in seconds */
+  get duration() {
+    return this.samplesPerChannel / this.sampleRate;
+  }
+  /** Duration of this frame in milliseconds */
+  get durationMs() {
+    return this.samplesPerChannel / this.sampleRate * 1e3;
+  }
+  /** Total number of samples (channels * samplesPerChannel) */
+  get totalSamples() {
+    return this.data.length;
+  }
+  /** Convert to Buffer (for Opus encoder or file I/O) */
+  toBuffer() {
+    return Buffer.from(this.data.buffer, this.data.byteOffset, this.data.byteLength);
+  }
+  /** Create AudioFrame from a Buffer of PCM16 data */
+  static fromBuffer(buffer, sampleRate, channels) {
+    const data = new Int16Array(
+      buffer.buffer,
+      buffer.byteOffset,
+      buffer.byteLength / 2
+    );
+    const samplesPerChannel = data.length / channels;
+    return new _AudioFrame(data, sampleRate, channels, samplesPerChannel);
+  }
+  /** Clone this AudioFrame */
+  clone() {
+    return new _AudioFrame(
+      new Int16Array(this.data),
+      this.sampleRate,
+      this.channels,
+      this.samplesPerChannel
+    );
+  }
+};
+
+// src/audio/opus-encoder.ts
+var log3 = createLogger("OpusEncoder");
+var OPUS_SAMPLE_RATE = 48e3;
+var OPUS_FRAME_DURATION_MS = 20;
+var OPUS_FRAME_SIZE = OPUS_SAMPLE_RATE * OPUS_FRAME_DURATION_MS / 1e3;
+var OpusEncoderClass = null;
+function getOpusEncoder() {
+  if (!OpusEncoderClass) {
+    try {
+      const opus = require("@discordjs/opus");
+      OpusEncoderClass = opus.OpusEncoder;
+    } catch {
+      try {
+        const OpusScript = require("opusscript");
+        OpusEncoderClass = OpusScript;
+      } catch {
+        throw new Error(
+          "No Opus library found. Install @discordjs/opus (recommended) or opusscript (WASM fallback)."
+        );
+      }
+    }
+  }
+  return OpusEncoderClass;
+}
+var OpusEncoder = class {
+  encoder;
+  channels;
+  /**
+   * Create an Opus encoder.
+   * @param sampleRate Must be 48000 (Opus native rate)
+   * @param channels Number of channels (1 = mono, 2 = stereo)
+   * @param bitrate Target bitrate in bps (default: 64000)
+   */
+  constructor(sampleRate = OPUS_SAMPLE_RATE, channels = 1, bitrate = 64e3) {
+    if (sampleRate !== OPUS_SAMPLE_RATE) {
+      throw new Error(`Opus encoder requires ${OPUS_SAMPLE_RATE}Hz, got ${sampleRate}Hz. Resample first.`);
+    }
+    this.channels = channels;
+    const Encoder = getOpusEncoder();
+    this.encoder = new Encoder(sampleRate, channels);
+    if (typeof this.encoder.setBitrate === "function") {
+      this.encoder.setBitrate(bitrate);
+    }
+    log3.debug(`Created Opus encoder: ${sampleRate}Hz, ${channels}ch, ${bitrate}bps`);
+  }
+  /**
+   * Encode a PCM16 frame to Opus.
+   * @param pcm PCM16 samples (Int16Array or Buffer). Must be exactly OPUS_FRAME_SIZE * channels samples.
+   * @returns Opus-encoded bytes
+   */
+  encode(pcm) {
+    const buf = pcm instanceof Int16Array ? Buffer.from(pcm.buffer, pcm.byteOffset, pcm.byteLength) : pcm;
+    return this.encoder.encode(buf, OPUS_FRAME_SIZE);
+  }
+  /** Clean up native resources */
+  destroy() {
+    if (this.encoder && typeof this.encoder.delete === "function") {
+      this.encoder.delete();
+    }
+    this.encoder = null;
+  }
+};
+
+// src/audio/opus-decoder.ts
+var log4 = createLogger("OpusDecoder");
+var OpusDecoderClass = null;
+function getOpusDecoder() {
+  if (!OpusDecoderClass) {
+    try {
+      OpusDecoderClass = require("opusscript");
+    } catch {
+      throw new Error(
+        "opusscript is required for Opus decoding. Install it: npm install opusscript"
+      );
+    }
+  }
+  return OpusDecoderClass;
+}
+var OpusDecoder = class {
+  decoder;
+  channels;
+  /**
+   * Create an Opus decoder.
+   * @param sampleRate Must be 48000 (Opus native rate)
+   * @param channels Number of channels (1 = mono, 2 = stereo)
+   */
+  constructor(sampleRate = OPUS_SAMPLE_RATE, channels = 1) {
+    if (sampleRate !== OPUS_SAMPLE_RATE) {
+      throw new Error(`Opus decoder requires ${OPUS_SAMPLE_RATE}Hz, got ${sampleRate}Hz`);
+    }
+    this.channels = channels;
+    const Decoder = getOpusDecoder();
+    this.decoder = new Decoder(sampleRate, channels);
+    log4.debug(`Created Opus decoder: ${sampleRate}Hz, ${channels}ch`);
+  }
+  /**
+   * Decode an Opus frame to PCM16.
+   * @param opus Opus-encoded bytes
+   * @returns PCM16 samples as Buffer (OPUS_FRAME_SIZE * channels * 2 bytes)
+   */
+  decode(opus) {
+    return this.decoder.decode(opus);
+  }
+  /**
+   * Decode an Opus frame to Int16Array.
+   * @param opus Opus-encoded bytes
+   * @returns PCM16 samples
+   */
+  decodeToInt16Array(opus) {
+    const decoded = this.decode(opus);
+    return new Int16Array(
+      decoded.buffer,
+      decoded.byteOffset,
+      decoded.byteLength / 2
+    );
+  }
+  /** Generate a silence frame (packet loss concealment) */
+  decodeMissing() {
+    return Buffer.alloc(OPUS_FRAME_SIZE * this.channels * 2);
+  }
+  /** Clean up resources */
+  destroy() {
+    if (this.decoder && typeof this.decoder.delete === "function") {
+      this.decoder.delete();
+    }
+    this.decoder = null;
+  }
+};
+
+// src/audio/rtp-opus.ts
+var log5 = createLogger("RTP-Opus");
+var OPUS_PAYLOAD_TYPE = 111;
+var OPUS_TIMESTAMP_INCREMENT = OPUS_FRAME_SIZE;
+var OpusRtpPacketizer = class {
+  sequenceNumber;
+  timestamp;
+  ssrc;
+  payloadType;
+  constructor(ssrc = 0, payloadType = OPUS_PAYLOAD_TYPE) {
+    this.sequenceNumber = Math.floor(Math.random() * 65535);
+    this.timestamp = Math.floor(Math.random() * 4294967295);
+    this.ssrc = ssrc;
+    this.payloadType = payloadType;
+  }
+  /**
+   * Get the next RTP header values for an Opus frame.
+   * Call this for each 20ms frame to get incrementing seq/ts.
+   */
+  nextPacketInfo() {
+    const info = {
+      sequenceNumber: this.sequenceNumber & 65535,
+      timestamp: this.timestamp >>> 0,
+      ssrc: this.ssrc
+    };
+    this.sequenceNumber = this.sequenceNumber + 1 & 65535;
+    this.timestamp = this.timestamp + OPUS_TIMESTAMP_INCREMENT >>> 0;
+    return info;
+  }
+  /** Reset the packetizer state */
+  reset() {
+    this.sequenceNumber = Math.floor(Math.random() * 65535);
+    this.timestamp = Math.floor(Math.random() * 4294967295);
+  }
+};
+var OpusRtpDepacketizer = class {
+  lastSequenceNumber = -1;
+  lastTimestamp = -1;
+  lostPackets = 0;
+  /**
+   * Process an incoming RTP packet containing an Opus frame.
+   * Returns the Opus payload and metadata.
+   */
+  processPacket(payload, sequenceNumber, timestamp) {
+    let lost = 0;
+    const isFirst = this.lastSequenceNumber === -1;
+    if (!isFirst) {
+      const expectedSeq = this.lastSequenceNumber + 1 & 65535;
+      if (sequenceNumber !== expectedSeq) {
+        if (sequenceNumber > this.lastSequenceNumber) {
+          lost = sequenceNumber - this.lastSequenceNumber - 1;
+        } else {
+          lost = 65535 - this.lastSequenceNumber + sequenceNumber;
+        }
+        this.lostPackets += lost;
+        if (lost > 0) {
+          log5.debug(`Lost ${lost} packets (seq ${this.lastSequenceNumber} \u2192 ${sequenceNumber})`);
+        }
+      }
+    }
+    this.lastSequenceNumber = sequenceNumber;
+    this.lastTimestamp = timestamp;
+    return {
+      opusFrame: payload,
+      lost,
+      isFirst
+    };
+  }
+  /** Total packets lost since creation */
+  get totalLost() {
+    return this.lostPackets;
+  }
+  /** Reset depacketizer state */
+  reset() {
+    this.lastSequenceNumber = -1;
+    this.lastTimestamp = -1;
+    this.lostPackets = 0;
+  }
+};
+
+// src/audio/resampler.ts
+function downsample(input, fromRate, toRate, channels = 1) {
+  if (fromRate === toRate) {
+    return new Int16Array(input);
+  }
+  if (fromRate < toRate) {
+    throw new Error(`downsample: fromRate (${fromRate}) must be >= toRate (${toRate})`);
+  }
+  const ratio = fromRate / toRate;
+  if (!Number.isInteger(ratio)) {
+    return resampleLinear(input, fromRate, toRate, channels);
+  }
+  const inputSamplesPerChannel = input.length / channels;
+  const outputSamplesPerChannel = Math.floor(inputSamplesPerChannel / ratio);
+  const output = new Int16Array(outputSamplesPerChannel * channels);
+  for (let ch = 0; ch < channels; ch++) {
+    for (let i = 0; i < outputSamplesPerChannel; i++) {
+      let sum = 0;
+      for (let j = 0; j < ratio; j++) {
+        sum += input[(i * ratio + j) * channels + ch];
+      }
+      output[i * channels + ch] = Math.round(sum / ratio);
+    }
+  }
+  return output;
+}
+function upsample(input, fromRate, toRate, channels = 1) {
+  if (fromRate === toRate) {
+    return new Int16Array(input);
+  }
+  if (fromRate > toRate) {
+    throw new Error(`upsample: fromRate (${fromRate}) must be <= toRate (${toRate})`);
+  }
+  const ratio = toRate / fromRate;
+  if (!Number.isInteger(ratio)) {
+    return resampleLinear(input, fromRate, toRate, channels);
+  }
+  const inputSamplesPerChannel = input.length / channels;
+  const outputSamplesPerChannel = inputSamplesPerChannel * ratio;
+  const output = new Int16Array(outputSamplesPerChannel * channels);
+  for (let ch = 0; ch < channels; ch++) {
+    for (let i = 0; i < inputSamplesPerChannel; i++) {
+      const currentSample = input[i * channels + ch];
+      const nextSample = i + 1 < inputSamplesPerChannel ? input[(i + 1) * channels + ch] : currentSample;
+      for (let j = 0; j < ratio; j++) {
+        const t = j / ratio;
+        const interpolated = currentSample + (nextSample - currentSample) * t;
+        output[(i * ratio + j) * channels + ch] = Math.round(interpolated);
+      }
+    }
+  }
+  return output;
+}
+function resampleLinear(input, fromRate, toRate, channels) {
+  const inputSamplesPerChannel = input.length / channels;
+  const outputSamplesPerChannel = Math.round(inputSamplesPerChannel * toRate / fromRate);
+  const output = new Int16Array(outputSamplesPerChannel * channels);
+  const ratio = fromRate / toRate;
+  for (let ch = 0; ch < channels; ch++) {
+    for (let i = 0; i < outputSamplesPerChannel; i++) {
+      const srcPos = i * ratio;
+      const srcIndex = Math.floor(srcPos);
+      const frac = srcPos - srcIndex;
+      const s0 = srcIndex < inputSamplesPerChannel ? input[srcIndex * channels + ch] : 0;
+      const s1 = srcIndex + 1 < inputSamplesPerChannel ? input[(srcIndex + 1) * channels + ch] : s0;
+      output[i * channels + ch] = Math.round(s0 + (s1 - s0) * frac);
+    }
+  }
+  return output;
+}
+function resample(input, fromRate, toRate, channels = 1) {
+  if (fromRate === toRate) return new Int16Array(input);
+  if (fromRate > toRate) return downsample(input, fromRate, toRate, channels);
+  return upsample(input, fromRate, toRate, channels);
+}
+
+// src/utils/queue.ts
+var AsyncQueue = class {
+  buffer = [];
+  resolvers = [];
+  closed = false;
+  /** Push an item into the queue. */
+  push(item) {
+    if (this.closed) return;
+    if (this.resolvers.length > 0) {
+      const resolve = this.resolvers.shift();
+      resolve({ value: item, done: false });
+    } else {
+      this.buffer.push(item);
+    }
+  }
+  /** Close the queue. Pending consumers receive done. */
+  close() {
+    this.closed = true;
+    for (const resolve of this.resolvers) {
+      resolve({ value: void 0, done: true });
+    }
+    this.resolvers.length = 0;
+  }
+  /** Number of buffered items. */
+  get size() {
+    return this.buffer.length;
+  }
+  /** Whether the queue is closed. */
+  get isClosed() {
+    return this.closed;
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: () => {
+        if (this.buffer.length > 0) {
+          return Promise.resolve({ value: this.buffer.shift(), done: false });
+        }
+        if (this.closed) {
+          return Promise.resolve({ value: void 0, done: true });
+        }
+        return new Promise((resolve) => {
+          this.resolvers.push(resolve);
+        });
+      }
+    };
+  }
+};
+
+// src/audio/audio-stream.ts
+var log6 = createLogger("AudioStream");
+var AudioStream = class {
+  decoder = null;
+  depacketizer;
+  queue;
+  outputSampleRate;
+  outputChannels;
+  track = null;
+  _closed = false;
+  /**
+   * @param track The remote audio track to stream from
+   * @param sampleRate Desired output sample rate (default: 16000 for STT)
+   * @param channels Desired output channels (default: 1 = mono)
+   */
+  constructor(track, sampleRate = 16e3, channels = 1) {
+    this.outputSampleRate = sampleRate;
+    this.outputChannels = channels;
+    this.depacketizer = new OpusRtpDepacketizer();
+    this.queue = new AsyncQueue();
+    this.track = track;
+    this.start();
+  }
+  get closed() {
+    return this._closed;
+  }
+  /** Close the stream and release resources */
+  close() {
+    if (this._closed) return;
+    this._closed = true;
+    this.queue.close();
+    if (this.decoder) {
+      this.decoder.destroy();
+      this.decoder = null;
+    }
+    this.track = null;
+    log6.debug("AudioStream closed");
+  }
+  [Symbol.asyncIterator]() {
+    return this.queue[Symbol.asyncIterator]();
+  }
+  start() {
+    if (!this.track) return;
+    this.track.onReceiveRtp.subscribe((rtpPacket) => {
+      if (this._closed) return;
+      try {
+        this.processRtpPacket(rtpPacket);
+      } catch (err) {
+        log6.error("Failed to process RTP packet", err);
+      }
+    });
+    this.track.onReceiveRtp.once(() => {
+    });
+    log6.debug(`AudioStream started, output: ${this.outputSampleRate}Hz ${this.outputChannels}ch`);
+  }
+  processRtpPacket(rtp) {
+    if (!rtp.payload || rtp.payload.length === 0) {
+      return;
+    }
+    const payloadCopy = Buffer.from(rtp.payload);
+    if (payloadCopy.length > 1500) {
+      log6.warn(`Skipping oversized RTP payload: ${payloadCopy.length} bytes`);
+      return;
+    }
+    if (!this.decoder) {
+      this.decoder = new OpusDecoder(OPUS_SAMPLE_RATE, this.outputChannels);
+    }
+    const { opusFrame, lost } = this.depacketizer.processPacket(
+      payloadCopy,
+      rtp.header.sequenceNumber,
+      rtp.header.timestamp
+    );
+    for (let i = 0; i < lost && i < 3; i++) {
+      const silence = Buffer.alloc(OPUS_FRAME_SIZE * this.outputChannels * 2);
+      this.emitFrame(silence);
+    }
+    if (opusFrame.length < 1) {
+      return;
+    }
+    try {
+      const opusCopy = Buffer.alloc(opusFrame.length);
+      opusFrame.copy(opusCopy);
+      const pcmBuffer = this.decoder.decode(opusCopy);
+      this.emitFrame(pcmBuffer);
+    } catch (err) {
+      log6.error(`Opus decode failed (${opusFrame.length} bytes)`, err);
+    }
+  }
+  emitFrame(pcm48k) {
+    let samples = new Int16Array(
+      pcm48k.buffer,
+      pcm48k.byteOffset,
+      pcm48k.byteLength / 2
+    );
+    if (this.outputSampleRate !== OPUS_SAMPLE_RATE) {
+      samples = downsample(samples, OPUS_SAMPLE_RATE, this.outputSampleRate, this.outputChannels);
+    }
+    const samplesPerChannel = samples.length / this.outputChannels;
+    const frame = new AudioFrame(samples, this.outputSampleRate, this.outputChannels, samplesPerChannel);
+    this.queue.push(frame);
+  }
+};
+
+// src/track.ts
+var log7 = createLogger("Track");
+var TrackPublication = class extends TypedEmitter {
+  sid;
+  name;
+  kind;
+  source;
+  mimeType;
+  muted;
+  constructor(info) {
+    super();
+    this.sid = info.sid;
+    this.name = info.name;
+    this.kind = info.type;
+    this.source = info.source;
+    this.mimeType = info.mimeType;
+    this.muted = info.muted;
+  }
+  updateInfo(info) {
+    const wasMuted = this.muted;
+    this.sid = info.sid;
+    this.name = info.name;
+    this.kind = info.type;
+    this.source = info.source;
+    this.mimeType = info.mimeType;
+    this.muted = info.muted;
+    if (wasMuted !== info.muted) {
+      this.emit(info.muted ? "muted" : "unmuted");
+    }
+  }
+};
+var LocalTrackPublication = class extends TrackPublication {
+  track;
+  constructor(info, track) {
+    super(info);
+    this.track = track;
+  }
+};
+var RemoteTrackPublication = class extends TrackPublication {
+  track = null;
+  setTrack(track) {
+    this.track = track;
+  }
+};
+var LocalAudioTrack = class _LocalAudioTrack {
+  name;
+  source;
+  /** werift MediaStreamTrack used by the PeerConnection sender */
+  mediaTrack;
+  transceiver = null;
+  packetizer;
+  _cid;
+  _sid = "";
+  constructor(name, source) {
+    this.name = name;
+    this.source = source;
+    this.mediaTrack = new import_werift2.MediaStreamTrack({ kind: "audio" });
+    this.packetizer = new OpusRtpPacketizer(0, OPUS_PAYLOAD_TYPE);
+    this._cid = `track-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  }
+  /** Create a local audio track from an AudioSource */
+  static createAudioTrack(name, source) {
+    return new _LocalAudioTrack(name, source);
+  }
+  /** Client-generated track ID (used before server assigns SID) */
+  get cid() {
+    return this._cid;
+  }
+  /** Server-assigned track SID */
+  get sid() {
+    return this._sid;
+  }
+  set sid(value) {
+    this._sid = value;
+  }
+  /**
+   * Set the RTP transceiver for sending audio.
+   * Called internally by LocalParticipant after negotiation.
+   */
+  setTransceiver(transceiver) {
+    this.transceiver = transceiver;
+    this.source.onEncodedFrame = (opusData) => {
+      if (this.mediaTrack.stopped) return;
+      try {
+        const info = this.packetizer.nextPacketInfo();
+        const header = new import_werift2.RtpHeader();
+        header.payloadType = OPUS_PAYLOAD_TYPE;
+        header.sequenceNumber = info.sequenceNumber;
+        header.timestamp = info.timestamp;
+        header.ssrc = info.ssrc;
+        header.marker = false;
+        const packet = new import_werift2.RtpPacket(header, opusData);
+        this.mediaTrack.writeRtp(packet);
+      } catch (err) {
+        log7.error("Failed to send RTP via track", err);
+      }
+    };
+  }
+  /** Stop the track and release resources */
+  stop() {
+    this.source.flush();
+    this.source.destroy();
+    this.mediaTrack.stop();
+    this.transceiver = null;
+  }
+};
+var RemoteAudioTrack = class extends TypedEmitter {
+  sid;
+  name;
+  mediaTrack;
+  _streams = [];
+  constructor(sid, name, mediaTrack) {
+    super();
+    this.sid = sid;
+    this.name = name;
+    this.mediaTrack = mediaTrack;
+  }
+  /**
+   * Create an AudioStream to consume decoded PCM16 frames from this track.
+   * @param sampleRate Desired output sample rate (default: 16000 for STT)
+   * @param channels Desired channels (default: 1)
+   */
+  createStream(sampleRate = 16e3, channels = 1) {
+    const stream = new AudioStream(this.mediaTrack, sampleRate, channels);
+    this._streams.push(stream);
+    return stream;
+  }
+  /** Close all streams and release resources */
+  stop() {
+    for (const stream of this._streams) {
+      stream.close();
+    }
+    this._streams = [];
+    this.emit("ended");
+  }
+};
+
+// src/participant.ts
+var log8 = createLogger("Participant");
+var Participant = class extends TypedEmitter {
+  sid;
+  identity;
+  name;
+  metadata;
+  state;
+  _trackPublications = /* @__PURE__ */ new Map();
+  constructor(sid, identity, name = "", metadata = "") {
+    super();
+    this.sid = sid;
+    this.identity = identity;
+    this.name = name;
+    this.metadata = metadata;
+    this.state = 0 /* JOINING */;
+  }
+  get trackPublications() {
+    return this._trackPublications;
+  }
+  /** Update participant info from server */
+  updateInfo(info) {
+    const metadataChanged = this.metadata !== info.metadata;
+    this.sid = info.sid;
+    this.identity = info.identity;
+    this.name = info.name;
+    this.metadata = info.metadata;
+    this.state = info.state;
+    if (metadataChanged) {
+      this.emit("metadataChanged", info.metadata);
+    }
+  }
+};
+var LocalParticipant = class extends Participant {
+  engine;
+  publishedTracks = /* @__PURE__ */ new Map();
+  constructor(engine, sid, identity, name = "", metadata = "") {
+    super(sid, identity, name, metadata);
+    this.engine = engine;
+  }
+  /**
+   * Publish an audio track to the room.
+   *
+   * Flow:
+   * 1. Send AddTrackRequest to server
+   * 2. Wait for TrackPublishedResponse (server assigns SID)
+   * 3. Add transceiver to publisher PeerConnection
+   * 4. Negotiate SDP
+   */
+  async publishTrack(track, options) {
+    const name = options?.name ?? track.name;
+    const source = options?.source ?? 2 /* MICROPHONE */;
+    const disableDtx = options?.disableDtx ?? false;
+    log8.info(`Publishing track "${name}" (cid=${track.cid})`);
+    const response = await this.engine.requestPublishTrack(
+      track.cid,
+      name,
+      0 /* AUDIO */,
+      source,
+      { disableDtx }
+    );
+    if (!response.track) {
+      throw new Error("Server did not return track info");
+    }
+    track.sid = response.track.sid;
+    log8.debug(`Track published: cid=${track.cid}, sid=${track.sid}`);
+    const transceiver = await this.engine.addTransceiver(track.mediaTrack);
+    track.setTransceiver(transceiver);
+    await this.engine.negotiate();
+    const publication = new LocalTrackPublication(response.track, track);
+    this._trackPublications.set(response.track.sid, publication);
+    this.publishedTracks.set(track.cid, track);
+    this.emit("trackPublished", publication);
+    return publication;
+  }
+  /**
+   * Unpublish an audio track from the room.
+   */
+  async unpublishTrack(track) {
+    log8.info(`Unpublishing track "${track.name}" (sid=${track.sid})`);
+    track.stop();
+    this._trackPublications.delete(track.sid);
+    this.publishedTracks.delete(track.cid);
+    await this.engine.negotiate();
+    this.emit("trackUnpublished", new TrackPublication({
+      sid: track.sid,
+      name: track.name,
+      type: 0 /* AUDIO */,
+      source: 2 /* MICROPHONE */,
+      muted: false,
+      width: 0,
+      height: 0,
+      simulcast: false,
+      disableDtx: false,
+      layers: [],
+      mimeType: "audio/opus",
+      mid: ""
+    }));
+  }
+  /**
+   * Publish data to the room.
+   *
+   * @param data The data payload
+   * @param options Delivery options (kind, destinations, topic)
+   */
+  async publishData(data, options = {}) {
+    const kind = options.kind ?? 0 /* RELIABLE */;
+    const destinationSids = options.destinationSids ?? [];
+    const topic = options.topic;
+    const packet = {
+      kind,
+      user: {
+        participantSid: this.sid,
+        payload: data,
+        destinationSids,
+        topic
+      }
+    };
+    const encoded = DataPacket.encode(packet).finish();
+    const channelKind = kind === 0 /* RELIABLE */ ? "reliable" : "lossy";
+    this.engine.sendData(new Uint8Array(encoded), channelKind);
+  }
+};
+var RemoteParticipant = class extends TypedEmitter {
+  sid;
+  identity;
+  name;
+  metadata;
+  state;
+  _trackPublications = /* @__PURE__ */ new Map();
+  _audioTracks = /* @__PURE__ */ new Map();
+  constructor(info) {
+    super();
+    this.sid = info.sid;
+    this.identity = info.identity;
+    this.name = info.name;
+    this.metadata = info.metadata;
+    this.state = info.state;
+    for (const trackInfo of info.tracks) {
+      const pub = new RemoteTrackPublication(trackInfo);
+      this._trackPublications.set(trackInfo.sid, pub);
+    }
+  }
+  get trackPublications() {
+    return this._trackPublications;
+  }
+  get audioTracks() {
+    return this._audioTracks;
+  }
+  /** Update participant info from server */
+  updateInfo(info) {
+    const metadataChanged = this.metadata !== info.metadata;
+    this.sid = info.sid;
+    this.identity = info.identity;
+    this.name = info.name;
+    this.metadata = info.metadata;
+    this.state = info.state;
+    const activeSids = /* @__PURE__ */ new Set();
+    for (const trackInfo of info.tracks) {
+      activeSids.add(trackInfo.sid);
+      const existing = this._trackPublications.get(trackInfo.sid);
+      if (existing) {
+        existing.updateInfo(trackInfo);
+      } else {
+        const pub = new RemoteTrackPublication(trackInfo);
+        this._trackPublications.set(trackInfo.sid, pub);
+        this.emit("trackPublished", pub);
+      }
+    }
+    for (const [sid, pub] of this._trackPublications) {
+      if (!activeSids.has(sid)) {
+        this._trackPublications.delete(sid);
+        if (pub.track) {
+          this.removeTrack(sid);
+        }
+        this.emit("trackUnpublished", pub);
+      }
+    }
+    if (metadataChanged) {
+      this.emit("metadataChanged", info.metadata);
+    }
+  }
+  /**
+   * Called when a remote media track is received on the subscriber PC.
+   * Associates the media track with the correct publication.
+   */
+  addSubscribedTrack(mediaTrack, trackSid, trackName) {
+    const publication = this._trackPublications.get(trackSid);
+    if (!publication) {
+      log8.warn(`No publication found for track ${trackSid}`);
+      const tempPub = new RemoteTrackPublication({
+        sid: trackSid,
+        name: trackName,
+        type: 0 /* AUDIO */,
+        source: 2 /* MICROPHONE */,
+        muted: false,
+        width: 0,
+        height: 0,
+        simulcast: false,
+        disableDtx: false,
+        layers: [],
+        mimeType: "audio/opus",
+        mid: ""
+      });
+      this._trackPublications.set(trackSid, tempPub);
+    }
+    const pub = this._trackPublications.get(trackSid);
+    const remoteTrack = new RemoteAudioTrack(trackSid, pub.name, mediaTrack);
+    pub.setTrack(remoteTrack);
+    this._audioTracks.set(trackSid, remoteTrack);
+    log8.debug(`Track subscribed: ${pub.name} (${trackSid}) from ${this.identity}`);
+    this.emit("trackSubscribed", remoteTrack, pub);
+    return remoteTrack;
+  }
+  /** Remove a subscribed track */
+  removeTrack(trackSid) {
+    const track = this._audioTracks.get(trackSid);
+    if (!track) return null;
+    track.stop();
+    this._audioTracks.delete(trackSid);
+    const pub = this._trackPublications.get(trackSid);
+    if (pub) {
+      pub.setTrack(null);
+      this.emit("trackUnsubscribed", track, pub);
+    }
+    return track;
+  }
+  /** Clean up all tracks */
+  destroy() {
+    for (const [sid] of this._audioTracks) {
+      this.removeTrack(sid);
+    }
+    this._trackPublications.clear();
+  }
+};
+
+// src/room.ts
+var log9 = createLogger("Room");
+var Room = class extends TypedEmitter {
+  /** Local participant (this bot) */
+  localParticipant;
+  /** Remote participants indexed by SID */
+  remoteParticipants = /* @__PURE__ */ new Map();
+  /** Room name */
+  name = "";
+  /** Room SID */
+  sid = "";
+  /** Room metadata */
+  metadata = "";
+  engine;
+  _isConnected = false;
+  activeSpeakers = [];
+  roomInfo = null;
+  constructor() {
+    super();
+    this.engine = new RTCEngine();
+  }
+  get isConnected() {
+    return this._isConnected;
+  }
+  /**
+   * Connect to a dTelecom room.
+   *
+   * @param url WebSocket URL of the dTelecom server (e.g. "wss://my.dtelecom.org")
+   * @param token JWT access token (from AccessToken in @dtelecom/server-sdk-js)
+   * @param options Room connection options
+   */
+  async connect(url, token, options = {}) {
+    log9.info("Connecting to room...");
+    const joinResponse = await this.engine.connect(url, token, {
+      autoSubscribe: options.autoSubscribe ?? true,
+      connectTimeout: options.connectTimeout ?? 1e4
+    });
+    this.handleJoinResponse(joinResponse);
+    this.setupEngineHandlers();
+    this.setupSignalHandlers();
+    this._isConnected = true;
+    log9.info(`Connected to room "${this.name}" as "${this.localParticipant.identity}"`);
+  }
+  /**
+   * Disconnect from the room.
+   */
+  async disconnect() {
+    if (!this._isConnected) return;
+    log9.info("Disconnecting from room...");
+    this._isConnected = false;
+    for (const [sid, participant] of this.remoteParticipants) {
+      participant.destroy();
+      this.remoteParticipants.delete(sid);
+    }
+    await this.engine.disconnect();
+    this.emit("disconnected", "client_initiated");
+  }
+  /** Get a remote participant by SID */
+  getParticipant(sid) {
+    return this.remoteParticipants.get(sid);
+  }
+  /** Get a remote participant by identity */
+  getParticipantByIdentity(identity) {
+    for (const p of this.remoteParticipants.values()) {
+      if (p.identity === identity) return p;
+    }
+    return void 0;
+  }
+  // ─── Private ────────────────────────────────────────────────────────────
+  handleJoinResponse(join) {
+    if (join.room) {
+      this.roomInfo = join.room;
+      this.name = join.room.name;
+      this.sid = join.room.sid;
+      this.metadata = join.room.metadata;
+    }
+    if (join.participant) {
+      this.localParticipant = new LocalParticipant(
+        this.engine,
+        join.participant.sid,
+        join.participant.identity,
+        join.participant.name,
+        join.participant.metadata
+      );
+    }
+    for (const info of join.otherParticipants) {
+      this.getOrCreateParticipant(info);
+    }
+  }
+  setupEngineHandlers() {
+    this.engine.on("connected", () => {
+      log9.info("WebRTC connection established");
+    });
+    this.engine.on("disconnected", (reason) => {
+      if (this._isConnected) {
+        this._isConnected = false;
+        this.emit("disconnected", reason);
+      }
+    });
+    this.engine.on("remoteTrack", (mediaTrack, transceiver) => {
+      this.handleRemoteTrack(mediaTrack, transceiver);
+    });
+    this.engine.on("dataMessage", (data, kind) => {
+      this.handleDataMessage(data, kind);
+    });
+  }
+  setupSignalHandlers() {
+    this.engine.signal.on("participantUpdate", (update) => {
+      this.handleParticipantUpdate(update);
+    });
+    this.engine.signal.on("speakersChanged", (changed) => {
+      this.handleSpeakersChanged(changed);
+    });
+    this.engine.signal.on("roomUpdate", (update) => {
+      if (update.room) {
+        this.roomInfo = update.room;
+        const oldMetadata = this.metadata;
+        this.metadata = update.room.metadata;
+        if (oldMetadata !== this.metadata) {
+          this.emit("roomMetadataChanged", this.metadata);
+        }
+      }
+    });
+    this.engine.signal.on("tokenRefresh", (token) => {
+      log9.debug("Token refreshed");
+    });
+  }
+  handleParticipantUpdate(update) {
+    for (const info of update.participants) {
+      if (info.sid === this.localParticipant.sid || info.identity === this.localParticipant.identity) {
+        this.localParticipant.updateInfo(info);
+        continue;
+      }
+      if (info.state === 3 /* DISCONNECTED */) {
+        const participant = this.remoteParticipants.get(info.sid);
+        if (participant) {
+          participant.destroy();
+          this.remoteParticipants.delete(info.sid);
+          log9.info(`Participant disconnected: ${participant.identity}`);
+          this.emit("participantDisconnected", participant);
+        }
+      } else {
+        const isNew = !this.remoteParticipants.has(info.sid);
+        const participant = this.getOrCreateParticipant(info);
+        if (isNew) {
+          log9.info(`Participant connected: ${participant.identity}`);
+          this.emit("participantConnected", participant);
+        }
+      }
+    }
+  }
+  handleRemoteTrack(mediaTrack, transceiver) {
+    const mid = transceiver.mid;
+    const mediaKind = mediaTrack?.kind;
+    const expectedType = mediaKind === "audio" ? 0 /* AUDIO */ : 1 /* VIDEO */;
+    for (const participant of this.remoteParticipants.values()) {
+      for (const [sid, pub] of participant.trackPublications) {
+        if (!pub.track && pub.kind === expectedType) {
+          if (mediaKind !== "audio") {
+            log9.debug(`Skipping ${mediaKind} track ${sid} (audio-only SDK)`);
+            return;
+          }
+          participant.addSubscribedTrack(mediaTrack, sid, pub.name);
+          return;
+        }
+      }
+    }
+    log9.warn(`Received remote track (mid=${mid}, kind=${mediaKind}) but couldn't match to a participant`);
+  }
+  handleDataMessage(data, kind) {
+    try {
+      const packet = DataPacket.decode(data);
+      if (packet.user) {
+        const participant = this.remoteParticipants.get(packet.user.participantSid);
+        const packetKind = kind === "reliable" ? 0 /* RELIABLE */ : 1 /* LOSSY */;
+        this.emit("dataReceived", packet.user.payload, participant, packetKind, packet.user.topic);
+      }
+    } catch (err) {
+      log9.error("Failed to decode data message", err);
+    }
+  }
+  handleSpeakersChanged(changed) {
+    const speakers = [];
+    for (const speaker of changed.speakers) {
+      if (speaker.sid === this.localParticipant.sid) {
+        speakers.push(this.localParticipant);
+      } else {
+        const p = this.remoteParticipants.get(speaker.sid);
+        if (p) speakers.push(p);
+      }
+    }
+    this.activeSpeakers = speakers;
+    this.emit("activeSpeakersChanged", speakers);
+  }
+  getOrCreateParticipant(info) {
+    let participant = this.remoteParticipants.get(info.sid);
+    if (participant) {
+      participant.updateInfo(info);
+    } else {
+      participant = new RemoteParticipant(info);
+      this.remoteParticipants.set(info.sid, participant);
+      participant.on("trackSubscribed", (track, pub) => {
+        this.emit("trackSubscribed", track, pub, participant);
+      });
+      participant.on("trackUnsubscribed", (track, pub) => {
+        this.emit("trackUnsubscribed", track, pub, participant);
+      });
+      participant.on("trackPublished", (pub) => {
+        this.emit("trackPublished", pub, participant);
+      });
+      participant.on("trackUnpublished", (pub) => {
+        this.emit("trackUnpublished", pub, participant);
+      });
+    }
+    return participant;
+  }
+};
+
+// src/audio/audio-source.ts
+var log10 = createLogger("AudioSource");
+var AudioSource = class {
+  sampleRate;
+  channels;
+  encoder = null;
+  track = null;
+  // Buffer for accumulating samples to form exact 20ms frames at 48kHz
+  sampleBuffer;
+  bufferOffset = 0;
+  frameSizeAt48k;
+  // Callback set by LocalAudioTrack to receive encoded Opus frames
+  _onEncodedFrame = null;
+  /**
+   * @param sampleRate Input sample rate (e.g. 16000 for STT/TTS)
+   * @param channels Number of channels (1 = mono)
+   */
+  constructor(sampleRate, channels = 1) {
+    this.sampleRate = sampleRate;
+    this.channels = channels;
+    this.frameSizeAt48k = OPUS_FRAME_SIZE * channels;
+    this.sampleBuffer = new Int16Array(this.frameSizeAt48k);
+  }
+  /** Set the callback for encoded Opus frames. Used internally by LocalAudioTrack. */
+  set onEncodedFrame(cb) {
+    this._onEncodedFrame = cb;
+  }
+  /** Associate this source with a werift MediaStreamTrack */
+  setTrack(track) {
+    this.track = track;
+  }
+  /**
+   * Feed a PCM16 audio frame into the source.
+   *
+   * The frame is resampled to 48kHz, buffered to 20ms boundaries,
+   * Opus-encoded, and sent to the track for RTP transmission.
+   */
+  async captureFrame(frame) {
+    if (!this.encoder) {
+      this.encoder = new OpusEncoder(OPUS_SAMPLE_RATE, this.channels);
+    }
+    let samples = frame.data;
+    if (frame.sampleRate !== OPUS_SAMPLE_RATE) {
+      samples = upsample(frame.data, frame.sampleRate, OPUS_SAMPLE_RATE, this.channels);
+    }
+    let offset = 0;
+    while (offset < samples.length) {
+      const remaining = this.frameSizeAt48k - this.bufferOffset;
+      const available = samples.length - offset;
+      const toCopy = Math.min(remaining, available);
+      this.sampleBuffer.set(samples.subarray(offset, offset + toCopy), this.bufferOffset);
+      this.bufferOffset += toCopy;
+      offset += toCopy;
+      if (this.bufferOffset >= this.frameSizeAt48k) {
+        this.encodeAndSend(this.sampleBuffer);
+        this.bufferOffset = 0;
+      }
+    }
+  }
+  /** Clear any buffered samples */
+  flush() {
+    if (this.bufferOffset > 0) {
+      this.sampleBuffer.fill(0, this.bufferOffset);
+      this.encodeAndSend(this.sampleBuffer);
+      this.bufferOffset = 0;
+    }
+  }
+  /** Release encoder resources */
+  destroy() {
+    if (this.encoder) {
+      this.encoder.destroy();
+      this.encoder = null;
+    }
+    this._onEncodedFrame = null;
+    this.track = null;
+  }
+  encodeAndSend(pcm) {
+    if (!this.encoder) return;
+    try {
+      const opusData = this.encoder.encode(pcm);
+      if (this._onEncodedFrame) {
+        this._onEncodedFrame(opusData);
+      }
+    } catch (err) {
+      log10.error("Opus encode failed", err);
+    }
+  }
+};
+
+// src/data/data-channel.ts
+var log11 = createLogger("DataChannel");
+function encodeDataPacket(participantSid, payload, kind = 0 /* RELIABLE */, options) {
+  const packet = {
+    kind,
+    user: {
+      participantSid,
+      payload,
+      destinationSids: options?.destinationSids ?? [],
+      topic: options?.topic
+    }
+  };
+  return DataPacket.encode(packet).finish();
+}
+function decodeDataPacket(data) {
+  return DataPacket.decode(data);
+}
+function createTextMessage(participantSid, text, options) {
+  const payload = new TextEncoder().encode(text);
+  return encodeDataPacket(participantSid, payload, 0 /* RELIABLE */, options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AudioFrame,
+  AudioSource,
+  AudioStream,
+  ConnectionQuality,
+  DataPacket_Kind,
+  DisconnectReason,
+  LocalAudioTrack,
+  LocalParticipant,
+  LocalTrackPublication,
+  LogLevel,
+  Participant,
+  ParticipantInfo_State,
+  RemoteAudioTrack,
+  RemoteParticipant,
+  RemoteTrackPublication,
+  Room,
+  TrackPublication,
+  TrackSource,
+  TrackType,
+  createTextMessage,
+  decodeDataPacket,
+  downsample,
+  encodeDataPacket,
+  resample,
+  setLogLevel,
+  upsample
+});
+//# sourceMappingURL=index.js.map