@camstack/addon-webrtc-adaptive 0.1.1

package/dist/index.cjs

@@ -0,0 +1,3319 @@
+"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, {
+  AdaptiveController: () => AdaptiveController,
+  AdaptiveFfmpegSource: () => AdaptiveFfmpegSource,
+  AdaptiveRtspRelay: () => AdaptiveRtspRelay,
+  AdaptiveSession: () => AdaptiveSession,
+  AdaptiveStreamServer: () => AdaptiveStreamServer,
+  AsyncBoundedQueue: () => AsyncBoundedQueue,
+  FfmpegProcess: () => FfmpegProcess,
+  H264RtpDepacketizer: () => H264RtpDepacketizer,
+  H265RtpDepacketizer: () => H265RtpDepacketizer,
+  SharedSession: () => SharedSession,
+  StreamFanout: () => StreamFanout,
+  WebrtcAdaptiveAddon: () => WebrtcAdaptiveAddon,
+  asLogger: () => asLogger,
+  convertH264ToAnnexB: () => convertH264ToAnnexB,
+  convertH265ToAnnexB: () => convertH265ToAnnexB,
+  createDefaultProfiles: () => createDefaultProfiles,
+  createNullLogger: () => createNullLogger,
+  detectVideoCodecFromNal: () => detectVideoCodecFromNal,
+  extractH264ParamSets: () => extractH264ParamSets,
+  extractH265ParamSets: () => extractH265ParamSets,
+  fromEventEmitter: () => fromEventEmitter,
+  fromNativeStream: () => fromNativeStream,
+  fromPushCallback: () => fromPushCallback,
+  getH265NalType: () => getH265NalType,
+  hasStartCodes: () => hasStartCodes,
+  isH264IdrAccessUnit: () => isH264IdrAccessUnit,
+  isH264KeyframeAnnexB: () => isH264KeyframeAnnexB,
+  isH265Irap: () => isH265Irap,
+  isH265IrapAccessUnit: () => isH265IrapAccessUnit,
+  isH265KeyframeAnnexB: () => isH265KeyframeAnnexB,
+  joinNalsToAnnexB: () => joinNalsToAnnexB,
+  prependStartCode: () => prependStartCode,
+  splitAnnexBToNals: () => splitAnnexBToNals
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/server.ts
+var import_node_crypto = __toESM(require("crypto"), 1);
+var import_node_events = require("events");
+
+// src/types.ts
+function asLogger(logger) {
+  if (!logger) return createNullLogger();
+  const noop = () => {
+  };
+  return {
+    log: logger.log?.bind(logger) ?? noop,
+    info: logger.info?.bind(logger) ?? noop,
+    warn: logger.warn?.bind(logger) ?? noop,
+    error: logger.error?.bind(logger) ?? noop,
+    debug: logger.debug?.bind(logger) ?? noop
+  };
+}
+function createNullLogger() {
+  const noop = () => {
+  };
+  return { log: noop, info: noop, warn: noop, error: noop, debug: noop };
+}
+
+// src/fanout.ts
+var AsyncBoundedQueue = class {
+  maxItems;
+  queue = [];
+  waiting;
+  closed = false;
+  constructor(maxItems) {
+    this.maxItems = Math.max(1, maxItems | 0);
+  }
+  push(item) {
+    if (this.closed) return;
+    if (this.waiting) {
+      const { resolve } = this.waiting;
+      this.waiting = void 0;
+      resolve({ value: item, done: false });
+      return;
+    }
+    this.queue.push(item);
+    if (this.queue.length > this.maxItems) {
+      this.queue.splice(0, this.queue.length - this.maxItems);
+    }
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    if (this.waiting) {
+      const { resolve } = this.waiting;
+      this.waiting = void 0;
+      resolve({ value: void 0, done: true });
+    }
+  }
+  async next() {
+    const item = this.queue.shift();
+    if (item !== void 0) return { value: item, done: false };
+    if (this.closed) return { value: void 0, done: true };
+    return await new Promise((resolve) => {
+      this.waiting = { resolve };
+    });
+  }
+  isClosed() {
+    return this.closed;
+  }
+  size() {
+    return this.queue.length;
+  }
+};
+var StreamFanout = class {
+  opts;
+  queues = /* @__PURE__ */ new Map();
+  source = null;
+  running = false;
+  pumpPromise = null;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  /** Start pumping frames from the source to all subscribers. */
+  start() {
+    if (this.running) return;
+    this.running = true;
+    this.source = this.opts.createSource();
+    this.pumpPromise = (async () => {
+      try {
+        for await (const frame of this.source) {
+          try {
+            this.opts.onFrame?.(frame);
+          } catch {
+          }
+          for (const q of this.queues.values()) {
+            q.push(frame);
+          }
+        }
+      } catch (e) {
+        this.opts.onError?.(e);
+      } finally {
+        this.running = false;
+        for (const q of this.queues.values()) q.close();
+        this.queues.clear();
+      }
+    })();
+  }
+  /**
+   * Create a subscriber async generator.
+   * Returns an async generator that yields frames from the shared source.
+   * The generator terminates when the source ends or unsubscribe is called.
+   */
+  subscribe(id) {
+    const q = new AsyncBoundedQueue(this.opts.maxQueueItems);
+    if (!this.running) {
+      q.close();
+    } else {
+      this.queues.set(id, q);
+    }
+    const self = this;
+    return (async function* () {
+      try {
+        while (true) {
+          const r = await q.next();
+          if (r.done) return;
+          yield r.value;
+        }
+      } finally {
+        q.close();
+        self.queues.delete(id);
+      }
+    })();
+  }
+  /** Unsubscribe a specific subscriber. */
+  unsubscribe(id) {
+    const q = this.queues.get(id);
+    if (q) {
+      q.close();
+      this.queues.delete(id);
+    }
+  }
+  /** Stop the source and close all subscriber queues. */
+  async stop() {
+    if (!this.running) return;
+    this.running = false;
+    const src = this.source;
+    this.source = null;
+    for (const q of this.queues.values()) q.close();
+    this.queues.clear();
+    const STOP_TIMEOUT = 3e3;
+    const timeout = new Promise((r) => setTimeout(r, STOP_TIMEOUT));
+    try {
+      await Promise.race([
+        (async () => {
+          try {
+            await src?.return(void 0);
+          } catch {
+          }
+          try {
+            await this.pumpPromise;
+          } catch {
+          }
+        })(),
+        timeout
+      ]);
+    } catch {
+    }
+    this.pumpPromise = null;
+  }
+  /** Returns true if the fan-out is running. */
+  isRunning() {
+    return this.running;
+  }
+  /** Returns the number of active subscribers. */
+  subscriberCount() {
+    return this.queues.size;
+  }
+};
+
+// src/ffmpeg-source.ts
+var import_node_child_process = require("child_process");
+
+// src/nal-utils.ts
+var NAL_START_CODE_4B = Buffer.from([0, 0, 0, 1]);
+var NAL_START_CODE_3B = Buffer.from([0, 0, 1]);
+function hasStartCodes(data) {
+  if (data.length < 4) return false;
+  if (data.subarray(0, 4).equals(NAL_START_CODE_4B)) return true;
+  if (data.subarray(0, 3).equals(NAL_START_CODE_3B)) return true;
+  return false;
+}
+function splitAnnexBToNals(annexB) {
+  const nals = [];
+  const len = annexB.length;
+  const isStartCodeAt = (i2) => {
+    if (i2 + 3 <= len && annexB[i2] === 0 && annexB[i2 + 1] === 0) {
+      if (annexB[i2 + 2] === 1) return 3;
+      if (i2 + 4 <= len && annexB[i2 + 2] === 0 && annexB[i2 + 3] === 1)
+        return 4;
+    }
+    return 0;
+  };
+  let i = 0;
+  while (i < len) {
+    const sc = isStartCodeAt(i);
+    if (sc) break;
+    i++;
+  }
+  while (i < len) {
+    const sc = isStartCodeAt(i);
+    if (!sc) {
+      i++;
+      continue;
+    }
+    const nalStart = i + sc;
+    let j = nalStart;
+    while (j < len) {
+      const sc2 = isStartCodeAt(j);
+      if (sc2) break;
+      j++;
+    }
+    if (nalStart < j) {
+      const nal = annexB.subarray(nalStart, j);
+      if (nal.length > 0) nals.push(nal);
+    }
+    i = j;
+  }
+  return nals;
+}
+function prependStartCode(nal) {
+  return Buffer.concat([NAL_START_CODE_4B, nal]);
+}
+function joinNalsToAnnexB(...nals) {
+  const present = nals.filter((n) => !!n && n.length > 0);
+  if (!present.length) return;
+  const parts = [];
+  for (const nal of present) {
+    parts.push(NAL_START_CODE_4B, nal);
+  }
+  return Buffer.concat(parts);
+}
+function detectVideoCodecFromNal(data) {
+  if (!data || data.length < 5) return null;
+  let nalStart = -1;
+  for (let i = 0; i < Math.min(data.length - 4, 100); i++) {
+    if (data[i] === 0 && data[i + 1] === 0) {
+      if (data[i + 2] === 0 && data[i + 3] === 1) {
+        nalStart = i + 4;
+        break;
+      }
+      if (data[i + 2] === 1) {
+        nalStart = i + 3;
+        break;
+      }
+    }
+  }
+  if (nalStart < 0 && data.length >= 5) {
+    const len = data.readUInt32BE(0);
+    if (len > 0 && len <= data.length - 4) {
+      nalStart = 4;
+    }
+  }
+  if (nalStart < 0 || nalStart >= data.length) return null;
+  const nalByte = data[nalStart];
+  if (nalByte === void 0) return null;
+  const forbiddenBit264 = nalByte >> 7 & 1;
+  const h264Type = nalByte & 31;
+  if (forbiddenBit264 === 0 && h264Type > 0 && h264Type <= 12) {
+    if (h264Type === 7 || h264Type === 8) return "H264";
+    if (h264Type === 5) return "H264";
+    if (h264Type === 1) {
+      const nalRefIdc = nalByte >> 5 & 3;
+      if (nalRefIdc >= 1) return "H264";
+    }
+  }
+  if (nalStart + 1 < data.length) {
+    const nalByte2 = data[nalStart + 1];
+    if (nalByte2 !== void 0) {
+      const forbiddenBit = nalByte >> 7 & 1;
+      const hevcType = nalByte >> 1 & 63;
+      const temporalId = nalByte2 & 7;
+      if (forbiddenBit === 0 && temporalId > 0 && hevcType <= 40) {
+        if (hevcType === 32 || hevcType === 33 || hevcType === 34)
+          return "H265";
+        if (hevcType === 19 || hevcType === 20 || hevcType === 21)
+          return "H265";
+        if (hevcType <= 1 && nalByte <= 3) return "H265";
+      }
+    }
+  }
+  return null;
+}
+
+// src/h264-utils.ts
+function tryConvertWithLengthReader(data, readLen) {
+  const result = [];
+  let offset = 0;
+  let nalCount = 0;
+  while (offset < data.length) {
+    if (offset + 4 > data.length) return null;
+    const nalLength = readLen(data, offset);
+    offset += 4;
+    if (nalLength <= 0) return null;
+    if (nalLength > data.length - offset) return null;
+    result.push(NAL_START_CODE_4B);
+    result.push(data.subarray(offset, offset + nalLength));
+    offset += nalLength;
+    nalCount++;
+  }
+  if (nalCount === 0) return null;
+  return Buffer.concat(result);
+}
+function tryConvertWithLengthReader16(data, readLen) {
+  const result = [];
+  let offset = 0;
+  let nalCount = 0;
+  while (offset < data.length) {
+    if (offset + 2 > data.length) return null;
+    const nalLength = readLen(data, offset);
+    offset += 2;
+    if (nalLength <= 0) return null;
+    if (nalLength > data.length - offset) return null;
+    result.push(NAL_START_CODE_4B);
+    result.push(data.subarray(offset, offset + nalLength));
+    offset += nalLength;
+    nalCount++;
+  }
+  if (nalCount === 0) return null;
+  return Buffer.concat(result);
+}
+function tryConvertWithLengthReader24(data, endian) {
+  const result = [];
+  let offset = 0;
+  let nalCount = 0;
+  const readLen24 = (buf, at) => {
+    if (at + 3 > buf.length) return 0;
+    const b0 = buf[at];
+    const b1 = buf[at + 1];
+    const b2 = buf[at + 2];
+    return endian === "be" ? (b0 << 16 | b1 << 8 | b2) >>> 0 : (b2 << 16 | b1 << 8 | b0) >>> 0;
+  };
+  while (offset < data.length) {
+    if (offset + 3 > data.length) return null;
+    const nalLength = readLen24(data, offset);
+    offset += 3;
+    if (nalLength <= 0) return null;
+    if (nalLength > data.length - offset) return null;
+    result.push(NAL_START_CODE_4B);
+    result.push(data.subarray(offset, offset + nalLength));
+    offset += nalLength;
+    nalCount++;
+  }
+  if (nalCount === 0) return null;
+  return Buffer.concat(result);
+}
+function looksLikeSingleH264Nal(nalPayload) {
+  if (nalPayload.length < 1) return false;
+  const b0 = nalPayload[0];
+  if (b0 === void 0) return false;
+  if ((b0 & 128) !== 0) return false;
+  const nalType = b0 & 31;
+  return nalType >= 1 && nalType <= 23;
+}
+function depacketizeRtpAggregationToAnnexB(payload) {
+  if (payload.length < 1) return null;
+  const nalHeader = payload[0];
+  const nalType = nalHeader & 31;
+  const out = [];
+  const pushNal = (nal) => {
+    if (nal.length === 0) return;
+    out.push(NAL_START_CODE_4B, nal);
+  };
+  if (nalType === 24) {
+    let off = 1;
+    while (off + 2 <= payload.length) {
+      const size = payload.readUInt16BE(off);
+      off += 2;
+      if (size <= 0 || off + size > payload.length) return null;
+      pushNal(payload.subarray(off, off + size));
+      off += size;
+    }
+    return out.length ? Buffer.concat(out) : null;
+  }
+  if (nalType === 25) {
+    let off = 1 + 2;
+    if (off > payload.length) return null;
+    while (off + 2 <= payload.length) {
+      const size = payload.readUInt16BE(off);
+      off += 2;
+      if (size <= 0 || off + size > payload.length) return null;
+      pushNal(payload.subarray(off, off + size));
+      off += size;
+    }
+    return out.length ? Buffer.concat(out) : null;
+  }
+  if (nalType === 26) {
+    let off = 1 + 2;
+    if (off > payload.length) return null;
+    while (off + 2 <= payload.length) {
+      const size = payload.readUInt16BE(off);
+      off += 2;
+      if (off + 1 + 2 > payload.length) return null;
+      off += 1 + 2;
+      if (size <= 0 || off + size > payload.length) return null;
+      pushNal(payload.subarray(off, off + size));
+      off += size;
+    }
+    return out.length ? Buffer.concat(out) : null;
+  }
+  if (nalType === 27) {
+    let off = 1 + 2;
+    if (off > payload.length) return null;
+    while (off + 2 <= payload.length) {
+      const size = payload.readUInt16BE(off);
+      off += 2;
+      if (off + 1 + 3 > payload.length) return null;
+      off += 1 + 3;
+      if (size <= 0 || off + size > payload.length) return null;
+      pushNal(payload.subarray(off, off + size));
+      off += size;
+    }
+    return out.length ? Buffer.concat(out) : null;
+  }
+  return null;
+}
+function convertH264ToAnnexB(data) {
+  if (hasStartCodes(data)) return data;
+  const sc4 = Buffer.from([0, 0, 0, 1]);
+  const sc3 = Buffer.from([0, 0, 1]);
+  const maxScan = Math.min(64, data.length);
+  const idx4 = data.subarray(0, maxScan).indexOf(sc4);
+  if (idx4 > 0) return data.subarray(idx4);
+  const idx3 = data.subarray(0, maxScan).indexOf(sc3);
+  if (idx3 > 0) return data.subarray(idx3);
+  const be = tryConvertWithLengthReader(data, (b, o) => b.readUInt32BE(o));
+  if (be) return be;
+  const le = tryConvertWithLengthReader(data, (b, o) => b.readUInt32LE(o));
+  if (le) return le;
+  const be24 = tryConvertWithLengthReader24(data, "be");
+  if (be24) return be24;
+  const le24 = tryConvertWithLengthReader24(data, "le");
+  if (le24) return le24;
+  const be16 = tryConvertWithLengthReader16(data, (b, o) => b.readUInt16BE(o));
+  if (be16) return be16;
+  const le16 = tryConvertWithLengthReader16(data, (b, o) => b.readUInt16LE(o));
+  if (le16) return le16;
+  const agg = depacketizeRtpAggregationToAnnexB(data);
+  if (agg) return agg;
+  if (looksLikeSingleH264Nal(data)) {
+    return Buffer.concat([NAL_START_CODE_4B, data]);
+  }
+  return data;
+}
+function isH264KeyframeAnnexB(annexB) {
+  const nals = splitAnnexBToNals(annexB);
+  let hasSps = false;
+  let hasPps = false;
+  let hasIdr = false;
+  for (const nal of nals) {
+    const t = (nal[0] ?? 0) & 31;
+    if (t === 7) hasSps = true;
+    if (t === 8) hasPps = true;
+    if (t === 5) hasIdr = true;
+  }
+  return hasIdr && hasSps && hasPps;
+}
+function isH264IdrAccessUnit(annexB) {
+  const nals = splitAnnexBToNals(annexB);
+  for (const nal of nals) {
+    if (nal.length < 1) continue;
+    const t = (nal[0] ?? 0) & 31;
+    if (t === 5) return true;
+  }
+  return false;
+}
+function extractH264ParamSets(annexB) {
+  const nals = splitAnnexBToNals(annexB);
+  let sps;
+  let pps;
+  let profileLevelId;
+  for (const nal of nals) {
+    if (nal.length < 1) continue;
+    const nalType = nal[0] & 31;
+    if (nalType === 7) {
+      sps = nal;
+      if (nal.length >= 4) {
+        profileLevelId = Buffer.from([nal[1], nal[2], nal[3]]).toString(
+          "hex"
+        );
+      }
+    } else if (nalType === 8) {
+      pps = nal;
+    }
+  }
+  const out = {};
+  if (sps) out.sps = sps;
+  if (pps) out.pps = pps;
+  if (profileLevelId) out.profileLevelId = profileLevelId;
+  return out;
+}
+var H264RtpDepacketizer = class _H264RtpDepacketizer {
+  fuNalHeader = null;
+  fuParts = [];
+  static parseRtpPayload(packet) {
+    if (!packet || packet.length < 12) return null;
+    const version = packet[0] >> 6 & 3;
+    if (version !== 2) return null;
+    const padding = (packet[0] & 32) !== 0;
+    const extension = (packet[0] & 16) !== 0;
+    const csrcCount = packet[0] & 15;
+    let offset = 12 + csrcCount * 4;
+    if (offset > packet.length) return null;
+    if (extension) {
+      if (offset + 4 > packet.length) return null;
+      const extLenWords = packet.readUInt16BE(offset + 2);
+      offset += 4 + extLenWords * 4;
+      if (offset > packet.length) return null;
+    }
+    let end = packet.length;
+    if (padding) {
+      const padLen = packet[packet.length - 1];
+      if (padLen <= 0 || padLen > packet.length) return null;
+      end = packet.length - padLen;
+      if (end < offset) return null;
+    }
+    if (end <= offset) return null;
+    return packet.subarray(offset, end);
+  }
+  reset() {
+    this.fuNalHeader = null;
+    this.fuParts = [];
+  }
+  push(payload) {
+    if (payload.length === 0) return [];
+    const rtpPayload = _H264RtpDepacketizer.parseRtpPayload(payload);
+    if (rtpPayload) payload = rtpPayload;
+    if (hasStartCodes(payload)) return [payload];
+    const b0 = payload[0];
+    if ((b0 & 128) !== 0) return [];
+    const nalType = b0 & 31;
+    if (nalType >= 1 && nalType <= 23) {
+      return [Buffer.concat([NAL_START_CODE_4B, payload])];
+    }
+    if (nalType === 24) {
+      if (payload.length < 1 + 2) return [];
+      let off = 1;
+      const out = [];
+      while (off + 2 <= payload.length) {
+        const size = payload.readUInt16BE(off);
+        off += 2;
+        if (size <= 0 || off + size > payload.length) return [];
+        const nal = payload.subarray(off, off + size);
+        off += size;
+        if (nal.length < 1) return [];
+        if ((nal[0] & 128) !== 0) return [];
+        const t = nal[0] & 31;
+        if (t === 0 || t >= 24) return [];
+        out.push(Buffer.concat([NAL_START_CODE_4B, nal]));
+      }
+      return out;
+    }
+    if (nalType === 28 || nalType === 29) {
+      if (payload.length < 2) return [];
+      const fuIndicator = payload[0];
+      const fuHeader = payload[1];
+      const start = (fuHeader & 128) !== 0;
+      const end = (fuHeader & 64) !== 0;
+      const origType = fuHeader & 31;
+      const reconstructedHeader = fuIndicator & 224 | origType;
+      let off = 2;
+      if (nalType === 29) {
+        if (payload.length < off + 2) return [];
+        off += 2;
+      }
+      const frag = payload.subarray(off);
+      if (start) {
+        this.fuNalHeader = reconstructedHeader;
+        this.fuParts = [frag];
+      } else if (this.fuNalHeader != null) {
+        this.fuParts.push(frag);
+      } else {
+        return [];
+      }
+      if (end && this.fuNalHeader != null) {
+        const nal = Buffer.concat([
+          Buffer.from([this.fuNalHeader]),
+          ...this.fuParts
+        ]);
+        this.reset();
+        return [Buffer.concat([NAL_START_CODE_4B, nal])];
+      }
+      return [];
+    }
+    return [];
+  }
+};
+
+// src/ffmpeg-source.ts
+var AnnexBAccessUnitAssembler = class {
+  buffer = Buffer.alloc(0);
+  /** Feed data from ffmpeg stdout. Returns complete access units (one per frame). */
+  feed(data) {
+    this.buffer = this.buffer.length > 0 ? Buffer.concat([this.buffer, data]) : data;
+    const aus = [];
+    const audPositions = [];
+    for (let i = 0; i < this.buffer.length - 5; i++) {
+      if (this.buffer[i] === 0 && this.buffer[i + 1] === 0) {
+        let scLen = 0;
+        if (this.buffer[i + 2] === 0 && this.buffer[i + 3] === 1) scLen = 4;
+        else if (this.buffer[i + 2] === 1) scLen = 3;
+        if (scLen > 0) {
+          const nalType = this.buffer[i + scLen] & 31;
+          if (nalType === 9) {
+            audPositions.push(i);
+          }
+        }
+      }
+    }
+    if (audPositions.length < 2) return aus;
+    for (let j = 0; j < audPositions.length - 1; j++) {
+      const au = this.buffer.subarray(audPositions[j], audPositions[j + 1]);
+      if (au.length > 4) aus.push(au);
+    }
+    this.buffer = this.buffer.subarray(audPositions[audPositions.length - 1]);
+    return aus;
+  }
+  /** Flush any remaining buffered data as a final access unit. */
+  flush() {
+    if (this.buffer.length <= 4) return null;
+    const au = this.buffer;
+    this.buffer = Buffer.alloc(0);
+    return au;
+  }
+};
+var AdaptiveFfmpegSource = class {
+  rtspUrl;
+  ffmpegPath;
+  logger;
+  label;
+  audioMode;
+  currentParams;
+  proc = null;
+  audioProc = null;
+  closed = false;
+  /** Push callback for the frame source. */
+  pushFrame = null;
+  closeSource = null;
+  /** The FrameSource async generator. Created once, survives ffmpeg restarts. */
+  source;
+  constructor(options) {
+    this.rtspUrl = options.rtspUrl;
+    this.ffmpegPath = options.ffmpegPath ?? "ffmpeg";
+    this.audioMode = options.audioMode ?? "copy";
+    this.logger = options.logger;
+    this.label = options.label ?? "adaptive-ffmpeg";
+    this.currentParams = { ...options.initialParams };
+    const queue = [];
+    let resolve = null;
+    let done = false;
+    this.pushFrame = (mf) => {
+      if (done) return;
+      if (resolve) {
+        const r = resolve;
+        resolve = null;
+        r({ value: mf, done: false });
+      } else {
+        queue.push(mf);
+        if (queue.length > 120) queue.splice(0, queue.length - 60);
+      }
+    };
+    this.closeSource = () => {
+      done = true;
+      if (resolve) {
+        const r = resolve;
+        resolve = null;
+        r({ value: void 0, done: true });
+      }
+    };
+    this.source = (async function* () {
+      try {
+        while (true) {
+          const item = queue.shift();
+          if (item) {
+            yield item;
+            continue;
+          }
+          if (done) return;
+          const result = await new Promise((r) => {
+            resolve = r;
+          });
+          if (result.done) return;
+          yield result.value;
+        }
+      } finally {
+        done = true;
+      }
+    })();
+  }
+  /** Start the ffmpeg process with current encoding params. */
+  async start() {
+    if (this.closed) return;
+    this.spawnFfmpeg();
+  }
+  /** Get the current encoding parameters. */
+  getParams() {
+    return { ...this.currentParams };
+  }
+  /**
+   * Hot-swap encoding parameters.
+   * Stops the current ffmpeg and starts a new one with updated params.
+   * The FrameSource continues seamlessly — the new ffmpeg's first keyframe
+   * is gated internally so consumers see a clean transition.
+   */
+  async updateParams(params) {
+    const prev = { ...this.currentParams };
+    if (params.maxBitrateKbps !== void 0) this.currentParams.maxBitrateKbps = params.maxBitrateKbps;
+    if (params.width !== void 0) this.currentParams.width = params.width;
+    if (params.height !== void 0) this.currentParams.height = params.height;
+    if (params.preset !== void 0) this.currentParams.preset = params.preset;
+    if (prev.maxBitrateKbps === this.currentParams.maxBitrateKbps && prev.width === this.currentParams.width && prev.height === this.currentParams.height) return;
+    this.logger?.info(
+      `[${this.label}] Updating params: ${prev.maxBitrateKbps}kbps ${prev.width}x${prev.height} \u2192 ${this.currentParams.maxBitrateKbps}kbps ${this.currentParams.width}x${this.currentParams.height}`
+    );
+    await this.killFfmpeg();
+    if (!this.closed) {
+      this.spawnFfmpeg();
+    }
+  }
+  /** Stop the source and kill ffmpeg. */
+  async stop() {
+    if (this.closed) return;
+    this.closed = true;
+    await this.killFfmpeg();
+    this.closeSource?.();
+  }
+  // -----------------------------------------------------------------------
+  // Private
+  // -----------------------------------------------------------------------
+  spawnFfmpeg() {
+    const { maxBitrateKbps, width, height, preset } = this.currentParams;
+    const args = [
+      "-hide_banner",
+      "-loglevel",
+      "error",
+      "-fflags",
+      "+nobuffer",
+      "-flags",
+      "+low_delay",
+      "-rtsp_transport",
+      "tcp",
+      "-i",
+      this.rtspUrl,
+      "-c:v",
+      "libx264",
+      "-preset",
+      preset ?? "ultrafast",
+      "-tune",
+      "zerolatency",
+      "-crf",
+      "28",
+      "-maxrate",
+      `${maxBitrateKbps}k`,
+      "-bufsize",
+      `${Math.round(maxBitrateKbps * 0.5)}k`,
+      "-g",
+      "50",
+      "-keyint_min",
+      "25",
+      "-x264opts",
+      "aud=1:sliced-threads=1",
+      "-flush_packets",
+      "1"
+    ];
+    if (width > 0 && height > 0) {
+      args.push("-vf", `scale=${width}:${height}`);
+    }
+    args.push(
+      "-an",
+      "-f",
+      "h264",
+      "-"
+    );
+    this.proc = (0, import_node_child_process.spawn)(this.ffmpegPath, args, {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    this.proc.on("error", (err) => {
+      this.logger?.error(`[${this.label}] ffmpeg spawn error: ${err.message}`);
+    });
+    this.proc.on("close", (code, signal) => {
+      this.logger?.debug(`[${this.label}] ffmpeg exited code=${code} signal=${signal}`);
+      this.proc = null;
+      if (!this.closed) {
+        setTimeout(() => {
+          if (!this.closed) this.spawnFfmpeg();
+        }, 2e3);
+      }
+    });
+    this.proc.stderr?.on("data", (data) => {
+      const s = data.toString();
+      if (s.includes("error") || s.includes("Error") || s.includes("fatal")) {
+        this.logger?.error(`[${this.label}] ffmpeg: ${s.trim()}`);
+      }
+    });
+    if (!this.proc.stdout) {
+      this.logger?.error(`[${this.label}] ffmpeg stdout not available`);
+      return;
+    }
+    const assembler = new AnnexBAccessUnitAssembler();
+    const startTime = Date.now();
+    this.proc.stdout.on("data", (data) => {
+      if (this.closed) return;
+      const aus = assembler.feed(data);
+      for (const au of aus) {
+        if (au.length < 4) continue;
+        const isKeyframe = isH264IdrAccessUnit(au);
+        const timestampMicros = (Date.now() - startTime) * 1e3;
+        const vf = {
+          data: au,
+          codec: "H264",
+          isKeyframe,
+          timestampMicros
+        };
+        this.pushFrame?.({ type: "video", frame: vf });
+      }
+    });
+    this.proc.stdout.on("end", () => {
+      const remaining = assembler.flush();
+      if (remaining && remaining.length > 4 && this.pushFrame) {
+        const vf = {
+          data: remaining,
+          codec: "H264",
+          isKeyframe: isH264IdrAccessUnit(remaining),
+          timestampMicros: (Date.now() - startTime) * 1e3
+        };
+        this.pushFrame({ type: "video", frame: vf });
+      }
+    });
+    if (this.audioMode !== "off") {
+      const audioArgs = [
+        "-hide_banner",
+        "-loglevel",
+        "error",
+        "-fflags",
+        "+nobuffer+flush_packets",
+        "-rtsp_transport",
+        "tcp",
+        "-analyzeduration",
+        "500000",
+        "-probesize",
+        "500000",
+        "-i",
+        this.rtspUrl,
+        "-vn"
+      ];
+      let audioCodecLabel;
+      let frameSize;
+      let sampleRate;
+      let codecName;
+      if (this.audioMode === "opus") {
+        audioArgs.push("-c:a", "libopus", "-ar", "48000", "-ac", "2", "-b:a", "64k", "-f", "ogg", "-");
+        audioCodecLabel = "opus";
+        frameSize = 960;
+        sampleRate = 48e3;
+        codecName = "Opus";
+        audioArgs.length = 0;
+        audioArgs.push(
+          "-hide_banner",
+          "-loglevel",
+          "error",
+          "-rtsp_transport",
+          "tcp",
+          "-i",
+          this.rtspUrl,
+          "-vn",
+          "-c:a",
+          "pcm_mulaw",
+          "-ar",
+          "8000",
+          "-ac",
+          "1",
+          "-f",
+          "mulaw",
+          "-"
+        );
+        audioCodecLabel = "pcmu(opus-fallback)";
+        frameSize = 160;
+        sampleRate = 8e3;
+        codecName = "Pcmu";
+      } else {
+        audioArgs.push("-c:a", "pcm_mulaw", "-ar", "8000", "-ac", "1", "-f", "mulaw", "-");
+        audioCodecLabel = "pcmu";
+        frameSize = 160;
+        sampleRate = 8e3;
+        codecName = "Pcmu";
+      }
+      this.audioProc = (0, import_node_child_process.spawn)(this.ffmpegPath, audioArgs, {
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      this.audioProc.on("error", () => {
+      });
+      this.audioProc.on("close", () => {
+        this.audioProc = null;
+      });
+      if (this.audioProc.stdout) {
+        let audioBuf = Buffer.alloc(0);
+        this.audioProc.stdout.on("data", (data) => {
+          if (this.closed || !this.pushFrame) return;
+          audioBuf = audioBuf.length > 0 ? Buffer.concat([audioBuf, data]) : data;
+          while (audioBuf.length >= frameSize) {
+            const audioFrame = audioBuf.subarray(0, frameSize);
+            audioBuf = audioBuf.subarray(frameSize);
+            this.pushFrame({
+              type: "audio",
+              frame: {
+                data: Buffer.from(audioFrame),
+                codec: codecName,
+                sampleRate,
+                channels: 1,
+                timestampMicros: (Date.now() - startTime) * 1e3
+              }
+            });
+          }
+        });
+      }
+      this.logger?.info(
+        `[${this.label}] Started: ${maxBitrateKbps}kbps ` + (width > 0 ? `${width}x${height}` : "native") + ` +audio(${audioCodecLabel})`
+      );
+    } else {
+      this.logger?.info(
+        `[${this.label}] Started: ${maxBitrateKbps}kbps ` + (width > 0 ? `${width}x${height}` : "native") + " (no audio)"
+      );
+    }
+  }
+  async killFfmpeg() {
+    const proc = this.proc;
+    if (proc) {
+      this.proc = null;
+      try {
+        proc.kill("SIGTERM");
+      } catch {
+      }
+      await new Promise((resolve) => {
+        const timer = setTimeout(() => {
+          try {
+            proc.kill("SIGKILL");
+          } catch {
+          }
+          resolve();
+        }, 3e3);
+        proc.on("close", () => {
+          clearTimeout(timer);
+          resolve();
+        });
+      });
+    }
+    const audioProc = this.audioProc;
+    if (audioProc) {
+      this.audioProc = null;
+      try {
+        audioProc.kill("SIGTERM");
+      } catch {
+      }
+      await new Promise((resolve) => {
+        const timer = setTimeout(() => {
+          try {
+            audioProc.kill("SIGKILL");
+          } catch {
+          }
+          resolve();
+        }, 1e3);
+        audioProc.on("close", () => {
+          clearTimeout(timer);
+          resolve();
+        });
+      });
+    }
+  }
+};
+
+// src/adaptive-controller.ts
+var EWMA = class {
+  value = null;
+  alpha;
+  constructor(alpha = 0.3) {
+    this.alpha = alpha;
+  }
+  update(sample) {
+    if (this.value === null) {
+      this.value = sample;
+    } else {
+      this.value = this.alpha * sample + (1 - this.alpha) * this.value;
+    }
+    return this.value;
+  }
+  get() {
+    return this.value ?? 0;
+  }
+  reset() {
+    this.value = null;
+  }
+};
+var AdaptiveController = class {
+  profiles;
+  degradeThreshold;
+  recoverThreshold;
+  degradeCount;
+  recoverCount;
+  onQualityChange;
+  logger;
+  currentIndex;
+  consecutiveBad = 0;
+  consecutiveGood = 0;
+  switching = false;
+  /** Smoothed stats per session (aggregated for decisions). */
+  sessionStats = /* @__PURE__ */ new Map();
+  /** Manual override tier (null = auto). */
+  forcedTier = null;
+  constructor(options) {
+    if (options.profiles.length === 0) {
+      throw new Error("At least one quality profile is required");
+    }
+    this.profiles = options.profiles;
+    this.degradeThreshold = options.degradeThreshold ?? 0.02;
+    this.recoverThreshold = options.recoverThreshold ?? 5e-3;
+    this.degradeCount = options.degradeCount ?? 2;
+    this.recoverCount = options.recoverCount ?? 3;
+    this.onQualityChange = options.onQualityChange;
+    this.logger = options.logger;
+    this.currentIndex = 0;
+  }
+  /** Get the current quality profile. */
+  get currentProfile() {
+    return this.profiles[this.currentIndex];
+  }
+  /** Get the current quality tier. */
+  get currentTier() {
+    return this.currentProfile.tier;
+  }
+  /** Get aggregated stats summary. */
+  getAggregatedStats() {
+    if (this.sessionStats.size === 0) {
+      return { packetLoss: 0, jitterMs: 0, rttMs: 0 };
+    }
+    let totalLoss = 0;
+    let totalJitter = 0;
+    let totalRtt = 0;
+    let count = 0;
+    for (const stats of this.sessionStats.values()) {
+      if (Date.now() - stats.lastUpdate > 3e4) continue;
+      totalLoss += stats.loss.get();
+      totalJitter += stats.jitter.get();
+      totalRtt += stats.rtt.get();
+      count++;
+    }
+    if (count === 0) return { packetLoss: 0, jitterMs: 0, rttMs: 0 };
+    return {
+      packetLoss: totalLoss / count,
+      jitterMs: totalJitter / count,
+      rttMs: totalRtt / count
+    };
+  }
+  /**
+   * Report stats from a session (RTCP or client-reported).
+   * Call this periodically (e.g. every 3–5 seconds).
+   */
+  reportStats(sessionId, stats) {
+    let entry = this.sessionStats.get(sessionId);
+    if (!entry) {
+      entry = {
+        loss: new EWMA(0.3),
+        jitter: new EWMA(0.3),
+        rtt: new EWMA(0.3),
+        lastUpdate: 0
+      };
+      this.sessionStats.set(sessionId, entry);
+    }
+    entry.loss.update(stats.packetLoss);
+    entry.jitter.update(stats.jitterMs);
+    entry.rtt.update(stats.rttMs);
+    entry.lastUpdate = stats.timestamp;
+    this.evaluate();
+  }
+  /** Remove a session's stats (call on session close). */
+  removeSession(sessionId) {
+    this.sessionStats.delete(sessionId);
+  }
+  /** Force a specific quality tier (null = auto). */
+  forceQuality(tier) {
+    this.forcedTier = tier;
+    if (tier === null) {
+      this.consecutiveBad = 0;
+      this.consecutiveGood = 0;
+      return;
+    }
+    const targetIdx = this.profiles.findIndex((p) => p.tier === tier);
+    if (targetIdx >= 0 && targetIdx !== this.currentIndex) {
+      void this.switchTo(targetIdx);
+    }
+  }
+  /** Check if auto-adaptation is active (not forced). */
+  get isAuto() {
+    return this.forcedTier === null;
+  }
+  // -----------------------------------------------------------------------
+  // Private
+  // -----------------------------------------------------------------------
+  evaluate() {
+    if (this.forcedTier !== null || this.switching) return;
+    const { packetLoss } = this.getAggregatedStats();
+    if (packetLoss > this.degradeThreshold) {
+      this.consecutiveGood = 0;
+      this.consecutiveBad++;
+      if (this.consecutiveBad >= this.degradeCount) {
+        this.consecutiveBad = 0;
+        this.degrade();
+      }
+    } else if (packetLoss < this.recoverThreshold) {
+      this.consecutiveBad = 0;
+      this.consecutiveGood++;
+      if (this.consecutiveGood >= this.recoverCount) {
+        this.consecutiveGood = 0;
+        this.recover();
+      }
+    } else {
+      this.consecutiveBad = 0;
+      this.consecutiveGood = 0;
+    }
+  }
+  degrade() {
+    if (this.currentIndex >= this.profiles.length - 1) {
+      this.logger?.debug("[adaptive] Already at lowest quality, cannot degrade further");
+      return;
+    }
+    void this.switchTo(this.currentIndex + 1);
+  }
+  recover() {
+    if (this.currentIndex <= 0) {
+      this.logger?.debug("[adaptive] Already at highest quality, cannot recover further");
+      return;
+    }
+    void this.switchTo(this.currentIndex - 1);
+  }
+  async switchTo(newIndex) {
+    if (this.switching) return;
+    if (newIndex === this.currentIndex) return;
+    if (newIndex < 0 || newIndex >= this.profiles.length) return;
+    this.switching = true;
+    const from = this.profiles[this.currentIndex];
+    const to = this.profiles[newIndex];
+    this.logger?.info(
+      `[adaptive] Quality change: ${from.tier} \u2192 ${to.tier} (${from.encoding.maxBitrateKbps}kbps \u2192 ${to.encoding.maxBitrateKbps}kbps)`
+    );
+    try {
+      await this.onQualityChange(from, to);
+      this.currentIndex = newIndex;
+    } catch (err) {
+      this.logger?.error("[adaptive] Quality change failed:", err);
+    } finally {
+      this.switching = false;
+    }
+  }
+};
+
+// src/h265-utils.ts
+function tryConvertWithLengthReader2(data, readLen) {
+  const result = [];
+  let offset = 0;
+  let nalCount = 0;
+  while (offset < data.length) {
+    if (offset + 4 > data.length) return null;
+    const nalLength = readLen(data, offset);
+    offset += 4;
+    if (nalLength <= 0) return null;
+    if (nalLength > data.length - offset) return null;
+    result.push(NAL_START_CODE_4B);
+    result.push(data.subarray(offset, offset + nalLength));
+    offset += nalLength;
+    nalCount++;
+  }
+  if (nalCount === 0) return null;
+  return Buffer.concat(result);
+}
+function tryConvertWithLengthReader162(data, readLen) {
+  const result = [];
+  let offset = 0;
+  let nalCount = 0;
+  while (offset < data.length) {
+    if (offset + 2 > data.length) return null;
+    const nalLength = readLen(data, offset);
+    offset += 2;
+    if (nalLength <= 0) return null;
+    if (nalLength > data.length - offset) return null;
+    result.push(NAL_START_CODE_4B);
+    result.push(data.subarray(offset, offset + nalLength));
+    offset += nalLength;
+    nalCount++;
+  }
+  if (nalCount === 0) return null;
+  return Buffer.concat(result);
+}
+function tryConvertWithLengthReader242(data, endian) {
+  const result = [];
+  let offset = 0;
+  let nalCount = 0;
+  const readLen24 = (buf, at) => {
+    if (at + 3 > buf.length) return 0;
+    const b0 = buf[at];
+    const b1 = buf[at + 1];
+    const b2 = buf[at + 2];
+    return endian === "be" ? (b0 << 16 | b1 << 8 | b2) >>> 0 : (b2 << 16 | b1 << 8 | b0) >>> 0;
+  };
+  while (offset < data.length) {
+    if (offset + 3 > data.length) return null;
+    const nalLength = readLen24(data, offset);
+    offset += 3;
+    if (nalLength <= 0) return null;
+    if (nalLength > data.length - offset) return null;
+    result.push(NAL_START_CODE_4B);
+    result.push(data.subarray(offset, offset + nalLength));
+    offset += nalLength;
+    nalCount++;
+  }
+  if (nalCount === 0) return null;
+  return Buffer.concat(result);
+}
+function looksLikeSingleH265Nal(nalPayload) {
+  if (nalPayload.length < 2) return false;
+  const b0 = nalPayload[0];
+  if (b0 === void 0) return false;
+  if ((b0 & 128) !== 0) return false;
+  const nalType = b0 >> 1 & 63;
+  return nalType <= 40;
+}
+function convertH265ToAnnexB(data) {
+  if (hasStartCodes(data)) return data;
+  const sc4 = Buffer.from([0, 0, 0, 1]);
+  const sc3 = Buffer.from([0, 0, 1]);
+  const maxScan = Math.min(64, data.length);
+  const idx4 = data.subarray(0, maxScan).indexOf(sc4);
+  if (idx4 > 0) return data.subarray(idx4);
+  const idx3 = data.subarray(0, maxScan).indexOf(sc3);
+  if (idx3 > 0) return data.subarray(idx3);
+  const be = tryConvertWithLengthReader2(data, (b, o) => b.readUInt32BE(o));
+  if (be) return be;
+  const le = tryConvertWithLengthReader2(data, (b, o) => b.readUInt32LE(o));
+  if (le) return le;
+  const be24 = tryConvertWithLengthReader242(data, "be");
+  if (be24) return be24;
+  const le24 = tryConvertWithLengthReader242(data, "le");
+  if (le24) return le24;
+  const be16 = tryConvertWithLengthReader162(data, (b, o) => b.readUInt16BE(o));
+  if (be16) return be16;
+  const le16 = tryConvertWithLengthReader162(data, (b, o) => b.readUInt16LE(o));
+  if (le16) return le16;
+  if (looksLikeSingleH265Nal(data)) {
+    return Buffer.concat([NAL_START_CODE_4B, data]);
+  }
+  return data;
+}
+function getH265NalType(nalPayload) {
+  if (nalPayload.length < 1) return null;
+  const b0 = nalPayload[0];
+  if (b0 === void 0) return null;
+  if ((b0 & 128) !== 0) return null;
+  return b0 >> 1 & 63;
+}
+function isH265Irap(nalType) {
+  return nalType >= 16 && nalType <= 23;
+}
+function isH265KeyframeAnnexB(annexB) {
+  const nals = splitAnnexBToNals(annexB);
+  let hasVps = false;
+  let hasSps = false;
+  let hasPps = false;
+  let hasIrap = false;
+  for (const nal of nals) {
+    const nalType = getH265NalType(nal);
+    if (nalType === null) continue;
+    if (nalType === 32) hasVps = true;
+    if (nalType === 33) hasSps = true;
+    if (nalType === 34) hasPps = true;
+    if (isH265Irap(nalType)) hasIrap = true;
+  }
+  return hasIrap && hasVps && hasSps && hasPps;
+}
+function isH265IrapAccessUnit(annexB) {
+  const nals = splitAnnexBToNals(annexB);
+  for (const nal of nals) {
+    if (nal.length < 2) continue;
+    const b0 = nal[0];
+    if (b0 === void 0) continue;
+    if ((b0 & 128) !== 0) continue;
+    const nalType = b0 >> 1 & 63;
+    if (isH265Irap(nalType)) return true;
+  }
+  return false;
+}
+function extractH265ParamSets(annexB) {
+  const nals = splitAnnexBToNals(annexB);
+  let vps;
+  let sps;
+  let pps;
+  for (const nal of nals) {
+    if (nal.length < 2) continue;
+    const nalType = nal[0] >> 1 & 63;
+    if (nalType === 32) vps = nal;
+    else if (nalType === 33) sps = nal;
+    else if (nalType === 34) pps = nal;
+  }
+  const out = {};
+  if (vps) out.vps = vps;
+  if (sps) out.sps = sps;
+  if (pps) out.pps = pps;
+  return out;
+}
+var H265RtpDepacketizer = class _H265RtpDepacketizer {
+  fuParts = null;
+  static parseRtpPayload(packet) {
+    if (!packet || packet.length < 12) return null;
+    const version = packet[0] >> 6 & 3;
+    if (version !== 2) return null;
+    const padding = (packet[0] & 32) !== 0;
+    const extension = (packet[0] & 16) !== 0;
+    const csrcCount = packet[0] & 15;
+    let offset = 12 + csrcCount * 4;
+    if (offset > packet.length) return null;
+    if (extension) {
+      if (offset + 4 > packet.length) return null;
+      const extLenWords = packet.readUInt16BE(offset + 2);
+      offset += 4 + extLenWords * 4;
+      if (offset > packet.length) return null;
+    }
+    let end = packet.length;
+    if (padding) {
+      const padLen = packet[packet.length - 1];
+      if (padLen <= 0 || padLen > packet.length) return null;
+      end = packet.length - padLen;
+      if (end < offset) return null;
+    }
+    if (end <= offset) return null;
+    return packet.subarray(offset, end);
+  }
+  reset() {
+    this.fuParts = null;
+  }
+  push(payload) {
+    if (!payload || payload.length < 2) return [];
+    const rtpPayload = _H265RtpDepacketizer.parseRtpPayload(payload);
+    if (rtpPayload) payload = rtpPayload;
+    const h0 = payload[0];
+    const h1 = payload[1];
+    if ((h0 & 128) !== 0) return [];
+    const nalType = h0 >> 1 & 63;
+    if (nalType === 48) {
+      let off = 2;
+      const out = [];
+      while (off + 2 <= payload.length) {
+        const size = payload.readUInt16BE(off);
+        off += 2;
+        if (size <= 0 || off + size > payload.length) return [];
+        const nal = payload.subarray(off, off + size);
+        off += size;
+        if (nal.length) out.push(NAL_START_CODE_4B, nal);
+      }
+      return out.length ? [Buffer.concat(out)] : [];
+    }
+    if (nalType === 49) {
+      if (payload.length < 3) return [];
+      const fuHeader = payload[2];
+      const start = (fuHeader & 128) !== 0;
+      const end = (fuHeader & 64) !== 0;
+      const origType = fuHeader & 63;
+      const orig0 = h0 & 129 | (origType & 63) << 1;
+      const orig1 = h1;
+      const frag = payload.subarray(3);
+      if (start) {
+        this.fuParts = [NAL_START_CODE_4B, Buffer.from([orig0, orig1]), frag];
+      } else {
+        if (!this.fuParts) return [];
+        this.fuParts.push(frag);
+      }
+      if (end) {
+        if (!this.fuParts) return [];
+        const out = Buffer.concat(this.fuParts);
+        this.fuParts = null;
+        return [out];
+      }
+      return [];
+    }
+    return [Buffer.concat([NAL_START_CODE_4B, payload])];
+  }
+};
+
+// src/session.ts
+var _werift;
+async function loadWerift() {
+  if (_werift) return _werift;
+  try {
+    const moduleName = "werift";
+    _werift = await Function("m", "return import(m)")(moduleName);
+    return _werift;
+  } catch {
+    throw new Error(
+      "The 'werift' package is required for WebRTC support but is not installed. Install it with: npm install werift"
+    );
+  }
+}
+var AdaptiveSession = class _AdaptiveSession {
+  sessionId;
+  source;
+  logger;
+  intercom;
+  iceConfig;
+  onStats;
+  debug;
+  createdAt;
+  state = "new";
+  pc = null;
+  videoTrack = null;
+  audioTrack = null;
+  /** Transceiver senders for direct sendRtp (more reliable than track.writeRtp) */
+  videoSender = null;
+  audioSender = null;
+  feedAbort = null;
+  closed = false;
+  statsTimer = null;
+  /** RTP sequence number counter (must increment per packet). */
+  videoSeqNum = 0;
+  audioSeqNum = 0;
+  /** Previous RTCP stats for delta calculation. */
+  prevPacketsReceived = 0;
+  prevPacketsLost = 0;
+  constructor(options) {
+    this.sessionId = options.sessionId;
+    this.source = options.source;
+    this.logger = options.logger;
+    this.intercom = options.intercom;
+    this.iceConfig = options.iceConfig;
+    this.onStats = options.onStats;
+    this.debug = options.debug ?? false;
+    this.createdAt = Date.now();
+  }
+  /** Build PeerConnection options including H.264 codec config. */
+  async buildPcOptions() {
+    const werift = await loadWerift();
+    const iceServers = [];
+    if (this.iceConfig?.stunServers) {
+      for (const url of this.iceConfig.stunServers) iceServers.push({ urls: url });
+    }
+    if (this.iceConfig?.turnServers) {
+      for (const turn of this.iceConfig.turnServers) {
+        iceServers.push({ urls: turn.urls, username: turn.username, credential: turn.credential });
+      }
+    }
+    const pcOptions = {
+      // H.264 + Opus codecs with RTCP feedback (matching Scrypted's proven config)
+      codecs: {
+        video: [
+          new werift.RTCRtpCodecParameters({
+            mimeType: "video/H264",
+            clockRate: 9e4,
+            payloadType: 96,
+            parameters: "level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f",
+            rtcpFeedback: [
+              { type: "transport-cc" },
+              { type: "ccm", parameter: "fir" },
+              { type: "nack" },
+              { type: "nack", parameter: "pli" },
+              { type: "goog-remb" }
+            ]
+          })
+        ],
+        audio: [
+          new werift.RTCRtpCodecParameters({
+            mimeType: "audio/PCMU",
+            clockRate: 8e3,
+            payloadType: 0,
+            channels: 1,
+            parameters: ""
+          })
+        ]
+      }
+    };
+    if (iceServers.length > 0) pcOptions.iceServers = iceServers;
+    if (this.iceConfig?.portRange) pcOptions.icePortRange = this.iceConfig.portRange;
+    if (this.iceConfig?.additionalHostAddresses) {
+      pcOptions.iceAdditionalHostAddresses = this.iceConfig.additionalHostAddresses;
+    }
+    return { werift, pcOptions };
+  }
+  /** Create offer SDP (server → client). */
+  async createOffer() {
+    const { werift, pcOptions } = await this.buildPcOptions();
+    this.pc = new werift.RTCPeerConnection(pcOptions);
+    this.pc.iceConnectionStateChange.subscribe((state) => {
+      this.logger.debug(`[session:${this.sessionId}] ICE: ${state}`);
+      if (state === "connected") {
+        this.state = "connected";
+        this.startStatsCollection();
+      } else if (state === "disconnected" || state === "failed" || state === "closed") {
+        this.state = state === "disconnected" ? "disconnected" : "closed";
+        void this.close();
+      }
+    });
+    this.videoTrack = new werift.MediaStreamTrack({ kind: "video" });
+    const videoTransceiver = this.pc.addTransceiver(this.videoTrack, { direction: "sendonly" });
+    this.videoSender = videoTransceiver.sender;
+    this.audioTrack = new werift.MediaStreamTrack({ kind: "audio" });
+    const audioDir = this.intercom ? "sendrecv" : "sendonly";
+    const audioTransceiver = this.pc.addTransceiver(this.audioTrack, { direction: audioDir });
+    this.audioSender = audioTransceiver.sender;
+    if (this.intercom) {
+      const cb = this.intercom.onAudioReceived;
+      audioTransceiver.onTrack.subscribe((track) => {
+        track.onReceiveRtp.subscribe((pkt) => {
+          try {
+            const payload = pkt.payload;
+            if (payload?.length > 0) void cb(payload, "Opus");
+          } catch (err) {
+            this.logger.error(`[session:${this.sessionId}] Intercom error:`, err);
+          }
+        });
+      });
+    }
+    const offer = await this.pc.createOffer();
+    await this.pc.setLocalDescription(offer);
+    await new Promise((resolve) => {
+      if (this.pc.iceGatheringState === "complete") {
+        resolve();
+        return;
+      }
+      this.pc.iceGatheringStateChange.subscribe((state) => {
+        if (state === "complete") resolve();
+      });
+      setTimeout(resolve, 5e3);
+    });
+    let finalSdp = this.pc.localDescription?.sdp ?? offer.sdp;
+    finalSdp = finalSdp.replace(/a=setup:active\r?\n/g, "a=setup:actpass\r\n");
+    this.state = "connecting";
+    this.logger.info(`[session:${this.sessionId}] Offer created`);
+    return { sdp: finalSdp, type: "offer" };
+  }
+  /** Handle WHEP answer: client sends SDP answer, we set remote description and start feeding. */
+  async handleAnswer(answer) {
+    if (!this.pc) throw new Error("Call createOffer() first");
+    const werift = await loadWerift();
+    const desc = new werift.RTCSessionDescription(answer.sdp, answer.type);
+    await this.pc.setRemoteDescription(desc);
+    this.logger.info(`[session:${this.sessionId}] Answer set, feeding started`);
+    this.startFeedingFrames();
+  }
+  /**
+   * Handle WHEP offer: client sends SDP offer, we create answer.
+   *
+   * Uses the server-creates-offer pattern internally: we create our own offer
+   * with sendonly tracks, then use the client's offer codecs to build a
+   * compatible answer. This avoids werift transceiver direction issues.
+   */
+  async handleOffer(clientOffer) {
+    const { werift, pcOptions } = await this.buildPcOptions();
+    this.pc = new werift.RTCPeerConnection(pcOptions);
+    this.pc.iceConnectionStateChange.subscribe((state) => {
+      this.logger.debug(`[session:${this.sessionId}] ICE: ${state}`);
+      if (state === "connected") {
+        this.state = "connected";
+        this.startStatsCollection();
+      } else if (state === "disconnected" || state === "failed" || state === "closed") {
+        this.state = state === "disconnected" ? "disconnected" : "closed";
+        void this.close();
+      }
+    });
+    const remoteDesc = new werift.RTCSessionDescription(clientOffer.sdp, clientOffer.type);
+    await this.pc.setRemoteDescription(remoteDesc);
+    const transceivers = this.pc.getTransceivers();
+    for (const t of transceivers) {
+      const kind = t.receiver?.track?.kind ?? t.kind;
+      if (kind === "video" && !this.videoTrack) {
+        this.videoTrack = new werift.MediaStreamTrack({ kind: "video" });
+        await t.sender.replaceTrack(this.videoTrack);
+      } else if (kind === "audio" && !this.audioTrack) {
+        this.audioTrack = new werift.MediaStreamTrack({ kind: "audio" });
+        await t.sender.replaceTrack(this.audioTrack);
+      }
+    }
+    if (!this.videoTrack) {
+      this.logger.warn(`[session:${this.sessionId}] No video transceiver found in offer, adding one`);
+      this.videoTrack = new werift.MediaStreamTrack({ kind: "video" });
+      this.pc.addTransceiver(this.videoTrack, { direction: "sendonly" });
+    }
+    if (!this.audioTrack) {
+      this.logger.warn(`[session:${this.sessionId}] No audio transceiver found in offer, adding one`);
+      this.audioTrack = new werift.MediaStreamTrack({ kind: "audio" });
+      this.pc.addTransceiver(this.audioTrack, { direction: "sendonly" });
+    }
+    const answer = await this.pc.createAnswer();
+    await this.pc.setLocalDescription(answer);
+    this.state = "connecting";
+    this.logger.info(`[session:${this.sessionId}] WHEP answer created`);
+    this.startFeedingFrames();
+    return { sdp: answer.sdp, type: "answer" };
+  }
+  /** Add ICE candidate. */
+  async addIceCandidate(candidate) {
+    if (!this.pc) throw new Error("Call createOffer() first");
+    const werift = await loadWerift();
+    await this.pc.addIceCandidate(new werift.RTCIceCandidate(candidate));
+  }
+  /**
+   * Detach the frame source (for connection pooling).
+   * The session stays alive (ICE/DTLS connected) but stops feeding frames.
+   * Call replaceSource() later to reattach a camera.
+   */
+  detachSource() {
+    if (this.feedAbort) {
+      this.feedAbort.abort();
+      this.feedAbort = null;
+    }
+    this.logger.debug(`[session:${this.sessionId}] Source detached (idle)`);
+  }
+  /** Whether the session has an active feed (vs idle/pooled). */
+  get isFeeding() {
+    return this.feedAbort !== null && !this.feedAbort.signal.aborted;
+  }
+  /**
+   * Replace the frame source (for seamless source switching).
+   * The new source will take effect at the next keyframe.
+   */
+  replaceSource(newSource) {
+    this.source = newSource;
+    if (this.feedAbort) {
+      this.feedAbort.abort();
+      this.feedAbort = null;
+    }
+    this.startFeedingFrames();
+  }
+  getInfo() {
+    return { sessionId: this.sessionId, state: this.state, createdAt: this.createdAt };
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.state = "closed";
+    this.logger.info(`[session:${this.sessionId}] Closing`);
+    if (this.statsTimer) {
+      clearInterval(this.statsTimer);
+      this.statsTimer = null;
+    }
+    if (this.feedAbort) {
+      this.feedAbort.abort();
+      this.feedAbort = null;
+    }
+    try {
+      await this.source.return(void 0);
+    } catch {
+    }
+    if (this.pc) {
+      try {
+        await this.pc.close();
+      } catch {
+      }
+      this.pc = null;
+    }
+    this.videoTrack = null;
+    this.audioTrack = null;
+  }
+  // -----------------------------------------------------------------------
+  // Frame feeding
+  // -----------------------------------------------------------------------
+  startFeedingFrames() {
+    this.feedAbort = new AbortController();
+    const { signal } = this.feedAbort;
+    void (async () => {
+      let gotKeyframe = false;
+      let videoTimestampBase = null;
+      let audioTimestampBase = null;
+      let frameCount = 0;
+      try {
+        for await (const mediaFrame of this.source) {
+          if (signal.aborted || this.closed) break;
+          frameCount++;
+          if (this.debug && (frameCount <= 5 || frameCount % 100 === 0)) {
+            this.logger.debug(
+              `[session:${this.sessionId}] Frame #${frameCount}: ${mediaFrame.type} size=${mediaFrame.frame.data.length} ` + (mediaFrame.type === "video" ? `key=${mediaFrame.frame.isKeyframe}` : "")
+            );
+          }
+          if (mediaFrame.type === "video") {
+            const frame = mediaFrame.frame;
+            const annexB = frame.codec === "H264" ? convertH264ToAnnexB(frame.data) : convertH265ToAnnexB(frame.data);
+            if (!gotKeyframe) {
+              const isKey = frame.codec === "H264" ? isH264IdrAccessUnit(annexB) : isH265IrapAccessUnit(annexB);
+              if (!isKey) continue;
+              gotKeyframe = true;
+              if (this.debug) {
+                const iceState = this.pc?.iceConnectionState ?? "unknown";
+                const connState = this.pc?.connectionState ?? "unknown";
+                this.logger.info(
+                  `[session:${this.sessionId}] First keyframe at frame #${frameCount}, size=${annexB.length}, ICE=${iceState}, conn=${connState}`
+                );
+              }
+            }
+            if (videoTimestampBase === null) videoTimestampBase = frame.timestampMicros;
+            const rtpTs = Math.floor(
+              (frame.timestampMicros - videoTimestampBase) * 9e4 / 1e6
+            ) >>> 0;
+            const nals = splitAnnexBToNals(annexB).filter((n) => {
+              const t = n[0] & 31;
+              return t !== 9 && t !== 6;
+            });
+            if (nals.length > 0 && this.videoTrack) {
+              this.writeVideoNals(nals, rtpTs, frame.codec);
+              if (this.debug && frameCount % 250 === 0) {
+                this.logger.info(
+                  `[session:${this.sessionId}] ${frameCount} frames, ${this.rtpPacketsSent} RTP pkts, ICE=${this.pc?.iceConnectionState}, conn=${this.pc?.connectionState}`
+                );
+              }
+            }
+          } else if (mediaFrame.type === "audio") {
+            const frame = mediaFrame.frame;
+            if (!this.audioSender) continue;
+            if (audioTimestampBase === null) audioTimestampBase = 0;
+            audioTimestampBase = audioTimestampBase + frame.data.length >>> 0;
+            const rtpTs = audioTimestampBase;
+            this.writeAudio(frame.data, rtpTs, frame.codec);
+          }
+        }
+      } catch (err) {
+        if (!signal.aborted && !this.closed) {
+          this.logger.error(`[session:${this.sessionId}] Feed error:`, err);
+        }
+      } finally {
+        if (!this.closed) {
+          this.logger.info(`[session:${this.sessionId}] Feed ended`);
+          void this.close();
+        }
+      }
+    })();
+  }
+  /** Build a serialized RTP packet for sender.sendRtp(). */
+  buildRtpBuffer(weriftModule, payload, rtpTs, payloadType, marker, isVideo) {
+    const header = new weriftModule.RtpHeader();
+    header.payloadType = payloadType;
+    header.timestamp = rtpTs;
+    header.marker = marker;
+    header.sequenceNumber = isVideo ? this.videoSeqNum = this.videoSeqNum + 1 & 65535 : this.audioSeqNum = this.audioSeqNum + 1 & 65535;
+    const pkt = new weriftModule.RtpPacket(header, payload);
+    return pkt.serialize();
+  }
+  /** Max RTP payload size (MTU 1200 to stay under typical network MTU). */
+  static MAX_RTP_PAYLOAD = 1200;
+  rtpPacketsSent = 0;
+  writeVideoNals(nals, rtpTs, codec) {
+    if (!this.videoSender || !_werift) return;
+    const pt = codec === "H264" ? 96 : 97;
+    const sendPkt = (payload, marker) => {
+      try {
+        const buf = this.buildRtpBuffer(_werift, payload, rtpTs, pt, marker, true);
+        this.videoSender.sendRtp(buf);
+        this.rtpPacketsSent++;
+      } catch (err) {
+        if (this.rtpPacketsSent <= 10) {
+          this.logger.error(`[session:${this.sessionId}] sendRtp error #${this.rtpPacketsSent}:`, err);
+        }
+      }
+    };
+    for (let i = 0; i < nals.length; i++) {
+      const nal = nals[i];
+      const isLastNal = i === nals.length - 1;
+      if (nal.length <= _AdaptiveSession.MAX_RTP_PAYLOAD) {
+        sendPkt(nal, isLastNal);
+      } else {
+        const nalHeader = nal[0];
+        const fnri = nalHeader & 224;
+        const nalType = nalHeader & 31;
+        const fuIndicator = fnri | 28;
+        const nalBody = nal.subarray(1);
+        let offset = 0;
+        let isFirst = true;
+        while (offset < nalBody.length) {
+          const end = Math.min(offset + _AdaptiveSession.MAX_RTP_PAYLOAD - 2, nalBody.length);
+          const isLast = end >= nalBody.length;
+          let fuHeader = nalType;
+          if (isFirst) fuHeader |= 128;
+          if (isLast) fuHeader |= 64;
+          const fragment = Buffer.alloc(2 + (end - offset));
+          fragment[0] = fuIndicator;
+          fragment[1] = fuHeader;
+          nalBody.copy(fragment, 2, offset, end);
+          sendPkt(fragment, isLastNal && isLast);
+          offset = end;
+          isFirst = false;
+        }
+      }
+    }
+  }
+  writeAudio(data, rtpTs, codec) {
+    if (!this.audioSender || !_werift) return;
+    const pt = codec === "Pcmu" || codec === "Pcma" ? 0 : 111;
+    try {
+      const buf = this.buildRtpBuffer(_werift, data, rtpTs, pt, true, false);
+      this.audioSender.sendRtp(buf);
+    } catch (err) {
+      this.logger.debug(`[session:${this.sessionId}] Audio write error:`, err);
+    }
+  }
+  // -----------------------------------------------------------------------
+  // RTCP stats collection
+  // -----------------------------------------------------------------------
+  startStatsCollection() {
+    if (this.statsTimer || !this.onStats) return;
+    this.statsTimer = setInterval(() => {
+      if (!this.pc || this.closed) return;
+      this.collectStats();
+    }, 3e3);
+  }
+  collectStats() {
+    if (!this.pc || !this.onStats) return;
+    try {
+      const senders = this.pc.getSenders?.() ?? [];
+      for (const sender of senders) {
+        const track = sender.track;
+        if (!track || track.kind !== "video") continue;
+        const report = sender.lastReceiverReport ?? sender.rtcpReport;
+        if (!report) continue;
+        const fractionLost = report.fractionLost ?? 0;
+        const packetsLost = report.packetsLost ?? report.cumulativeLost ?? 0;
+        const jitter = report.jitter ?? 0;
+        const rtt = report.roundTripTime ?? report.rtt ?? 0;
+        const packetLoss = fractionLost / 256;
+        this.onStats({
+          sessionId: this.sessionId,
+          packetLoss,
+          jitterMs: jitter,
+          rttMs: rtt * 1e3,
+          // seconds → ms
+          packetsReceived: 0,
+          // Not available from sender side
+          packetsLost,
+          timestamp: Date.now()
+        });
+        return;
+      }
+    } catch {
+    }
+  }
+};
+
+// src/server.ts
+function createDefaultProfiles() {
+  return [
+    {
+      tier: "high",
+      encoding: { maxBitrateKbps: 6e3, width: 0, height: 0 },
+      // native resolution
+      sourceProfile: "main"
+    },
+    {
+      tier: "medium",
+      encoding: { maxBitrateKbps: 2500, width: 1280, height: 720 },
+      sourceProfile: "main"
+    },
+    {
+      tier: "low",
+      encoding: { maxBitrateKbps: 1e3, width: 640, height: 360 },
+      sourceProfile: "sub"
+    }
+  ];
+}
+var AdaptiveStreamServer = class extends import_node_events.EventEmitter {
+  ffmpegPath;
+  stunServers;
+  turnServers;
+  icePortRange;
+  iceAdditionalHostAddresses;
+  logger;
+  cameras = /* @__PURE__ */ new Map();
+  sessionCamera = /* @__PURE__ */ new Map();
+  stopped = false;
+  constructor(options = {}) {
+    super();
+    this.ffmpegPath = options.ffmpegPath ?? "ffmpeg";
+    this.stunServers = options.stunServers;
+    this.turnServers = options.turnServers;
+    this.icePortRange = options.icePortRange;
+    this.iceAdditionalHostAddresses = options.iceAdditionalHostAddresses;
+    this.logger = options.logger ? asLogger(options.logger) : createNullLogger();
+    this.logger.info("[adaptive-server] Initialized");
+  }
+  // -----------------------------------------------------------------------
+  // Camera management
+  // -----------------------------------------------------------------------
+  /** Register a camera with adaptive streaming. */
+  addCamera(name, config) {
+    if (this.cameras.has(name)) {
+      this.logger.warn(`[adaptive-server] Camera "${name}" already registered`);
+      return;
+    }
+    const profiles = config.profiles;
+    const initialParams = profiles[0].encoding;
+    const mainFfmpegSource = new AdaptiveFfmpegSource({
+      rtspUrl: config.rtspUrl,
+      initialParams,
+      audioMode: config.audioMode ?? "copy",
+      ffmpegPath: this.ffmpegPath,
+      logger: this.logger,
+      label: `ffmpeg:${name}:main`
+    });
+    const mainFanout = new StreamFanout({
+      maxQueueItems: 30,
+      createSource: () => mainFfmpegSource.source,
+      onError: (err) => {
+        this.logger.error(`[adaptive-server] Main fanout error (${name}):`, err);
+      }
+    });
+    const controller = new AdaptiveController({
+      profiles,
+      onQualityChange: async (from, to) => {
+        await this.handleQualityChange(name, from, to);
+      },
+      logger: this.logger
+    });
+    this.cameras.set(name, {
+      config,
+      mainFfmpegSource,
+      mainFanout,
+      subFfmpegSource: null,
+      subFanout: null,
+      activeSourceProfile: "main",
+      controller,
+      sessions: /* @__PURE__ */ new Map(),
+      autoStopTimer: null,
+      switching: false
+    });
+    this.logger.info(`[adaptive-server] Camera "${name}" added`);
+  }
+  /** Remove a camera and close all its sessions. */
+  async removeCamera(name) {
+    const cam = this.cameras.get(name);
+    if (!cam) return;
+    const closePs = [];
+    for (const [sid, session] of cam.sessions) {
+      this.sessionCamera.delete(sid);
+      closePs.push(session.close().catch(() => {
+      }));
+    }
+    await Promise.all(closePs);
+    cam.sessions.clear();
+    await cam.mainFanout.stop();
+    await cam.mainFfmpegSource.stop();
+    if (cam.subFanout) await cam.subFanout.stop();
+    if (cam.subFfmpegSource) await cam.subFfmpegSource.stop();
+    if (cam.autoStopTimer) {
+      clearTimeout(cam.autoStopTimer);
+      cam.autoStopTimer = null;
+    }
+    this.cameras.delete(name);
+    this.logger.info(`[adaptive-server] Camera "${name}" removed`);
+  }
+  getCameraNames() {
+    return [...this.cameras.keys()];
+  }
+  // -----------------------------------------------------------------------
+  // Signaling (2-step: server creates offer, client sends answer)
+  // -----------------------------------------------------------------------
+  /**
+   * Create an adaptive session for a camera.
+   * Returns a server-generated SDP offer that the client must answer.
+   *
+   * Flow: createSession() → server offer → client sets remote, creates answer → handleAnswer()
+   */
+  async createSession(cameraName) {
+    if (this.stopped) throw new Error("Server stopped");
+    const cam = this.cameras.get(cameraName);
+    if (!cam) throw new Error(`Camera not found: ${cameraName}`);
+    if (cam.autoStopTimer) {
+      clearTimeout(cam.autoStopTimer);
+      cam.autoStopTimer = null;
+    }
+    this.ensureCameraRunning(cameraName, cam);
+    const sessionId = import_node_crypto.default.randomUUID();
+    const activeFanout = this.getActiveFanout(cam);
+    const source = activeFanout.subscribe(sessionId);
+    const session = new AdaptiveSession({
+      sessionId,
+      source,
+      iceConfig: {
+        stunServers: this.stunServers,
+        turnServers: this.turnServers,
+        portRange: this.icePortRange,
+        additionalHostAddresses: this.iceAdditionalHostAddresses
+      },
+      onStats: (stats) => {
+        cam.controller.reportStats(sessionId, {
+          packetLoss: stats.packetLoss,
+          jitterMs: stats.jitterMs,
+          rttMs: stats.rttMs,
+          timestamp: stats.timestamp
+        });
+        this.emit("session:stats", { camera: cameraName, ...stats });
+      },
+      logger: this.logger
+    });
+    cam.sessions.set(sessionId, session);
+    this.sessionCamera.set(sessionId, cameraName);
+    try {
+      const offer = await session.createOffer();
+      this.emit("session:created", { sessionId, camera: cameraName });
+      return { sessionId, sdpOffer: offer.sdp };
+    } catch (err) {
+      cam.sessions.delete(sessionId);
+      this.sessionCamera.delete(sessionId);
+      activeFanout.unsubscribe(sessionId);
+      await session.close().catch(() => {
+      });
+      this.scheduleCameraAutoStop(cameraName, cam);
+      throw err;
+    }
+  }
+  /**
+   * Handle the client's SDP answer for an adaptive session.
+   * Call after createSession() with the client's answer.
+   */
+  async handleAnswer(sessionId, sdpAnswer) {
+    const camName = this.sessionCamera.get(sessionId);
+    if (!camName) throw new Error(`Session not found: ${sessionId}`);
+    const cam = this.cameras.get(camName);
+    if (!cam) throw new Error(`Camera not found: ${camName}`);
+    const session = cam.sessions.get(sessionId);
+    if (!session) throw new Error(`Session not found: ${sessionId}`);
+    await session.handleAnswer({ sdp: sdpAnswer, type: "answer" });
+  }
+  /**
+   * Convenience: handleWhepOffer is NOT supported — werift requires server-initiated offers.
+   * Use createSession() + handleAnswer() instead.
+   */
+  async handleWhepOffer(_cameraName, _sdpOffer) {
+    throw new Error(
+      "handleWhepOffer is not supported \u2014 werift requires server-initiated offers. Use createSession() to get a server offer, then handleAnswer() with the client's answer."
+    );
+  }
+  // -----------------------------------------------------------------------
+  // Connection pool: pre-warmed sessions without camera assignment
+  // -----------------------------------------------------------------------
+  /** Pooled sessions: sessionId → true (idle, no camera attached). */
+  pooledSessions = /* @__PURE__ */ new Set();
+  /**
+   * Create a pooled session (no camera attached yet).
+   * The SDP exchange happens, ICE connects, but no ffmpeg is started.
+   * Call attachCamera() later to start feeding frames.
+   */
+  async createPooledSession() {
+    if (this.stopped) throw new Error("Server stopped");
+    const sessionId = import_node_crypto.default.randomUUID();
+    const emptySource = (async function* () {
+      await new Promise(() => {
+      });
+    })();
+    const session = new AdaptiveSession({
+      sessionId,
+      source: emptySource,
+      iceConfig: {
+        stunServers: this.stunServers,
+        turnServers: this.turnServers,
+        portRange: this.icePortRange,
+        additionalHostAddresses: this.iceAdditionalHostAddresses
+      },
+      logger: this.logger
+    });
+    this.pooledSessions.add(sessionId);
+    const poolCamKey = "__pool__";
+    if (!this.cameras.has(poolCamKey)) {
+      const dummyFfmpeg = new AdaptiveFfmpegSource({
+        rtspUrl: "rtsp://0.0.0.0/dummy",
+        initialParams: { maxBitrateKbps: 0, width: 0, height: 0 }
+      });
+      const dummyFanout = new StreamFanout({
+        maxQueueItems: 1,
+        createSource: () => dummyFfmpeg.source
+      });
+      const dummyController = new AdaptiveController({
+        profiles: createDefaultProfiles(),
+        onQualityChange: async () => {
+        }
+      });
+      this.cameras.set(poolCamKey, {
+        config: { rtspUrl: "", profiles: createDefaultProfiles() },
+        mainFfmpegSource: dummyFfmpeg,
+        mainFanout: dummyFanout,
+        subFfmpegSource: null,
+        subFanout: null,
+        activeSourceProfile: "main",
+        controller: dummyController,
+        sessions: /* @__PURE__ */ new Map(),
+        autoStopTimer: null,
+        switching: false
+      });
+    }
+    const poolCam = this.cameras.get(poolCamKey);
+    poolCam.sessions.set(sessionId, session);
+    this.sessionCamera.set(sessionId, poolCamKey);
+    try {
+      const offer = await session.createOffer();
+      this.logger.info(`[adaptive-server] Pooled session ${sessionId.slice(0, 8)} created`);
+      return { sessionId, sdpOffer: offer.sdp };
+    } catch (err) {
+      poolCam.sessions.delete(sessionId);
+      this.sessionCamera.delete(sessionId);
+      this.pooledSessions.delete(sessionId);
+      await session.close().catch(() => {
+      });
+      throw err;
+    }
+  }
+  /**
+   * Attach a camera to a pooled session.
+   * Starts the ffmpeg transcoder and begins feeding frames.
+   */
+  async attachCamera(sessionId, cameraName) {
+    if (!this.pooledSessions.has(sessionId)) {
+      throw new Error(`Session ${sessionId} is not a pooled session`);
+    }
+    const cam = this.cameras.get(cameraName);
+    if (!cam) throw new Error(`Camera not found: ${cameraName}`);
+    this.ensureCameraRunning(cameraName, cam);
+    const poolCam = this.cameras.get("__pool__");
+    const session = poolCam?.sessions.get(sessionId);
+    if (!session) throw new Error(`Pooled session not found: ${sessionId}`);
+    poolCam.sessions.delete(sessionId);
+    cam.sessions.set(sessionId, session);
+    this.sessionCamera.set(sessionId, cameraName);
+    this.pooledSessions.delete(sessionId);
+    const activeFanout = this.getActiveFanout(cam);
+    const source = activeFanout.subscribe(sessionId);
+    session.replaceSource(source);
+    this.logger.info(`[adaptive-server] Attached camera "${cameraName}" to session ${sessionId.slice(0, 8)}`);
+  }
+  /**
+   * Detach a camera from a session (session returns to pool).
+   */
+  async detachCamera(sessionId) {
+    const camName = this.sessionCamera.get(sessionId);
+    if (!camName || camName === "__pool__") return;
+    const cam = this.cameras.get(camName);
+    if (!cam) return;
+    const session = cam.sessions.get(sessionId);
+    if (!session) return;
+    session.detachSource();
+    const activeFanout = this.getActiveFanout(cam);
+    activeFanout.unsubscribe(sessionId);
+    cam.sessions.delete(sessionId);
+    const poolCam = this.cameras.get("__pool__");
+    if (poolCam) {
+      poolCam.sessions.set(sessionId, session);
+      this.sessionCamera.set(sessionId, "__pool__");
+      this.pooledSessions.add(sessionId);
+    }
+    this.logger.info(`[adaptive-server] Detached camera "${camName}" from session ${sessionId.slice(0, 8)} (back to pool)`);
+    this.scheduleCameraAutoStop(camName, cam);
+  }
+  /** Check if a session is in the idle pool. */
+  isPooledSession(sessionId) {
+    return this.pooledSessions.has(sessionId);
+  }
+  /** Set debug flag on all sessions for a camera. */
+  setDebug(cameraName, debug) {
+    const cam = this.cameras.get(cameraName);
+    if (!cam) return 0;
+    let count = 0;
+    for (const session of cam.sessions.values()) {
+      session.debug = debug;
+      count++;
+    }
+    return count;
+  }
+  /** Get count of idle pooled sessions. */
+  getPoolSize() {
+    return this.pooledSessions.size;
+  }
+  // -----------------------------------------------------------------------
+  // Session management
+  // -----------------------------------------------------------------------
+  /** Close a specific session. */
+  async closeSession(sessionId) {
+    const camName = this.sessionCamera.get(sessionId);
+    if (!camName) return;
+    const cam = this.cameras.get(camName);
+    if (!cam) return;
+    const session = cam.sessions.get(sessionId);
+    if (!session) return;
+    cam.sessions.delete(sessionId);
+    this.sessionCamera.delete(sessionId);
+    const activeFanout = this.getActiveFanout(cam);
+    activeFanout.unsubscribe(sessionId);
+    cam.controller.removeSession(sessionId);
+    await session.close();
+    this.logger.info(`[adaptive-server] Session ${sessionId} closed (camera "${camName}", remaining: ${cam.sessions.size})`);
+    this.emit("session:closed", { sessionId, camera: camName });
+    this.scheduleCameraAutoStop(camName, cam);
+  }
+  /**
+   * Report client-side stats for a session (supplements RTCP monitoring).
+   * Call from tRPC route when the client pushes stats.
+   */
+  reportClientStats(sessionId, stats) {
+    const camName = this.sessionCamera.get(sessionId);
+    if (!camName) return null;
+    const cam = this.cameras.get(camName);
+    if (!cam) return null;
+    cam.controller.reportStats(sessionId, stats);
+    const profile = cam.controller.currentProfile;
+    return {
+      currentTier: profile.tier,
+      currentBitrateKbps: profile.encoding.maxBitrateKbps,
+      currentResolution: { width: profile.encoding.width, height: profile.encoding.height },
+      sourceProfile: cam.activeSourceProfile
+    };
+  }
+  /** Force quality for a camera (null = auto). */
+  forceQuality(cameraName, tier) {
+    const cam = this.cameras.get(cameraName);
+    if (!cam) return false;
+    cam.controller.forceQuality(tier);
+    return true;
+  }
+  /** Get current quality info for a camera. */
+  getCameraQuality(cameraName) {
+    const cam = this.cameras.get(cameraName);
+    if (!cam) return null;
+    const profile = cam.controller.currentProfile;
+    return {
+      tier: profile.tier,
+      encoding: profile.encoding,
+      isAuto: cam.controller.isAuto,
+      stats: cam.controller.getAggregatedStats(),
+      sessionCount: cam.sessions.size,
+      sourceProfile: cam.activeSourceProfile
+    };
+  }
+  /** Get all sessions. */
+  getSessions(cameraName) {
+    const infos = [];
+    if (cameraName) {
+      const cam = this.cameras.get(cameraName);
+      if (cam) {
+        for (const s of cam.sessions.values()) infos.push(s.getInfo());
+      }
+    } else {
+      for (const cam of this.cameras.values()) {
+        for (const s of cam.sessions.values()) infos.push(s.getInfo());
+      }
+    }
+    return infos;
+  }
+  getSessionCount(cameraName) {
+    if (cameraName) return this.cameras.get(cameraName)?.sessions.size ?? 0;
+    let total = 0;
+    for (const cam of this.cameras.values()) total += cam.sessions.size;
+    return total;
+  }
+  /** Stop all cameras and sessions. */
+  async stop() {
+    if (this.stopped) return;
+    this.stopped = true;
+    const closePs = [];
+    for (const [name, cam] of this.cameras) {
+      if (cam.autoStopTimer) {
+        clearTimeout(cam.autoStopTimer);
+        cam.autoStopTimer = null;
+      }
+      for (const [sid, session] of cam.sessions) {
+        this.sessionCamera.delete(sid);
+        closePs.push(session.close().catch(() => {
+        }));
+      }
+      cam.sessions.clear();
+      closePs.push(cam.mainFanout.stop().catch(() => {
+      }));
+      closePs.push(cam.mainFfmpegSource.stop().catch(() => {
+      }));
+      if (cam.subFanout) closePs.push(cam.subFanout.stop().catch(() => {
+      }));
+      if (cam.subFfmpegSource) closePs.push(cam.subFfmpegSource.stop().catch(() => {
+      }));
+    }
+    await Promise.all(closePs);
+    this.cameras.clear();
+    this.logger.info("[adaptive-server] Stopped");
+    this.emit("stopped");
+  }
+  // -----------------------------------------------------------------------
+  // Private
+  // -----------------------------------------------------------------------
+  /** Get the currently active fanout for a camera. */
+  getActiveFanout(cam) {
+    if (cam.activeSourceProfile === "sub" && cam.subFanout) {
+      return cam.subFanout;
+    }
+    return cam.mainFanout;
+  }
+  ensureCameraRunning(name, cam) {
+    const activeFanout = this.getActiveFanout(cam);
+    if (activeFanout.isRunning()) return;
+    this.logger.info(`[adaptive-server] Starting camera "${name}" (${cam.activeSourceProfile})`);
+    if (cam.activeSourceProfile === "sub" && cam.subFfmpegSource) {
+      void cam.subFfmpegSource.start();
+      cam.subFanout.start();
+    } else {
+      void cam.mainFfmpegSource.start();
+      cam.mainFanout.start();
+    }
+  }
+  scheduleCameraAutoStop(name, cam) {
+    if (cam.sessions.size > 0 || this.stopped) return;
+    if (cam.autoStopTimer) clearTimeout(cam.autoStopTimer);
+    cam.autoStopTimer = setTimeout(async () => {
+      cam.autoStopTimer = null;
+      if (cam.sessions.size > 0 || this.stopped) return;
+      this.logger.info(`[adaptive-server] No viewers for "${name}", stopping ffmpeg`);
+      await cam.mainFanout.stop();
+      await cam.mainFfmpegSource.stop();
+      if (cam.subFanout) await cam.subFanout.stop();
+      if (cam.subFfmpegSource) await cam.subFfmpegSource.stop();
+    }, 1e4);
+  }
+  // -----------------------------------------------------------------------
+  // Source switching (Phase 5)
+  // -----------------------------------------------------------------------
+  /**
+   * Handle a quality change from the AdaptiveController.
+   * When the sourceProfile changes (main ↔ sub), performs a seamless source
+   * switch for all active sessions. When only encoding params change (same
+   * sourceProfile), updates ffmpeg params in-place.
+   */
+  async handleQualityChange(cameraName, from, to) {
+    const cam = this.cameras.get(cameraName);
+    if (!cam) return;
+    const sourceChanged = from.sourceProfile !== to.sourceProfile;
+    if (sourceChanged) {
+      await this.switchSource(cameraName, cam, to);
+    } else {
+      const activeSource = cam.activeSourceProfile === "sub" ? cam.subFfmpegSource : cam.mainFfmpegSource;
+      if (activeSource) {
+        await activeSource.updateParams(to.encoding);
+      }
+    }
+    this.emit("quality:change", {
+      camera: cameraName,
+      tier: to.tier,
+      encoding: to.encoding,
+      sourceProfile: to.sourceProfile
+    });
+  }
+  /**
+   * Switch all active sessions from one source to another (main ↔ sub).
+   *
+   * Steps:
+   * 1. Create/start the target ffmpeg source + fanout
+   * 2. For each session: subscribe to new fanout, call replaceSource()
+   * 3. Unsubscribe all from old fanout
+   * 4. Stop old ffmpeg + fanout (save resources)
+   * 5. Update activeSourceProfile
+   */
+  async switchSource(cameraName, cam, toProfile) {
+    if (cam.switching) {
+      this.logger.warn(`[adaptive-server] Source switch already in progress for "${cameraName}", skipping`);
+      return;
+    }
+    cam.switching = true;
+    const switchingToSub = toProfile.sourceProfile === "sub";
+    this.logger.info(
+      `[adaptive-server] Source switch for "${cameraName}": ${cam.activeSourceProfile} \u2192 ${toProfile.sourceProfile}`
+    );
+    try {
+      if (switchingToSub) {
+        if (!cam.config.subRtspUrl) {
+          this.logger.warn(
+            `[adaptive-server] No subRtspUrl configured for "${cameraName}", cannot switch to sub stream \u2014 falling back to param update only`
+          );
+          await cam.mainFfmpegSource.updateParams(toProfile.encoding);
+          return;
+        }
+        if (!cam.subFfmpegSource) {
+          cam.subFfmpegSource = new AdaptiveFfmpegSource({
+            rtspUrl: cam.config.subRtspUrl,
+            initialParams: toProfile.encoding,
+            ffmpegPath: this.ffmpegPath,
+            logger: this.logger,
+            label: `ffmpeg:${cameraName}:sub`
+          });
+          cam.subFanout = new StreamFanout({
+            maxQueueItems: 30,
+            createSource: () => cam.subFfmpegSource.source,
+            onError: (err) => {
+              this.logger.error(`[adaptive-server] Sub fanout error (${cameraName}):`, err);
+            }
+          });
+        }
+        void cam.subFfmpegSource.start();
+        cam.subFanout.start();
+        for (const [sid, session] of cam.sessions) {
+          cam.mainFanout.unsubscribe(sid);
+          const newSource = cam.subFanout.subscribe(sid);
+          session.replaceSource(newSource);
+        }
+        await cam.mainFanout.stop();
+        await cam.mainFfmpegSource.stop();
+        cam.activeSourceProfile = "sub";
+      } else {
+        cam.mainFfmpegSource = new AdaptiveFfmpegSource({
+          rtspUrl: cam.config.rtspUrl,
+          initialParams: toProfile.encoding,
+          ffmpegPath: this.ffmpegPath,
+          logger: this.logger,
+          label: `ffmpeg:${cameraName}:main`
+        });
+        cam.mainFanout = new StreamFanout({
+          maxQueueItems: 30,
+          createSource: () => cam.mainFfmpegSource.source,
+          onError: (err) => {
+            this.logger.error(`[adaptive-server] Main fanout error (${cameraName}):`, err);
+          }
+        });
+        void cam.mainFfmpegSource.start();
+        cam.mainFanout.start();
+        for (const [sid, session] of cam.sessions) {
+          if (cam.subFanout) cam.subFanout.unsubscribe(sid);
+          const newSource = cam.mainFanout.subscribe(sid);
+          session.replaceSource(newSource);
+        }
+        if (cam.subFanout) await cam.subFanout.stop();
+        if (cam.subFfmpegSource) await cam.subFfmpegSource.stop();
+        cam.subFfmpegSource = null;
+        cam.subFanout = null;
+        cam.activeSourceProfile = "main";
+      }
+      this.logger.info(
+        `[adaptive-server] Source switch complete for "${cameraName}": now on ${cam.activeSourceProfile} stream`
+      );
+    } catch (err) {
+      this.logger.error(`[adaptive-server] Source switch failed for "${cameraName}":`, err);
+    } finally {
+      cam.switching = false;
+    }
+  }
+};
+
+// src/addon.ts
+var WebrtcAdaptiveAddon = class {
+  manifest = {
+    id: "webrtc-adaptive",
+    name: "Adaptive WebRTC",
+    version: "0.1.0",
+    description: "Adaptive WebRTC streaming with quality degradation/recovery",
+    capabilities: [{ name: "webrtc", mode: "collection" }]
+  };
+  server = null;
+  currentConfig = {};
+  async initialize(context) {
+    this.currentConfig = {
+      ffmpegPath: context.addonConfig.ffmpegPath ?? "ffmpeg",
+      logger: context.logger
+    };
+    this.server = new AdaptiveStreamServer(this.currentConfig);
+    context.logger.info("WebRTC Adaptive streaming initialized");
+  }
+  async shutdown() {
+    this.server = null;
+  }
+  getCapabilityProvider(name) {
+    if (name === "webrtc" && this.server) {
+      return this.server;
+    }
+    return null;
+  }
+  getConfigSchema() {
+    return { sections: [] };
+  }
+  getConfig() {
+    return { ...this.currentConfig };
+  }
+  async onConfigChange(config) {
+    this.currentConfig = {
+      ...this.currentConfig,
+      ffmpegPath: config.ffmpegPath ?? this.currentConfig.ffmpegPath
+    };
+  }
+  getServer() {
+    return this.server;
+  }
+};
+
+// src/ffmpeg-process.ts
+var import_node_child_process2 = require("child_process");
+var FfmpegProcess = class {
+  constructor(options) {
+    this.options = options;
+    this.logger = options.logger;
+    this.label = options.label ?? "ffmpeg";
+  }
+  process = null;
+  killed = false;
+  logger;
+  label;
+  /** Spawn the FFmpeg process. Returns stdin writable stream. */
+  start() {
+    if (this.process) {
+      throw new Error(`[${this.label}] FFmpeg process already started`);
+    }
+    const ffmpegPath = this.options.ffmpegPath ?? "ffmpeg";
+    const stdio = [
+      "pipe",
+      "ignore",
+      "pipe",
+      ...this.options.extraStdio ?? []
+    ];
+    this.process = (0, import_node_child_process2.spawn)(ffmpegPath, this.options.args, { stdio });
+    this.process.on("error", (error) => {
+      this.logger?.error(`[${this.label}] Failed to spawn FFmpeg:`, error);
+    });
+    this.process.on("close", (code, signal) => {
+      this.options.onExit?.(code, signal);
+    });
+    this.process.stderr?.on("data", (data) => {
+      const output = data.toString();
+      this.options.onStderr?.(output);
+    });
+    this.process.stdin?.on("error", (error) => {
+      const code = error?.code;
+      if (code === "EPIPE" || code === "ERR_STREAM_WRITE_AFTER_END") return;
+      this.logger?.error(`[${this.label}] FFmpeg stdin error:`, error);
+    });
+    return this.process.stdin;
+  }
+  /** Get a specific stdio stream by fd index (e.g. 3 for pipe:3). */
+  getStdio(fd) {
+    if (!this.process) return null;
+    return this.process.stdio?.[fd] ?? null;
+  }
+  /** Get the underlying ChildProcess. */
+  getProcess() {
+    return this.process;
+  }
+  /** Kill the FFmpeg process gracefully (SIGTERM then SIGKILL after timeout). */
+  async kill(timeoutMs = 3e3) {
+    if (this.killed || !this.process) return;
+    this.killed = true;
+    const proc = this.process;
+    this.process = null;
+    try {
+      proc.stdin?.end();
+    } catch {
+    }
+    try {
+      proc.kill("SIGTERM");
+    } catch {
+    }
+    await new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        try {
+          proc.kill("SIGKILL");
+        } catch {
+        }
+        resolve();
+      }, timeoutMs);
+      proc.on("close", () => {
+        clearTimeout(timer);
+        resolve();
+      });
+    });
+  }
+  /** Check if the process is running. */
+  isRunning() {
+    return this.process !== null && !this.killed;
+  }
+};
+
+// src/frame-source.ts
+function fromEventEmitter(emitter, videoEvent = "videoFrame", audioEvent = "audioFrame") {
+  const queue = [];
+  let resolve = null;
+  let done = false;
+  const onVideo = (frame) => {
+    const mf = { type: "video", frame };
+    if (resolve) {
+      const r = resolve;
+      resolve = null;
+      r({ value: mf, done: false });
+    } else {
+      queue.push(mf);
+      if (queue.length > 500) queue.splice(0, queue.length - 500);
+    }
+  };
+  const onAudio = (frame) => {
+    const mf = { type: "audio", frame };
+    if (resolve) {
+      const r = resolve;
+      resolve = null;
+      r({ value: mf, done: false });
+    } else {
+      queue.push(mf);
+      if (queue.length > 500) queue.splice(0, queue.length - 500);
+    }
+  };
+  const cleanup = () => {
+    done = true;
+    emitter.removeListener(videoEvent, onVideo);
+    emitter.removeListener(audioEvent, onAudio);
+    if (resolve) {
+      const r = resolve;
+      resolve = null;
+      r({ value: void 0, done: true });
+    }
+  };
+  emitter.on(videoEvent, onVideo);
+  emitter.on(audioEvent, onAudio);
+  emitter.once("close", cleanup);
+  emitter.once("end", cleanup);
+  return (async function* () {
+    try {
+      while (true) {
+        const item = queue.shift();
+        if (item) {
+          yield item;
+          continue;
+        }
+        if (done) return;
+        const result = await new Promise((r) => {
+          resolve = r;
+        });
+        if (result.done) return;
+        yield result.value;
+      }
+    } finally {
+      cleanup();
+    }
+  })();
+}
+function fromPushCallback() {
+  const queue = [];
+  let resolve = null;
+  let closed = false;
+  const push = (mf) => {
+    if (closed) return;
+    if (resolve) {
+      const r = resolve;
+      resolve = null;
+      r({ value: mf, done: false });
+    } else {
+      queue.push(mf);
+      if (queue.length > 500) queue.splice(0, queue.length - 500);
+    }
+  };
+  const source = (async function* () {
+    try {
+      while (true) {
+        const item = queue.shift();
+        if (item) {
+          yield item;
+          continue;
+        }
+        if (closed) return;
+        const result = await new Promise((r) => {
+          resolve = r;
+        });
+        if (result.done) return;
+        yield result.value;
+      }
+    } finally {
+      closed = true;
+    }
+  })();
+  return {
+    source,
+    pushVideo: (frame) => push({ type: "video", frame }),
+    pushAudio: (frame) => push({ type: "audio", frame }),
+    close: () => {
+      closed = true;
+      if (resolve) {
+        const r = resolve;
+        resolve = null;
+        r({ value: void 0, done: true });
+      }
+    }
+  };
+}
+function fromNativeStream(native) {
+  return (async function* () {
+    for await (const frame of native) {
+      if (frame.audio) {
+        yield {
+          type: "audio",
+          frame: {
+            data: frame.data,
+            codec: frame.codec === "aac" ? "Aac" : "Adpcm",
+            sampleRate: frame.sampleRate ?? 8e3,
+            channels: 1,
+            timestampMicros: frame.microseconds ?? Date.now() * 1e3
+          }
+        };
+      } else {
+        yield {
+          type: "video",
+          frame: {
+            data: frame.data,
+            codec: frame.videoType ?? "H264",
+            isKeyframe: frame.isKeyframe ?? false,
+            timestampMicros: frame.microseconds ?? Date.now() * 1e3
+          }
+        };
+      }
+    }
+  })();
+}
+
+// src/rtsp-relay.ts
+var import_node_child_process3 = require("child_process");
+var AdaptiveRtspRelay = class {
+  rtspUrl;
+  rtspOutputUrl;
+  ffmpegPath;
+  logger;
+  label;
+  currentParams;
+  proc = null;
+  closed = false;
+  constructor(options) {
+    this.rtspUrl = options.rtspUrl;
+    this.rtspOutputUrl = options.rtspOutputUrl;
+    this.ffmpegPath = options.ffmpegPath ?? "ffmpeg";
+    this.logger = options.logger;
+    this.label = options.label ?? "adaptive-rtsp";
+    this.currentParams = { ...options.initialParams };
+  }
+  getParams() {
+    return { ...this.currentParams };
+  }
+  /** Start the ffmpeg relay. */
+  start() {
+    if (this.closed) return;
+    this.spawnFfmpeg();
+  }
+  /** Hot-swap encoding parameters by restarting ffmpeg. */
+  async updateParams(params) {
+    const prev = { ...this.currentParams };
+    if (params.maxBitrateKbps !== void 0) this.currentParams.maxBitrateKbps = params.maxBitrateKbps;
+    if (params.width !== void 0) this.currentParams.width = params.width;
+    if (params.height !== void 0) this.currentParams.height = params.height;
+    if (params.preset !== void 0) this.currentParams.preset = params.preset;
+    if (prev.maxBitrateKbps === this.currentParams.maxBitrateKbps && prev.width === this.currentParams.width && prev.height === this.currentParams.height) return;
+    this.logger?.info(
+      `[${this.label}] Updating: ${prev.maxBitrateKbps}kbps ${prev.width}x${prev.height} \u2192 ${this.currentParams.maxBitrateKbps}kbps ${this.currentParams.width}x${this.currentParams.height}`
+    );
+    await this.killFfmpeg();
+    if (!this.closed) this.spawnFfmpeg();
+  }
+  /** Stop the relay. */
+  async stop() {
+    if (this.closed) return;
+    this.closed = true;
+    await this.killFfmpeg();
+  }
+  /** Check if ffmpeg is running. */
+  isRunning() {
+    return this.proc !== null;
+  }
+  // -----------------------------------------------------------------------
+  // Private
+  // -----------------------------------------------------------------------
+  spawnFfmpeg() {
+    const { maxBitrateKbps, width, height, preset } = this.currentParams;
+    const args = [
+      "-hide_banner",
+      "-loglevel",
+      "error",
+      // Input
+      "-rtsp_transport",
+      "tcp",
+      "-i",
+      this.rtspUrl,
+      // Video encoding
+      "-c:v",
+      "libx264",
+      "-preset",
+      preset ?? "ultrafast",
+      "-tune",
+      "zerolatency",
+      "-crf",
+      "28",
+      "-maxrate",
+      `${maxBitrateKbps}k`,
+      "-bufsize",
+      `${Math.round(maxBitrateKbps * 0.5)}k`,
+      "-g",
+      "50",
+      "-keyint_min",
+      "25"
+    ];
+    if (width > 0 && height > 0) {
+      args.push("-vf", `scale=${width}:${height}`);
+    }
+    args.push("-c:a", "aac", "-b:a", "64k");
+    args.push(
+      "-f",
+      "rtsp",
+      "-rtsp_transport",
+      "tcp",
+      this.rtspOutputUrl
+    );
+    this.proc = (0, import_node_child_process3.spawn)(this.ffmpegPath, args, {
+      stdio: ["ignore", "ignore", "pipe"]
+    });
+    this.proc.on("error", (err) => {
+      this.logger?.error(`[${this.label}] ffmpeg spawn error: ${err.message}`);
+    });
+    this.proc.on("close", (code, signal) => {
+      this.logger?.debug(`[${this.label}] ffmpeg exited code=${code} signal=${signal}`);
+      this.proc = null;
+      if (!this.closed) {
+        setTimeout(() => {
+          if (!this.closed) this.spawnFfmpeg();
+        }, 2e3);
+      }
+    });
+    this.proc.stderr?.on("data", (data) => {
+      const s = data.toString();
+      if (s.includes("error") || s.includes("Error") || s.includes("fatal")) {
+        this.logger?.error(`[${this.label}] ffmpeg: ${s.trim()}`);
+      }
+    });
+    this.logger?.info(
+      `[${this.label}] Started: ${maxBitrateKbps}kbps ` + (width > 0 ? `${width}x${height}` : "native") + ` \u2192 ${this.rtspOutputUrl}`
+    );
+  }
+  async killFfmpeg() {
+    const proc = this.proc;
+    if (!proc) return;
+    this.proc = null;
+    try {
+      proc.kill("SIGTERM");
+    } catch {
+    }
+    await new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        try {
+          proc.kill("SIGKILL");
+        } catch {
+        }
+        resolve();
+      }, 3e3);
+      proc.on("close", () => {
+        clearTimeout(timer);
+        resolve();
+      });
+    });
+  }
+};
+
+// src/shared-session.ts
+var _werift2;
+async function loadWerift2() {
+  if (_werift2) return _werift2;
+  const moduleName = "werift";
+  _werift2 = await Function("m", "return import(m)")(moduleName);
+  return _werift2;
+}
+var SharedSession = class {
+  constructor(options) {
+    this.options = options;
+    this.logger = options.logger;
+    this.iceConfig = options.iceConfig;
+    this.onTrackRequested = options.onTrackRequested;
+    this.onTrackReleased = options.onTrackReleased;
+  }
+  logger;
+  iceConfig;
+  onTrackRequested;
+  onTrackReleased;
+  pc = null;
+  dataChannel = null;
+  activeTracks = /* @__PURE__ */ new Map();
+  closed = false;
+  negotiating = false;
+  /** Create the initial SDP offer (with data channel, no media tracks yet). */
+  async createOffer() {
+    const werift = await loadWerift2();
+    const iceServers = [];
+    if (this.iceConfig?.stunServers) {
+      for (const url of this.iceConfig.stunServers) iceServers.push({ urls: url });
+    }
+    if (this.iceConfig?.turnServers) {
+      for (const t of this.iceConfig.turnServers) {
+        iceServers.push({ urls: t.urls, username: t.username, credential: t.credential });
+      }
+    }
+    const pcOptions = {
+      codecs: {
+        video: [
+          new werift.RTCRtpCodecParameters({
+            mimeType: "video/H264",
+            clockRate: 9e4,
+            payloadType: 96,
+            parameters: "level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f",
+            rtcpFeedback: [
+              { type: "transport-cc" },
+              { type: "ccm", parameter: "fir" },
+              { type: "nack" },
+              { type: "nack", parameter: "pli" },
+              { type: "goog-remb" }
+            ]
+          })
+        ],
+        audio: [
+          new werift.RTCRtpCodecParameters({
+            mimeType: "audio/opus",
+            clockRate: 48e3,
+            payloadType: 111,
+            channels: 2,
+            parameters: "minptime=10;useinbandfec=1"
+          })
+        ]
+      }
+    };
+    if (iceServers.length > 0) pcOptions.iceServers = iceServers;
+    if (this.iceConfig?.portRange) pcOptions.icePortRange = this.iceConfig.portRange;
+    if (this.iceConfig?.additionalHostAddresses) {
+      pcOptions.iceAdditionalHostAddresses = this.iceConfig.additionalHostAddresses;
+    }
+    this.pc = new werift.RTCPeerConnection(pcOptions);
+    this.pc.iceConnectionStateChange.subscribe((state) => {
+      this.logger.debug(`[shared] ICE: ${state}`);
+    });
+    this.dataChannel = this.pc.createDataChannel("control", { ordered: true });
+    this.dataChannel.message.subscribe((msg) => {
+      try {
+        const data = JSON.parse(typeof msg === "string" ? msg : msg.toString());
+        this.handleDataChannelMessage(data);
+      } catch (err) {
+        this.logger.error("[shared] DC message parse error:", err);
+      }
+    });
+    const offer = await this.pc.createOffer();
+    await this.pc.setLocalDescription(offer);
+    await new Promise((resolve) => {
+      if (this.pc.iceGatheringState === "complete") {
+        resolve();
+        return;
+      }
+      this.pc.iceGatheringStateChange.subscribe((state) => {
+        if (state === "complete") resolve();
+      });
+      setTimeout(resolve, 5e3);
+    });
+    const sdp = this.pc.localDescription?.sdp ?? offer.sdp;
+    this.logger.info("[shared] Initial offer created (data channel only)");
+    return sdp;
+  }
+  /** Handle the client's SDP answer. */
+  async handleAnswer(sdpAnswer) {
+    const werift = await loadWerift2();
+    const desc = new werift.RTCSessionDescription(sdpAnswer, "answer");
+    await this.pc.setRemoteDescription(desc);
+    this.logger.info("[shared] Answer set, connection ready");
+  }
+  /** Close the shared session and all tracks. */
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    for (const [, track] of this.activeTracks) {
+      track.feedAbort.abort();
+      this.onTrackReleased?.(track.cameraName);
+    }
+    this.activeTracks.clear();
+    if (this.pc) {
+      try {
+        await this.pc.close();
+      } catch {
+      }
+      this.pc = null;
+    }
+    this.logger.info("[shared] Session closed");
+  }
+  // -----------------------------------------------------------------------
+  // Data channel message handling
+  // -----------------------------------------------------------------------
+  async handleDataChannelMessage(msg) {
+    try {
+      switch (msg.type) {
+        case "addTrack":
+          await this.handleAddTrack(msg.cameraName, msg.trackId);
+          break;
+        case "removeTrack":
+          await this.handleRemoveTrack(msg.trackId);
+          break;
+        case "answer":
+          await this.handleRenegotiationAnswer(msg.sdp);
+          break;
+        default:
+          this.logger.warn("[shared] Unknown DC message type:", msg.type);
+      }
+    } catch (err) {
+      this.logger.error("[shared] DC handler error:", err);
+      this.sendDC({ type: "error", message: err.message });
+    }
+  }
+  async handleAddTrack(cameraName, trackId) {
+    if (this.activeTracks.has(trackId)) {
+      this.sendDC({ type: "error", message: `Track ${trackId} already exists` });
+      return;
+    }
+    const werift = await loadWerift2();
+    const videoTrack = new werift.MediaStreamTrack({ kind: "video" });
+    const videoTransceiver = this.pc.addTransceiver(videoTrack, { direction: "sendonly" });
+    const audioTrack = new werift.MediaStreamTrack({ kind: "audio" });
+    const audioDirection = this.options.onIntercomAudio ? "sendrecv" : "sendonly";
+    const audioTransceiver = this.pc.addTransceiver(audioTrack, { direction: audioDirection });
+    if (this.options.onIntercomAudio) {
+      const intercomCb = this.options.onIntercomAudio;
+      audioTransceiver.onTrack.subscribe((incomingTrack) => {
+        incomingTrack.onReceiveRtp.subscribe((rtpPacket) => {
+          const payload = rtpPacket.payload;
+          if (payload?.length > 0) {
+            intercomCb(cameraName, payload);
+          }
+        });
+      });
+    }
+    await this.renegotiate();
+    const videoMid = videoTransceiver.mid;
+    const audioMid = audioTransceiver.mid;
+    const source = this.onTrackRequested(cameraName);
+    if (!source) {
+      this.sendDC({ type: "error", message: `Camera not found: ${cameraName}` });
+      return;
+    }
+    const feedAbort = new AbortController();
+    const activeTrack = {
+      trackId,
+      cameraName,
+      videoSender: videoTransceiver.sender,
+      audioSender: audioTransceiver.sender,
+      feedAbort,
+      videoSeqNum: 0,
+      audioSeqNum: 0
+    };
+    this.activeTracks.set(trackId, activeTrack);
+    this.sendDC({ type: "trackReady", trackId, videoMid, audioMid });
+    this.startFeeding(activeTrack, source);
+    this.logger.info(`[shared] Track "${trackId}" added for camera "${cameraName}" (video=${videoMid}, audio=${audioMid})`);
+  }
+  async handleRemoveTrack(trackId) {
+    const track = this.activeTracks.get(trackId);
+    if (!track) return;
+    track.feedAbort.abort();
+    this.activeTracks.delete(trackId);
+    this.onTrackReleased?.(track.cameraName);
+    await this.renegotiate();
+    this.sendDC({ type: "trackRemoved", trackId });
+    this.logger.info(`[shared] Track "${trackId}" removed`);
+  }
+  async handleRenegotiationAnswer(sdp) {
+    const werift = await loadWerift2();
+    const desc = new werift.RTCSessionDescription(sdp, "answer");
+    await this.pc.setRemoteDescription(desc);
+    this.negotiating = false;
+    this.logger.debug("[shared] Renegotiation answer set");
+  }
+  // -----------------------------------------------------------------------
+  // SDP renegotiation
+  // -----------------------------------------------------------------------
+  async renegotiate() {
+    if (!this.pc || !this.dataChannel) return;
+    this.negotiating = true;
+    const offer = await this.pc.createOffer();
+    await this.pc.setLocalDescription(offer);
+    await new Promise((resolve) => {
+      if (this.pc.iceGatheringState === "complete") {
+        resolve();
+        return;
+      }
+      this.pc.iceGatheringStateChange.subscribe((state) => {
+        if (state === "complete") resolve();
+      });
+      setTimeout(resolve, 3e3);
+    });
+    const sdp = this.pc.localDescription?.sdp ?? offer.sdp;
+    this.sendDC({ type: "offer", sdp });
+    await new Promise((resolve) => {
+      const check = setInterval(() => {
+        if (!this.negotiating) {
+          clearInterval(check);
+          resolve();
+        }
+      }, 50);
+      setTimeout(() => {
+        clearInterval(check);
+        resolve();
+      }, 1e4);
+    });
+  }
+  // -----------------------------------------------------------------------
+  // Frame feeding
+  // -----------------------------------------------------------------------
+  startFeeding(track, source) {
+    const { signal } = track.feedAbort;
+    const werift = _werift2;
+    if (!werift) return;
+    void (async () => {
+      let gotKeyframe = false;
+      let videoTimestampBase = null;
+      let audioTimestampBase = null;
+      try {
+        for await (const mediaFrame of source) {
+          if (signal.aborted || this.closed) break;
+          if (mediaFrame.type === "audio") {
+            const frame2 = mediaFrame.frame;
+            if (audioTimestampBase === null) audioTimestampBase = frame2.timestampMicros;
+            const rtpTs2 = Math.floor(
+              (frame2.timestampMicros - audioTimestampBase) * (frame2.sampleRate || 48e3) / 1e6
+            ) >>> 0;
+            track.audioSeqNum = track.audioSeqNum + 1 & 65535;
+            const header = new werift.RtpHeader();
+            header.payloadType = 111;
+            header.timestamp = rtpTs2;
+            header.marker = true;
+            header.sequenceNumber = track.audioSeqNum;
+            const pkt = new werift.RtpPacket(header, frame2.data);
+            try {
+              track.audioSender.sendRtp(pkt.serialize());
+            } catch {
+            }
+            continue;
+          }
+          if (mediaFrame.type !== "video") continue;
+          const frame = mediaFrame.frame;
+          const annexB = convertH264ToAnnexB(frame.data);
+          if (!gotKeyframe) {
+            if (!isH264IdrAccessUnit(annexB)) continue;
+            gotKeyframe = true;
+          }
+          if (videoTimestampBase === null) videoTimestampBase = frame.timestampMicros;
+          const rtpTs = Math.floor(
+            (frame.timestampMicros - videoTimestampBase) * 9e4 / 1e6
+          ) >>> 0;
+          const nals = splitAnnexBToNals(annexB).filter((n) => {
+            const t = n[0] & 31;
+            return t !== 9 && t !== 6;
+          });
+          for (let i = 0; i < nals.length; i++) {
+            const nal = nals[i];
+            const isLastNal = i === nals.length - 1;
+            if (nal.length <= 1200) {
+              track.videoSeqNum = track.videoSeqNum + 1 & 65535;
+              const header = new werift.RtpHeader();
+              header.payloadType = 96;
+              header.timestamp = rtpTs;
+              header.marker = isLastNal;
+              header.sequenceNumber = track.videoSeqNum;
+              const pkt = new werift.RtpPacket(header, nal);
+              try {
+                track.videoSender.sendRtp(pkt.serialize());
+              } catch {
+              }
+            } else {
+              const nalHeader = nal[0];
+              const fnri = nalHeader & 224;
+              const nalType = nalHeader & 31;
+              const fuIndicator = fnri | 28;
+              const nalBody = nal.subarray(1);
+              let offset = 0;
+              let isFirst = true;
+              while (offset < nalBody.length) {
+                const end = Math.min(offset + 1198, nalBody.length);
+                const isLast = end >= nalBody.length;
+                let fuHeader = nalType;
+                if (isFirst) fuHeader |= 128;
+                if (isLast) fuHeader |= 64;
+                const frag = Buffer.alloc(2 + (end - offset));
+                frag[0] = fuIndicator;
+                frag[1] = fuHeader;
+                nalBody.copy(frag, 2, offset, end);
+                track.videoSeqNum = track.videoSeqNum + 1 & 65535;
+                const header = new werift.RtpHeader();
+                header.payloadType = 96;
+                header.timestamp = rtpTs;
+                header.marker = isLastNal && isLast;
+                header.sequenceNumber = track.videoSeqNum;
+                const pkt = new werift.RtpPacket(header, frag);
+                try {
+                  track.videoSender.sendRtp(pkt.serialize());
+                } catch {
+                }
+                offset = end;
+                isFirst = false;
+              }
+            }
+          }
+        }
+      } catch (err) {
+        if (!signal.aborted) {
+          this.logger.error(`[shared] Feed error for track "${track.trackId}":`, err);
+        }
+      }
+    })();
+  }
+  // -----------------------------------------------------------------------
+  // Helpers
+  // -----------------------------------------------------------------------
+  sendDC(msg) {
+    if (this.dataChannel?.readyState === "open") {
+      this.dataChannel.send(JSON.stringify(msg));
+    }
+  }
+  get isConnected() {
+    return this.pc?.iceConnectionState === "connected" && !this.closed;
+  }
+  get trackCount() {
+    return this.activeTracks.size;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AdaptiveController,
+  AdaptiveFfmpegSource,
+  AdaptiveRtspRelay,
+  AdaptiveSession,
+  AdaptiveStreamServer,
+  AsyncBoundedQueue,
+  FfmpegProcess,
+  H264RtpDepacketizer,
+  H265RtpDepacketizer,
+  SharedSession,
+  StreamFanout,
+  WebrtcAdaptiveAddon,
+  asLogger,
+  convertH264ToAnnexB,
+  convertH265ToAnnexB,
+  createDefaultProfiles,
+  createNullLogger,
+  detectVideoCodecFromNal,
+  extractH264ParamSets,
+  extractH265ParamSets,
+  fromEventEmitter,
+  fromNativeStream,
+  fromPushCallback,
+  getH265NalType,
+  hasStartCodes,
+  isH264IdrAccessUnit,
+  isH264KeyframeAnnexB,
+  isH265Irap,
+  isH265IrapAccessUnit,
+  isH265KeyframeAnnexB,
+  joinNalsToAnnexB,
+  prependStartCode,
+  splitAnnexBToNals
+});
+//# sourceMappingURL=index.cjs.map